inngest 1.8.5 → 2.0.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # inngest
 
+## 1.9.0
+
+### Minor Changes
+
+- 48d94a2: Allow user provided logger to be used within functions (experimental)
+
 ## 1.8.5
 
 ### Patch Changes

package/components/EventSchemas.d.ts

@@ -0,0 +1,154 @@
+import { type Simplify } from "type-fest";
+import { type z } from "zod";
+import { type IsStringLiteral } from "../helpers/types";
+import { type EventPayload } from "../types";
+export type StandardEventSchema = {
+    data: Record<string, any>;
+    user?: Record<string, any>;
+};
+/**
+ * A helper type that declares a standardised custom part of the event schema.
+ *
+ * @public
+ */
+export type StandardEventSchemas = Record<string, StandardEventSchema>;
+/**
+ * A helper type that declares a standardised custom part of the event schema,
+ * defined using Zod.
+ *
+ * @public
+ */
+export type ZodEventSchemas = Record<string, {
+    data: z.AnyZodObject | z.ZodAny;
+    user?: z.AnyZodObject | z.ZodAny;
+}>;
+/**
+ * A helper type to convert input schemas into the format expected by the
+ * `EventSchemas` class, which ensures that each event contains all pieces
+ * of information required.
+ *
+ * It purposefully uses slightly more complex (read: verbose) mapped types to
+ * flatten the output.
+ *
+ * @public
+ */
+export type StandardEventSchemaToPayload<T> = Simplify<{
+    [K in keyof T & string]: {
+        [K2 in keyof (Omit<EventPayload, keyof T[K]> & T[K] & {
+            name: K;
+        })]: (Omit<EventPayload, keyof T[K]> & T[K] & {
+            name: K;
+        })[K2];
+    };
+}>;
+/**
+ * A helper type to combine two event schemas together, ensuring the result is
+ * as flat as possible and that we don't accidentally overwrite existing schemas
+ * with a generic `string` key.
+ *
+ * @public
+ */
+export type Combine<TCurr extends Record<string, EventPayload>, TInc extends StandardEventSchemas> = IsStringLiteral<keyof TCurr & string> extends true ? Simplify<Omit<TCurr, keyof StandardEventSchemaToPayload<TInc>> & StandardEventSchemaToPayload<TInc>> : StandardEventSchemaToPayload<TInc>;
+/**
+ * Provide an `EventSchemas` class to type events, providing type safety when
+ * sending events and running functions via Inngest.
+ *
+ * You can provide generated Inngest types, custom types, types using Zod, or
+ * a combination of the above. See {@link EventSchemas} for more information.
+ *
+ * @example
+ *
+ * ```ts
+ * export const inngest = new Inngest({
+ *   name: "My App",
+ *   schemas: new EventSchemas().fromZod({
+ *     "app/user.created": {
+ *       data: z.object({
+ *         id: z.string(),
+ *         name: z.string(),
+ *       }),
+ *     },
+ *   }),
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare class EventSchemas<S extends Record<string, EventPayload>> {
+    /**
+     * Use generated Inngest types to type events.
+     */
+    fromGenerated<T extends StandardEventSchemas>(): EventSchemas<Combine<S, T>>;
+    /**
+     * Use a `Record<>` type to type events.
+     *
+     * @example
+     *
+     * ```ts
+     * export const inngest = new Inngest({
+     *   name: "My App",
+     *   schemas: new EventSchemas().fromRecord<{
+     *     "app/user.created": {
+     *       data: {
+     *         id: string;
+     *         name: string;
+     *       };
+     *     };
+     *   }>(),
+     * });
+     * ```
+     */
+    fromRecord<T extends StandardEventSchemas>(): EventSchemas<Combine<S, T>>;
+    /**
+     * Use a union type to type events.
+     *
+     * @example
+     *
+     * ```ts
+     * type AccountCreated = {
+     *   name: "app/account.created";
+     *   data: { org: string };
+     *   user: { id: string };
+     * };
+     *
+     * type AccountDeleted = {
+     *   name: "app/account.deleted";
+     *   data: { org: string };
+     *   user: { id: string };
+     * };
+     *
+     * type Events = AccountCreated | AccountDeleted;
+     *
+     * export const inngest = new Inngest({
+     *   name: "My App",
+     *   schemas: new EventSchemas().fromUnion<Events>(),
+     * });
+     * ```
+     */
+    fromUnion<T extends {
+        name: string;
+    } & StandardEventSchema>(): EventSchemas<Combine<S, { [K in T["name"]]: Extract<T, {
+        name: K;
+    }>; }>>;
+    /**
+     * Use Zod to type events.
+     *
+     * @example
+     *
+     * ```ts
+     * export const inngest = new Inngest({
+     *   name: "My App",
+     *   schemas: new EventSchemas().fromZod({
+     *     "app/user.created": {
+     *       data: z.object({
+     *         id: z.string(),
+     *         name: z.string(),
+     *       }),
+     *     },
+     *   }),
+     * });
+     * ```
+     */
+    fromZod<T extends ZodEventSchemas>(schemas: T): EventSchemas<Combine<S, { [EventName in keyof T & string]: { [Key in keyof T[EventName] & string]: T[EventName][Key] extends z.ZodTypeAny ? z.TypeOf<T[EventName][Key]> : T[EventName][Key]; }; }>>;
+}
+//# sourceMappingURL=EventSchemas.d.ts.map

package/components/EventSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventSchemas.d.ts","sourceRoot":"","sources":["../../src/components/EventSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,mBAAmB,GAAG;IAEhC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE1B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAClC,MAAM,EACN;IACE,IAAI,EAAE,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,IAAI,CAAC,EAAE,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;CAClC,CACF,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,4BAA4B,CAAC,CAAC,IAAI,QAAQ,CAAC;KACpD,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG;SACtB,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG;YAAE,IAAI,EAAE,CAAC,CAAA;SAAE,CAAC,GAAG,CAAC,IAAI,CACxE,YAAY,EACZ,MAAM,CAAC,CAAC,CAAC,CAAC,CACX,GACC,CAAC,CAAC,CAAC,CAAC,GAAG;YAAE,IAAI,EAAE,CAAC,CAAA;SAAE,CAAC,CAAC,EAAE,CAAC;KAC1B;CACF,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CACjB,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC1C,IAAI,SAAS,oBAAoB,IAC/B,eAAe,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,IAAI,GAClD,QAAQ,CACN,IAAI,CAAC,KAAK,EAAE,MAAM,4BAA4B,CAAC,IAAI,CAAC,CAAC,GACnD,4BAA4B,CAAC,IAAI,CAAC,CACrC,GACD,4BAA4B,CAAC,IAAI,CAAC,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9D;;OAEG;IACI,aAAa,CAAC,CAAC,SAAS,oBAAoB;IAInD;;;;;;;;;;;;;;;;;;OAkBG;IACI,UAAU,CAAC,CAAC,SAAS,oBAAoB;IAIhD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,SAAS,CAAC,CAAC,SAAS;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,mBAAmB;;;IAWjE;;;;;;;;;;;;;;;;;;OAkBG;IAEI,OAAO,CAAC,CAAC,SAAS,eAAe,EAAE,OAAO,EAAE,CAAC;CAerD"}

package/components/EventSchemas.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSchemas = void 0;
+/**
+ * Provide an `EventSchemas` class to type events, providing type safety when
+ * sending events and running functions via Inngest.
+ *
+ * You can provide generated Inngest types, custom types, types using Zod, or
+ * a combination of the above. See {@link EventSchemas} for more information.
+ *
+ * @example
+ *
+ * ```ts
+ * export const inngest = new Inngest({
+ *   name: "My App",
+ *   schemas: new EventSchemas().fromZod({
+ *     "app/user.created": {
+ *       data: z.object({
+ *         id: z.string(),
+ *         name: z.string(),
+ *       }),
+ *     },
+ *   }),
+ * });
+ * ```
+ *
+ * @public
+ */
+class EventSchemas {
+    /**
+     * Use generated Inngest types to type events.
+     */
+    fromGenerated() {
+        return new EventSchemas();
+    }
+    /**
+     * Use a `Record<>` type to type events.
+     *
+     * @example
+     *
+     * ```ts
+     * export const inngest = new Inngest({
+     *   name: "My App",
+     *   schemas: new EventSchemas().fromRecord<{
+     *     "app/user.created": {
+     *       data: {
+     *         id: string;
+     *         name: string;
+     *       };
+     *     };
+     *   }>(),
+     * });
+     * ```
+     */
+    fromRecord() {
+        return new EventSchemas();
+    }
+    /**
+     * Use a union type to type events.
+     *
+     * @example
+     *
+     * ```ts
+     * type AccountCreated = {
+     *   name: "app/account.created";
+     *   data: { org: string };
+     *   user: { id: string };
+     * };
+     *
+     * type AccountDeleted = {
+     *   name: "app/account.deleted";
+     *   data: { org: string };
+     *   user: { id: string };
+     * };
+     *
+     * type Events = AccountCreated | AccountDeleted;
+     *
+     * export const inngest = new Inngest({
+     *   name: "My App",
+     *   schemas: new EventSchemas().fromUnion<Events>(),
+     * });
+     * ```
+     */
+    fromUnion() {
+        return new EventSchemas();
+    }
+    /**
+     * Use Zod to type events.
+     *
+     * @example
+     *
+     * ```ts
+     * export const inngest = new Inngest({
+     *   name: "My App",
+     *   schemas: new EventSchemas().fromZod({
+     *     "app/user.created": {
+     *       data: z.object({
+     *         id: z.string(),
+     *         name: z.string(),
+     *       }),
+     *     },
+     *   }),
+     * });
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    fromZod(schemas) {
+        return new EventSchemas();
+    }
+}
+exports.EventSchemas = EventSchemas;
+//# sourceMappingURL=EventSchemas.js.map

package/components/EventSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventSchemas.js","sourceRoot":"","sources":["../../src/components/EventSchemas.ts"],"names":[],"mappings":";;;AAsEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAa,YAAY;IACvB;;OAEG;IACI,aAAa;QAClB,OAAO,IAAI,YAAY,EAAiB,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACI,UAAU;QACf,OAAO,IAAI,YAAY,EAAiB,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,SAAS;QACd,OAAO,IAAI,YAAY,EAOpB,CAAC;IACN,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,6DAA6D;IACtD,OAAO,CAA4B,OAAU;QAClD,OAAO,IAAI,YAAY,EAYpB,CAAC;IACN,CAAC;CACF;AAvGD,oCAuGC"}

package/components/Inngest.d.ts

@@ -1,6 +1,16 @@
-import { type PartialK, type SendEventPayload, type SingleOrArray } from "../helpers/types";
-import { type ClientOptions, type EventNameFromTrigger, type EventPayload, type FailureEventArgs, type FunctionOptions, type Handler, type ShimmedFns, type TriggerOptions } from "../types";
+import { type SendEventPayload } from "../helpers/types";
+import { type Logger } from "../middleware/logger";
+import { type ClientOptions, type EventNameFromTrigger, type EventPayload, type FailureEventArgs, type FunctionOptions, type FunctionTrigger, type Handler, type MiddlewareStack, type ShimmedFns, type TriggerOptions } from "../types";
+import { type EventSchemas } from "./EventSchemas";
 import { InngestFunction } from "./InngestFunction";
+import { InngestMiddleware, type MiddlewareStackRunInputMutation } from "./InngestMiddleware";
+/**
+ * Given a set of client options for Inngest, return the event types that can
+ * be sent or received.
+ *
+ * @public
+ */
+export type EventsFromOpts<TOpts extends ClientOptions> = TOpts["schemas"] extends EventSchemas<infer U> ? U : Record<string, EventPayload>;
 /**
  * A client used to interact with the Inngest API by sending or reacting to
  * events.
@@ -26,7 +36,7 @@ import { InngestFunction } from "./InngestFunction";
  *
  * @public
  */
-export declare class Inngest<Events extends Record<string, EventPayload> = Record<string, EventPayload>> {
+export declare class Inngest<TOpts extends ClientOptions = ClientOptions> {
     #private;
     /**
      * The name of this instance, most commonly the name of the application it
@@ -47,6 +57,12 @@ export declare class Inngest<Events extends Record<string, EventPayload> = Recor
     private inngestApiUrl;
     private readonly headers;
     private readonly fetch;
+    private readonly logger;
+    /**
+     * A promise that resolves when the middleware stack has been initialized and
+     * the client is ready to be used.
+     */
+    private readonly middleware;
     /**
      * A client used to interact with the Inngest API by sending or reacting to
      * events.
@@ -70,7 +86,12 @@ export declare class Inngest<Events extends Record<string, EventPayload> = Recor
      * >({ name: "My App" });
      * ```
      */
-    constructor({ name, eventKey, inngestBaseUrl, fetch, env, }: ClientOptions);
+    constructor({ name, eventKey, inngestBaseUrl, fetch, env, logger, middleware, }: TOpts);
+    /**
+     * Initialize all passed middleware, running the `register` function on each
+     * in sequence and returning the requested hook registrations.
+     */
+    private initializeMiddleware;
     /**
      * Set the event key for this instance of Inngest. This is useful if for some
      * reason the key is not available at time of instantiation or present in the
@@ -83,31 +104,6 @@ export declare class Inngest<Events extends Record<string, EventPayload> = Recor
      * in the `INNGEST_EVENT_KEY` environment variable.
      */
     eventKey: string): void;
-    /**
-     * Send one or many events to Inngest. Takes a known event from this Inngest
-     * instance based on the given `name`.
-     *
-     * ```ts
-     * await inngest.send("app/user.created", { data: { id: 123 } });
-     * ```
-     *
-     * Returns a promise that will resolve if the event(s) were sent successfully,
-     * else throws with an error explaining what went wrong.
-     *
-     * If you wish to send an event with custom types (i.e. one that hasn't been
-     * generated), make sure to add it when creating your Inngest instance, like
-     * so:
-     *
-     * ```ts
-     * const inngest = new Inngest<Events & {
-     *   "my/event": {
-     *     name: "my/event";
-     *     data: { bar: string; };
-     *   }
-     * }>("My App", "API_KEY");
-     * ```
-     */
-    send<Event extends keyof Events>(name: Event, payload: SingleOrArray<PartialK<Omit<Events[Event], "name" | "v">, "ts">>): Promise<void>;
     /**
      * Send one or many events to Inngest. Takes an entire payload (including
      * name) as each input.
@@ -132,8 +128,8 @@ export declare class Inngest<Events extends Record<string, EventPayload> = Recor
      * }>("My App", "API_KEY");
      * ```
      */
-    send<Payload extends SendEventPayload<Events>>(payload: Payload): Promise<void>;
-    createFunction<TFns extends Record<string, unknown>, TTrigger extends TriggerOptions<keyof Events & string>, TShimmedFns extends Record<string, (...args: any[]) => any> = ShimmedFns<TFns>, TTriggerName extends keyof Events & string = EventNameFromTrigger<Events, TTrigger>>(nameOrOpts: string | (Omit<FunctionOptions<Events, TTriggerName>, "fns" | "onFailure"> & {
+    send<Payload extends SendEventPayload<EventsFromOpts<TOpts>>>(payload: Payload): Promise<void>;
+    createFunction<TFns extends Record<string, unknown>, TMiddleware extends MiddlewareStack, TTrigger extends TriggerOptions<keyof EventsFromOpts<TOpts> & string>, TShimmedFns extends Record<string, (...args: any[]) => any> = ShimmedFns<TFns>, TTriggerName extends keyof EventsFromOpts<TOpts> & string = EventNameFromTrigger<EventsFromOpts<TOpts>, TTrigger>>(nameOrOpts: string | (Omit<FunctionOptions<EventsFromOpts<TOpts>, TTriggerName>, "fns" | "onFailure" | "middleware"> & {
         /**
          * Pass in an object of functions that will be wrapped in Inngest
          * tooling and passes to your handler. This wrapping ensures that each
@@ -175,7 +171,48 @@ export declare class Inngest<Events extends Record<string, EventPayload> = Recor
          * after a failure and supports all the same functionality as a
          * regular handler.
          */
-        onFailure?: Handler<Events, TTriggerName, TShimmedFns, FailureEventArgs<Events[TTriggerName]>>;
-    }), trigger: TTrigger, handler: Handler<Events, TTriggerName, TShimmedFns>): InngestFunction;
+        onFailure?: Handler<TOpts, EventsFromOpts<TOpts>, TTriggerName, TShimmedFns, FailureEventArgs<EventsFromOpts<TOpts>[TTriggerName]>>;
+        /**
+         * TODO
+         */
+        middleware?: TMiddleware;
+    }), trigger: TTrigger, handler: Handler<TOpts, EventsFromOpts<TOpts>, TTriggerName, TShimmedFns, MiddlewareStackRunInputMutation<{}, typeof builtInMiddleware> & MiddlewareStackRunInputMutation<{}, NonNullable<TOpts["middleware"]>> & MiddlewareStackRunInputMutation<{}, TMiddleware>>): InngestFunction<TOpts, EventsFromOpts<TOpts>, FunctionTrigger<keyof EventsFromOpts<TOpts> & string>, FunctionOptions<EventsFromOpts<TOpts>, keyof EventsFromOpts<TOpts> & string>>;
 }
+/**
+ * Default middleware that is included in every client, placed after the user's
+ * middleware on the client but before function-level middleware.
+ *
+ * It is defined here to ensure that comments are included in the generated TS
+ * definitions. Without this, we infer the stack of built-in middleware without
+ * comments, losing a lot of value.
+ *
+ * If this is moved, please ensure that using this package in another project
+ * can correctly access comments on mutated input and output.
+ */
+declare const builtInMiddleware: [InngestMiddleware<{
+    name: string;
+    register({ client }: {
+        client: Inngest<any>;
+        fn?: InngestFunction<any, any, any, any> | undefined;
+    }): {
+        run(): {
+            input(): {
+                ctx: {
+                    /**
+                     * The passed in logger from the user.
+                     * Defaults to a console logger if not provided.
+                     */
+                    logger: Logger;
+                };
+            };
+            beforeExecution(): void;
+            output({ result: { error } }: {
+                result: Readonly<Pick<import("../types").OutgoingOp, "data" | "error">>;
+                step?: Readonly<Omit<import("../types").OutgoingOp, "id">> | undefined;
+            }): void;
+            beforeResponse(): Promise<void>;
+        };
+    };
+}>];
+export {};
 //# sourceMappingURL=Inngest.d.ts.map

package/components/Inngest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Inngest.d.ts","sourceRoot":"","sources":["../../src/components/Inngest.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAOpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,OAAO,CAClB,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;;IAE1E;;;OAGG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAM;IAEtB;;OAEG;IACH,SAAgB,cAAc,EAAE,GAAG,CAAC;IAEpC;;OAEG;IACH,OAAO,CAAC,aAAa,CAAyD;IAE9E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IAEjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B;;;;;;;;;;;;;;;;;;;;;;OAsBG;gBACS,EACV,IAAI,EACJ,QAAQ,EACR,cAAkC,EAClC,KAAK,EACL,GAAG,GACJ,EAAE,aAAa;IAmEhB;;;;OAIG;IACI,WAAW;IAChB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,GACf,IAAI;IAKP;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,IAAI,CAAC,KAAK,SAAS,MAAM,MAAM,EAC1C,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GACxE,OAAO,CAAC,IAAI,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,IAAI,CAAC,OAAO,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACxD,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC;IA+FT,cAAc,CACnB,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,QAAQ,SAAS,cAAc,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,EACtD,WAAW,SAAS,MAAM,CACxB,MAAM,EAEN,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CACxB,GAAG,UAAU,CAAC,IAAI,CAAC,EACpB,YAAY,SAAS,MAAM,MAAM,GAAG,MAAM,GAAG,oBAAoB,CAC/D,MAAM,EACN,QAAQ,CACT,EAED,UAAU,EACN,MAAM,GACN,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,KAAK,GAAG,WAAW,CAAC,GAAG;QAClE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA+BG;QACH,GAAG,CAAC,EAAE,IAAI,CAAC;QAEX;;;;;;;WAOG;QACH,SAAS,CAAC,EAAE,OAAO,CACjB,MAAM,EACN,YAAY,EACZ,WAAW,EACX,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CACvC,CAAC;KACH,CAAC,EACN,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,CAAC,GAClD,eAAe;CAYnB"}
+{"version":3,"file":"Inngest.d.ts","sourceRoot":"","sources":["../../src/components/Inngest.ts"],"names":[],"mappings":"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"}

package/components/Inngest.js

@@ -11,7 +11,9 @@ const consts_1 = require("../helpers/consts");
 const devserver_1 = require("../helpers/devserver");
 const env_1 = require("../helpers/env");
 const errors_1 = require("../helpers/errors");
+const logger_1 = require("../middleware/logger");
 const InngestFunction_1 = require("./InngestFunction");
+const InngestMiddleware_1 = require("./InngestMiddleware");
 /**
  * A client used to interact with the Inngest API by sending or reacting to
  * events.
@@ -61,7 +63,7 @@ class Inngest {
      * >({ name: "My App" });
      * ```
      */
-    constructor({ name, eventKey, inngestBaseUrl = "https://inn.gs/", fetch, env, }) {
+    constructor({ name, eventKey, inngestBaseUrl = "https://inn.gs/", fetch, env, logger = new logger_1.DefaultLogger(), middleware, }) {
         _Inngest_instances.add(this);
         /**
          * Inngest event key, used to send events to Inngest Cloud.
@@ -92,6 +94,30 @@ class Inngest {
             inngestEnv: env,
         });
         this.fetch = (0, env_1.getFetch)(fetch);
+        this.logger = logger;
+        this.middleware = this.initializeMiddleware([
+            ...builtInMiddleware,
+            ...(middleware || []),
+        ]);
+    }
+    /**
+     * Initialize all passed middleware, running the `register` function on each
+     * in sequence and returning the requested hook registrations.
+     */
+    async initializeMiddleware(middleware = [], opts) {
+        var _a;
+        /**
+         * Wait for the prefix stack to run first; do not trigger ours before this
+         * is complete.
+         */
+        const prefix = await ((_a = opts === null || opts === void 0 ? void 0 : opts.prefixStack) !== null && _a !== void 0 ? _a : []);
+        const stack = middleware.reduce(async (acc, m) => {
+            // Be explicit about waiting for the previous middleware to finish
+            const prev = await acc;
+            const next = await m.register(Object.assign({ client: this }, opts === null || opts === void 0 ? void 0 : opts.registerInput));
+            return [...prev, next];
+        }, Promise.resolve([]));
+        return [...prefix, ...(await stack)];
     }
     /**
      * Set the event key for this instance of Inngest. This is useful if for some
@@ -108,7 +134,40 @@ class Inngest {
         this.eventKey = eventKey;
         this.inngestApiUrl = new URL(`e/${this.eventKey}`, this.inngestBaseUrl);
     }
-    async send(nameOrPayload, maybePayload) {
+    /**
+     * Send one or many events to Inngest. Takes an entire payload (including
+     * name) as each input.
+     *
+     * ```ts
+     * await inngest.send({ name: "app/user.created", data: { id: 123 } });
+     * ```
+     *
+     * Returns a promise that will resolve if the event(s) were sent successfully,
+     * else throws with an error explaining what went wrong.
+     *
+     * If you wish to send an event with custom types (i.e. one that hasn't been
+     * generated), make sure to add it when creating your Inngest instance, like
+     * so:
+     *
+     * ```ts
+     * const inngest = new Inngest<Events & {
+     *   "my/event": {
+     *     name: "my/event";
+     *     data: { bar: string; };
+     *   }
+     * }>("My App", "API_KEY");
+     * ```
+     */
+    async send(payload) {
+        var _a, _b;
+        const hooks = await (0, InngestMiddleware_1.getHookStack)(this.middleware, "sendEvent", undefined, {
+            input: (prev, output) => {
+                return Object.assign(Object.assign({}, prev), output);
+            },
+            output: (prev, _output) => {
+                return prev;
+            },
+        });
         if (!this.eventKey) {
             throw new Error((0, errors_1.prettyError)({
                 whatHappened: "Failed to send event",
@@ -117,26 +176,14 @@ class Inngest {
                 toFixNow: errors_1.fixEventKeyMissingSteps,
             }));
         }
-        let payloads;
-        if (typeof nameOrPayload === "string") {
-            /**
-             * Add our payloads and ensure they all have a name.
-             */
-            payloads = (Array.isArray(maybePayload)
-                ? maybePayload
-                : maybePayload
-                    ? [maybePayload]
-                    : []).map((payload) => (Object.assign(Object.assign({}, payload), { name: nameOrPayload })));
-        }
-        else {
-            /**
-             * Grab our payloads straight from the args.
-             */
-            payloads = (Array.isArray(nameOrPayload)
-                ? nameOrPayload
-                : nameOrPayload
-                    ? [nameOrPayload]
-                    : []);
+        let payloads = Array.isArray(payload)
+            ? payload
+            : payload
+                ? [payload]
+                : [];
+        const inputChanges = await ((_a = hooks.input) === null || _a === void 0 ? void 0 : _a.call(hooks, { payloads: [...payloads] }));
+        if (inputChanges === null || inputChanges === void 0 ? void 0 : inputChanges.payloads) {
+            payloads = [...inputChanges.payloads];
         }
         /**
          * It can be valid for a user to send an empty list of events; if this
@@ -169,13 +216,15 @@ class Inngest {
             headers: Object.assign({}, this.headers),
         });
         if (response.status >= 200 && response.status < 300) {
-            return;
+            return void (await ((_b = hooks.output) === null || _b === void 0 ? void 0 : _b.call(hooks)));
         }
         throw await __classPrivateFieldGet(this, _Inngest_instances, "m", _Inngest_getResponseError).call(this, response);
     }
     createFunction(nameOrOpts, trigger, handler) {
-        const opts = (typeof nameOrOpts === "string" ? { name: nameOrOpts } : nameOrOpts);
-        return new InngestFunction_1.InngestFunction(this, opts, typeof trigger === "string" ? { event: trigger } : trigger, handler);
+        const sanitizedOpts = (typeof nameOrOpts === "string" ? { name: nameOrOpts } : nameOrOpts);
+        return new InngestFunction_1.InngestFunction(this, sanitizedOpts, typeof trigger === "string" ? { event: trigger } : trigger, 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+        handler);
     }
 }
 exports.Inngest = Inngest;
@@ -214,4 +263,51 @@ async function _Inngest_getResponseError(response) {
     }
     return new Error(`Inngest API Error: ${response.status} ${errorMessage}`);
 };
+/**
+ * Default middleware that is included in every client, placed after the user's
+ * middleware on the client but before function-level middleware.
+ *
+ * It is defined here to ensure that comments are included in the generated TS
+ * definitions. Without this, we infer the stack of built-in middleware without
+ * comments, losing a lot of value.
+ *
+ * If this is moved, please ensure that using this package in another project
+ * can correctly access comments on mutated input and output.
+ */
+const builtInMiddleware = ((m) => m)([
+    new InngestMiddleware_1.InngestMiddleware({
+        name: "Inngest: Logger",
+        register({ client }) {
+            return {
+                run() {
+                    const logger = new logger_1.ProxyLogger(client["logger"]);
+                    return {
+                        input() {
+                            return {
+                                ctx: {
+                                    /**
+                                     * The passed in logger from the user.
+                                     * Defaults to a console logger if not provided.
+                                     */
+                                    logger: logger,
+                                },
+                            };
+                        },
+                        beforeExecution() {
+                            logger.enable();
+                        },
+                        output({ result: { error } }) {
+                            if (error) {
+                                logger.error(error);
+                            }
+                        },
+                        async beforeResponse() {
+                            await logger.flush();
+                        },
+                    };
+                },
+            };
+        },
+    }),
+]);
 //# sourceMappingURL=Inngest.js.map