open-index/open-npm huggingface dataset:
npm package: @inngest/middleware-sentry
Description: Sentry middleware for Inngest.
Author: Inngest Inc.
Latest version: 1.0.0

# @inngest/middleware-sentry

This package provides a middleware for Inngest to interface with
[Sentry](https://sentry.io).

## Features

- Capture exceptions for reporting
- Add tracing to each function run
- Include useful context for each exception and trace like function ID and event
  names

## Installation

```sh
npm install @inngest/middleware-sentry
```

> [!NOTE]
> Requires `inngest@>=4.0.0` and `@sentry/*@>=8.0.0`

## Usage

To use the middleware, pass the `SentryMiddleware` class to your Inngest client.
It assumes that Sentry has already been initialized elsewhere in your code using
`Sentry.init()`.

```ts
import * as Sentry from "@sentry/node";
import { Inngest } from "inngest";
import { SentryMiddleware } from "@inngest/middleware-sentry";

// Initialize Sentry as usual wherever is appropriate
Sentry.init(...);

const inngest = new Inngest({
  id: "my-app",
  middleware: [SentryMiddleware],
});
```

To customize options, use the `sentryMiddleware()` factory:

```ts
import { sentryMiddleware } from "@inngest/middleware-sentry";

const inngest = new Inngest({
  id: "my-app",
  middleware: [sentryMiddleware({ onlyCaptureFinalAttempt: false })],
});
```

## Options

### `captureStepErrors`

**Default: `false`**

When `true`, step-level errors are captured as separate Sentry events in
addition to function-level errors. Each step error event is tagged with
`inngest.error.source: "step"` and `inngest.step.name` so you can distinguish
them from function-level events (`inngest.error.source: "run"`).

When `false`, step errors are still visible as error spans and breadcrumbs in
traces, but only function-level errors produce Sentry events.

### `onlyCaptureFinalAttempt`

**Default: `true`**

When `true`, exceptions are only sent to Sentry on the final attempt of a step
or function run (when retries are exhausted or the error is non-retriable).
Intermediate retry attempts still set span error status and add breadcrumbs, but
won't create Sentry events. Set to `false` to capture every attempt.

### `disableAutomaticFlush`

**Default: `false`**

By default, the middleware will force Sentry to
[flush](https://docs.sentry.io/platforms/javascript/guides/node/configuration/draining/)
as part of the Inngest request, ensuring all events, exceptions, and traces are
sent before a response is returned.

This is important for serverless environments where the runtime doesn't wait for
the event loop to be empty and background tasks such as sending exception data
may be lost.

If you're not in a serverless runtime or otherwise wish to have Sentry handle
flushing itself, set this to `true`.
npm package: @inngest/middleware-validation
Description: Schema validation middleware for Inngest.
Author: Inngest Inc.
Latest version: 0.0.5

# @inngest/middleware-validation

This package provides a validation middleware for Inngest, enabling parsing of
incoming and outgoing events using Zod schemas provided using `new
EventSchemas().fromZod()`.

## Features

- Validates incoming event payloads when a function is run
- Validates outgoing event payloads using `inngest.send()` or `step.sendEvent()`
- Optionally disallow events without specified schemas

## Installation

```sh
npm install @inngest/middleware-validation
```

> [!NOTE]
> Requires TypeScript SDK >= 3.23.1

## Usage

To use the validation middleware, import and initialize it.

```ts
import { Inngest, EventSchemas } from "inngest";
import { validationMiddleware } from "@inngest/middleware-validation";
import { z } from "zod";

const inngest = new Inngest({
  id: "my-app",
  middleware: [validationMiddleware()], // just add this
  schemas: new EventSchemas().fromZod({
    "example/event": {
      data: z.object({
        message: z.string(),
      }),
    },
  }),
});
```

By default, simply adding `validationMiddleware()` to an existing client that uses Zod schemas will validate all incoming and outgoing events.

You can provide some extra options to customize the behaviour:

```ts
validationMiddleware({ ... });

{
  /**
   * Disallow events that don't have a schema defined.
   *
   * For this to happen, it probably means that the event is typed using
   * `.fromRecord()` or some other type-only method, and we have no way of
   * validating the payload at runtime.
   *
   * @default false
   */
  disallowSchemalessEvents?: boolean;

  /**
   * Disallow events that have a schema defined, but the schema is unknown and
   * not handled in this code.
   *
   * This is most likely to happen if schemas can be defined using a library not yet
   * supported by this middleware.
   *
   * @default false
   */
  disallowUnknownSchemas?: boolean;

  /**
   * Disable validation of incoming events.
   *
   * @default false
   */
  disableIncomingValidation?: boolean;

  /**
   * Disable validation of outgoing events using `inngest.send()` or
   * `step.sendEvent()`.
   *
   * @default false
   */
  disableOutgoingValidation?: boolean;
}
```

> [!NOTE]
> Due to current typing restrictions within middleware, _transforming_
> types is currently unsupported, for example using `z.transform()`. This can be
> introduced in a later update once more mature middleware typing is available,
> likely in `inngest@^4.0.0`.
npm package: @inngest/realtime
Description: Deprecated: Use inngest/realtime instead.
Author: Inngest Inc.
Latest version: 0.4.7
Deprecated: This package is deprecated. Realtime functionality is now built into the inngest package.

# @inngest/realtime

> **Deprecated:** This package is deprecated. Realtime functionality is now built into the `inngest` package. Use `inngest/realtime` and `inngest/react` instead.