inngest/components/triggers/triggers.cjs.map

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.

{"version":3,"file":"triggers.cjs","names":[],"sources":["../../../src/components/triggers/triggers.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Represents a cron trigger for scheduled function execution.\n *\n * @property cron - Cron expression defining the schedule (e.g., \"0 0 * * *\")\n */\ntype CronTrigger = {\n  cron: string;\n};\n\n/**\n * Represents an event trigger for function execution.\n *\n * @property event - The event name to trigger on\n * @property if - Optional CEL expression for conditional execution\n * @property schema - Optional StandardSchema for type-safe event data validation\n */\ntype EventTrigger = {\n  event: string;\n  if?: string;\n\n  // biome-ignore lint/suspicious/noExplicitAny: schema can be any StandardSchemaV1\n  schema?: StandardSchemaV1<any>;\n};\n\n/**\n * Union type of all possible trigger types.\n *\n * A trigger determines when and how a function is executed.\n */\nexport type Trigger = CronTrigger | EventTrigger;\n\n/**\n * Create a cron trigger for scheduled function execution.\n *\n * @param schedule - Cron expression (e.g., \"0 0 * * *\" for daily at midnight)\n * @returns Cron trigger\n */\nexport function cron<T extends string>(schedule: T) {\n  return {\n    cron: schedule,\n  };\n}\n\n/**\n * Args for the `EventType.create` method\n */\ntype EventCreateArgs<\n  TSchema extends StandardSchemaV1<Record<string, unknown>> | undefined,\n> = TSchema extends undefined\n  ? [\n      data?: Record<string, unknown>,\n      options?: {\n        id?: string;\n        ts?: number;\n        v?: string;\n      },\n    ]\n  : [\n      data: ExtractSchemaData<TSchema>,\n      options?: {\n        id?: string;\n        ts?: number;\n        v?: string;\n      },\n    ];\n\n/**\n * Extract the input type from a StandardSchemaV1.\n */\ntype ExtractSchemaData<TData> = TData extends StandardSchemaV1<infer TData>\n  ? TData\n  : undefined;\n\n/**\n * An event that has been created but not validated.\n * @template TData - The input data type of the event (i.e. before validation)\n * @template TOutputData - The output data type of the event (i.e. after validation)\n */\ntype UnvalidatedCreatedEvent<\n  TName extends string,\n  TData,\n> = ValidatedCreatedEvent<TName, TData> & {\n  validate: () => Promise<void>;\n};\n\n/**\n * An event that has been validated.\n * @template TData - The data type of the event.\n */\ntype ValidatedCreatedEvent<TName extends string, TData> = {\n  data: TData;\n  name: TName;\n  id?: string;\n  ts?: number;\n  v?: string;\n};\n\nexport type EventTypeWithAnySchema<TName extends string> = EventType<\n  TName,\n  // biome-ignore lint/suspicious/noExplicitAny: any is fine\n  any\n>;\n\n/**\n * Represents a typed event definition that can be used both as a trigger\n * and for creating events with validation.\n *\n * @template TName - The event name (e.g., \"user.created\")\n * @template TSchema - Optional StandardSchema for type-safe event data\n */\nexport class EventType<\n  TName extends string,\n  TSchema extends StandardSchemaV1<Record<string, unknown>> | undefined,\n> {\n  /**\n   * The event name. This is the same as the `name` property, but is necessary\n   * to make the event type compatible with other features (e.g. event\n   * triggers).\n   */\n  readonly event: TName;\n\n  readonly name: TName;\n  schema: TSchema;\n  version?: string;\n\n  constructor({\n    name,\n    schema,\n    version,\n  }: {\n    name: TName;\n    schema: TSchema;\n    version?: string;\n  }) {\n    this.event = name;\n    this.name = name;\n    this.schema = schema;\n    this.version = version;\n  }\n\n  /**\n   * Creates an event to send.\n   *\n   * The returned event object includes a `validate()` method that can be called\n   * to validate the event data against the schema (if one was provided). The\n   * `validate()` method returns a new event object with the validated data,\n   * including any transforms defined in the schema.\n   *\n   * Validation is not performed within this method because validation may be async.\n   *\n   * @param data - Event data (required if schema is defined, optional otherwise)\n   * @param options - Optional event options including id, timestamp, and version\n   */\n  create(\n    ...args: EventCreateArgs<TSchema>\n  ): UnvalidatedCreatedEvent<TName, ExtractSchemaData<TSchema>> {\n    const [data, options] = args;\n    const event: UnvalidatedCreatedEvent<TName, ExtractSchemaData<TSchema>> = {\n      name: this.name,\n      data: data as ExtractSchemaData<TSchema>,\n      id: options?.id,\n      ts: options?.ts,\n      v: options?.v ?? this.version,\n\n      // Method for validating and transforming the event data against the\n      // schema\n      validate: async (): Promise<void> => {\n        if (this.schema) {\n          // Only perform validation if a schema was provided\n\n          if (!data) {\n            throw new Error(\"data is required\");\n          }\n\n          const check = await this.schema[\"~standard\"].validate(data);\n          if (check.issues) {\n            throw new Error(\n              check.issues\n                .map((issue) => {\n                  if (issue.path && issue.path.length > 0) {\n                    return `${issue.path.join(\".\")}: ${issue.message}`;\n                  }\n                  return issue.message;\n                })\n                .join(\", \"),\n            );\n          }\n        }\n      },\n    };\n\n    return event;\n  }\n}\n\n/**\n * This type's only purpose is to clearly highlight static type error messages\n * in our codebase. To end users, it's exactly the same as a normal string.\n */\ntype StaticTypeError<TMessage extends string> = TMessage;\n\n/**\n * Ensure that users don't use transforms in their schemas, since we don't\n * support transforms.\n */\ntype AssertNoTransform<TSchema extends StandardSchemaV1 | undefined> =\n  TSchema extends undefined\n    ? // Undefined schema is OK\n      undefined\n    : TSchema extends StandardSchemaV1<infer TInput, infer TOutput>\n      ? // Wrap in tuples to prevent distributive conditional over union types. This ensures that the schema can be a union.\n        [TInput] extends [TOutput]\n        ? // Input and output schemas match, so we're good\n          TSchema\n        : // Return an error message since the input and output schemas don't match\n          StaticTypeError<\"Transforms not supported: schema input/output types must match\">\n      : // Return an error message since the schema is not a StandardSchemaV1\n        StaticTypeError<\"Transforms not supported: schema input/output types must match\">;\n\n/**\n * Create an event type definition that can be used as a trigger and for\n * creating events.\n *\n * This is the primary way to define typed events in Inngest. It creates an\n * EventType instance that provides type safety and optional runtime validation.\n *\n * @param name - The event name (e.g., \"user.created\")\n * @param options - Optional options for the event type\n * @param options.schema - Optional StandardSchema for type-safe event data validation\n * @param options.version - Optional version of the event\n * @returns EventType instance that can be used as a trigger or for creating events\n */\nexport function eventType<\n  TName extends string,\n  TSchema extends\n    | StandardSchemaV1<Record<string, unknown>>\n    | undefined = undefined,\n>(\n  name: TName,\n  {\n    schema,\n    version,\n  }: {\n    schema?: AssertNoTransform<TSchema>;\n    version?: string;\n  } = {},\n): EventType<TName, TSchema> {\n  return new EventType<TName, TSchema>({\n    name,\n    schema: schema as TSchema,\n    version,\n  });\n}\n\n/**\n * Create a type-only schema that provides TypeScript types without runtime\n * validation. Returns a hardcoded StandardSchemaV1 whose `validate` is a\n * passthrough, so invalid data will not be rejected at runtime. Use this when\n * you want event type safety without pulling in a validation library like Zod.\n */\nexport function staticSchema<\n  TSchema extends Record<string, unknown>,\n>(): StandardSchemaV1<TSchema> {\n  return {\n    \"~standard\": {\n      version: 1,\n      vendor: \"inngest\",\n      validate: (value) => ({ value: value as TSchema }),\n    },\n  };\n}\n\n/**\n * Create an invoke trigger for function-to-function calls.\n *\n * This creates a trigger that allows your function to be invoked directly by\n * other functions using `step.invoke()`. The schema defines the expected data\n * structure for invocations.\n *\n * @param schema - StandardSchema defining the invoke payload structure\n * @returns Invoke trigger\n */\nexport function invoke<TData extends Record<string, unknown>>(\n  schema: StandardSchemaV1<TData>,\n) {\n  return new EventType({\n    name: \"inngest/function.invoked\",\n    schema,\n  });\n}\n"],"mappings":";;;;;;;;AAuCA,SAAgB,KAAuB,UAAa;AAClD,QAAO,EACL,MAAM,UACP;;;;;;;;;AAsEH,IAAa,YAAb,MAGE;;;;;;CAMA,AAAS;CAET,AAAS;CACT;CACA;CAEA,YAAY,EACV,MACA,QACA,WAKC;AACD,OAAK,QAAQ;AACb,OAAK,OAAO;AACZ,OAAK,SAAS;AACd,OAAK,UAAU;;;;;;;;;;;;;;;CAgBjB,OACE,GAAG,MACyD;EAC5D,MAAM,CAAC,MAAM,WAAW;AAmCxB,SAlC0E;GACxE,MAAM,KAAK;GACL;GACN,IAAI,SAAS;GACb,IAAI,SAAS;GACb,GAAG,SAAS,KAAK,KAAK;GAItB,UAAU,YAA2B;AACnC,QAAI,KAAK,QAAQ;AAGf,SAAI,CAAC,KACH,OAAM,IAAI,MAAM,mBAAmB;KAGrC,MAAM,QAAQ,MAAM,KAAK,OAAO,aAAa,SAAS,KAAK;AAC3D,SAAI,MAAM,OACR,OAAM,IAAI,MACR,MAAM,OACH,KAAK,UAAU;AACd,UAAI,MAAM,QAAQ,MAAM,KAAK,SAAS,EACpC,QAAO,GAAG,MAAM,KAAK,KAAK,IAAI,CAAC,IAAI,MAAM;AAE3C,aAAO,MAAM;OACb,CACD,KAAK,KAAK,CACd;;;GAIR;;;;;;;;;;;;;;;;AA2CL,SAAgB,UAMd,MACA,EACE,QACA,YAIE,EAAE,EACqB;AAC3B,QAAO,IAAI,UAA0B;EACnC;EACQ;EACR;EACD,CAAC;;;;;;;;AASJ,SAAgB,eAEe;AAC7B,QAAO,EACL,aAAa;EACX,SAAS;EACT,QAAQ;EACR,WAAW,WAAW,EAAS,OAAkB;EAClD,EACF;;;;;;;;;;;;AAaH,SAAgB,OACd,QACA;AACA,QAAO,IAAI,UAAU;EACnB,MAAM;EACN;EACD,CAAC"}