zitejs 0.10.0-start.7 → 0.10.0-start.8

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

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import type { AirtableFieldShape } from './arrayFields.js';
+/**
+ * Supported filter operators for Airtable queries
+ */
+export declare const WhereConditionOperators: z.ZodEnum<{
+    in: "in";
+    not: "not";
+    contains: "contains";
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    notIn: "notIn";
+    ilike: "ilike";
+}>;
+export type WhereConditionOperatorType = z.infer<typeof WhereConditionOperators>;
+/**
+ * Check if a key is a condition operator
+ */
+export declare const isConditionOperator: (key: string) => key is WhereConditionOperatorType;
+/**
+ * Check if a value is a nested condition object (e.g., { contains: 'value' })
+ */
+export declare const isNestedCondition: (value: unknown) => value is Partial<Record<WhereConditionOperatorType, unknown>>;
+/**
+ * Check if a string is a valid Airtable record ID
+ */
+export declare const isValidRecordId: (value: string) => boolean;
+export type FiltersToFormulaOptions = {
+    /**
+     * Filters object with field names as keys.
+     * Values can be direct values (equality) or operator objects like { contains: 'value' }
+     */
+    filters: Record<string, unknown> | undefined;
+    /**
+     * Table schema for field lookups (optional).
+     * If provided, field IDs will be resolved to field names.
+     */
+    tableSchema?: {
+        fields: Array<AirtableFieldShape & {
+            id: string;
+            name: string;
+        }>;
+    };
+    /**
+     * Callback to resolve a linked record ID to its primary field value.
+     * Required for filtering on multipleRecordLinks fields by record ID.
+     */
+    getPrimaryFieldForRecord?: (tableId: string, recordId: string) => Promise<string | undefined>;
+};
+/**
+ * Convert filters to Airtable filterByFormula string.
+ *
+ * Supports operators: contains, not, in, notIn, lt, lte, gt, gte, ilike
+ *
+ * @example
+ * // Equality
+ * { name: 'John' } -> {Name}="John"
+ *
+ * @example
+ * // Contains
+ * { name: { contains: 'john' } } -> SEARCH("john", {Name}) != ""
+ *
+ * @example
+ * // Multiple conditions
+ * { status: 'active', age: { gte: 18 } } -> AND({Status}="active", {Age}>=18)
+ */
+export declare const filtersToFormula: ({ filters, tableSchema, getPrimaryFieldForRecord, }: FiltersToFormulaOptions) => Promise<string | undefined>;

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

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+import { airtableEqualsFormula } from './arrayFields.js';
+// =============================================================================
+// Condition Operators
+// =============================================================================
+/**
+ * Supported filter operators for Airtable queries
+ */
+export const WhereConditionOperators = z.enum([
+    'contains',
+    'not',
+    'in',
+    'notIn',
+    'lt',
+    'lte',
+    'gt',
+    'gte',
+    'ilike',
+]);
+const WHERE_CONDITION_OPERATORS = WhereConditionOperators.options;
+/**
+ * Check if a key is a condition operator
+ */
+export const isConditionOperator = (key) => WHERE_CONDITION_OPERATORS.includes(key);
+/**
+ * Check if a value is a nested condition object (e.g., { contains: 'value' })
+ */
+export const isNestedCondition = (value) => {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return false;
+    // Check if any keys are condition operators
+    return Object.keys(value).some(key => isConditionOperator(key));
+};
+// =============================================================================
+// Formula Helpers
+// =============================================================================
+/** Regex to validate Airtable record IDs */
+const AIRTABLE_RECORD_ID_REGEX = /^rec[a-zA-Z0-9]{14}$/;
+/** SDK field name for record ID */
+const SDK_ID_FIELD = 'id';
+/**
+ * Check if a string is a valid Airtable record ID
+ */
+export const isValidRecordId = (value) => {
+    return !!value.match(AIRTABLE_RECORD_ID_REGEX);
+};
+/**
+ * Escape quotes in string values for Airtable formulas
+ */
+const escapeFormulaString = (value) => value.replace(/"/g, '\\"');
+/**
+ * Format a value for use in Airtable formulas
+ */
+const getAirtableFilterValue = (value) => {
+    if (value instanceof Date) {
+        if (!Number.isFinite(value.getTime())) {
+            throw new Error('Invalid Date passed to Airtable filter formula. Use a valid Date or ISO date string.');
+        }
+        return `"${value.toISOString()}"`;
+    }
+    if (typeof value === 'string') {
+        return `"${escapeFormulaString(value)}"`;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'TRUE()' : 'FALSE()';
+    }
+    if (value === undefined || value === null) {
+        return 'BLANK()';
+    }
+    // For numbers and other types, use as is
+    return String(value);
+};
+/**
+ * Convert filters to Airtable filterByFormula string.
+ *
+ * Supports operators: contains, not, in, notIn, lt, lte, gt, gte, ilike
+ *
+ * @example
+ * // Equality
+ * { name: 'John' } -> {Name}="John"
+ *
+ * @example
+ * // Contains
+ * { name: { contains: 'john' } } -> SEARCH("john", {Name}) != ""
+ *
+ * @example
+ * // Multiple conditions
+ * { status: 'active', age: { gte: 18 } } -> AND({Status}="active", {Age}>=18)
+ */
+export const filtersToFormula = async ({ filters, tableSchema, getPrimaryFieldForRecord, }) => {
+    if (!filters || Object.keys(filters).length === 0)
+        return undefined;
+    const conditions = [];
+    for (const [field, condition] of Object.entries(filters)) {
+        let value = condition;
+        let operator = 'equals';
+        if (isNestedCondition(condition)) {
+            operator = Object.keys(condition)[0];
+            value = condition[operator];
+        }
+        // Special case for id field - use RECORD_ID()
+        if (field === SDK_ID_FIELD || field === 'id') {
+            const recordIds = Array.isArray(value) ? value : [value];
+            if (operator === 'equals') {
+                conditions.push(`RECORD_ID() = '${recordIds[0]}'`);
+            }
+            else {
+                const recordIdClause = `OR(${recordIds
+                    .map(recordId => `RECORD_ID() = '${recordId}'`)
+                    .join(', ')})`;
+                if (operator === 'notIn' || operator === 'not') {
+                    conditions.push(`NOT(${recordIdClause})`);
+                    continue;
+                }
+                conditions.push(recordIdClause);
+            }
+            continue;
+        }
+        // Find the actual field in the schema
+        const fieldInfo = tableSchema?.fields.find(f => f.id === field || f.name === field);
+        // Skip undefined conditions
+        if (condition === undefined)
+            continue;
+        // Use field name from schema if available, otherwise use the key as-is
+        const fieldName = `{${fieldInfo?.name || field}}`;
+        // Pre-process linked record values
+        if (fieldInfo?.type === 'multipleRecordLinks' && getPrimaryFieldForRecord) {
+            const linkedRecordOptions = fieldInfo.options;
+            let linkedRecords = [];
+            if (value !== undefined) {
+                if (!Array.isArray(value)) {
+                    if (value !== '') {
+                        linkedRecords = [String(value)];
+                    }
+                }
+                else {
+                    linkedRecords = value;
+                }
+            }
+            // Resolve record IDs to primary field values
+            if (linkedRecordOptions?.linkedTableId) {
+                value = (await Promise.all(linkedRecords.map(async (recordValue) => {
+                    if (isValidRecordId(recordValue)) {
+                        const primaryColumn = await getPrimaryFieldForRecord(linkedRecordOptions.linkedTableId, recordValue);
+                        if (primaryColumn) {
+                            return primaryColumn;
+                        }
+                    }
+                    return recordValue;
+                }))).flat();
+            }
+        }
+        // Handle checkbox fields with string values
+        if (fieldInfo?.type === 'checkbox' &&
+            (operator === 'equals' || operator === 'not') &&
+            typeof value === 'string') {
+            const TRUE_VALUES = ['true', 'yes', 'y', 'TRUE'];
+            value = TRUE_VALUES.includes(value.toLowerCase()) ? true : false;
+        }
+        // Skip undefined values
+        if (value === undefined)
+            continue;
+        const textFieldRef = `ARRAYJOIN(${fieldName})`;
+        const equalsClause = (v) => fieldInfo
+            ? airtableEqualsFormula({
+                field: fieldInfo,
+                fieldName,
+                value: getAirtableFilterValue(v),
+            })
+            : `${fieldName}=${getAirtableFilterValue(v)}`;
+        // Build condition based on operator
+        switch (operator) {
+            case 'equals':
+                if (Array.isArray(value)) {
+                    const andClauses = value.map(equalsClause);
+                    conditions.push(`AND(${andClauses.join(',')})`);
+                }
+                else {
+                    conditions.push(equalsClause(value));
+                }
+                break;
+            case 'contains':
+                if (Array.isArray(value)) {
+                    const andClauses = value.map(v => `SEARCH(${getAirtableFilterValue(v)}, ${textFieldRef}) != ""`);
+                    conditions.push(`AND(${andClauses.join(',')})`);
+                }
+                else {
+                    conditions.push(`SEARCH(${getAirtableFilterValue(value)}, ${textFieldRef}) != ""`);
+                }
+                break;
+            case 'not':
+                if (Array.isArray(value) && value.length === 0) {
+                    break;
+                }
+                conditions.push(`NOT(${Array.isArray(value)
+                    ? `OR(${value.map(equalsClause).join(',')})`
+                    : equalsClause(value)})`);
+                break;
+            case 'in':
+                if (Array.isArray(value)) {
+                    const orClauses = value.map(equalsClause);
+                    conditions.push(`OR(${orClauses.join(',')})`);
+                }
+                break;
+            case 'notIn':
+                if (Array.isArray(value) && value.length > 0) {
+                    const orClauses = value.map(equalsClause);
+                    conditions.push(`NOT(OR(${orClauses.join(',')}))`);
+                }
+                break;
+            case 'lt':
+                conditions.push(`${fieldName}<${getAirtableFilterValue(value)}`);
+                break;
+            case 'lte':
+                conditions.push(`${fieldName}<=${getAirtableFilterValue(value)}`);
+                break;
+            case 'gt':
+                conditions.push(`${fieldName}>${getAirtableFilterValue(value)}`);
+                break;
+            case 'gte':
+                conditions.push(`${fieldName}>=${getAirtableFilterValue(value)}`);
+                break;
+            case 'ilike':
+                conditions.push(`LOWER(${textFieldRef}) = LOWER(${getAirtableFilterValue(value)})`);
+                break;
+        }
+    }
+    if (conditions.length === 0)
+        return undefined;
+    if (conditions.length === 1)
+        return conditions[0];
+    return `AND(${conditions.join(',')})`;
+};

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

@@ -0,0 +1,11 @@
+import { type AirtableSettings } from "./dispatch.js";
+import type { PlatformSession, ZiteRequestContext } from "../types.js";
+/** The build's Airtable integration `integrationId`, or undefined when it isn't one, or the host can't say. */
+export declare const airtableSettingsOf: (session: PlatformSession, integrationId: string) => Promise<AirtableSettings | undefined>;
+/**
+ * One generated Airtable table call, run here with the connection's placeholder
+ * token; egress swaps the real one in for Airtable alone, and refreshes it.
+ */
+export declare function runAirtableCall(host: ZiteRequestContext, session: PlatformSession, integrationId: string, settings: AirtableSettings, methodName: string, params: unknown, access: "signedIn" | "anyone" | "webhook" | "workflow"): Promise<unknown>;
+/** For tests: forget what this isolate learned. */
+export declare const resetAirtableSettings: () => void;

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

@@ -0,0 +1,70 @@
+import { executeAirtableCall } from "./dispatch.js";
+import { ZiteError, isZiteErrorCode } from "../errors.js";
+const AIRTABLE_API = "https://api.airtable.com";
+// The platform id `integrations.get` is answered under (`INTEGRATIONS_SDK_INTEGRATION_ID`).
+const CONNECTIONS = "__connections__";
+// A build's integrations don't change, so per isolate: only answers, never a pending call.
+const settingsHeld = new Map();
+let unsupported = false;
+const NOT_IMPLEMENTED = /does not implement (?:the )?method/i;
+/** The build's Airtable integration `integrationId`, or undefined when it isn't one, or the host can't say. */
+export const airtableSettingsOf = async (session, integrationId) => {
+    if (unsupported || !session.integrationSettings)
+        return undefined;
+    if (settingsHeld.has(integrationId))
+        return settingsHeld.get(integrationId) ?? undefined;
+    try {
+        const answer = await session.integrationSettings(integrationId);
+        const settings = answer?.serviceType === "airtable" && typeof answer.baseId === "string"
+            ? { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null }
+            : null;
+        settingsHeld.set(integrationId, settings);
+        return settings ?? undefined;
+    }
+    catch (error) {
+        if (error instanceof Error && NOT_IMPLEMENTED.test(error.message)) {
+            unsupported = true;
+            return undefined;
+        }
+        throw error;
+    }
+};
+/**
+ * One generated Airtable table call, run here with the connection's placeholder
+ * token; egress swaps the real one in for Airtable alone, and refreshes it.
+ */
+export async function runAirtableCall(host, session, integrationId, settings, methodName, params, access) {
+    // As classic: a demo reaches no connected account.
+    if (host.mode === "demo")
+        throw new ZiteError("FORBIDDEN", "This action is not available in demo mode");
+    const connection = await session.call({
+        integrationId: CONNECTIONS,
+        className: "Connections",
+        methodName: "get",
+        params: { name: integrationId },
+        access,
+    });
+    if ("error" in connection) {
+        const { code, message, userFacingMessage } = connection.error;
+        throw new ZiteError({ code: isZiteErrorCode(code) ? code : "INTERNAL_ERROR", message, userFacingMessage });
+    }
+    const token = connection.value?.accessToken;
+    if (typeof token !== "string") {
+        throw new ZiteError("INTERNAL_ERROR", `The ${integrationId} connection has no token`);
+    }
+    host.airtableReads ??= new Map();
+    return executeAirtableCall({
+        settings,
+        reads: host.airtableReads,
+        fetch: (path, init) => fetch(`${AIRTABLE_API}${path}`, {
+            method: init.method,
+            headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+            body: init.body === undefined ? undefined : JSON.stringify(init.body),
+        }),
+    }, methodName, params);
+}
+/** For tests: forget what this isolate learned. */
+export const resetAirtableSettings = () => {
+    settingsHeld.clear();
+    unsupported = false;
+};

package/dist/esm/start/data/baseRunner.d.ts

@@ -0,0 +1,92 @@
+import { type BulkCreateResponseType, type FindAllResponseType, type FindOneResponseType, type GetBaseResponseType, type LegacyRecordsFilterClauseType, type NameMappings } from "./types.js";
+/** One base-runner request, `path` from `/api/v1`; the platform sends it and answers with base-runner's response. */
+export type DataTransport = (request: {
+    method: string;
+    path: string;
+    body?: string;
+}) => Promise<Response>;
+type Sort = string | Array<{
+    field: string;
+    direction: "asc" | "desc";
+}>;
+/** An id as one path segment: an unencoded `/` or a `..` would move the request to another base's URL. */
+export declare const segment: (id: string | number) => string;
+export declare const createBaseRunner: (transport: DataTransport) => {
+    bases: {
+        get: ({ baseId }: {
+            baseId: string;
+        }) => Promise<GetBaseResponseType>;
+    };
+    records: {
+        get: ({ baseId, tableId, recordId, fields }: {
+            baseId: string;
+            tableId: string;
+            recordId: string;
+            fields?: string[];
+        }) => Promise<FindOneResponseType>;
+        findAll: ({ baseId, tableId, filters, offset, sort, limit, fields, }: {
+            baseId: string;
+            tableId: string;
+            filters?: LegacyRecordsFilterClauseType;
+            offset?: number;
+            sort?: Sort;
+            limit?: number;
+            fields?: string[];
+        }) => Promise<FindAllResponseType>;
+        create: ({ baseId, tableId, record }: {
+            baseId: string;
+            tableId: string;
+            record: Record<string, unknown>;
+        }) => Promise<FindOneResponseType>;
+        update: ({ baseId, tableId, recordId, record, }: {
+            baseId: string;
+            tableId: string;
+            recordId: string;
+            record: Record<string, unknown>;
+        }) => Promise<FindOneResponseType>;
+        delete: ({ baseId, tableId, recordId }: {
+            baseId: string;
+            tableId: string;
+            recordId: string;
+        }) => Promise<{
+            id: string;
+        }>;
+        bulkCreate: ({ baseId, tableId, records, matchOn, }: {
+            baseId: string;
+            tableId: string;
+            records: Record<string, unknown>[];
+            matchOn?: string[];
+        }) => Promise<BulkCreateResponseType>;
+    };
+    sql: {
+        execute: ({ baseId, sql, params, statementTimeoutMs, nameMappings, }: {
+            baseId: string;
+            sql: string;
+            params?: unknown[];
+            statementTimeoutMs?: number;
+            nameMappings?: NameMappings;
+        }) => Promise<unknown>;
+    };
+    auth: {
+        findAll: ({ baseId, appIds, filters, filter, offset, sort, limit, }: {
+            baseId: string;
+            appIds?: string[];
+            filters?: LegacyRecordsFilterClauseType;
+            filter?: unknown;
+            offset?: number;
+            sort?: Sort;
+            limit?: number;
+        }) => Promise<unknown>;
+        update: ({ baseId, userId, profile, }: {
+            baseId: string;
+            userId: string;
+            profile: {
+                firstName?: string | null;
+                lastName?: string | null;
+                image?: string | null;
+            };
+        }) => Promise<unknown>;
+    };
+};
+export type BaseRunner = ReturnType<typeof createBaseRunner>;
+export {};

package/dist/esm/start/data/baseRunner.js

@@ -0,0 +1,83 @@
+// Ported from restly's packages/workflow-edge/src/databases (client, records, sql, authUsers, bases):
+// the requests are the same bytes classic's DatabasesSdk sends; the host adds the key and the acting user.
+import { DatabasesApiError, } from "./types.js";
+/** An id as one path segment: an unencoded `/` or a `..` would move the request to another base's URL. */
+export const segment = (id) => {
+    const value = String(id);
+    const invalid = new DatabasesApiError(`Invalid id: "${value}"`, 400, "Bad Request");
+    if (value === "" || value === "." || value === "..")
+        throw invalid;
+    try {
+        return encodeURIComponent(value);
+    }
+    catch {
+        // A lone surrogate, which a visitor can send as JSON.
+        throw invalid;
+    }
+};
+/** Every path, however it was built: none may climb out of where it starts. */
+const apiPath = (path) => {
+    const full = `/api/v1${path}`;
+    const pathname = full.split("?")[0];
+    if (!new URL(full, "https://base-runner.invalid").pathname.endsWith(pathname)) {
+        throw new DatabasesApiError(`Invalid path: ${pathname}`, 400, "Bad Request");
+    }
+    return full;
+};
+export const createBaseRunner = (transport) => {
+    const send = async (method, path, body) => {
+        const response = await transport({ method, path: apiPath(path), body: body ? JSON.stringify(body) : undefined });
+        if (!response.ok) {
+            let errorMessage = response.statusText;
+            try {
+                const errorBody = (await response.json());
+                errorMessage = errorBody?.error?.message || errorBody?.message || errorMessage;
+            }
+            catch {
+                // If we can't parse the error body, fall back to statusText
+            }
+            throw new DatabasesApiError(errorMessage, response.status, response.statusText);
+        }
+        return response;
+    };
+    const json = async (method, path, body) => (await send(method, path, body)).json();
+    return {
+        bases: {
+            get: ({ baseId }) => json("GET", `/bases/${segment(baseId)}`),
+        },
+        records: {
+            get: ({ baseId, tableId, recordId, fields }) => json("GET", `/bases/${segment(baseId)}/tables/${segment(tableId)}/records/${segment(recordId)}${fields?.length ? `?fields=${encodeURIComponent(fields.join(","))}` : ""}`),
+            findAll: ({ baseId, tableId, filters, offset, sort, limit = 500, fields, }) => json("POST", `/bases/${segment(baseId)}/tables/${segment(tableId)}/records/list`, {
+                filters,
+                offset,
+                sort,
+                limit,
+                fields,
+            }),
+            create: ({ baseId, tableId, record }) => json("POST", `/bases/${segment(baseId)}/tables/${segment(tableId)}/records`, { record }),
+            update: ({ baseId, tableId, recordId, record, }) => json("PATCH", `/bases/${segment(baseId)}/tables/${segment(tableId)}/records/${segment(recordId)}`, { record }),
+            delete: async ({ baseId, tableId, recordId }) => {
+                await send("DELETE", `/bases/${segment(baseId)}/tables/${segment(tableId)}/records/${segment(recordId)}`);
+                return { id: recordId };
+            },
+            bulkCreate: ({ baseId, tableId, records, matchOn, }) => json("POST", `/bases/${segment(baseId)}/tables/${segment(tableId)}/records/bulk`, {
+                records,
+                matchOn,
+            }),
+        },
+        sql: {
+            execute: ({ baseId, sql, params, statementTimeoutMs, nameMappings, }) => json("POST", `/bases/${segment(baseId)}/sql`, { sql, params, statementTimeoutMs, nameMappings }),
+        },
+        auth: {
+            findAll: ({ baseId, appIds, filters, filter, offset, sort, limit = 500, }) => json("POST", `/bases/${segment(baseId)}/auth/users/list`, {
+                appIds,
+                filters,
+                filter,
+                offset,
+                sort,
+                limit,
+            }),
+            update: ({ baseId, userId, profile, }) => json("PATCH", `/bases/${segment(baseId)}/auth/users/${segment(userId)}`, profile),
+        },
+    };
+};

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

@@ -0,0 +1,16 @@
+import type { BaseRunner } from "./baseRunner.js";
+import { type BaseTable, type DataNameMappings } from "./types.js";
+export type DataContext = {
+    baseRunner: BaseRunner;
+    /** The build's base, from the platform; a base id the app sends is ignored. */
+    baseId: string;
+    nameMappings: DataNameMappings | null;
+    /** The base's tables, for field names and SQL names. */
+    tables: BaseTable[] | undefined;
+    /** A demo: only reads reach the database. */
+    readOnly: boolean;
+};
+export declare const DEMO_UNAVAILABLE_MESSAGE = "This action is not available in demo mode";
+export declare function asZiteClientError(error: unknown): unknown;
+/** One `zite.*` data call, as classic's dispatch runs it. */
+export declare function executeDatabasesCall(context: DataContext, methodName: string, params: any): Promise<any>;