zitejs 0.2.0 → 0.4.0

package/api/index.d.ts

@@ -1,42 +1,21 @@
 /**
- * zitejs/api — Server-side endpoint definition.
+ * zitejs/api — Client-side typed API caller.
  *
- * Usage:
- *   import { createEndpoint, ZiteError } from 'zitejs/api';
+ * Used in generated .zite/api.ts files:
+ *   import { createCaller } from 'zitejs/api';
+ *   import myEndpoint from '../src/api/myEndpoint';
+ *   export const api = { myEndpoint: createCaller(myEndpoint) };
  *
- *   export default createEndpoint({
- *     description: 'Get user by ID',
- *     inputSchema: z.object({ id: z.string() }),
- *     outputSchema: z.object({ name: z.string() }),
- *     execute: async ({ input }) => {
- *       const user = await zite.users.findOne(input.id);
- *       return { name: user.name };
- *     },
- *   });
+ * Then consumed in app code:
+ *   import { api } from 'zitejs/api'; // resolved via tsconfig to .zite/api.ts
+ *   await api.myEndpoint({ ... });
  */
 
-export interface ZiteRequestContext {
-  userId?: string;
-  organizationId?: string;
-  [key: string]: unknown;
+export interface EndpointConfig<TInput = unknown, TOutput = unknown> {
+  _name?: string;
+  execute: (params: { input: TInput; context: unknown }) => Promise<TOutput> | TOutput;
 }
 
-export interface ZiteScheduledContext extends ZiteRequestContext {
-  scheduledAt: string;
-}
-
-export declare class ZiteError extends Error {
-  constructor(message: string, options?: { statusCode?: number });
-  statusCode: number;
-}
-
-export declare function createEndpoint<TInput = unknown, TOutput = unknown>(config: {
-  description?: string;
-  inputSchema?: unknown;
-  outputSchema?: unknown;
-  stream?: boolean;
-  execute: (params: {
-    input: TInput;
-    context: ZiteRequestContext | ZiteScheduledContext;
-  }) => Promise<TOutput> | TOutput;
-}): unknown;
+export declare function createCaller<TInput, TOutput>(
+  endpoint: EndpointConfig<TInput, TOutput>,
+): (input: TInput) => Promise<TOutput>;

package/api/index.js

@@ -1,13 +1,22 @@
-// zitejs/api — runtime stub.
-// The actual implementations are injected by the Zite sandbox at runtime.
-export class ZiteError extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = 'ZiteError';
-    this.statusCode = options?.statusCode ?? 500;
-  }
-}
+// zitejs/api — client-side typed API caller factory.
+
+const BASE_URL = process.env.ZITE_API_URL ?? '';
+const TOKEN = process.env.ZITE_DB_TOKEN ?? '';
 
-export function createEndpoint(config) {
-  return config;
+export function createCaller(endpoint) {
+  return async (input) => {
+    const res = await fetch(BASE_URL + '/api/' + endpoint._name, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(input),
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`API call failed (${res.status}): ${text}`);
+    }
+    return res.json();
+  };
 }

package/backend/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * zitejs/backend — Server-side endpoint definition.
+ *
+ * Usage:
+ *   import { createEndpoint, ZiteError } from 'zitejs/backend';
+ *   export default createEndpoint({ ... });
+ */
+
+export interface ZiteRequestContext {
+  userId?: string;
+  organizationId?: string;
+  [key: string]: unknown;
+}
+
+export interface ZiteScheduledContext extends ZiteRequestContext {
+  scheduledAt: string;
+}
+
+export declare class ZiteError extends Error {
+  constructor(message: string, options?: { statusCode?: number });
+  statusCode: number;
+}
+
+export interface EndpointConfig<TInput = unknown, TOutput = unknown> {
+  description?: string;
+  inputSchema?: unknown;
+  outputSchema?: unknown;
+  stream?: boolean;
+  _name?: string;
+  execute: (params: {
+    input: TInput;
+    context: ZiteRequestContext | ZiteScheduledContext;
+  }) => Promise<TOutput> | TOutput;
+}
+
+export declare function createEndpoint<
+  TInput = unknown,
+  TOutput = unknown,
+>(config: EndpointConfig<TInput, TOutput>): EndpointConfig<TInput, TOutput>;

package/backend/index.js

@@ -0,0 +1,13 @@
+// zitejs/backend — server-side endpoint definition.
+
+export class ZiteError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = 'ZiteError';
+    this.statusCode = options?.statusCode ?? 500;
+  }
+}
+
+export function createEndpoint(config) {
+  return config;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "bin": {
@@ -15,6 +15,10 @@
       "types": "./api/index.d.ts",
       "default": "./api/index.js"
     },
+    "./backend": {
+      "types": "./backend/index.d.ts",
+      "default": "./backend/index.js"
+    },
     "./auth": {
       "types": "./auth/index.d.ts",
       "default": "./auth/index.js"
@@ -30,11 +34,15 @@
     "./schedules": {
       "types": "./schedules/index.d.ts",
       "default": "./schedules/index.js"
+    },
+    "./sync": {
+      "default": "./sync/lib.js"
     }
   },
   "files": [
     "db",
     "api",
+    "backend",
     "auth",
     "upload",
     "pdf",

package/sync/index.js

@@ -1,68 +1,21 @@
 #!/usr/bin/env node
 
 /**
- * zitejs sync — fetches your Zite Database schema and generates
- * a typed .zite/db.ts client with a fetch()-based runtime.
+ * zitejs sync — CLI entry point.
+ * Fetches database schema, generates .zite/db.ts and .zite/api.ts.
  *
  * Usage:
  *   ZITE_DB_TOKEN=sk_prod_... npx zitejs sync
- *
- * Environment:
- *   ZITE_DB_TOKEN  — API token (required)
- *   ZITE_DB_URL    — Base URL (default: https://tables.fillout.com/api/v1)
- *   ZITE_BASE_ID   — Database ID (auto-detected from zite.config.json if omitted)
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
+import { generateSchema, generateDbTs, generateApiTs } from './lib.js';
 
 const BASE_URL =
   process.env.ZITE_DB_URL ?? 'https://tables.fillout.com/api/v1';
 const TOKEN = process.env.ZITE_DB_TOKEN ?? '';
 
-// Field type → TypeScript type mapping
-const FIELD_TYPE_MAP = {
-  single_line_text: 'string',
-  long_text: 'string',
-  email: 'string',
-  url: 'string',
-  phone_number: 'string',
-  number: 'number',
-  currency: 'number',
-  percent: 'number',
-  rating: 'number',
-  duration: 'number',
-  single_select: 'string',
-  multiple_select: 'string[]',
-  checkbox: 'boolean',
-  date: 'string',
-  datetime: 'string',
-  attachments: 'Array<{ url: string; name?: string }>',
-  linked_record: 'string[]',
-  lookup: 'unknown',
-  autonumber: 'number',
-  source: 'string',
-};
-
-function toLowerCamel(name) {
-  return name.charAt(0).toLowerCase() + name.slice(1);
-}
-
-function toPascalCase(name) {
-  return name
-    .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
-    .replace(/^(.)/, (_, c) => c.toUpperCase());
-}
-
-function toCamelCase(name) {
-  const pascal = toPascalCase(name);
-  return toLowerCamel(pascal);
-}
-
-function tsTypeForField(field) {
-  return FIELD_TYPE_MAP[field.type] ?? 'unknown';
-}
-
 async function fetchBaseMetadata(baseId) {
   const url = `${BASE_URL}/bases/${encodeURIComponent(baseId)}`;
   const res = await fetch(url, {
@@ -76,121 +29,22 @@ async function fetchBaseMetadata(baseId) {
   return res.json();
 }
 
-function generateSchema(base) {
-  const schema = { tables: {} };
-  for (const table of base.tables ?? []) {
-    const tableName = toCamelCase(table.name);
-    const fields = {};
-    for (const field of table.fields ?? []) {
-      fields[toCamelCase(field.name)] = { id: field.id };
-    }
-    schema.tables[tableName] = { id: table.id, fields };
-  }
-  return schema;
-}
-
-function generateDbTs(base, schema, baseId) {
-  const lines = [];
-
-  lines.push('// Auto-generated by zitejs sync. Do not edit manually.');
-  lines.push('');
-
-  // Runtime
-  lines.push(`const BASE_URL = process.env.ZITE_DB_URL ?? 'https://tables.fillout.com/api/v1';`);
-  lines.push(`const TOKEN = process.env.ZITE_DB_TOKEN ?? '';`);
-  lines.push('');
-  lines.push('async function dbFetch(method: string, path: string, body?: unknown) {');
-  lines.push('  const res = await fetch(BASE_URL + path, {');
-  lines.push('    method,');
-  lines.push('    headers: {');
-  lines.push('      Authorization: `Bearer ${TOKEN}`,');
-  lines.push("      ...(body ? { 'Content-Type': 'application/json' } : {}),");
-  lines.push('    },');
-  lines.push('    body: body ? JSON.stringify(body) : undefined,');
-  lines.push('  });');
-  lines.push('  if (!res.ok) {');
-  lines.push("    const text = await res.text().catch(() => '');");
-  lines.push('    throw new Error(`Zite DB request failed (${res.status}): ${text}`);');
-  lines.push('  }');
-  lines.push('  return res.json();');
-  lines.push('}');
-  lines.push('');
-
-  // Per-table types + client
-  for (const table of base.tables ?? []) {
-    const className = toPascalCase(table.name);
-    const propName = toCamelCase(table.name);
-    const recordType = `${className}RecordType`;
-
-    // Record type
-    lines.push(`export type ${recordType} = {`);
-    lines.push('  id: string;');
-    for (const field of table.fields ?? []) {
-      const fieldName = toCamelCase(field.name);
-      const tsType = tsTypeForField(field);
-      lines.push(`  ${fieldName}: ${tsType};`);
-    }
-    lines.push('  createdAt: string;');
-    lines.push('  updatedAt: string;');
-    lines.push('};');
-    lines.push('');
-  }
-
-  // createTableClient helper
-  lines.push('function createTableClient<T>(baseId: string, tableId: string) {');
-  lines.push('  const base = `/bases/${encodeURIComponent(baseId)}/tables/${encodeURIComponent(tableId)}`;');
-  lines.push('  return {');
-  lines.push('    findMany: (options?: { limit?: number; offset?: number; sort?: unknown[]; filter?: unknown }): Promise<{ records: T[]; total: number; hasMore: boolean }> =>');
-  lines.push('      dbFetch("POST", `${base}/records/list`, options),');
-  lines.push('    findOne: (recordId: string): Promise<T> =>');
-  lines.push('      dbFetch("GET", `${base}/records/${encodeURIComponent(recordId)}`),');
-  lines.push('    create: (data: Partial<T>): Promise<T> =>');
-  lines.push('      dbFetch("POST", `${base}/records`, { record: data }),');
-  lines.push('    update: (recordId: string, data: Partial<T>): Promise<T> =>');
-  lines.push('      dbFetch("PATCH", `${base}/records/${encodeURIComponent(recordId)}`, { record: data }),');
-  lines.push('    delete: (recordId: string): Promise<{ deleted: true }> =>');
-  lines.push('      dbFetch("DELETE", `${base}/records/${encodeURIComponent(recordId)}`),');
-  lines.push('    bulkCreate: (records: Partial<T>[]): Promise<T[]> =>');
-  lines.push('      dbFetch("POST", `${base}/records/bulk`, { records }),');
-  lines.push('  };');
-  lines.push('}');
-  lines.push('');
-
-  // Singleton
-  lines.push(`const BASE_ID = '${baseId}';`);
-  lines.push('');
-  lines.push('export const zite = {');
-  for (const table of base.tables ?? []) {
-    const className = toPascalCase(table.name);
-    const propName = toCamelCase(table.name);
-    const tableId = schema.tables[propName]?.id ?? table.id;
-    lines.push(`  ${propName}: createTableClient<${className}RecordType>(BASE_ID, '${tableId}'),`);
-  }
-  lines.push('};');
-  lines.push('');
-
-  return lines.join('\n');
-}
-
 async function main() {
   if (!TOKEN) {
-    console.error('Error: ZITE_DB_TOKEN is required. Set it in your .env or environment.');
+    console.error('Error: ZITE_DB_TOKEN is required.');
     process.exit(1);
   }
 
-  // Find base ID from zite.config.json or env
   let baseId = process.env.ZITE_BASE_ID;
   if (!baseId) {
     try {
       const config = JSON.parse(readFileSync('zite.config.json', 'utf-8'));
       baseId = config.project?.basePublicIdentifier;
-    } catch {
-      // ignore
-    }
+    } catch { /* ignore */ }
   }
 
   if (!baseId) {
-    console.error('Error: Could not determine base ID. Set ZITE_BASE_ID or ensure zite.config.json exists.');
+    console.error('Error: Could not determine base ID.');
     process.exit(1);
   }
 
@@ -201,17 +55,29 @@ async function main() {
 
   const schema = generateSchema(base);
 
-  // Write zite.schema.json
   writeFileSync('zite.schema.json', JSON.stringify(schema, null, 2));
   console.log('Wrote zite.schema.json');
 
-  // Write .zite/db.ts
   const dbTs = generateDbTs(base, schema, baseId);
   const dbPath = join('.zite', 'db.ts');
   mkdirSync(dirname(dbPath), { recursive: true });
   writeFileSync(dbPath, dbTs);
   console.log(`Wrote ${dbPath}`);
 
+  // Generate .zite/api.ts from src/api/*.ts
+  const apiDir = join('src', 'api');
+  if (existsSync(apiDir)) {
+    const endpointFiles = readdirSync(apiDir).filter(
+      f => f.endsWith('.ts') || f.endsWith('.js'),
+    );
+    const apiTs = generateApiTs(endpointFiles);
+    if (apiTs) {
+      const apiPath = join('.zite', 'api.ts');
+      writeFileSync(apiPath, apiTs);
+      console.log(`Wrote ${apiPath}`);
+    }
+  }
+
   console.log('Done!');
 }
 

package/sync/lib.js

@@ -0,0 +1,173 @@
+/**
+ * zitejs/sync — pure generator functions.
+ *
+ * These can be imported as a library (by our backend) or used by the
+ * CLI entry point. No fs/network dependencies — just string generation.
+ */
+
+// Field type → TypeScript type mapping
+const FIELD_TYPE_MAP = {
+  single_line_text: 'string',
+  long_text: 'string',
+  email: 'string',
+  url: 'string',
+  phone_number: 'string',
+  number: 'number',
+  currency: 'number',
+  percent: 'number',
+  rating: 'number',
+  duration: 'number',
+  single_select: 'string',
+  multiple_select: 'string[]',
+  checkbox: 'boolean',
+  date: 'string',
+  datetime: 'string',
+  attachments: 'Array<{ url: string; name?: string }>',
+  linked_record: 'string[]',
+  lookup: 'unknown',
+  autonumber: 'number',
+  source: 'string',
+};
+
+export function toPascalCase(name) {
+  return name
+    .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
+    .replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+
+export function toCamelCase(name) {
+  const pascal = toPascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function tsTypeForField(field) {
+  return FIELD_TYPE_MAP[field.type] ?? 'unknown';
+}
+
+/**
+ * Generate zite.schema.json content from base metadata.
+ */
+export function generateSchema(base) {
+  const schema = { tables: {} };
+  for (const table of base.tables ?? []) {
+    const tableName = toCamelCase(table.name);
+    const fields = {};
+    for (const field of table.fields ?? []) {
+      fields[toCamelCase(field.name)] = { id: field.id };
+    }
+    schema.tables[tableName] = { id: table.id, fields };
+  }
+  return schema;
+}
+
+/**
+ * Generate .zite/db.ts content from base metadata + schema.
+ */
+export function generateDbTs(base, schema, baseId) {
+  const lines = [];
+
+  lines.push('// Auto-generated by zitejs sync. Do not edit manually.');
+  lines.push('');
+  lines.push(`const BASE_URL = process.env.ZITE_DB_URL ?? 'https://tables.fillout.com/api/v1';`);
+  lines.push(`const TOKEN = process.env.ZITE_DB_TOKEN ?? '';`);
+  lines.push('');
+  lines.push('async function dbFetch(method: string, path: string, body?: unknown) {');
+  lines.push('  const res = await fetch(BASE_URL + path, {');
+  lines.push('    method,');
+  lines.push('    headers: {');
+  lines.push('      Authorization: `Bearer ${TOKEN}`,');
+  lines.push("      ...(body ? { 'Content-Type': 'application/json' } : {}),");
+  lines.push('    },');
+  lines.push('    body: body ? JSON.stringify(body) : undefined,');
+  lines.push('  });');
+  lines.push('  if (!res.ok) {');
+  lines.push("    const text = await res.text().catch(() => '');");
+  lines.push('    throw new Error(`Zite DB request failed (${res.status}): ${text}`);');
+  lines.push('  }');
+  lines.push('  return res.json();');
+  lines.push('}');
+  lines.push('');
+
+  for (const table of base.tables ?? []) {
+    const className = toPascalCase(table.name);
+    const recordType = `${className}RecordType`;
+
+    lines.push(`export type ${recordType} = {`);
+    lines.push('  id: string;');
+    for (const field of table.fields ?? []) {
+      const fieldName = toCamelCase(field.name);
+      const tsType = tsTypeForField(field);
+      lines.push(`  ${fieldName}: ${tsType};`);
+    }
+    lines.push('  createdAt: string;');
+    lines.push('  updatedAt: string;');
+    lines.push('};');
+    lines.push('');
+  }
+
+  lines.push('function createTableClient<T>(baseId: string, tableId: string) {');
+  lines.push('  const base = `/bases/${encodeURIComponent(baseId)}/tables/${encodeURIComponent(tableId)}`;');
+  lines.push('  return {');
+  lines.push('    findMany: (options?: { limit?: number; offset?: number; sort?: unknown[]; filter?: unknown }): Promise<{ records: T[]; total: number; hasMore: boolean }> =>');
+  lines.push('      dbFetch("POST", `${base}/records/list`, options),');
+  lines.push('    findOne: (recordId: string): Promise<T> =>');
+  lines.push('      dbFetch("GET", `${base}/records/${encodeURIComponent(recordId)}`),');
+  lines.push('    create: (data: Partial<T>): Promise<T> =>');
+  lines.push('      dbFetch("POST", `${base}/records`, { record: data }),');
+  lines.push('    update: (recordId: string, data: Partial<T>): Promise<T> =>');
+  lines.push('      dbFetch("PATCH", `${base}/records/${encodeURIComponent(recordId)}`, { record: data }),');
+  lines.push('    delete: (recordId: string): Promise<{ deleted: true }> =>');
+  lines.push('      dbFetch("DELETE", `${base}/records/${encodeURIComponent(recordId)}`),');
+  lines.push('    bulkCreate: (records: Partial<T>[]): Promise<T[]> =>');
+  lines.push('      dbFetch("POST", `${base}/records/bulk`, { records }),');
+  lines.push('  };');
+  lines.push('}');
+  lines.push('');
+
+  lines.push(`const BASE_ID = '${baseId}';`);
+  lines.push('');
+  lines.push('export const zite = {');
+  for (const table of base.tables ?? []) {
+    const className = toPascalCase(table.name);
+    const propName = toCamelCase(table.name);
+    const tableId = schema.tables[propName]?.id ?? table.id;
+    lines.push(`  ${propName}: createTableClient<${className}RecordType>(BASE_ID, '${tableId}'),`);
+  }
+  lines.push('};');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate .zite/api.ts content from a list of endpoint file names.
+ * @param endpointFiles — array of filenames like ['deleteRecord.ts', 'getRecords.ts']
+ */
+export function generateApiTs(endpointFiles) {
+  if (!endpointFiles || endpointFiles.length === 0) return null;
+
+  const lines = [
+    '// Auto-generated by zitejs sync. Do not edit manually.',
+    '',
+    "import { createCaller } from 'zitejs/api';",
+    '',
+  ];
+
+  const endpointNames = [];
+  for (const file of endpointFiles) {
+    const name = file.replace(/\.(ts|js)$/, '');
+    const camelName = toCamelCase(name);
+    lines.push(`import ${camelName}Endpoint from '../src/api/${name}';`);
+    endpointNames.push(camelName);
+  }
+
+  lines.push('');
+  lines.push('export const api = {');
+  for (const name of endpointNames) {
+    lines.push(`  ${name}: createCaller(${name}Endpoint),`);
+  }
+  lines.push('};');
+  lines.push('');
+
+  return lines.join('\n');
+}