@tailor-platform/sdk 2.0.0-next.2 → 2.0.0-next.4

package/dist/configure/services/auth/index.d.mts

@@ -0,0 +1,34 @@
+import { DefinedFieldMetadata, FieldMetadata, TailorField, TailorFieldType } from "../../types/field.types.mjs";
+import { AuthConnectionConfig, AuthConnectionOAuth2Config } from "../../../types/auth-connection.generated.mjs";
+import { BuiltinIdP, IDToken, IdProvider, OAuth2ClientInput, OIDC, SAML, SCIMAttribute, SCIMAttributeMapping, SCIMAuthorization, SCIMConfig, SCIMResource, TenantProvider } from "../../../types/auth.generated.mjs";
+import { AuthConfig, AuthConnectionTokenResult, AuthExternalConfig, AuthOwnConfig, AuthServiceInput, BeforeLoginClaims, BeforeLoginHookArgs, DefinedAuth, FederatedIdentity, FederatedIdentityClaims, FederatedIdentityProvider, OAuth2ClientGrantType, SCIMAttributeType, UserAttributeKey, UserAttributeListKey, UserAttributes, UsernameFieldKey, ValueOperand } from "./types.mjs";
+import { TailorDBInstance } from "../tailordb/schema.mjs";
+
+//#region src/configure/services/auth/index.d.ts
+type MachineUserAttributeFields = Record<string, TailorField<DefinedFieldMetadata, unknown, FieldMetadata, TailorFieldType>>;
+type PlaceholderUser = TailorDBInstance<Record<string, never>, Record<string, never>>;
+type PlaceholderAttributes = UserAttributes<PlaceholderUser>;
+type PlaceholderAttributeList = UserAttributeListKey<PlaceholderUser>[];
+type UserProfileAuthInput<User extends TailorDBInstance, Attributes extends UserAttributes<User>, AttributeList extends UserAttributeListKey<User>[], MachineUserNames extends string, ConnectionNames extends string = string> = Omit<AuthServiceInput<User, Attributes, AttributeList, MachineUserNames, undefined, ConnectionNames>, "userProfile" | "machineUserAttributes"> & {
+  userProfile: NonNullable<AuthServiceInput<User, Attributes, AttributeList, MachineUserNames, undefined>["userProfile"]>;
+  machineUserAttributes?: never;
+};
+type MachineUserOnlyAuthInput<MachineUserNames extends string, MachineUserAttributes extends MachineUserAttributeFields, ConnectionNames extends string = string> = Omit<AuthServiceInput<PlaceholderUser, PlaceholderAttributes, PlaceholderAttributeList, MachineUserNames, MachineUserAttributes, ConnectionNames>, "userProfile" | "machineUserAttributes"> & {
+  userProfile?: never;
+  machineUserAttributes: MachineUserAttributes;
+};
+/**
+ * Define an auth service for the Tailor SDK.
+ * @template Name
+ * @template User
+ * @template Attributes
+ * @template AttributeList
+ * @template MachineUserNames
+ * @param name - Auth service name
+ * @param config - Auth service configuration
+ * @returns Defined auth service
+ */
+declare function defineAuth<const Name extends string, const User extends TailorDBInstance, const Attributes extends UserAttributes<User>, const AttributeList extends UserAttributeListKey<User>[], const MachineUserNames extends string, const ConnectionNames extends string = string>(name: Name, config: UserProfileAuthInput<User, Attributes, AttributeList, MachineUserNames, ConnectionNames>): DefinedAuth<Name, UserProfileAuthInput<User, Attributes, AttributeList, MachineUserNames, ConnectionNames>>;
+declare function defineAuth<const Name extends string, const MachineUserAttributes extends MachineUserAttributeFields, const MachineUserNames extends string, const ConnectionNames extends string = string>(name: Name, config: MachineUserOnlyAuthInput<MachineUserNames, MachineUserAttributes, ConnectionNames>): DefinedAuth<Name, MachineUserOnlyAuthInput<MachineUserNames, MachineUserAttributes, ConnectionNames>>;
+//#endregion
+export { type AuthConfig, type AuthConnectionConfig, type AuthConnectionOAuth2Config, type AuthConnectionTokenResult, type AuthExternalConfig, type AuthOwnConfig, type AuthServiceInput, type BeforeLoginClaims, type BeforeLoginHookArgs, type BuiltinIdP, type DefinedAuth, type FederatedIdentity, type FederatedIdentityClaims, type FederatedIdentityProvider, type IDToken, type IdProvider as IdProviderConfig, type OAuth2ClientInput as OAuth2Client, type OAuth2ClientGrantType, type OIDC, type SAML, type SCIMAttribute, type SCIMAttributeMapping, type SCIMAttributeType, type SCIMAuthorization, type SCIMConfig, type SCIMResource, type TenantProvider as TenantProviderConfig, type UserAttributeKey, type UserAttributeListKey, type UserAttributes, type UsernameFieldKey, type ValueOperand, defineAuth };

package/dist/configure/services/auth/types.d.mts

@@ -0,0 +1,172 @@
+import { TailorEnv } from "../../../runtime/types.mjs";
+import { output } from "../../../types/helpers.mjs";
+import { DefinedFieldMetadata, FieldMetadata, TailorField, TailorFieldType } from "../../types/field.types.mjs";
+import { TailorDBInstance } from "../tailordb/types.mjs";
+import { AuthConnectionConfig } from "../../../types/auth-connection.generated.mjs";
+import { IdProvider, OAuth2Client, OAuth2ClientInput, SCIMAttribute, SCIMConfig, TenantProvider } from "../../../types/auth.generated.mjs";
+import { IsAny, JsonObject, JsonValue } from "type-fest";
+
+//#region src/configure/services/auth/types.d.ts
+type OAuth2ClientGrantType = OAuth2Client["grantTypes"][number];
+type SCIMAttributeType = SCIMAttribute["type"];
+interface MachineUserNameRegistry {}
+/**
+ * Machine user name.
+ *
+ * When `tailor.d.ts` is generated (via `tailor deploy`/`generate`), this is narrowed
+ * to the union of defined machine user names. When no machine users are registered yet,
+ * falls back to `string` to avoid blocking editing before the first generate run.
+ */
+type MachineUserName = keyof MachineUserNameRegistry extends never ? string : keyof MachineUserNameRegistry & string;
+/** Result of retrieving a connection token at runtime. */
+type AuthConnectionTokenResult = {
+  access_token: string;
+};
+type ValueOperand = string | boolean | string[] | boolean[];
+type AuthAttributeValue = ValueOperand | null | undefined;
+type UserFieldKeys<User extends TailorDBInstance> = keyof output<User> & string;
+type FieldDefined<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = User["fields"][Key] extends {
+  _defined: infer Defined;
+} ? Defined : never;
+type FieldOutput<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = output<User>[Key];
+type FieldIsRequired<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = undefined extends FieldOutput<User, Key> ? false : true;
+type FieldIsOfType<User extends TailorDBInstance, Key extends UserFieldKeys<User>, Type extends string> = FieldDefined<User, Key> extends {
+  type: Type;
+} ? true : false;
+type FieldIsArray<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = FieldDefined<User, Key> extends {
+  array: true;
+} ? true : false;
+type FieldIsUnique<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = FieldDefined<User, Key> extends {
+  unique: true;
+} ? true : false;
+type FieldSupportsValueOperand<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = FieldOutput<User, Key> extends ValueOperand | null | undefined ? true : false;
+type UsernameFieldKey<User extends TailorDBInstance> = IsAny<User> extends true ? string : { [K in UserFieldKeys<User>]: FieldIsRequired<User, K> extends true ? FieldIsOfType<User, K, "string"> extends true ? FieldIsArray<User, K> extends true ? never : FieldIsUnique<User, K> extends true ? K : never : never : never }[UserFieldKeys<User>];
+type UserAttributeKey<User extends TailorDBInstance> = { [K in UserFieldKeys<User>]: K extends "id" ? never : FieldSupportsValueOperand<User, K> extends true ? FieldIsOfType<User, K, "datetime" | "date" | "time"> extends true ? never : K : never }[UserFieldKeys<User>];
+type UserAttributeListKey<User extends TailorDBInstance> = { [K in UserFieldKeys<User>]: K extends "id" ? never : FieldIsOfType<User, K, "uuid"> extends true ? FieldIsArray<User, K> extends true ? never : K : never }[UserFieldKeys<User>];
+type UserAttributes<User extends TailorDBInstance> = { [K in UserAttributeKey<User>]?: true };
+type DisallowExtraKeys<T, Allowed extends PropertyKey> = T & { [K in Exclude<keyof T, Allowed>]: never };
+type AttributeListValue<User extends TailorDBInstance, Key extends UserAttributeListKey<User>> = Key extends keyof output<User> ? output<User>[Key] : never;
+type AttributeListToTuple<User extends TailorDBInstance, AttributeList extends readonly UserAttributeListKey<User>[]> = { [Index in keyof AttributeList]: AttributeList[Index] extends UserAttributeListKey<User> ? AttributeListValue<User, AttributeList[Index]> : never };
+type SelectedAttributeKeys<User extends TailorDBInstance, Attributes extends UserAttributes<User>> = Extract<{ [K in keyof Attributes]-?: undefined extends Attributes[K] ? never : K }[keyof Attributes], UserAttributeKey<User>>;
+type UserProfile<User extends TailorDBInstance, Attributes extends UserAttributes<User>, AttributeList extends UserAttributeListKey<User>[]> = {
+  /**
+   * TailorDB namespace where the user type is defined.
+   *
+   * Usually auto-resolved, so you don't need to specify this.
+   * Required only when multiple TailorDBs exist and the type is in an external TailorDB.
+   */
+  namespace?: string;
+  type: User;
+  usernameField: UsernameFieldKey<User>;
+  attributes?: DisallowExtraKeys<Attributes, UserAttributeKey<User>>;
+  attributeList?: AttributeList;
+};
+type MachineUserAttributeFields = Record<string, TailorField<DefinedFieldMetadata, unknown, FieldMetadata, TailorFieldType>>;
+type TailorFieldOutputValue<Field> = Field extends TailorField<DefinedFieldMetadata, infer Output, FieldMetadata, TailorFieldType> ? Output : never;
+type MachineUserAttributeValues<Fields extends MachineUserAttributeFields> = { [K in keyof Fields]: TailorFieldOutputValue<Fields[K]> extends ValueOperand | null | undefined ? TailorFieldOutputValue<Fields[K]> : never };
+type MachineUserFromAttributes<Fields extends MachineUserAttributeFields> = (keyof Fields extends never ? {
+  attributes?: never;
+} : {
+  attributes: DisallowExtraKeys<MachineUserAttributeValues<Fields>, keyof Fields>;
+}) & {
+  attributeList?: string[];
+};
+type MachineUser<User extends TailorDBInstance, Attributes extends UserAttributes<User> = UserAttributes<User>, AttributeList extends UserAttributeListKey<User>[] = [], MachineUserAttributes extends MachineUserAttributeFields | undefined = undefined> = IsAny<MachineUserAttributes> extends true ? IsAny<User> extends true ? {
+  attributes: Record<string, AuthAttributeValue>;
+  attributeList?: string[];
+} : (SelectedAttributeKeys<User, Attributes> extends never ? {
+  attributes?: never;
+} : {
+  attributes: { [K in SelectedAttributeKeys<User, Attributes>]: K extends keyof output<User> ? output<User>[K] : never } & { [K in Exclude<keyof output<User>, SelectedAttributeKeys<User, Attributes>>]?: never };
+}) & ([] extends AttributeList ? {
+  attributeList?: never;
+} : {
+  attributeList: AttributeListToTuple<User, AttributeList>;
+}) : [MachineUserAttributes] extends [MachineUserAttributeFields] ? MachineUserFromAttributes<MachineUserAttributes> : IsAny<User> extends true ? {
+  attributes: Record<string, AuthAttributeValue>;
+  attributeList?: string[];
+} : (SelectedAttributeKeys<User, Attributes> extends never ? {
+  attributes?: never;
+} : {
+  attributes: { [K in SelectedAttributeKeys<User, Attributes>]: K extends keyof output<User> ? output<User>[K] : never } & { [K in Exclude<keyof output<User>, SelectedAttributeKeys<User, Attributes>>]?: never };
+}) & ([] extends AttributeList ? {
+  attributeList?: never;
+} : {
+  attributeList: AttributeListToTuple<User, AttributeList>;
+});
+/** Upstream OAuth provider that federated a login through the Built-in IdP. */
+type FederatedIdentityProvider = "google" | "microsoft";
+/**
+ * Profile claims forwarded from the upstream OAuth provider's ID token.
+ *
+ * Commonly present claims are typed; any other claim the provider issues is
+ * forwarded as-is and reachable through the index signature. Availability
+ * varies by provider (e.g. Microsoft does not issue `picture`).
+ */
+type FederatedIdentityClaims = {
+  name?: string;
+  given_name?: string;
+  family_name?: string;
+  picture?: string;
+  locale?: string;
+  [claim: string]: JsonValue | undefined;
+};
+/**
+ * The upstream identity that federated this login, populated when a user signs
+ * in through a Built-in IdP OAuth provider (Google or Microsoft).
+ *
+ * Available on {@link BeforeLoginClaims.federated_identity}; `undefined` for
+ * password logins.
+ */
+type FederatedIdentity = {
+  provider: FederatedIdentityProvider;
+  claims: FederatedIdentityClaims;
+};
+/**
+ * Token claims passed to the {@link BeforeLoginHook} handler. Carries the IdP's
+ * own claims (e.g. `sub`, `email`) plus, for federated logins, the upstream
+ * provider's profile under {@link BeforeLoginClaims.federated_identity}.
+ */
+type BeforeLoginClaims = JsonObject & {
+  /** Present only for federated (Google/Microsoft) logins; `undefined` for password logins. */federated_identity?: FederatedIdentity;
+};
+type BeforeLoginHookArgs = {
+  claims: BeforeLoginClaims;
+  idpConfigName: string; /** Environment variables defined in `defineConfig({ env })`. */
+  env: TailorEnv;
+};
+type BeforeLoginHook<MachineUserNames extends string> = {
+  handler(args: BeforeLoginHookArgs): Promise<void>;
+  invoker: NoInfer<MachineUserNames>;
+};
+type AuthHooks<MachineUserNames extends string> = {
+  beforeLogin?: BeforeLoginHook<MachineUserNames>;
+};
+type AuthServiceInput<User extends TailorDBInstance, Attributes extends UserAttributes<User>, AttributeList extends UserAttributeListKey<User>[], MachineUserNames extends string, MachineUserAttributes extends MachineUserAttributeFields | undefined = MachineUserAttributeFields | undefined, ConnectionNames extends string = string> = {
+  hooks?: AuthHooks<MachineUserNames>;
+  userProfile?: UserProfile<User, Attributes, AttributeList>;
+  machineUserAttributes?: MachineUserAttributes;
+  machineUsers?: Record<MachineUserNames, MachineUser<User, Attributes, AttributeList, MachineUserAttributes>>;
+  oauth2Clients?: Record<string, OAuth2ClientInput>;
+  idProvider?: IdProvider;
+  scim?: SCIMConfig;
+  tenantProvider?: TenantProvider;
+  connections?: Record<ConnectionNames, AuthConnectionConfig>;
+  publishSessionEvents?: boolean;
+};
+declare const authDefinitionBrand: unique symbol;
+type AuthDefinitionBrand = {
+  readonly [authDefinitionBrand]: true;
+};
+type DefinedAuth<Name extends string, Config> = Config & {
+  name: Name;
+} & AuthDefinitionBrand;
+type AuthExternalConfig = {
+  name: string;
+  external: true;
+};
+type AuthServiceInputLoose = AuthServiceInput<any, any, any, string, any>;
+type AuthOwnConfig = DefinedAuth<string, AuthServiceInputLoose>;
+type AuthConfig = AuthOwnConfig | AuthExternalConfig;
+//#endregion
+export { AuthAttributeValue, AuthConfig, AuthConnectionTokenResult, AuthDefinitionBrand, AuthExternalConfig, AuthHooks, AuthOwnConfig, AuthServiceInput, BeforeLoginClaims, BeforeLoginHook, BeforeLoginHookArgs, DefinedAuth, FederatedIdentity, FederatedIdentityClaims, FederatedIdentityProvider, MachineUserName, MachineUserNameRegistry, OAuth2ClientGrantType, SCIMAttributeType, UserAttributeKey, UserAttributeListKey, UserAttributes, UsernameFieldKey, ValueOperand };

package/dist/configure/services/executor/executor.d.mts

@@ -0,0 +1,81 @@
+import { MachineUserName } from "../auth/types.mjs";
+import { ExecutorInput } from "../../../types/executor.generated.mjs";
+import { Workflow } from "../workflow/workflow.mjs";
+import { Operation } from "./operation.mjs";
+import { Trigger } from "./trigger/index.mjs";
+
+//#region src/configure/services/executor/executor.d.ts
+/**
+ * Extract mainJob's Input type from Workflow.
+ */
+type WorkflowInput<W extends Workflow> = Parameters<W["trigger"]>[0];
+type TriggerArgs<T extends Trigger<unknown>> = T extends {
+  __args: infer Args;
+} ? Args : never;
+type ExecutorBase<T extends Trigger<unknown>> = Omit<ExecutorInput, "trigger" | "operation"> & {
+  trigger: T;
+};
+/**
+ * Executor type with conditional inference for workflow operations.
+ * When operation.kind is "workflow", infers W from the workflow property
+ * to ensure args type matches the workflow's mainJob input type.
+ */
+type Executor<T extends Trigger<unknown>, O> = O extends {
+  kind: "workflow";
+  workflow: infer W extends Workflow;
+} ? ExecutorBase<T> & {
+  operation: {
+    kind: "workflow";
+    workflow: W;
+    args?: WorkflowInput<W> | ((args: TriggerArgs<T>) => WorkflowInput<W>);
+    invoker?: MachineUserName;
+  };
+} : ExecutorBase<T> & {
+  operation: O;
+};
+/**
+ * Create an executor configuration for the Tailor SDK.
+ *
+ * Executors are event-driven handlers that respond to record changes,
+ * resolver executions, or other events.
+ *
+ * Operation kinds: "function", "graphql", "webhook", "workflow".
+ * @template T
+ * @template O
+ * @param config - Executor configuration
+ * @returns The same executor configuration
+ * @example
+ * import { createExecutor, recordCreatedTrigger } from "@tailor-platform/sdk";
+ * import { order } from "../tailordb/order";
+ *
+ * export default createExecutor({
+ *   name: "order-created",
+ *   description: "Handles new order creation",
+ *   trigger: recordCreatedTrigger({ type: order }),
+ *   operation: {
+ *     kind: "function",
+ *     body: async ({ newRecord }) => {
+ *       console.log("New order:", newRecord.id);
+ *     },
+ *   },
+ * });
+ */
+declare function createExecutor<T extends Trigger<unknown>, O extends Operation<TriggerArgs<T>> | {
+  kind: "workflow";
+  workflow: Workflow;
+}>(config: Executor<T, O>): Executor<T, O>;
+/**
+ * Create an executor configuration for the Tailor SDK.
+ * This overload preserves source compatibility for legacy explicit generic calls,
+ * where the first generic argument represents trigger args.
+ * @template Args
+ * @template O
+ * @param config - Executor configuration
+ * @returns The same executor configuration
+ */
+declare function createExecutor<Args, O extends Operation<Args> | {
+  kind: "workflow";
+  workflow: Workflow;
+}>(config: Executor<Trigger<Args>, O>): Executor<Trigger<Args>, O>;
+//#endregion
+export { createExecutor };

package/dist/configure/services/executor/index.d.mts

@@ -0,0 +1,8 @@
+import { ExecutorServiceConfig, ExecutorServiceInput } from "../../config/types.mjs";
+import { FunctionOperation, GqlOperation, Operation, WebhookOperation, WorkflowOperation } from "./operation.mjs";
+import { AuthAccessTokenArgs, AuthAccessTokenIssuedArgs, AuthAccessTokenRefreshedArgs, AuthAccessTokenRevokedArgs, AuthAccessTokenTrigger, IdpUserArgs, IdpUserCreatedArgs, IdpUserDeletedArgs, IdpUserTrigger, IdpUserUpdatedArgs, RecordCreatedArgs, RecordDeletedArgs, RecordUpdatedArgs, ResolverExecutedArgs, ResolverExecutedTrigger, TailorDBTrigger, authAccessTokenIssuedTrigger, authAccessTokenRefreshedTrigger, authAccessTokenRevokedTrigger, authAccessTokenTrigger, idpUserCreatedTrigger, idpUserDeletedTrigger, idpUserTrigger, idpUserUpdatedTrigger, recordCreatedTrigger, recordDeletedTrigger, recordTrigger, recordUpdatedTrigger, resolverExecutedTrigger } from "./trigger/event.mjs";
+import { ScheduleArgs, ScheduleTrigger, scheduleTrigger } from "./trigger/schedule.mjs";
+import { IncomingWebhookArgs, IncomingWebhookRequest, IncomingWebhookResponse, IncomingWebhookResponseConfig, IncomingWebhookTrigger, IncomingWebhookTriggerOptions, incomingWebhookTrigger } from "./trigger/webhook.mjs";
+import { Trigger } from "./trigger/index.mjs";
+import { createExecutor } from "./executor.mjs";
+export { AuthAccessTokenArgs, AuthAccessTokenIssuedArgs, AuthAccessTokenRefreshedArgs, AuthAccessTokenRevokedArgs, AuthAccessTokenTrigger, type ExecutorServiceConfig, type ExecutorServiceInput, FunctionOperation, GqlOperation, IdpUserArgs, IdpUserCreatedArgs, IdpUserDeletedArgs, IdpUserTrigger, IdpUserUpdatedArgs, IncomingWebhookArgs, IncomingWebhookRequest, IncomingWebhookResponse, IncomingWebhookResponseConfig, IncomingWebhookTrigger, IncomingWebhookTriggerOptions, Operation, RecordCreatedArgs, RecordDeletedArgs, RecordUpdatedArgs, ResolverExecutedArgs, ResolverExecutedTrigger, ScheduleArgs, ScheduleTrigger, TailorDBTrigger, Trigger, WebhookOperation, WorkflowOperation, authAccessTokenIssuedTrigger, authAccessTokenRefreshedTrigger, authAccessTokenRevokedTrigger, authAccessTokenTrigger, createExecutor, idpUserCreatedTrigger, idpUserDeletedTrigger, idpUserTrigger, idpUserUpdatedTrigger, incomingWebhookTrigger, recordCreatedTrigger, recordDeletedTrigger, recordTrigger, recordUpdatedTrigger, resolverExecutedTrigger, scheduleTrigger };

package/dist/configure/services/executor/operation.d.mts

@@ -0,0 +1,45 @@
+import { TailorPrincipal } from "../../../runtime/types.mjs";
+import { MachineUserName } from "../auth/types.mjs";
+import { FunctionOperation as FunctionOperation$1, GqlOperation as GqlOperation$1, WebhookOperation as WebhookOperation$1, WorkflowOperation as WorkflowOperation$1 } from "../../../types/executor.generated.mjs";
+import { Workflow } from "../workflow/workflow.mjs";
+import { Client } from "@urql/core";
+
+//#region src/configure/services/executor/operation.d.ts
+/** Function-based executor operation. The body receives the trigger args and the `invoker`. */
+type FunctionOperation<Args> = Omit<FunctionOperation$1, "body" | "invoker"> & {
+  body: (args: Args & {
+    invoker: TailorPrincipal | null;
+  }) => void | Promise<void>;
+  invoker?: MachineUserName;
+};
+type UrqlOperationArgs = Parameters<Client["query"] | Client["mutation"]>;
+/** GraphQL-based executor operation. Executes a GraphQL query or mutation. */
+type GqlOperation<Args> = Omit<GqlOperation$1, "query" | "variables" | "invoker"> & {
+  query: UrqlOperationArgs[0];
+  variables?: (args: Args) => UrqlOperationArgs[1];
+  invoker?: MachineUserName;
+};
+type RequestHeader = "A-IM" | "Accept" | "Accept-Additions" | "Accept-CH" | "Accept-Charset" | "Accept-Datetime" | "Accept-Encoding" | "Accept-Features" | "Accept-Language" | "Accept-Patch" | "Accept-Post" | "Accept-Ranges" | "Accept-Signature" | "Access-Control" | "Access-Control-Allow-Credentials" | "Access-Control-Allow-Headers" | "Access-Control-Allow-Methods" | "Access-Control-Allow-Origin" | "Access-Control-Expose-Headers" | "Access-Control-Max-Age" | "Access-Control-Request-Headers" | "Access-Control-Request-Method" | "Age" | "Allow" | "ALPN" | "Alt-Svc" | "Alt-Used" | "Alternates" | "AMP-Cache-Transform" | "Apply-To-Redirect-Ref" | "Authentication-Control" | "Authentication-Info" | "Authorization" | "Available-Dictionary" | "C-Ext" | "C-Man" | "C-Opt" | "C-PEP" | "C-PEP-Info" | "Cache-Control" | "Cache-Status" | "Cal-Managed-ID" | "CalDAV-Timezones" | "Capsule-Protocol" | "CDN-Cache-Control" | "CDN-Loop" | "Cert-Not-After" | "Cert-Not-Before" | "Clear-Site-Data" | "Client-Cert" | "Client-Cert-Chain" | "Close" | "CMCD-Object" | "CMCD-Request" | "CMCD-Session" | "CMCD-Status" | "CMSD-Dynamic" | "CMSD-Static" | "Concealed-Auth-Export" | "Configuration-Context" | "Connection" | "Content-Base" | "Content-Digest" | "Content-Disposition" | "Content-Encoding" | "Content-ID" | "Content-Language" | "Content-Length" | "Content-Location" | "Content-MD5" | "Content-Range" | "Content-Script-Type" | "Content-Security-Policy" | "Content-Security-Policy-Report-Only" | "Content-Style-Type" | "Content-Type" | "Content-Version" | "Cookie" | "Cookie2" | "Cross-Origin-Embedder-Policy" | "Cross-Origin-Embedder-Policy-Report-Only" | "Cross-Origin-Opener-Policy" | "Cross-Origin-Opener-Policy-Report-Only" | "Cross-Origin-Resource-Policy" | "CTA-Common-Access-Token" | "DASL" | "Date" | "DAV" | "Default-Style" | "Delta-Base" | "Deprecation" | "Depth" | "Derived-From" | "Destination" | "Differential-ID" | "Dictionary-ID" | "Digest" | "DPoP" | "DPoP-Nonce" | "Early-Data" | "EDIINT-Features" | "ETag" | "Expect" | "Expect-CT" | "Expires" | "Ext" | "Forwarded" | "From" | "GetProfile" | "Hobareg" | "Host" | "HTTP2-Settings" | "If" | "If-Match" | "If-Modified-Since" | "If-None-Match" | "If-Range" | "If-Schedule-Tag-Match" | "If-Unmodified-Since" | "IM" | "Include-Referred-Token-Binding-ID" | "Isolation" | "Keep-Alive" | "Label" | "Last-Event-ID" | "Last-Modified" | "Link" | "Link-Template" | "Location" | "Lock-Token" | "Man" | "Max-Forwards" | "Memento-Datetime" | "Meter" | "Method-Check" | "Method-Check-Expires" | "MIME-Version" | "Negotiate" | "NEL" | "OData-EntityId" | "OData-Isolation" | "OData-MaxVersion" | "OData-Version" | "Opt" | "Optional-WWW-Authenticate" | "Ordering-Type" | "Origin" | "Origin-Agent-Cluster" | "OSCORE" | "OSLC-Core-Version" | "Overwrite" | "P3P" | "PEP" | "PEP-Info" | "Permissions-Policy" | "PICS-Label" | "Ping-From" | "Ping-To" | "Position" | "Pragma" | "Prefer" | "Preference-Applied" | "Priority" | "ProfileObject" | "Protocol" | "Protocol-Info" | "Protocol-Query" | "Protocol-Request" | "Proxy-Authenticate" | "Proxy-Authentication-Info" | "Proxy-Authorization" | "Proxy-Features" | "Proxy-Instruction" | "Proxy-Status" | "Public" | "Public-Key-Pins" | "Public-Key-Pins-Report-Only" | "Range" | "Redirect-Ref" | "Referer" | "Referer-Root" | "Referrer-Policy" | "Refresh" | "Repeatability-Client-ID" | "Repeatability-First-Sent" | "Repeatability-Request-ID" | "Repeatability-Result" | "Replay-Nonce" | "Reporting-Endpoints" | "Repr-Digest" | "Retry-After" | "Safe" | "Schedule-Reply" | "Schedule-Tag" | "Sec-GPC" | "Sec-Purpose" | "Sec-Token-Binding" | "Sec-WebSocket-Accept" | "Sec-WebSocket-Extensions" | "Sec-WebSocket-Key" | "Sec-WebSocket-Protocol" | "Sec-WebSocket-Version" | "Security-Scheme" | "Server" | "Server-Timing" | "Set-Cookie" | "Set-Cookie2" | "SetProfile" | "Signature" | "Signature-Input" | "SLUG" | "SoapAction" | "Status-URI" | "Strict-Transport-Security" | "Sunset" | "Surrogate-Capability" | "Surrogate-Control" | "TCN" | "TE" | "Timeout" | "Timing-Allow-Origin" | "Topic" | "Traceparent" | "Tracestate" | "Trailer" | "Transfer-Encoding" | "TTL" | "Upgrade" | "Urgency" | "URI" | "Use-As-Dictionary" | "User-Agent" | "Variant-Vary" | "Vary" | "Via" | "Want-Content-Digest" | "Want-Digest" | "Want-Repr-Digest" | "Warning" | "WWW-Authenticate" | "X-Content-Type-Options" | "X-Frame-Options" | (string & {});
+/** Outbound webhook executor operation. Sends HTTP requests to external URLs. */
+type WebhookOperation<Args> = Omit<WebhookOperation$1, "url" | "requestBody" | "headers"> & {
+  url: (args: Args) => string;
+  requestBody?: (args: Args) => Record<string, unknown>;
+  headers?: { [key in RequestHeader]?: string | {
+    vault: string;
+    key: string;
+  } };
+};
+/**
+ * Extract mainJob's Input type from Workflow.
+ * Workflow<Job> -> Job is WorkflowJob<Name, Input, Output> -> Input
+ */
+type WorkflowInput<W extends Workflow> = Parameters<W["trigger"]>[0];
+/** Workflow-triggering executor operation. Triggers a workflow in response to an event. */
+type WorkflowOperation<Args, W extends Workflow = Workflow> = Omit<WorkflowOperation$1, "workflowName" | "args" | "invoker"> & {
+  workflow: W;
+  args?: WorkflowInput<W> | ((args: Args) => WorkflowInput<W>);
+  invoker?: MachineUserName;
+};
+type Operation<Args> = FunctionOperation<Args> | GqlOperation<Args> | WebhookOperation<Args> | WorkflowOperation<Args>;
+//#endregion
+export { FunctionOperation, GqlOperation, Operation, WebhookOperation, WorkflowOperation };

package/dist/configure/services/executor/trigger/event.d.mts

@@ -0,0 +1,272 @@
+import { TailorEnv, TailorPrincipal } from "../../../../runtime/types.mjs";
+import { output } from "../../../../types/helpers.mjs";
+import { AuthAccessTokenTrigger as AuthAccessTokenTrigger$1, IdpUserTrigger as IdpUserTrigger$1, ResolverExecutedTrigger as ResolverExecutedTrigger$1, TailorDBTrigger as TailorDBTrigger$1 } from "../../../../types/executor.generated.mjs";
+import { TailorDBType } from "../../tailordb/schema.mjs";
+import { IdpName } from "../../../types/idp-name.mjs";
+import { ResolverConfig } from "../../resolver/resolver.mjs";
+
+//#region src/configure/services/executor/trigger/event.d.ts
+interface EventArgs {
+  workspaceId: string;
+  appNamespace: string;
+  env: TailorEnv;
+  actor: TailorPrincipal | null;
+}
+interface RecordArgs extends EventArgs {
+  typeName: string;
+}
+interface RecordCreatedArgs<T extends TailorDBType> extends RecordArgs {
+  event: "created";
+  rawEvent: "tailordb.type_record.created";
+  newRecord: output<T>;
+}
+interface RecordUpdatedArgs<T extends TailorDBType> extends RecordArgs {
+  event: "updated";
+  rawEvent: "tailordb.type_record.updated";
+  newRecord: output<T>;
+  oldRecord: output<T>;
+}
+interface RecordDeletedArgs<T extends TailorDBType> extends RecordArgs {
+  event: "deleted";
+  rawEvent: "tailordb.type_record.deleted";
+  oldRecord: output<T>;
+}
+/**
+ * Args for resolverExecutedTrigger. This is a discriminated union on `success`.
+ *
+ * When `success` is true, `result` contains the resolver output and `error` is never.
+ * When `success` is false, `error` contains the error message and `result` is never.
+ *
+ * Narrow on `success` to safely access either `result` or `error`.
+ * @example
+ * body: async (args) => {
+ *   if (args.success) {
+ *     console.log(args.result);
+ *   } else {
+ *     console.error(args.error);
+ *   }
+ * }
+ */
+type ResolverExecutedArgs<R extends ResolverConfig> = EventArgs & {
+  resolverName: string;
+} & ({
+  success: true;
+  result: output<R["output"]>;
+  error?: never;
+} | {
+  success: false;
+  result?: never;
+  error: string;
+});
+interface IdpUserCreatedArgs extends EventArgs {
+  event: "created";
+  rawEvent: "idp.user.created";
+  namespaceName: string;
+  userId: string;
+}
+interface IdpUserUpdatedArgs extends EventArgs {
+  event: "updated";
+  rawEvent: "idp.user.updated";
+  namespaceName: string;
+  userId: string;
+}
+interface IdpUserDeletedArgs extends EventArgs {
+  event: "deleted";
+  rawEvent: "idp.user.deleted";
+  namespaceName: string;
+  userId: string;
+}
+type IdpUserArgs = IdpUserCreatedArgs | IdpUserUpdatedArgs | IdpUserDeletedArgs;
+interface AuthAccessTokenIssuedArgs extends EventArgs {
+  event: "issued";
+  rawEvent: "auth.access_token.issued";
+  namespaceName: string;
+  userId: string;
+}
+interface AuthAccessTokenRefreshedArgs extends EventArgs {
+  event: "refreshed";
+  rawEvent: "auth.access_token.refreshed";
+  namespaceName: string;
+  userId: string;
+}
+interface AuthAccessTokenRevokedArgs extends EventArgs {
+  event: "revoked";
+  rawEvent: "auth.access_token.revoked";
+  namespaceName: string;
+  userId: string;
+}
+type AuthAccessTokenArgs = AuthAccessTokenIssuedArgs | AuthAccessTokenRefreshedArgs | AuthAccessTokenRevokedArgs;
+declare const recordEventMap: {
+  readonly created: "tailordb.type_record.created";
+  readonly updated: "tailordb.type_record.updated";
+  readonly deleted: "tailordb.type_record.deleted";
+};
+type RecordEventMap = typeof recordEventMap;
+type RecordEventKind = keyof RecordEventMap;
+type RecordArgsMap<T extends TailorDBType> = {
+  created: RecordCreatedArgs<T>;
+  updated: RecordUpdatedArgs<T>;
+  deleted: RecordDeletedArgs<T>;
+};
+type RecordMultiArgs<T extends TailorDBType, K extends RecordEventKind[]> = RecordArgsMap<T>[K[number]];
+type TailorDBTrigger<Args> = TailorDBTrigger$1 & {
+  __args: Args;
+};
+type RecordTriggerOptions<T extends TailorDBType, Args> = {
+  type: T;
+  condition?: (args: Args) => boolean;
+};
+/**
+ * Create a trigger that fires when a TailorDB record is created.
+ * @template T
+ * @param options - Trigger options
+ * @returns Record created trigger
+ */
+declare function recordCreatedTrigger<T extends TailorDBType>(options: RecordTriggerOptions<T, RecordCreatedArgs<T>>): TailorDBTrigger<RecordCreatedArgs<T>>;
+/**
+ * Create a trigger that fires when a TailorDB record is updated.
+ * @template T
+ * @param options - Trigger options
+ * @returns Record updated trigger
+ */
+declare function recordUpdatedTrigger<T extends TailorDBType>(options: RecordTriggerOptions<T, RecordUpdatedArgs<T>>): TailorDBTrigger<RecordUpdatedArgs<T>>;
+/**
+ * Create a trigger that fires when a TailorDB record is deleted.
+ * @template T
+ * @param options - Trigger options
+ * @returns Record deleted trigger
+ */
+declare function recordDeletedTrigger<T extends TailorDBType>(options: RecordTriggerOptions<T, RecordDeletedArgs<T>>): TailorDBTrigger<RecordDeletedArgs<T>>;
+type RecordTriggerMultiOptions<T extends TailorDBType, K extends RecordEventKind[]> = {
+  type: T;
+  events: K;
+  condition?: (args: RecordMultiArgs<T, K>) => boolean;
+};
+/**
+ * Create a trigger that fires on multiple TailorDB record event types.
+ * @template T
+ * @template K
+ * @param options - Trigger options with events array
+ * @returns TailorDB record trigger
+ */
+declare function recordTrigger<T extends TailorDBType, const K extends [RecordEventKind, ...RecordEventKind[]]>(options: RecordTriggerMultiOptions<T, K>): TailorDBTrigger<RecordMultiArgs<T, K>>;
+type ResolverExecutedTrigger<Args> = ResolverExecutedTrigger$1 & {
+  __args: Args;
+};
+type ResolverExecutedTriggerOptions<R extends ResolverConfig> = {
+  resolver: R;
+  condition?: (args: ResolverExecutedArgs<R>) => boolean;
+};
+/**
+ * Create a trigger that fires when a resolver is executed.
+ * @template R
+ * @param options - Trigger options
+ * @returns Resolver executed trigger
+ */
+declare function resolverExecutedTrigger<R extends ResolverConfig>(options: ResolverExecutedTriggerOptions<R>): ResolverExecutedTrigger<ResolverExecutedArgs<R>>;
+declare const idpUserEventMap: {
+  readonly created: "idp.user.created";
+  readonly updated: "idp.user.updated";
+  readonly deleted: "idp.user.deleted";
+};
+type IdpUserEventMap = typeof idpUserEventMap;
+type IdpUserEventKind = keyof IdpUserEventMap;
+type IdpUserArgsMap = {
+  created: IdpUserCreatedArgs;
+  updated: IdpUserUpdatedArgs;
+  deleted: IdpUserDeletedArgs;
+};
+type IdpUserMultiArgs<K extends IdpUserEventKind[]> = IdpUserArgsMap[K[number]];
+type IdpUserTrigger<Args> = IdpUserTrigger$1 & {
+  __args: Args;
+};
+type IdpUserSingleTriggerOptions = {
+  /**
+   * IdP namespace name to subscribe to. Required when the project defines
+   * multiple IdPs; optional when a single IdP exists. Must match an IdP name
+   * declared in `defineConfig({ idp: [...] })`.
+   */
+  idp?: IdpName;
+};
+/**
+ * Create a trigger that fires when an IdP user is created.
+ * @param options - Trigger options
+ * @param options.idp - IdP namespace name to subscribe to
+ * @returns IdP user created trigger
+ */
+declare function idpUserCreatedTrigger(options?: IdpUserSingleTriggerOptions): IdpUserTrigger<IdpUserCreatedArgs>;
+/**
+ * Create a trigger that fires when an IdP user is updated.
+ * @param options - Trigger options
+ * @param options.idp - IdP namespace name to subscribe to
+ * @returns IdP user updated trigger
+ */
+declare function idpUserUpdatedTrigger(options?: IdpUserSingleTriggerOptions): IdpUserTrigger<IdpUserUpdatedArgs>;
+/**
+ * Create a trigger that fires when an IdP user is deleted.
+ * @param options - Trigger options
+ * @param options.idp - IdP namespace name to subscribe to
+ * @returns IdP user deleted trigger
+ */
+declare function idpUserDeletedTrigger(options?: IdpUserSingleTriggerOptions): IdpUserTrigger<IdpUserDeletedArgs>;
+type IdpUserTriggerOptions<K extends IdpUserEventKind[]> = {
+  events: K;
+  /**
+   * IdP namespace name to subscribe to. Required when the project defines
+   * multiple IdPs; optional when a single IdP exists. Must match an IdP name
+   * declared in `defineConfig({ idp: [...] })`.
+   */
+  idp?: IdpName;
+};
+/**
+ * Create a trigger that fires on multiple IdP user event types.
+ * @template K
+ * @param options - Trigger options with events array
+ * @param options.events - IdP user event kinds to subscribe to
+ * @param options.idp - IdP namespace name to subscribe to
+ * @returns IdP user trigger
+ */
+declare function idpUserTrigger<const K extends [IdpUserEventKind, ...IdpUserEventKind[]]>(options: IdpUserTriggerOptions<K>): IdpUserTrigger<IdpUserMultiArgs<K>>;
+declare const authAccessTokenEventMap: {
+  readonly issued: "auth.access_token.issued";
+  readonly refreshed: "auth.access_token.refreshed";
+  readonly revoked: "auth.access_token.revoked";
+};
+type AuthAccessTokenEventMap = typeof authAccessTokenEventMap;
+type AuthAccessTokenEventKind = keyof AuthAccessTokenEventMap;
+type AuthAccessTokenArgsMap = {
+  issued: AuthAccessTokenIssuedArgs;
+  refreshed: AuthAccessTokenRefreshedArgs;
+  revoked: AuthAccessTokenRevokedArgs;
+};
+type AuthAccessTokenMultiArgs<K extends AuthAccessTokenEventKind[]> = AuthAccessTokenArgsMap[K[number]];
+type AuthAccessTokenTrigger<Args> = AuthAccessTokenTrigger$1 & {
+  __args: Args;
+};
+/**
+ * Create a trigger that fires when an access token is issued.
+ * @returns Auth access token issued trigger
+ */
+declare function authAccessTokenIssuedTrigger(): AuthAccessTokenTrigger<AuthAccessTokenIssuedArgs>;
+/**
+ * Create a trigger that fires when an access token is refreshed.
+ * @returns Auth access token refreshed trigger
+ */
+declare function authAccessTokenRefreshedTrigger(): AuthAccessTokenTrigger<AuthAccessTokenRefreshedArgs>;
+/**
+ * Create a trigger that fires when an access token is revoked.
+ * @returns Auth access token revoked trigger
+ */
+declare function authAccessTokenRevokedTrigger(): AuthAccessTokenTrigger<AuthAccessTokenRevokedArgs>;
+type AuthAccessTokenTriggerOptions<K extends AuthAccessTokenEventKind[]> = {
+  events: K;
+};
+/**
+ * Create a trigger that fires on multiple auth access token event types.
+ * @template K
+ * @param options - Trigger options with events array
+ * @returns Auth access token trigger
+ */
+declare function authAccessTokenTrigger<const K extends [AuthAccessTokenEventKind, ...AuthAccessTokenEventKind[]]>(options: AuthAccessTokenTriggerOptions<K>): AuthAccessTokenTrigger<AuthAccessTokenMultiArgs<K>>;
+//#endregion
+export { AuthAccessTokenArgs, AuthAccessTokenIssuedArgs, AuthAccessTokenRefreshedArgs, AuthAccessTokenRevokedArgs, AuthAccessTokenTrigger, IdpUserArgs, IdpUserCreatedArgs, IdpUserDeletedArgs, IdpUserTrigger, IdpUserUpdatedArgs, RecordCreatedArgs, RecordDeletedArgs, RecordUpdatedArgs, ResolverExecutedArgs, ResolverExecutedTrigger, TailorDBTrigger, authAccessTokenIssuedTrigger, authAccessTokenRefreshedTrigger, authAccessTokenRevokedTrigger, authAccessTokenTrigger, idpUserCreatedTrigger, idpUserDeletedTrigger, idpUserTrigger, idpUserUpdatedTrigger, recordCreatedTrigger, recordDeletedTrigger, recordTrigger, recordUpdatedTrigger, resolverExecutedTrigger };

package/dist/configure/services/executor/trigger/index.d.mts

@@ -0,0 +1,8 @@
+import { AuthAccessTokenArgs, AuthAccessTokenIssuedArgs, AuthAccessTokenRefreshedArgs, AuthAccessTokenRevokedArgs, AuthAccessTokenTrigger, IdpUserArgs, IdpUserCreatedArgs, IdpUserDeletedArgs, IdpUserTrigger, IdpUserUpdatedArgs, RecordCreatedArgs, RecordDeletedArgs, RecordUpdatedArgs, ResolverExecutedArgs, ResolverExecutedTrigger, TailorDBTrigger, authAccessTokenIssuedTrigger, authAccessTokenRefreshedTrigger, authAccessTokenRevokedTrigger, authAccessTokenTrigger, idpUserCreatedTrigger, idpUserDeletedTrigger, idpUserTrigger, idpUserUpdatedTrigger, recordCreatedTrigger, recordDeletedTrigger, recordTrigger, recordUpdatedTrigger, resolverExecutedTrigger } from "./event.mjs";
+import { ScheduleArgs, ScheduleTrigger, scheduleTrigger } from "./schedule.mjs";
+import { IncomingWebhookArgs, IncomingWebhookRequest, IncomingWebhookResponse, IncomingWebhookResponseConfig, IncomingWebhookTrigger, IncomingWebhookTriggerOptions, incomingWebhookTrigger } from "./webhook.mjs";
+
+//#region src/configure/services/executor/trigger/index.d.ts
+type Trigger<Args> = TailorDBTrigger<Args> | ResolverExecutedTrigger<Args> | ScheduleTrigger<Args> | IncomingWebhookTrigger<Args> | IdpUserTrigger<Args> | AuthAccessTokenTrigger<Args>;
+//#endregion
+export { AuthAccessTokenArgs, AuthAccessTokenIssuedArgs, AuthAccessTokenRefreshedArgs, AuthAccessTokenRevokedArgs, AuthAccessTokenTrigger, IdpUserArgs, IdpUserCreatedArgs, IdpUserDeletedArgs, IdpUserTrigger, IdpUserUpdatedArgs, IncomingWebhookArgs, IncomingWebhookRequest, IncomingWebhookResponse, IncomingWebhookResponseConfig, IncomingWebhookTrigger, IncomingWebhookTriggerOptions, RecordCreatedArgs, RecordDeletedArgs, RecordUpdatedArgs, ResolverExecutedArgs, ResolverExecutedTrigger, ScheduleArgs, ScheduleTrigger, TailorDBTrigger, Trigger, authAccessTokenIssuedTrigger, authAccessTokenRefreshedTrigger, authAccessTokenRevokedTrigger, authAccessTokenTrigger, idpUserCreatedTrigger, idpUserDeletedTrigger, idpUserTrigger, idpUserUpdatedTrigger, incomingWebhookTrigger, recordCreatedTrigger, recordDeletedTrigger, recordTrigger, recordUpdatedTrigger, resolverExecutedTrigger, scheduleTrigger };