inngest/helpers/functions.cjs

Official SDK for Inngest.com. Inngest is the reliability layer for modern applications. Inngest combines durable execution, events, and queues into a zero-infra platform with built-in observability.

const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
const require_consts = require('./consts.cjs');
const require_types = require('../types.cjs');
const require_schema = require('../api/schema.cjs');
const require_InngestExecution = require('../components/execution/InngestExecution.cjs');
const require_log = require('./log.cjs');
let zod_v3 = require("zod/v3");
let debug = require("debug");
debug = require_rolldown_runtime.__toESM(debug);

//#region src/helpers/functions.ts
const devDebug = (0, debug.default)(`${require_consts.debugPrefix}:functions`);
/**
* Given a value `v`, return `v` if it's not undefined, otherwise return `null`.
*/
const undefinedToNull = (v) => {
	return typeof v === "undefined" ? null : v;
};
const createVersionSchema = (internalLogger) => zod_v3.z.literal(-1).or(zod_v3.z.literal(0)).or(zod_v3.z.literal(1)).or(zod_v3.z.literal(2)).optional().transform((v) => {
	if (typeof v === "undefined") {
		devDebug("No request version specified by executor; using default");
		return {
			sdkDecided: true,
			version: require_InngestExecution.PREFERRED_ASYNC_EXECUTION_VERSION
		};
	}
	if (v === 0) {
		internalLogger.error("V0 execution version is no longer supported");
		throw new Error("V0 execution version is no longer supported");
	}
	if (v === -1) return {
		sdkDecided: true,
		version: require_InngestExecution.PREFERRED_ASYNC_EXECUTION_VERSION
	};
	return {
		sdkDecided: false,
		version: v
	};
});
const parseFnData = (data, headerVersion, internalLogger) => {
	const versionSchema = createVersionSchema(internalLogger);
	const fnDataVersionSchema = zod_v3.z.object({ version: versionSchema });
	let version;
	let sdkDecided = true;
	try {
		if (typeof headerVersion !== "undefined") try {
			const res = versionSchema.parse(headerVersion);
			version = res.version;
			sdkDecided = res.sdkDecided;
		} catch {}
		if (typeof version === "undefined") {
			const parsedVersionData = fnDataVersionSchema.parse(data);
			version = parsedVersionData.version.version;
			sdkDecided = parsedVersionData.version.sdkDecided;
		}
		return {
			version,
			sdkDecided,
			...zod_v3.z.object({
				event: zod_v3.z.record(zod_v3.z.any()),
				events: zod_v3.z.array(zod_v3.z.record(zod_v3.z.any())).default([]),
				steps: require_schema.stepSchema,
				ctx: zod_v3.z.object({
					run_id: zod_v3.z.string(),
					fn_id: zod_v3.z.string().optional(),
					attempt: zod_v3.z.number().default(0),
					max_attempts: zod_v3.z.number().optional(),
					disable_immediate_execution: zod_v3.z.boolean().default(false),
					use_api: zod_v3.z.boolean().default(false),
					qi_id: zod_v3.z.string().optional(),
					stack: zod_v3.z.object({
						stack: zod_v3.z.array(zod_v3.z.string()).nullable().transform((v) => Array.isArray(v) ? v : []),
						current: zod_v3.z.number()
					}).optional().nullable()
				}).optional().nullable()
			}).parse(data)
		};
	} catch (err$1) {
		throw new Error(parseFailureErr(err$1));
	}
};
const fetchAllFnData = async ({ data, api, logger }) => {
	const result = { ...data };
	try {
		if (result.ctx?.use_api) {
			if (!result.ctx?.run_id) return require_types.err(require_log.formatLogMessage({
				message: "Failed to attempt retrieving data from API",
				explanation: "Function execution can't continue. run_id is missing from context."
			}));
			const [evtResp, stepResp] = await Promise.all([api.getRunBatch(result.ctx.run_id), api.getRunSteps(result.ctx.run_id)]);
			if (evtResp.ok) result.events = evtResp.value;
			else return require_types.err(require_log.formatLogMessage({
				message: "Failed to retrieve list of events",
				explanation: `Function execution can't continue.${evtResp.error?.error ? ` ${evtResp.error.error}` : ""}`
			}));
			if (stepResp.ok) result.steps = stepResp.value;
			else return require_types.err(require_log.formatLogMessage({
				message: "Failed to retrieve steps for function run",
				explanation: `Function execution can't continue.${stepResp.error?.error ? ` ${stepResp.error.error}` : ""}`
			}));
		}
		const stepIds = Object.keys(result.steps || {});
		if (stepIds.length && !result.ctx?.stack?.stack?.length) result.ctx = {
			...result.ctx,
			stack: {
				stack: stepIds,
				current: stepIds.length - 1
			}
		};
		return require_types.ok(result);
	} catch (error) {
		logger.error({ err: error }, "Failed to fetch all function data");
		return require_types.err(parseFailureErr(error));
	}
};
const parseFailureErr = (err$1) => {
	let why;
	if (err$1 instanceof zod_v3.ZodError) why = err$1.toString();
	return require_log.formatLogMessage({
		message: "Failed to parse data from executor",
		explanation: `Function execution can't continue.${why ? ` ${why}` : ""}`,
		action: "Make sure that your API is set up to parse incoming request bodies as JSON, like body-parser for Express.",
		docs: "https://expressjs.com/en/resources/middleware/body-parser.html"
	});
};

//#endregion
exports.createVersionSchema = createVersionSchema;
exports.fetchAllFnData = fetchAllFnData;
exports.parseFnData = parseFnData;
exports.undefinedToNull = undefinedToNull;
//# sourceMappingURL=functions.cjs.map