inngest 4.7.0 → 4.9.0

package/components/execution/als.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"als.d.cts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAQA;AAA6B,UAAZ,YAAA,CAAY;;;;;;;EAmJhB,GAAA,EA5IN,OAAA,CAAQ,IA8Id;EAAA;;;;;;;;cApIa;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;aAYP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyGA,mBAAwB,QAAQ"}
+{"version":3,"file":"als.d.cts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAQA;AAA6B,UAAZ,YAAA,CAAY;;;;;;;EAsJhB,GAAA,EA/IN,OAAA,CAAQ,IAiJd;EAAA;;;;;;;;cAvIa;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;;aAeP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyGA,mBAAwB,QAAQ"}

package/components/execution/als.d.ts

@@ -37,6 +37,7 @@ interface AsyncContext {
      */
     executingStep?: StepOptions & {
       hashedId?: string;
+      userlandId?: string;
     };
     /**
      * If present, indicates the parallel mode that should be applied to steps

package/components/execution/als.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"als.d.ts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAQA;AAA6B,UAAZ,YAAA,CAAY;;;;;;;EAmJhB,GAAA,EA5IN,OAAA,CAAQ,IA8Id;EAAA;;;;;;;;cApIa;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;aAYP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyGA,mBAAwB,QAAQ"}
+{"version":3,"file":"als.d.ts","names":[],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAQA;AAA6B,UAAZ,YAAA,CAAY;;;;;;;EAsJhB,GAAA,EA/IN,OAAA,CAAQ,IAiJd;EAAA;;;;;;;;cAvIa;;;;;SAML,OAAA,CAAQ;;;;;;oBAOG;;;;;;;;;;;;;aAeP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyGA,mBAAwB,QAAQ"}

package/components/execution/als.js.map

@@ -1 +1 @@
-{"version":3,"file":"als.js","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { Stream } from \"../StreamTools.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions & { hashedId?: string };\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * The stream tools instance for this execution context. Used by the\n     * `stream` singleton to push/pipe SSE data to the client.\n     */\n    stream?: Stream;\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n      selectionStrategy: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;AAoFA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}
+{"version":3,"file":"als.js","names":["fallback: AsyncLocalStorageIsh"],"sources":["../../../src/components/execution/als.ts"],"sourcesContent":["import type { Context, StepOptions } from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { Stream } from \"../StreamTools.ts\";\nimport type { IInngestExecution } from \"./InngestExecution.ts\";\n\n/**\n * Note - this structure can be used by other libraries, so cannot have breaking changes.\n */\nexport interface AsyncContext {\n  /**\n   * The Inngest App that is currently being used to execute the function.\n   *\n   * If this is defined, we are in the context of an Inngest function execution,\n   * or a possible one.\n   */\n  app: Inngest.Like;\n\n  /**\n   * Details of the current function execution context. If this doesn't exist,\n   * then we're not currently in a function execution context.\n   */\n  execution?: {\n    /**\n     * The execution instance that is currently running the function.\n     */\n    instance: IInngestExecution;\n\n    /**\n     * The `ctx` object that has been passed in to this function execution,\n     * including values such as `step` and `event`.\n     */\n    ctx: Context.Any;\n\n    /**\n     * If present, this indicates we are currently executing a `step.run()` step's\n     * callback. Useful to understand whether we are in the context of a step\n     * execution or within the main function body.\n     */\n    executingStep?: StepOptions & {\n      hashedId?: string;\n      userlandId?: string;\n    };\n\n    /**\n     * If present, indicates the parallel mode that should be applied to steps\n     * created within this context. Set by `group.parallel()`.\n     */\n    parallelMode?: \"race\";\n\n    /**\n     * The stream tools instance for this execution context. Used by the\n     * `stream` singleton to push/pipe SSE data to the client.\n     */\n    stream?: Stream;\n\n    /**\n     * If present, indicates the variant callback is executing within an\n     * experiment. Set by `group.experiment()`. Any `step.*()` call within\n     * this context will include these fields in `OutgoingOp.opts`.\n     */\n    experimentContext?: {\n      experimentStepID: string;\n      experimentName: string;\n      variant: string;\n      selectionStrategy: string;\n    };\n\n    /**\n     * A mutable tracker used to detect whether any step tool was invoked\n     * during a variant callback. Set by `group.experiment()`, flipped by\n     * `createTool` in `InngestStepTools.ts`.\n     */\n    experimentStepTracker?: { found: boolean };\n\n    /**\n     * If true, we are inside the `select()` callback of\n     * `group.experiment()`. Any `step.*()` call here would create a\n     * nested step, which is not allowed.\n     */\n    insideExperimentSelect?: boolean;\n  };\n}\n\n/**\n * A local-only symbol used as a key in global state to store the async local\n * storage instance.\n */\nconst alsSymbol = Symbol.for(\"inngest:als\");\n\n/**\n * Cache structure that stores both the promise and resolved ALS instance.\n * This allows synchronous access after initialization.\n */\ntype ALSCache = {\n  promise: Promise<AsyncLocalStorageIsh>;\n  resolved?: AsyncLocalStorageIsh;\n  isFallback?: boolean;\n};\n\n/**\n * A type that represents a partial, runtime-agnostic interface of\n * `AsyncLocalStorage`.\n */\ntype AsyncLocalStorageIsh = {\n  getStore: () => AsyncContext | undefined;\n  run: <R>(store: AsyncContext, fn: () => R) => R;\n};\n\nconst getCache = (): ALSCache => {\n  const g = globalThis as Record<symbol, ALSCache | undefined>;\n\n  if (!g[alsSymbol]) {\n    g[alsSymbol] = createCache();\n  }\n\n  return g[alsSymbol];\n};\n\nconst createCache = (): ALSCache => {\n  const cache = {} as ALSCache;\n  cache.promise = initializeALS(cache);\n  return cache;\n};\n\nconst initializeALS = async (\n  cache: ALSCache,\n): Promise<AsyncLocalStorageIsh> => {\n  try {\n    const { AsyncLocalStorage } = await import(\"node:async_hooks\");\n    const als = new AsyncLocalStorage<AsyncContext>();\n    cache.resolved = als;\n    cache.isFallback = false;\n    return als;\n  } catch {\n    const fallback: AsyncLocalStorageIsh = {\n      getStore: () => undefined,\n      run: (_, fn) => fn(),\n    };\n    cache.resolved = fallback;\n    cache.isFallback = true;\n    console.warn(\n      \"node:async_hooks is not supported in this runtime. Async context is disabled.\",\n    );\n    return fallback;\n  }\n};\n\n/**\n * Check if AsyncLocalStorage is unavailable and we're using the fallback.\n * Returns `undefined` if ALS hasn't been initialized yet.\n */\nexport const isALSFallback = (): boolean | undefined => {\n  return getCache().isFallback;\n};\n\n/**\n * Retrieve the async context for the current execution.\n */\nexport const getAsyncCtx = async (): Promise<AsyncContext | undefined> => {\n  return getAsyncLocalStorage().then((als) => als.getStore());\n};\n\n/**\n * Retrieve the async context for the current execution synchronously.\n * Returns undefined if ALS hasn't been initialized yet.\n */\nexport const getAsyncCtxSync = (): AsyncContext | undefined => {\n  return getCache().resolved?.getStore();\n};\n\n/**\n * Get a singleton instance of `AsyncLocalStorage` used to store and retrieve\n * async context for the current execution.\n */\nexport const getAsyncLocalStorage = async (): Promise<AsyncLocalStorageIsh> => {\n  return getCache().promise;\n};\n"],"mappings":";;;;;AAuFA,MAAM,YAAY,OAAO,IAAI,cAAc;AAqB3C,MAAM,iBAA2B;CAC/B,MAAM,IAAI;AAEV,KAAI,CAAC,EAAE,WACL,GAAE,aAAa,aAAa;AAG9B,QAAO,EAAE;;AAGX,MAAM,oBAA8B;CAClC,MAAM,QAAQ,EAAE;AAChB,OAAM,UAAU,cAAc,MAAM;AACpC,QAAO;;AAGT,MAAM,gBAAgB,OACpB,UACkC;AAClC,KAAI;EACF,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,MAAM,IAAI,mBAAiC;AACjD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,SAAO;SACD;EACN,MAAMA,WAAiC;GACrC,gBAAgB;GAChB,MAAM,GAAG,OAAO,IAAI;GACrB;AACD,QAAM,WAAW;AACjB,QAAM,aAAa;AACnB,UAAQ,KACN,gFACD;AACD,SAAO;;;;;;;AAQX,MAAa,sBAA2C;AACtD,QAAO,UAAU,CAAC;;;;;AAMpB,MAAa,cAAc,YAA+C;AACxE,QAAO,sBAAsB,CAAC,MAAM,QAAQ,IAAI,UAAU,CAAC;;;;;;AAO7D,MAAa,wBAAkD;AAC7D,QAAO,UAAU,CAAC,UAAU,UAAU;;;;;;AAOxC,MAAa,uBAAuB,YAA2C;AAC7E,QAAO,UAAU,CAAC"}

package/components/execution/engine.cjs

@@ -194,7 +194,7 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 							traceparent: this.options.headers[require_consts.headerKeys.TraceParent],
 							tracestate: this.options.headers[require_consts.headerKeys.TraceState]
 						});
-						require_metadataProcessor.metadataSpanProcessor.declareStartingSpan({
+						if (this.options.client.aiMetadataEnabled) require_metadataProcessor.metadataSpanProcessor.declareStartingSpan({
 							span,
 							traceparent: this.options.headers[require_consts.headerKeys.TraceParent],
 							onAIMetadata: (aiMetadata) => {
@@ -912,7 +912,8 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		if (store?.execution) store.execution.executingStep = {
 			id,
 			name: displayName,
-			hashedId
+			hashedId,
+			userlandId: userland.id
 		};
 		this.devDebug(`executing step "${id}"`);
 		if (this.rootSpanId && this.options.checkpointingConfig) require_access.clientProcessorMap.get(this.options.client)?.declareStepExecution(this.rootSpanId, userland.id ?? "", userland.index ?? 0, hashedId, this.options.data?.attempt ?? 0);
@@ -1045,8 +1046,10 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		})), triggers);
 	}
 	/**
-	* Validate the deferred event's data against the defer function's own
-	* schema (set via `createDefer`'s `opts.schema`).
+	* Validate the deferred event's data against the defer function's own schema
+	* (set via `createDefer`'s `opts.schema`). Our internal metadata
+	* (`event.data._inngest`) was already stripped, so that won't affect
+	* validation.
 	*/
 	async validateDeferEventSchema() {
 		const fn = this.options.fn;
@@ -1189,10 +1192,6 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 			group: require_InngestGroupTools.createGroupTools({ experimentStepRun }),
 			defer
 		};
-		if (this.options.handlerKind === "defer") {
-			delete fnArg.event.data._inngest;
-			for (const event of fnArg.events) delete event.data._inngest;
-		}
 		/**
 		* Handle use of the `onFailure` option by deserializing the error.
 		*/
@@ -1486,7 +1485,7 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 	* schema mismatch) are logged and the call is silently skipped.
 	*/
 	buildDefer(stepHandler) {
-		return (idOrOptions, { function: deferFn, data }) => {
+		return (idOrOptions, { function: deferFn, data, experiment }) => {
 			const log = this.options.client[require_Inngest.internalLoggerSymbol];
 			const runId = this.fnArg.runId;
 			try {
@@ -1513,7 +1512,10 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 					input = result.value ?? data;
 				}
 				stepHandler({
-					args: [idOrOptions, input],
+					args: [idOrOptions, experiment && require_types$1.isRecord(input) ? {
+						...input,
+						[require_consts.deferExperimentKey]: experiment
+					} : input],
 					matchOp: (stepOptions, inputArg) => ({
 						id: stepOptions.id,
 						mode: require_types.StepMode.Sync,