zitejs 0.0.1 → 0.2.0

package/README.md

@@ -0,0 +1,30 @@
+# zitejs
+
+The Zite framework package. Provides typed access to your Zite Database, API endpoints, authentication, and more.
+
+## Usage
+
+```ts
+// Database client (generated per-project by `zite sync`)
+import { zite } from 'zitejs/db';
+const users = await zite.users.findMany();
+
+// Define API endpoints
+import { createEndpoint, ZiteError } from 'zitejs/api';
+export default createEndpoint({
+  execute: async ({ input }) => { ... },
+});
+
+// Authentication
+import { useAuth } from 'zitejs/auth';
+const { user } = useAuth();
+
+// File uploads
+import { useUpload } from 'zitejs/upload';
+
+// PDF generation
+import { ZitePdf } from 'zitejs/pdf';
+
+// Scheduled tasks
+import { ZiteSchedule } from 'zitejs/schedules';
+```

package/api/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * zitejs/api — Server-side endpoint definition.
+ *
+ * Usage:
+ *   import { createEndpoint, ZiteError } from 'zitejs/api';
+ *
+ *   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 };
+ *     },
+ *   });
+ */
+
+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 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;

package/api/index.js

@@ -0,0 +1,13 @@
+// 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;
+  }
+}
+
+export function createEndpoint(config) {
+  return config;
+}

package/auth/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * zitejs/auth — Authentication helpers.
+ *
+ * Usage:
+ *   import { useAuth } from 'zitejs/auth';
+ *   const { user, isLoading } = useAuth();
+ */
+
+export interface ZiteUser {
+  id: string;
+  email?: string;
+  name?: string;
+  [key: string]: unknown;
+}
+
+export declare function useAuth(): {
+  user: ZiteUser | null;
+  isLoading: boolean;
+  authLoading: boolean;
+  logout: () => void;
+};
+
+export declare function getCurrentUser(): ZiteUser | null;

package/auth/index.js

@@ -0,0 +1,8 @@
+// zitejs/auth — runtime stub.
+export function useAuth() {
+  return { user: null, isLoading: true, authLoading: true, logout: () => {} };
+}
+
+export function getCurrentUser() {
+  return null;
+}

package/db/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * zitejs/db — The database client.
+ *
+ * The `zite` object is generated per-project by `zite sync` and provides
+ * typed access to your Zite Database tables.
+ *
+ * Usage:
+ *   import { zite } from 'zitejs/db';
+ *   const users = await zite.users.findMany();
+ *
+ * The actual `zite` object is generated into `.zite/db.ts` in your project.
+ * This module re-exports it. If you see type errors, run `zite sync` to
+ * regenerate the client.
+ */
+
+export declare const zite: Record<
+  string,
+  {
+    findMany(params?: Record<string, unknown>): Promise<{
+      records: Record<string, unknown>[];
+      hasMore: boolean;
+    }>;
+    findOne(id: string): Promise<Record<string, unknown>>;
+    create(data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    update(
+      id: string,
+      data: Record<string, unknown>,
+    ): Promise<Record<string, unknown>>;
+    delete(id: string): Promise<void>;
+    bulkCreate(
+      items: Record<string, unknown>[],
+    ): Promise<Record<string, unknown>[]>;
+  }
+>;

package/db/index.js

@@ -0,0 +1,23 @@
+// zitejs/db — runtime stub.
+// The actual `zite` object is generated by `zite sync` into .zite/db.ts.
+// This stub exists so the package resolves; the generated code overrides it.
+export const zite = new Proxy(
+  {},
+  {
+    get(_, tableName) {
+      const notGenerated = () => {
+        throw new Error(
+          `zite.${String(tableName)} is not available. Run \`zite sync\` to generate the database client.`,
+        );
+      };
+      return {
+        findMany: notGenerated,
+        findOne: notGenerated,
+        create: notGenerated,
+        update: notGenerated,
+        delete: notGenerated,
+        bulkCreate: notGenerated,
+      };
+    },
+  },
+);

package/package.json

@@ -1,13 +1,50 @@
 {
   "name": "zitejs",
-  "version": "0.0.1",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.2.0",
+  "description": "The Zite framework — build apps on Zite Database",
+  "type": "module",
+  "bin": {
+    "zitejs": "./sync/index.js"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": "Official Zite JavaScript SDK",
-  "types": "index.d.ts"
+  "exports": {
+    "./db": {
+      "types": "./db/index.d.ts",
+      "default": "./db/index.js"
+    },
+    "./api": {
+      "types": "./api/index.d.ts",
+      "default": "./api/index.js"
+    },
+    "./auth": {
+      "types": "./auth/index.d.ts",
+      "default": "./auth/index.js"
+    },
+    "./upload": {
+      "types": "./upload/index.d.ts",
+      "default": "./upload/index.js"
+    },
+    "./pdf": {
+      "types": "./pdf/index.d.ts",
+      "default": "./pdf/index.js"
+    },
+    "./schedules": {
+      "types": "./schedules/index.d.ts",
+      "default": "./schedules/index.js"
+    }
+  },
+  "files": [
+    "db",
+    "api",
+    "auth",
+    "upload",
+    "pdf",
+    "schedules",
+    "sync"
+  ],
+  "keywords": ["zite", "zitejs", "framework", "database", "vibe-coding"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zite/zitejs"
+  }
 }

package/pdf/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * zitejs/pdf — PDF generation.
+ *
+ * Usage:
+ *   import { ZitePdf } from 'zitejs/pdf';
+ *   const pdf = new ZitePdf();
+ *   const result = await pdf.generate({ html: '<h1>Hello</h1>' });
+ */
+
+export declare class ZitePdf {
+  generate(options: { html: string; [key: string]: unknown }): Promise<{
+    url: string;
+    [key: string]: unknown;
+  }>;
+}

package/pdf/index.js

@@ -0,0 +1,6 @@
+// zitejs/pdf — runtime stub.
+export class ZitePdf {
+  async generate() {
+    throw new Error('ZitePdf is not available outside the Zite sandbox.');
+  }
+}

package/schedules/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * zitejs/schedules — Scheduled task helpers.
+ *
+ * Usage:
+ *   import { ZiteSchedule } from 'zitejs/schedules';
+ */
+
+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/schedules/index.js

@@ -0,0 +1,12 @@
+// zitejs/schedules — runtime stub.
+export class ZiteSchedule {
+  static async create() {
+    throw new Error('ZiteSchedule is not available outside the Zite sandbox.');
+  }
+  static async delete() {
+    throw new Error('ZiteSchedule is not available outside the Zite sandbox.');
+  }
+  static async list() {
+    throw new Error('ZiteSchedule is not available outside the Zite sandbox.');
+  }
+}

package/sync/index.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+/**
+ * zitejs sync — fetches your Zite Database schema and generates
+ * a typed .zite/db.ts client with a fetch()-based runtime.
+ *
+ * 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 { join, dirname } from 'path';
+
+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, {
+    headers: { Authorization: `Bearer ${TOKEN}` },
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to fetch base metadata (${res.status}): ${await res.text()}`,
+    );
+  }
+  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.');
+    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
+    }
+  }
+
+  if (!baseId) {
+    console.error('Error: Could not determine base ID. Set ZITE_BASE_ID or ensure zite.config.json exists.');
+    process.exit(1);
+  }
+
+  console.log(`Syncing database ${baseId}...`);
+
+  const base = await fetchBaseMetadata(baseId);
+  console.log(`Found ${base.tables?.length ?? 0} tables`);
+
+  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}`);
+
+  console.log('Done!');
+}
+
+main().catch(err => {
+  console.error('Sync failed:', err.message);
+  process.exit(1);
+});

package/upload/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * zitejs/upload — File upload helpers.
+ *
+ * Usage:
+ *   import { useUpload } from 'zitejs/upload';
+ */
+
+export declare function useUpload(): {
+  upload: (file: File) => Promise<{ url: string }>;
+  isUploading: boolean;
+};

package/upload/index.js

@@ -0,0 +1,4 @@
+// zitejs/upload — runtime stub.
+export function useUpload() {
+  return { upload: async () => ({ url: '' }), isUploading: false };
+}

package/index.d.ts

@@ -1 +0,0 @@
-export {};

package/index.js

@@ -1 +0,0 @@
-module.exports = {};