zitejs 0.10.0-start.6 → 0.10.0-start.8

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;

package/dist/esm/integrations/rules.js

@@ -44,15 +44,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`). */
 export const CREDENTIAL_FIELDS = FIELDS_BY_TYPE;
@@ -65,6 +93,7 @@ export const 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/esm/integrations/rules.test.js

@@ -16,6 +16,7 @@ describe("CREDENTIAL_FIELDS", () => {
         ]);
         expect(CREDENTIAL_FIELDS.jira).toEqual(["accessToken", "cloudId", "siteUrl"]);
         expect(CREDENTIAL_FIELDS.granola).toEqual(["accessToken"]);
+        expect(CREDENTIAL_FIELDS.smartsheet).toEqual(["accessToken", "apiBaseUrl"]);
     });
     it("has no type the runtime never serves", () => {
         for (const type of NON_CREDENTIAL_SERVICE_TYPES) {

package/dist/esm/start/airtable/arrayFields.d.ts

@@ -0,0 +1,10 @@
+export type AirtableFieldShape = {
+    type: string;
+    options?: unknown;
+};
+export declare const isArrayValuedAirtableField: (field: AirtableFieldShape) => boolean;
+export declare const airtableEqualsFormula: ({ field, fieldName, value, }: {
+    field: AirtableFieldShape;
+    fieldName: string;
+    value: string;
+}) => string;

package/dist/esm/start/airtable/arrayFields.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+const ARRAY_VALUED_AIRTABLE_FIELD_TYPES = new Set([
+    'multipleLookupValues',
+    'multipleSelects',
+    'multipleRecordLinks',
+    'multipleCollaborators',
+    'multipleAttachments',
+]);
+const resultTypeOptionsSchema = z.object({
+    result: z.object({ type: z.string().optional() }).optional(),
+});
+export const isArrayValuedAirtableField = (field) => {
+    if (field.type === 'formula' || field.type === 'rollup') {
+        const resultType = resultTypeOptionsSchema.safeParse(field.options).data
+            ?.result?.type;
+        return resultType
+            ? ARRAY_VALUED_AIRTABLE_FIELD_TYPES.has(resultType)
+            : false;
+    }
+    return ARRAY_VALUED_AIRTABLE_FIELD_TYPES.has(field.type);
+};
+const ELEMENT_SEPARATOR = ', ';
+export const airtableEqualsFormula = ({ field, fieldName, value, }) => {
+    if (!isArrayValuedAirtableField(field)) {
+        return `${fieldName}=${value}`;
+    }
+    const needle = `"${ELEMENT_SEPARATOR}" & ${value} & "${ELEMENT_SEPARATOR}"`;
+    const haystack = `"${ELEMENT_SEPARATOR}" & ARRAYJOIN(${fieldName}) & "${ELEMENT_SEPARATOR}"`;
+    return `SEARCH(${needle}, ${haystack}) != ""`;
+};

package/dist/esm/start/airtable/dispatch.d.ts

@@ -0,0 +1,54 @@
+/** As `@fillout/zite`'s `IntegrationFieldMappingType`, from zite.lock. */
+export type AirtableFieldMapping = {
+    mapping: {
+        sdkName: string;
+    };
+    fieldType?: string;
+    fieldName?: string;
+    fieldOptions?: Record<string, unknown>;
+};
+export type AirtableFieldMappings = Record<string, AirtableFieldMapping>;
+export type AirtableNameMappings = {
+    bases: Record<string, {
+        mapping: {
+            sdkName: string;
+        };
+        tables: Record<string, {
+            mapping: {
+                sdkName: string;
+            };
+            primaryFieldId?: string;
+            fields: AirtableFieldMappings;
+        }>;
+    }>;
+};
+/** An app's Airtable integration as its build declares it. */
+export type AirtableSettings = {
+    baseId: string;
+    nameMappings: AirtableNameMappings | null;
+};
+/** Answers one Airtable request; the platform puts the connection's token on it. */
+export type AirtableFetch = (path: string, init: {
+    method: string;
+    body?: unknown;
+}) => Promise<Response>;
+export type AirtableContext = {
+    settings: AirtableSettings;
+    fetch: AirtableFetch;
+    /** One request's reads, so the same read twice in a request goes to Airtable once. */
+    reads?: Map<string, Promise<unknown>>;
+    sleep?: (ms: number) => Promise<void>;
+};
+/** The npm SDK's error, whose shape apps (and the goldens) see: not an `Error`. */
+export declare class AirtableError {
+    error: string;
+    message: string;
+    statusCode: number;
+    constructor(error: string, message: string, statusCode: number);
+    toString(): string;
+}
+export declare function airtableRecordToSdkNames(record: Record<string, any> | undefined, fieldMappings: AirtableFieldMappings | undefined): Record<string, any> | undefined;
+/** A Duration cell (seconds) as HH:mm:ss, keeping seconds and fractions (ZIT-3889). */
+export declare function formatAirtableDuration(durationSeconds: number): string;
+/** One Airtable table call, as classic's dispatch runs it. */
+export declare function executeAirtableCall(context: AirtableContext, methodName: string, params: any): Promise<any>;