zitejs 0.10.0-start.5 → 0.10.0-start.7

package/dist/cjs/backend/index.d.ts

@@ -23,6 +23,8 @@ export type ZiteTrigger = {
     paused?: boolean;
     every?: never;
     events?: never;
+    table?: never;
+    form?: never;
 } | {
     /**
      * The connection's name in `zite.config.json`, for a provider whose
@@ -37,6 +39,8 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     every?: never;
+    table?: never;
+    form?: never;
 } | {
     /** `<n>m` (1–59) or `<n>h` (1–23). What makes the trigger a poll. */
     every: string;
@@ -46,6 +50,78 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     events?: never;
+    table?: never;
+    form?: never;
+} | {
+    /**
+     * A table in the project's own database, as `zite.<table>` names it.
+     * Every write to it reaches the trigger, from apps, forms, imports, the
+     * database view and other automations; nothing is registered.
+     */
+    table: string;
+    on: ZiteDatabaseTriggerEvent[];
+    /** Narrows `"updated"` to updates that changed one of these fields. */
+    fields?: string[];
+    /** The sentence the editor shows, e.g. "When an order ships". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    form?: never;
+} | {
+    /**
+     * One of the project's own Fillout forms, by its name as the project
+     * lists it, or its id. Each finished live submission fires the
+     * endpoint; nothing is registered.
+     */
+    form: string;
+    on: "submitted"[];
+    /** The sentence the editor shows, e.g. "When someone fills in the intake form". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    table?: never;
+};
+/**
+ * What a form trigger's run gets as `input`: one submission. `answers` is
+ * keyed by question name, `answersById` by question id; `submission` is the
+ * whole export, as the Fillout API returns it (`questions`, `calculations`,
+ * `urlParameters`, …). Two questions with the same label are named
+ * `Email` and `Email (1)` in an order the form doesn't show, so read those by
+ * id.
+ */
+export type ZiteFormTriggerInput = {
+    event: "submitted";
+    form: string;
+    formId: string;
+    submissionId: string;
+    submittedAt: string | null;
+    answers: Record<string, unknown>;
+    answersById: Record<string, unknown>;
+    submission: Record<string, unknown> & {
+        submissionId: string;
+    };
+};
+export type ZiteDatabaseTriggerEvent = "created" | "updated" | "deleted";
+/**
+ * What a database trigger's run gets as `input`: one changed record. Field
+ * keys are the SDK's, as `zite.<table>.findOne` returns them; cast `record`
+ * and `previous` to the table's generated `<Table>RecordType` from
+ * `zitejs/db` to type their fields.
+ */
+export type ZiteDatabaseTriggerInput<TRecord extends Record<string, unknown> = Record<string, unknown>> = {
+    event: ZiteDatabaseTriggerEvent;
+    table: string;
+    recordId: string;
+    /** Null if it was deleted before the run read it; on `"deleted"`, the record as it was. */
+    record: TRecord | null;
+    /** The record before an `"updated"`; null otherwise, and on a very large bulk write. */
+    previous: TRecord | null;
+    /** What an `"updated"` changed. */
+    changedFields: string[];
 };
 /**
  * What a provider trigger's `subscribe` export receives. Write it as
@@ -115,10 +191,20 @@ export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
 export type ZiteTriggerContext<TTrigger> = TTrigger extends {
     every: string;
 } ? ZiteTriggerRun : TTrigger extends {
+    table: string;
+} | {
+    form: string;
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
     events: string[];
 } ? ZiteTriggerDeliveryInfo : TTrigger extends {
     integration: string;
 } ? ZiteTriggerDeliveryRun : never;
+/** A database or form trigger's runs get the change or submission as `input`. */
+export type ZiteEndpointInput<TInput, TTrigger> = TTrigger extends {
+    table: string;
+} ? ZiteDatabaseTriggerInput : TTrigger extends {
+    form: string;
+} ? ZiteFormTriggerInput : TInput;
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -215,13 +301,15 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TInput;
+        input: ZiteEndpointInput<TInput, TTrigger>;
         /**
          * Durable steps. `step.run(name, fn)` runs `fn` once per logical run:
          * its result is saved before anything after it executes, and when a
          * failed run is resumed, completed steps return their saved results
          * instead of re-running their side effects. Names must be unique within
-         * a run, and results must be plain JSON data under 256KB.
+         * a run, and results must be plain JSON data under 256KB. In a run
+         * fired by a schedule, webhook or trigger, `step.sleep` pauses the run
+         * and a failed step is tried again.
          */
         step: ZiteStep;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
@@ -240,8 +328,32 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
  * it would matter, and give a step inside a loop the item's id in its name.
  */
 export interface ZiteStep {
-    run<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+    /**
+     * In a run fired by a schedule, webhook or trigger, a step that throws is
+     * tried again `retries` more times (default 3, at most 10), 30 seconds,
+     * 2 minutes, then 10 minutes apart. Elsewhere its error fails the request.
+     */
+    run<T>(name: string, fn: () => Promise<T> | T, options?: ZiteStepOptions): Promise<T>;
+    /**
+     * Pause the run for `duration`: `"30s"`, `"15m"`, `"2h"`, `"3d"`, `"1w"`,
+     * or milliseconds, at most 30 days. Only a run fired by a schedule, webhook
+     * or trigger can wait; an editor test run goes straight past, and a request
+     * from the app throws.
+     *
+     * The run continues in a later call, which runs `execute` again from the
+     * top: finished steps return their saved results, and code outside a step
+     * runs again, so keep side effects inside steps.
+     */
+    sleep(name: string, duration: ZiteStepDuration): Promise<void>;
+    /** Pause the run until `when`, at most 30 days ahead. See {@link ZiteStep.sleep}. */
+    sleepUntil(name: string, when: Date | string): Promise<void>;
+}
+export interface ZiteStepOptions {
+    /** How many more times to try the step after it throws: 0 to 10, default 3. */
+    retries?: number;
 }
+/** Milliseconds, or a number with a unit: `ms`, `s`, `m`, `h`, `d` or `w`. */
+export type ZiteStepDuration = number | `${number}${"ms" | "s" | "m" | "h" | "d" | "w"}`;
 /**
  * Create an endpoint definition, parsing `input` against `inputSchema` before
  * `execute` runs. Nothing downstream parses it — the worker calls `execute` on

package/dist/cjs/backend/index.test.js

@@ -8,6 +8,8 @@ const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
 // Direct execute() calls need the step surface the runtime always provides.
 const stepStub = {
     run: async (_name, fn) => await fn(),
+    sleep: async () => { },
+    sleepUntil: async () => { },
 };
 (0, vitest_1.afterEach)(() => {
     vitest_1.vi.unstubAllGlobals();
@@ -207,6 +209,62 @@ const stepStub = {
                 return params.trigger;
             },
         });
+        (0, index_js_1.createEndpoint)({
+            trigger: { table: "orders", on: ["updated"], fields: ["status"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a database change has no cursor API
+                trigger?.advance("x");
+                const status = input.record?.status;
+                return { status, changed: input.changedFields, at: input.event };
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error a database trigger names its table, not a connection
+            trigger: { table: "orders", on: ["created"], integration: "x" },
+            execute: async () => 1,
+        });
+        (0, index_js_1.createEndpoint)({
+            trigger: { form: "Intake form", on: ["submitted"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a form submission has no cursor API
+                trigger?.advance("x");
+                return {
+                    email: input.answers.Email,
+                    workEmail: input.answersById["wWorkEmail"],
+                    id: input.submissionId,
+                };
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error a form trigger watches submissions only
+            trigger: { form: "Intake form", on: ["updated"] },
+            execute: async () => 1,
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error only created, updated and deleted
+            trigger: { table: "orders", on: ["archived"] },
+            execute: async () => 1,
+        });
+    });
+    (0, vitest_1.it)("hands a database trigger its change without parsing it against the input schema", async () => {
+        const endpoint = (0, index_js_1.createEndpoint)({
+            inputSchema: zod_1.z.object({ orderId: zod_1.z.string() }),
+            trigger: { table: "orders", on: ["created"] },
+            execute: async ({ input }) => input.recordId,
+        });
+        await (0, vitest_1.expect)(endpoint.execute({
+            step: stepStub,
+            input: {
+                event: "created",
+                table: "orders",
+                recordId: "rec_1",
+                record: { id: "rec_1" },
+                previous: null,
+                changedFields: [],
+            },
+            context: { user: null },
+            trigger: { headers: {}, deliveryId: "db:e1:rec_1" },
+        })).resolves.toBe("rec_1");
     });
     (0, vitest_1.it)("types a trigger's registration exports and checks what subscribe returns", async () => {
         const subscribe = (async (input) => ({

package/dist/cjs/integrations/rules.d.ts

@@ -38,11 +38,24 @@ declare const FIELDS_BY_TYPE: {
     jira: readonly string[];
     typeform: readonly string[];
     apollo: readonly string[];
+    clay: readonly string[];
     attio: readonly string[];
     granola: readonly string[];
+    clickup: readonly string[];
     dropbox: readonly string[];
+    zendesk: readonly string[];
+    smartsheet: readonly string[];
     amazonS3: readonly string[];
     snowflake: readonly string[];
+    databricks: readonly string[];
+    confluence: readonly string[];
+    pipedrive: readonly string[];
+    shopify: readonly string[];
+    sharepoint: readonly string[];
+    excel: readonly string[];
+    x: readonly string[];
+    zoomMeetings: readonly string[];
+    smartsuite: readonly string[];
 };
 /** A service type `integrations.get` serves: one used through its npm package with a token. */
 export type CredentialServiceType = keyof typeof FIELDS_BY_TYPE;

package/dist/cjs/integrations/rules.js

@@ -47,15 +47,43 @@ const FIELDS_BY_TYPE = {
     jira: extras("cloudId", "siteUrl"),
     typeform: extras(),
     apollo: extras(),
+    clay: extras(),
     attio: extras(),
     granola: extras(),
+    clickup: extras(),
     dropbox: extras(),
+    // Every path is https://{subdomain}.zendesk.com/api/v2/..., and a token is
+    // only valid on the account it was issued for, so the subdomain travels with
+    // it rather than being configured per app.
+    zendesk: extras("subdomain"),
+    // Smartsheet's US, EU, AU and Gov regions are separate, and a token is only
+    // valid on its own region's host, so the host travels with it.
+    smartsheet: extras("apiBaseUrl"),
     // The IAM key alone reaches nothing: every call needs the region and the
     // bucket, and S3-compatible providers need the endpoint too.
     amazonS3: extras("keyId", "region", "bucket", "endpoint", "pathPrefix"),
     // The SQL API lives on each account's own host, and the token is pinned to
     // one role; the warehouse is optional and falls back to the user's default.
     snowflake: extras("accountUrl", "role", "warehouse"),
+    // A statement is addressed by workspace host and SQL warehouse, and the token
+    // derives neither.
+    databricks: extras("host", "warehouseId"),
+    // Cloud Confluence is addressed through api.atlassian.com by cloud id, the
+    // same as Jira; the site URL is only for links a human will click.
+    confluence: extras("cloudId", "siteUrl"),
+    // OAuth returns a per-company api_domain alongside the token, so there is no
+    // one host to call.
+    pipedrive: extras("apiBaseUrl"),
+    // Shopify has no global API host: every call goes to the store's own domain
+    // under a pinned API version. The storefront pair is the shopper-facing API,
+    // which installs predating those scopes do not have.
+    shopify: extras("shopDomain", "apiBaseUrl", "storefrontApiUrl", "storefrontAccessToken"),
+    sharepoint: extras(),
+    excel: extras(),
+    x: extras(),
+    zoomMeetings: extras(),
+    // Every request names the workspace in an Account-Id header beside the key.
+    smartsuite: extras("workspaceId"),
 };
 /** Per service type: `accessToken`, then its extra labels sorted (Salesforce `instanceUrl`). */
 exports.CREDENTIAL_FIELDS = FIELDS_BY_TYPE;
@@ -68,6 +96,7 @@ exports.OPTIONAL_CREDENTIAL_FIELDS = {
     // Only S3-compatible providers set an endpoint, and a prefix is opt-in.
     amazonS3: ["endpoint", "pathPrefix"],
     snowflake: ["warehouse"],
+    shopify: ["storefrontApiUrl", "storefrontAccessToken"],
 };
 /**
  * Types the runtime never serves: those with a generated client (Airtable, email,

package/dist/cjs/integrations/rules.test.js

@@ -18,6 +18,7 @@ const index_js_1 = require("../index.js");
         ]);
         (0, vitest_1.expect)(index_js_1.CREDENTIAL_FIELDS.jira).toEqual(["accessToken", "cloudId", "siteUrl"]);
         (0, vitest_1.expect)(index_js_1.CREDENTIAL_FIELDS.granola).toEqual(["accessToken"]);
+        (0, vitest_1.expect)(index_js_1.CREDENTIAL_FIELDS.smartsheet).toEqual(["accessToken", "apiBaseUrl"]);
     });
     (0, vitest_1.it)("has no type the runtime never serves", () => {
         for (const type of index_js_1.NON_CREDENTIAL_SERVICE_TYPES) {

package/dist/cjs/sync/lib.js

@@ -524,7 +524,7 @@ function generateDbTs(inputSchema) {
     lines.push('//       `not: null` means "is set". An empty `in: []` matches nothing; an', "//       empty `notIn: []` applies no filter.");
     lines.push("//     sort is currently IGNORED here — it is stripped before the request.", "//       (it does work on zite.auth.findAllUsers). Order in SQL instead.");
     lines.push("//     limit defaults to 500, max 2000; offset is a row count (a number)");
-    lines.push('//     a filter value of `undefined` is REJECTED (it would query unfiltered', '//       and match an arbitrary record). Check the value first.');
+    lines.push("//     a filter value of `undefined` is REJECTED (it would query unfiltered", "//       and match an arbitrary record). Check the value first.");
     lines.push("//   .findOne({ id?, filters?, fields? }) → T | undefined");
     lines.push("//   .create({ record }) → T");
     lines.push("//   .update({ id, record }) → { id: string, fields: Partial<T> }");
@@ -1232,13 +1232,13 @@ function generateBackendWrapperTs(envVarNames = []) {
         "// Auto-generated type-narrowing wrapper. Do not edit manually.",
         "// Re-exports createEndpoint with context.user typed to the app User.",
         "",
-        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStep, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteWebhook } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStep, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteEndpointInput, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStep, ZiteStreamInterface, ZiteTrigger, ZiteWebhook };",
         // A trigger's registration exports are typed against these, and they
         // only reach app code through this file.
-        "export type { ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
+        "export type { ZiteDatabaseTriggerEvent, ZiteDatabaseTriggerInput, ZiteFormTriggerInput, ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
         // The pre-monorepo SDK put this in scope for every endpoint, so migrated
         // code can name it. `createEndpoint` infers the same thing without it.
         "export type InferSchemaType<T> = T extends { _output: infer U } ? U : T;",
@@ -1326,12 +1326,12 @@ function generateBackendWrapperTs(envVarNames = []) {
         "  schedule?: TSchedule;",
         "  /** When set, an inbound webhook can also trigger this endpoint. Like `schedule`, it widens `context` — a webhook fire has no session. */",
         "  webhook?: TWebhook;",
-        "  /** When set, a connection's events (registered by this file's own `subscribe` export) or a poll (`every`) also fire this endpoint. Like `webhook`, it widens `context` — a trigger fire has no session. */",
+        "  /** When set, a connection's events (registered by this file's own `subscribe` export), a poll (`every`), a change to one of the project's tables (`table`) or a submission to one of its forms (`form`) also fire this endpoint. Like `webhook`, it widens `context` — a trigger fire has no session. */",
         "  trigger?: TTrigger;",
         "  execute: (",
         "    params: {",
-        "      input: TInput;",
-        "      /** Durable steps: step.run(name, fn) runs fn once per logical run — its result is saved before anything after it executes, and a resumed run replays completed steps from their saved results. Provided by the platform; never define a local stand-in. */",
+        "      input: ZiteEndpointInput<TInput, TTrigger>;",
+        "      /** Durable steps: step.run(name, fn) runs fn once per logical run — its result is saved before anything after it executes, and a resumed run replays completed steps from their saved results. In a run fired by a schedule, webhook or trigger, step.sleep(name, \"2d\") pauses the run and a failed step is tried again. Provided by the platform; never define a local stand-in. */",
         "      step: ZiteStep;",
         "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
         // Mirrors the base module: a trigger's run gets `trigger`.

package/dist/esm/backend/index.d.ts

@@ -23,6 +23,8 @@ export type ZiteTrigger = {
     paused?: boolean;
     every?: never;
     events?: never;
+    table?: never;
+    form?: never;
 } | {
     /**
      * The connection's name in `zite.config.json`, for a provider whose
@@ -37,6 +39,8 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     every?: never;
+    table?: never;
+    form?: never;
 } | {
     /** `<n>m` (1–59) or `<n>h` (1–23). What makes the trigger a poll. */
     every: string;
@@ -46,6 +50,78 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     events?: never;
+    table?: never;
+    form?: never;
+} | {
+    /**
+     * A table in the project's own database, as `zite.<table>` names it.
+     * Every write to it reaches the trigger, from apps, forms, imports, the
+     * database view and other automations; nothing is registered.
+     */
+    table: string;
+    on: ZiteDatabaseTriggerEvent[];
+    /** Narrows `"updated"` to updates that changed one of these fields. */
+    fields?: string[];
+    /** The sentence the editor shows, e.g. "When an order ships". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    form?: never;
+} | {
+    /**
+     * One of the project's own Fillout forms, by its name as the project
+     * lists it, or its id. Each finished live submission fires the
+     * endpoint; nothing is registered.
+     */
+    form: string;
+    on: "submitted"[];
+    /** The sentence the editor shows, e.g. "When someone fills in the intake form". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    table?: never;
+};
+/**
+ * What a form trigger's run gets as `input`: one submission. `answers` is
+ * keyed by question name, `answersById` by question id; `submission` is the
+ * whole export, as the Fillout API returns it (`questions`, `calculations`,
+ * `urlParameters`, …). Two questions with the same label are named
+ * `Email` and `Email (1)` in an order the form doesn't show, so read those by
+ * id.
+ */
+export type ZiteFormTriggerInput = {
+    event: "submitted";
+    form: string;
+    formId: string;
+    submissionId: string;
+    submittedAt: string | null;
+    answers: Record<string, unknown>;
+    answersById: Record<string, unknown>;
+    submission: Record<string, unknown> & {
+        submissionId: string;
+    };
+};
+export type ZiteDatabaseTriggerEvent = "created" | "updated" | "deleted";
+/**
+ * What a database trigger's run gets as `input`: one changed record. Field
+ * keys are the SDK's, as `zite.<table>.findOne` returns them; cast `record`
+ * and `previous` to the table's generated `<Table>RecordType` from
+ * `zitejs/db` to type their fields.
+ */
+export type ZiteDatabaseTriggerInput<TRecord extends Record<string, unknown> = Record<string, unknown>> = {
+    event: ZiteDatabaseTriggerEvent;
+    table: string;
+    recordId: string;
+    /** Null if it was deleted before the run read it; on `"deleted"`, the record as it was. */
+    record: TRecord | null;
+    /** The record before an `"updated"`; null otherwise, and on a very large bulk write. */
+    previous: TRecord | null;
+    /** What an `"updated"` changed. */
+    changedFields: string[];
 };
 /**
  * What a provider trigger's `subscribe` export receives. Write it as
@@ -115,10 +191,20 @@ export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
 export type ZiteTriggerContext<TTrigger> = TTrigger extends {
     every: string;
 } ? ZiteTriggerRun : TTrigger extends {
+    table: string;
+} | {
+    form: string;
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
     events: string[];
 } ? ZiteTriggerDeliveryInfo : TTrigger extends {
     integration: string;
 } ? ZiteTriggerDeliveryRun : never;
+/** A database or form trigger's runs get the change or submission as `input`. */
+export type ZiteEndpointInput<TInput, TTrigger> = TTrigger extends {
+    table: string;
+} ? ZiteDatabaseTriggerInput : TTrigger extends {
+    form: string;
+} ? ZiteFormTriggerInput : TInput;
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -215,13 +301,15 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TInput;
+        input: ZiteEndpointInput<TInput, TTrigger>;
         /**
          * Durable steps. `step.run(name, fn)` runs `fn` once per logical run:
          * its result is saved before anything after it executes, and when a
          * failed run is resumed, completed steps return their saved results
          * instead of re-running their side effects. Names must be unique within
-         * a run, and results must be plain JSON data under 256KB.
+         * a run, and results must be plain JSON data under 256KB. In a run
+         * fired by a schedule, webhook or trigger, `step.sleep` pauses the run
+         * and a failed step is tried again.
          */
         step: ZiteStep;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
@@ -240,8 +328,32 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
  * it would matter, and give a step inside a loop the item's id in its name.
  */
 export interface ZiteStep {
-    run<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+    /**
+     * In a run fired by a schedule, webhook or trigger, a step that throws is
+     * tried again `retries` more times (default 3, at most 10), 30 seconds,
+     * 2 minutes, then 10 minutes apart. Elsewhere its error fails the request.
+     */
+    run<T>(name: string, fn: () => Promise<T> | T, options?: ZiteStepOptions): Promise<T>;
+    /**
+     * Pause the run for `duration`: `"30s"`, `"15m"`, `"2h"`, `"3d"`, `"1w"`,
+     * or milliseconds, at most 30 days. Only a run fired by a schedule, webhook
+     * or trigger can wait; an editor test run goes straight past, and a request
+     * from the app throws.
+     *
+     * The run continues in a later call, which runs `execute` again from the
+     * top: finished steps return their saved results, and code outside a step
+     * runs again, so keep side effects inside steps.
+     */
+    sleep(name: string, duration: ZiteStepDuration): Promise<void>;
+    /** Pause the run until `when`, at most 30 days ahead. See {@link ZiteStep.sleep}. */
+    sleepUntil(name: string, when: Date | string): Promise<void>;
+}
+export interface ZiteStepOptions {
+    /** How many more times to try the step after it throws: 0 to 10, default 3. */
+    retries?: number;
 }
+/** Milliseconds, or a number with a unit: `ms`, `s`, `m`, `h`, `d` or `w`. */
+export type ZiteStepDuration = number | `${number}${"ms" | "s" | "m" | "h" | "d" | "w"}`;
 /**
  * Create an endpoint definition, parsing `input` against `inputSchema` before
  * `execute` runs. Nothing downstream parses it — the worker calls `execute` on

package/dist/esm/backend/index.test.js

@@ -6,6 +6,8 @@ const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
 // Direct execute() calls need the step surface the runtime always provides.
 const stepStub = {
     run: async (_name, fn) => await fn(),
+    sleep: async () => { },
+    sleepUntil: async () => { },
 };
 afterEach(() => {
     vi.unstubAllGlobals();
@@ -205,6 +207,62 @@ describe("platform-triggered runs", () => {
                 return params.trigger;
             },
         });
+        createEndpoint({
+            trigger: { table: "orders", on: ["updated"], fields: ["status"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a database change has no cursor API
+                trigger?.advance("x");
+                const status = input.record?.status;
+                return { status, changed: input.changedFields, at: input.event };
+            },
+        });
+        createEndpoint({
+            // @ts-expect-error a database trigger names its table, not a connection
+            trigger: { table: "orders", on: ["created"], integration: "x" },
+            execute: async () => 1,
+        });
+        createEndpoint({
+            trigger: { form: "Intake form", on: ["submitted"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a form submission has no cursor API
+                trigger?.advance("x");
+                return {
+                    email: input.answers.Email,
+                    workEmail: input.answersById["wWorkEmail"],
+                    id: input.submissionId,
+                };
+            },
+        });
+        createEndpoint({
+            // @ts-expect-error a form trigger watches submissions only
+            trigger: { form: "Intake form", on: ["updated"] },
+            execute: async () => 1,
+        });
+        createEndpoint({
+            // @ts-expect-error only created, updated and deleted
+            trigger: { table: "orders", on: ["archived"] },
+            execute: async () => 1,
+        });
+    });
+    it("hands a database trigger its change without parsing it against the input schema", async () => {
+        const endpoint = createEndpoint({
+            inputSchema: z.object({ orderId: z.string() }),
+            trigger: { table: "orders", on: ["created"] },
+            execute: async ({ input }) => input.recordId,
+        });
+        await expect(endpoint.execute({
+            step: stepStub,
+            input: {
+                event: "created",
+                table: "orders",
+                recordId: "rec_1",
+                record: { id: "rec_1" },
+                previous: null,
+                changedFields: [],
+            },
+            context: { user: null },
+            trigger: { headers: {}, deliveryId: "db:e1:rec_1" },
+        })).resolves.toBe("rec_1");
     });
     it("types a trigger's registration exports and checks what subscribe returns", async () => {
         const subscribe = (async (input) => ({

package/dist/esm/integrations/rules.d.ts

@@ -38,11 +38,24 @@ declare const FIELDS_BY_TYPE: {
     jira: readonly string[];
     typeform: readonly string[];
     apollo: readonly string[];
+    clay: readonly string[];
     attio: readonly string[];
     granola: readonly string[];
+    clickup: readonly string[];
     dropbox: readonly string[];
+    zendesk: readonly string[];
+    smartsheet: readonly string[];
     amazonS3: readonly string[];
     snowflake: readonly string[];
+    databricks: readonly string[];
+    confluence: readonly string[];
+    pipedrive: readonly string[];
+    shopify: readonly string[];
+    sharepoint: readonly string[];
+    excel: readonly string[];
+    x: readonly string[];
+    zoomMeetings: readonly string[];
+    smartsuite: readonly string[];
 };
 /** A service type `integrations.get` serves: one used through its npm package with a token. */
 export type CredentialServiceType = keyof typeof FIELDS_BY_TYPE;