zitejs 0.9.43 → 0.9.45

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/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/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,4 @@
+#!/usr/bin/env node
+export * from "./lib.js";
+export declare function runSync(): Promise<void>;
+export declare function regenerateApiTs(): void;

package/dist/cjs/sync/index.js

@@ -1,8 +1,23 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSync = runSync;
 exports.regenerateApiTs = regenerateApiTs;
+__exportStar(require("./lib.js"), exports);
 const fs_1 = require("fs");
 const path_1 = require("path");
 const lib_js_1 = require("./lib.js");

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;