zitejs 0.9.42 → 0.9.44

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

@@ -0,0 +1,2 @@
+export declare function runGenerate(): Promise<void>;
+export declare function runDev(): Promise<void>;

package/dist/cjs/dev/index.js

@@ -53,6 +53,42 @@ function regenerateAppApiTs(appDir) {
         console.log(`Updated apps/${appDir}/.zite/api.ts`);
     }
 }
+function regenerateAppAirtableSdk(appDir) {
+    const lockPath = (0, path_1.join)('apps', appDir, 'zite.lock');
+    if (!(0, fs_2.existsSync)(lockPath))
+        return;
+    try {
+        const lockContent = JSON.parse((0, fs_2.readFileSync)(lockPath, 'utf-8'));
+        const integrations = lockContent.integrations ?? {};
+        for (const [integrationId, integration] of Object.entries(integrations)) {
+            const int = integration;
+            if (!int.idMappings?.tables)
+                continue;
+            const airtableLock = {
+                integrationId,
+                tables: Object.entries(int.idMappings.tables).map(([sdkName, tableId]) => ({
+                    id: tableId,
+                    sdkName,
+                    fields: Object.entries(int.idMappings?.fields?.[sdkName] ?? {}).map(([fieldSdkName, fieldId]) => ({
+                        id: fieldId,
+                        sdkName: fieldSdkName,
+                        type: 'singleLineText',
+                    })),
+                })),
+            };
+            const content = (0, lib_js_1.generateAirtableTs)(airtableLock);
+            if (content) {
+                const outDir = (0, path_1.join)('apps', appDir, '.zite', 'integrations');
+                (0, fs_2.mkdirSync)(outDir, { recursive: true });
+                (0, fs_2.writeFileSync)((0, path_1.join)(outDir, 'airtable.ts'), content);
+                console.log(`Updated apps/${appDir}/.zite/integrations/airtable.ts`);
+            }
+        }
+    }
+    catch {
+        // Lock file invalid or missing — skip
+    }
+}
 async function runGenerate() {
     // 1. Run sync (generates root .zite/db.ts)
     try {
@@ -66,6 +102,7 @@ async function runGenerate() {
     for (const app of appDirs) {
         regenerateAppApiTs(app);
         regenerateAppTypedWrappers(app);
+        regenerateAppAirtableSdk(app);
     }
     console.log('Done!');
 }

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { Zite } from "./client/index.js";
+export type { Record, RecordListOutput, RecordListOptions, FieldCreateInput, FieldUpdateInput, TableCreateInput, TableUpdateInput, DatabaseCreateInput, DatabaseListOutput, } from "./client/index.js";
+export * from "./types/index.js";

package/dist/cjs/internal/env.d.ts

@@ -0,0 +1 @@
+export declare function getEnv(key: string, viteKey?: string): string | undefined;

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

@@ -0,0 +1,9 @@
+export declare class ZitePdf {
+    generate(options: {
+        html: string;
+        [key: string]: unknown;
+    }): Promise<{
+        url: string;
+        [key: string]: unknown;
+    }>;
+}

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

@@ -0,0 +1,69 @@
+export interface TableClient<T> {
+    findAll(options?: {
+        limit?: number;
+        offset?: number;
+        sort?: unknown[];
+        filter?: unknown;
+        filters?: unknown;
+    }): Promise<{
+        records: T[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    findOne(recordId: string | {
+        filters?: unknown;
+        filter?: unknown;
+    }): Promise<T>;
+    create(data: {
+        record: Partial<T>;
+    }): Promise<T>;
+    update(id: string, data: {
+        record: Partial<T>;
+    }): Promise<T>;
+    delete(id: string): Promise<{
+        deleted: true;
+    }>;
+    bulkCreate(records: Partial<T>[]): Promise<T[]>;
+}
+export declare function createTableClient<T>(className: string): TableClient<T>;
+export interface SqlResult {
+    rows: Record<string, unknown>[];
+    columns: Array<{
+        name: string;
+        originalName: string;
+    }>;
+    rowCount: number;
+    truncated: boolean;
+}
+export declare function createSqlClient(): (params: {
+    query: string;
+    params?: unknown[];
+}) => Promise<SqlResult>;
+export interface AirtableTableClient<T> {
+    findAll(options?: {
+        offset?: string;
+        limit?: number;
+        filters?: unknown;
+    }): Promise<{
+        records: T[];
+        offset: string | undefined;
+        hasMore: boolean;
+    }>;
+    findOne(params: {
+        id?: string;
+        filters?: unknown;
+    }): Promise<T | undefined>;
+    create(data: {
+        record: Partial<T>;
+    }): Promise<T>;
+    bulkCreate(records: Partial<T>[]): Promise<T[]>;
+    update(id: string, data: {
+        record: Partial<T>;
+    }): Promise<T>;
+    delete(id: string): Promise<{
+        deleted: true;
+    }>;
+}
+export declare function createAirtableClient<T>(integrationId: string, className: string, implicitParams: Record<string, unknown>): AirtableTableClient<T>;
+export { createCaller } from "../caller/index.js";
+export type { EndpointConfig } from "../caller/index.js";

package/dist/cjs/runtime/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCaller = void 0;
 exports.createTableClient = createTableClient;
 exports.createSqlClient = createSqlClient;
+exports.createAirtableClient = createAirtableClient;
 function getSdkCall() {
     const fn = globalThis.__wrapSdkCall;
     if (!fn) {
@@ -76,5 +77,34 @@ function createSqlClient() {
         ...params,
     });
 }
+function createAirtableClient(integrationId, className, implicitParams) {
+    return {
+        findAll: (options) => getSdkCall()(integrationId, className, "findAll", {
+            ...implicitParams,
+            ...options,
+        }),
+        findOne: (params) => getSdkCall()(integrationId, className, "findOne", {
+            ...implicitParams,
+            ...params,
+        }),
+        create: (data) => getSdkCall()(integrationId, className, "create", {
+            ...implicitParams,
+            ...data,
+        }),
+        bulkCreate: (records) => getSdkCall()(integrationId, className, "bulkCreate", {
+            ...implicitParams,
+            records,
+        }),
+        update: (id, data) => getSdkCall()(integrationId, className, "update", {
+            ...implicitParams,
+            id,
+            ...data,
+        }),
+        delete: (id) => getSdkCall()(integrationId, className, "delete", {
+            ...implicitParams,
+            id,
+        }),
+    };
+}
 var index_js_1 = require("../caller/index.js");
 Object.defineProperty(exports, "createCaller", { enumerable: true, get: function () { return index_js_1.createCaller; } });

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

@@ -0,0 +1,16 @@
+export declare class ZiteSchedule {
+    static create(config: {
+        name: string;
+        cron: string;
+        endpoint: string;
+        input?: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+    }>;
+    static delete(id: string): Promise<void>;
+    static list(): Promise<Array<{
+        id: string;
+        name: string;
+        cron: string;
+    }>>;
+}

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function runSync(): Promise<void>;
+export declare function regenerateApiTs(): void;

package/dist/cjs/sync/lib.d.ts

@@ -0,0 +1,55 @@
+import type { PublicFieldDefinition } from "../types/fields.js";
+import type { Database } from "../types/tables.js";
+export type ZiteSchemaField = {
+    id: string;
+    sdkName: string;
+    definition: PublicFieldDefinition;
+};
+export type ZiteSchemaTable = {
+    id: string;
+    sdkName: string;
+    primaryFieldId?: string;
+    fields: ZiteSchemaField[];
+};
+export type ZiteSchema = {
+    tables: ZiteSchemaTable[];
+};
+export declare function toPascalCase(name: string): string;
+export declare function toCamelCase(name: string): string;
+/**
+ * Build a ZiteSchema from a Database API response.
+ *
+ * If `existingSchema` is provided, locked SDK names are preserved for
+ * tables/fields that already exist (matched by ID). New tables/fields
+ * get fresh camelCase SDK names. This is how `zitejs sync` preserves
+ * name stability across schema changes.
+ */
+export declare function generateSchema(database: Database, existingSchema?: ZiteSchema): ZiteSchema;
+/**
+ * Generate .zite/db.ts purely from ZiteSchema.
+ * Pure function — no external data needed beyond what's in the schema file.
+ */
+export declare function generateDbTs(schema: ZiteSchema): string;
+export declare function generateApiTs(endpointFiles: string[]): string | null;
+export declare function generateUserTs(usersTableFields?: Array<{
+    name: string;
+    type: string;
+}>): string;
+export declare function generateAuthWrapperTs(): string;
+export type AirtableLockField = {
+    id: string;
+    sdkName: string;
+    type: string;
+    options?: string[];
+};
+export type AirtableLockTable = {
+    id: string;
+    sdkName: string;
+    fields: AirtableLockField[];
+};
+export type AirtableLock = {
+    integrationId: string;
+    tables: AirtableLockTable[];
+};
+export declare function generateAirtableTs(lock: AirtableLock): string | null;
+export declare function generateBackendWrapperTs(): string;

package/dist/cjs/sync/lib.js

@@ -7,6 +7,7 @@ exports.generateDbTs = generateDbTs;
 exports.generateApiTs = generateApiTs;
 exports.generateUserTs = generateUserTs;
 exports.generateAuthWrapperTs = generateAuthWrapperTs;
+exports.generateAirtableTs = generateAirtableTs;
 exports.generateBackendWrapperTs = generateBackendWrapperTs;
 const FIELD_TYPE_MAP = {
     single_line_text: "string",
@@ -357,6 +358,86 @@ function generateAuthWrapperTs() {
         "",
     ].join("\n");
 }
+const AIRTABLE_FIELD_TYPE_MAP = {
+    singleLineText: "string",
+    multilineText: "string",
+    richText: "string",
+    email: "string",
+    url: "string",
+    phoneNumber: "string",
+    number: "number",
+    currency: "number",
+    percent: "number",
+    rating: "number",
+    duration: "number",
+    singleSelect: "string",
+    multipleSelects: "string[]",
+    checkbox: "boolean",
+    date: "string",
+    dateTime: "string",
+    attachment: "Array<{ url: string; filename?: string }>",
+    multipleRecordLinks: "string | string[]",
+    formula: "unknown",
+    rollup: "unknown",
+    lookup: "unknown",
+    count: "number",
+    autoNumber: "number",
+    barcode: "string",
+    button: "unknown",
+    createdTime: "string",
+    lastModifiedTime: "string",
+    createdBy: "unknown",
+    lastModifiedBy: "unknown",
+    externalSyncSource: "unknown",
+    aiText: "string",
+};
+function airtableTsType(field) {
+    if ((field.type === "singleSelect" || field.type === "multipleSelects") &&
+        field.options &&
+        field.options.length > 0) {
+        const literals = field.options
+            .slice(0, MAX_SELECT_OPTIONS)
+            .map((o) => `"${o.replace(/"/g, '\\"')}"`)
+            .join(" | ");
+        const union = `${literals} | string`;
+        if (field.type === "multipleSelects")
+            return `(${union})[]`;
+        return union;
+    }
+    return AIRTABLE_FIELD_TYPE_MAP[field.type] ?? "unknown";
+}
+function generateAirtableTs(lock) {
+    if (lock.tables.length === 0)
+        return null;
+    const lines = [
+        "// Auto-generated by zitejs generate from zite.lock. Do not edit manually.",
+        "// Airtable SDK — uses createAirtableClient from zitejs/runtime.",
+        "// The airtable package is externalized (not bundled per-endpoint).",
+        "",
+        "import { createAirtableClient } from 'zitejs/runtime';",
+        "",
+    ];
+    for (const table of lock.tables) {
+        const recordType = `${table.sdkName}RecordType`;
+        lines.push(`export type ${recordType} = {`);
+        lines.push("  id: string;");
+        for (const field of table.fields) {
+            if (field.sdkName === "id")
+                continue;
+            const tsType = airtableTsType(field);
+            lines.push(`  ${field.sdkName}: ${tsType};`);
+        }
+        lines.push("};");
+        lines.push("");
+        lines.push(`export const ${table.sdkName} = createAirtableClient<${recordType}>(`);
+        lines.push(`  '${lock.integrationId}',`);
+        lines.push(`  '${table.sdkName}',`);
+        lines.push(`  { tableId: '${table.id}' },`);
+        lines.push(`);`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
 function generateBackendWrapperTs() {
     return [
         "// Auto-generated type-narrowing wrapper. Do not edit manually.",