zenstack-kit 0.1.1

package/dist/prompts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Prompt utilities with injectable provider for tests.
+ */
+export interface PromptProvider {
+    question(message: string): Promise<string>;
+}
+export declare function createDefaultPromptProvider(): PromptProvider;
+export declare function setPromptProvider(provider: PromptProvider | null): void;
+export declare function getPromptProvider(): PromptProvider;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../src/prompts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC5C;AAED,wBAAgB,2BAA2B,IAAI,cAAc,CAS5D;AAID,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAEvE;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAsBlD"}

package/dist/prompts.js

@@ -0,0 +1,41 @@
+/**
+ * Prompt utilities with injectable provider for tests.
+ */
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+export function createDefaultPromptProvider() {
+    return {
+        async question(message) {
+            const rl = createInterface({ input, output });
+            const answer = await rl.question(message);
+            rl.close();
+            return answer;
+        },
+    };
+}
+let currentProvider = null;
+export function setPromptProvider(provider) {
+    currentProvider = provider;
+}
+export function getPromptProvider() {
+    if (currentProvider) {
+        return currentProvider;
+    }
+    const envAnswers = process.env.ZENSTACK_KIT_PROMPT_ANSWERS;
+    if (envAnswers) {
+        try {
+            const parsed = JSON.parse(envAnswers);
+            const queue = Array.isArray(parsed) ? [...parsed] : [];
+            currentProvider = {
+                async question() {
+                    return queue.shift() ?? "";
+                },
+            };
+            return currentProvider;
+        }
+        catch {
+            return createDefaultPromptProvider();
+        }
+    }
+    return createDefaultPromptProvider();
+}

package/dist/pull.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Database pull utilities
+ *
+ * Uses Kysely introspection to generate a ZenStack schema from a live database.
+ */
+import { type KyselyDialect } from "./kysely-adapter.js";
+export interface PullOptions {
+    /** Database dialect */
+    dialect: KyselyDialect;
+    /** Database connection URL */
+    connectionUrl?: string;
+    /** SQLite database path (for SQLite dialect) */
+    databasePath?: string;
+    /** Output path for schema */
+    outputPath: string;
+}
+export interface PullResult {
+    outputPath: string;
+    schema: string;
+    tableCount: number;
+}
+export declare function pullSchema(options: PullOptions): Promise<PullResult>;
+//# sourceMappingURL=pull.d.ts.map

package/dist/pull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../src/pull.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE9E,MAAM,WAAW,WAAW;IAC1B,uBAAuB;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,8BAA8B;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gDAAgD;IAChD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAmfD,wBAAsB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAwC1E"}

package/dist/pull.js

@@ -0,0 +1,424 @@
+/**
+ * Database pull utilities
+ *
+ * Uses Kysely introspection to generate a ZenStack schema from a live database.
+ */
+import * as fs from "fs/promises";
+import * as path from "path";
+import { sql } from "kysely";
+import { createKyselyAdapter } from "./kysely-adapter.js";
+const INTERNAL_TABLES = new Set([
+    "_kysely_migration",
+    "_kysely_migration_lock",
+    "__drizzle_migrations",
+    "sqlite_sequence",
+]);
+function isInternalTable(name) {
+    return INTERNAL_TABLES.has(name) || name.startsWith("sqlite_");
+}
+function pluralize(word) {
+    if (word.endsWith("s") || word.endsWith("x") || word.endsWith("ch") || word.endsWith("sh")) {
+        return word + "es";
+    }
+    if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) {
+        return word.slice(0, -1) + "ies";
+    }
+    return word + "s";
+}
+function singularize(word) {
+    if (word.endsWith("ies")) {
+        return word.slice(0, -3) + "y";
+    }
+    if (word.endsWith("es") && (word.endsWith("ses") || word.endsWith("xes") || word.endsWith("ches") || word.endsWith("shes"))) {
+        return word.slice(0, -2);
+    }
+    if (word.endsWith("s") && !word.endsWith("ss")) {
+        return word.slice(0, -1);
+    }
+    return word;
+}
+function toPascalCase(value) {
+    const parts = value.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+    return parts
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join("");
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    return pascal.length > 0 ? pascal.charAt(0).toLowerCase() + pascal.slice(1) : value;
+}
+function normalizeType(dataType) {
+    const lower = dataType.toLowerCase();
+    const isArray = lower.endsWith("[]");
+    const base = isArray ? lower.slice(0, -2) : lower;
+    const normalized = base.replace(/\(.+\)/, "").trim();
+    if (normalized.includes("bigint"))
+        return { type: "BigInt", isArray };
+    if (normalized.includes("int"))
+        return { type: "Int", isArray };
+    if (normalized.includes("bool"))
+        return { type: "Boolean", isArray };
+    if (normalized.includes("date") || normalized.includes("time"))
+        return { type: "DateTime", isArray };
+    if (normalized.includes("json"))
+        return { type: "Json", isArray };
+    if (normalized.includes("blob") || normalized.includes("bytea") || normalized.includes("binary"))
+        return { type: "Bytes", isArray };
+    if (normalized.includes("decimal") || normalized.includes("numeric"))
+        return { type: "Decimal", isArray };
+    if (normalized.includes("real") || normalized.includes("double") || normalized.includes("float"))
+        return { type: "Float", isArray };
+    if (normalized.includes("char") || normalized.includes("text") || normalized.includes("uuid"))
+        return { type: "String", isArray };
+    return { type: "String", isArray };
+}
+function buildDatasourceBlock(dialect) {
+    return [
+        "datasource db {",
+        `  provider = \"${dialect}\"`,
+        "  url      = env(\"DATABASE_URL\")",
+        "}",
+        "",
+        "generator client {",
+        "  provider = \"prisma-client-js\"",
+        "}",
+        "",
+    ].join("\n");
+}
+function buildModelBlock(options) {
+    const { table, foreignKeys, indexes, primaryKeys, allTables } = options;
+    const modelName = toPascalCase(table.name) || "Model";
+    const fieldLines = [];
+    // Get primary key columns for this table
+    const tablePk = primaryKeys.find((pk) => pk.table === table.name);
+    const pkColumns = new Set(tablePk?.columns ?? []);
+    const isCompositePk = pkColumns.size > 1;
+    // Group foreign keys by fromColumn for this table
+    const fkByColumn = new Map();
+    const incomingFks = [];
+    for (const fk of foreignKeys) {
+        if (fk.fromTable === table.name) {
+            fkByColumn.set(fk.fromColumn, fk);
+        }
+        if (fk.toTable === table.name) {
+            incomingFks.push(fk);
+        }
+    }
+    // Get unique columns from indexes (excluding PK columns)
+    const uniqueColumns = new Set();
+    const compositeUniques = [];
+    for (const idx of indexes) {
+        if (idx.table === table.name && idx.isUnique) {
+            // Skip if this index matches the primary key
+            const isPkIndex = idx.columns.length === pkColumns.size &&
+                idx.columns.every((c) => pkColumns.has(c));
+            if (isPkIndex)
+                continue;
+            if (idx.columns.length === 1) {
+                uniqueColumns.add(idx.columns[0]);
+            }
+            else {
+                compositeUniques.push(idx.columns);
+            }
+        }
+    }
+    const sortedColumns = [...table.columns].sort((a, b) => a.name.localeCompare(b.name));
+    for (const column of sortedColumns) {
+        const fieldName = toCamelCase(column.name) || column.name;
+        const mapped = fieldName !== column.name;
+        const { type, isArray } = normalizeType(column.dataType);
+        const optional = column.isNullable ? "?" : "";
+        const modifiers = [];
+        const isPkColumn = pkColumns.has(column.name);
+        // For single-column PK, add @id to the field
+        if (isPkColumn && !isCompositePk) {
+            modifiers.push("@id");
+            if (column.isAutoIncrementing) {
+                modifiers.push("@default(autoincrement())");
+            }
+        }
+        // Add @unique for unique columns (but not PK columns)
+        if (uniqueColumns.has(column.name) && !isPkColumn) {
+            modifiers.push("@unique");
+        }
+        if (mapped) {
+            modifiers.push(`@map("${column.name}")`);
+        }
+        if (column.hasDefaultValue && !modifiers.some((m) => m.includes("@default"))) {
+            modifiers.push("@default(dbgenerated())");
+        }
+        const typeSuffix = isArray ? "[]" : "";
+        const modifierText = modifiers.length > 0 ? ` ${modifiers.join(" ")}` : "";
+        fieldLines.push(`  ${fieldName} ${type}${typeSuffix}${optional}${modifierText}`);
+    }
+    // Add relation fields for outgoing foreign keys
+    for (const fk of fkByColumn.values()) {
+        if (!allTables.has(fk.toTable))
+            continue;
+        const relatedModel = toPascalCase(fk.toTable);
+        const relationFieldName = toCamelCase(singularize(fk.toTable));
+        const fkFieldName = toCamelCase(fk.fromColumn);
+        // Find if the FK column is nullable
+        const fkColumn = table.columns.find((c) => c.name === fk.fromColumn);
+        const optional = fkColumn?.isNullable ? "?" : "";
+        fieldLines.push(`  ${relationFieldName} ${relatedModel}${optional} @relation(fields: [${fkFieldName}], references: [${toCamelCase(fk.toColumn)}])`);
+    }
+    // Add reverse relation fields for incoming foreign keys
+    const incomingByTable = new Map();
+    for (const fk of incomingFks) {
+        if (!allTables.has(fk.fromTable))
+            continue;
+        const existing = incomingByTable.get(fk.fromTable) ?? [];
+        existing.push(fk);
+        incomingByTable.set(fk.fromTable, existing);
+    }
+    for (const [fromTable, fks] of incomingByTable) {
+        const relatedModel = toPascalCase(fromTable);
+        const relationFieldName = toCamelCase(pluralize(fromTable));
+        // If there are multiple FKs from the same table, we need to name them
+        if (fks.length > 1) {
+            for (const fk of fks) {
+                const suffix = toPascalCase(fk.fromColumn.replace(/Id$/, ""));
+                fieldLines.push(`  ${relationFieldName}By${suffix} ${relatedModel}[]`);
+            }
+        }
+        else {
+            fieldLines.push(`  ${relationFieldName} ${relatedModel}[]`);
+        }
+    }
+    const lines = [`model ${modelName} {`, ...fieldLines];
+    // Add composite primary key
+    if (isCompositePk && tablePk) {
+        const fieldNames = tablePk.columns.map((c) => toCamelCase(c));
+        lines.push(`  @@id([${fieldNames.join(", ")}])`);
+    }
+    // Add composite unique constraints
+    for (const columns of compositeUniques) {
+        const fieldNames = columns.map((c) => toCamelCase(c));
+        lines.push(`  @@unique([${fieldNames.join(", ")}])`);
+    }
+    if (table.name !== modelName.toLowerCase()) {
+        lines.push(`  @@map("${table.name}")`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+async function extractForeignKeys(db, dialect) {
+    const foreignKeys = [];
+    if (dialect === "sqlite") {
+        // SQLite: query each table's foreign keys via PRAGMA
+        const tables = await db.introspection.getTables({ withInternalKyselyTables: false });
+        for (const table of tables) {
+            if (table.isView || isInternalTable(table.name))
+                continue;
+            const result = await sql `PRAGMA foreign_key_list(${sql.raw(`"${table.name}"`)})`.execute(db);
+            for (const row of result.rows) {
+                foreignKeys.push({
+                    constraintName: `fk_${table.name}_${row.from}`,
+                    fromTable: table.name,
+                    fromColumn: row.from,
+                    toTable: row.table,
+                    toColumn: row.to,
+                });
+            }
+        }
+    }
+    else if (dialect === "postgres") {
+        const result = await sql `
+      SELECT
+        tc.constraint_name,
+        tc.table_name as from_table,
+        kcu.column_name as from_column,
+        ccu.table_name as to_table,
+        ccu.column_name as to_column
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
+    `.execute(db);
+        for (const row of result.rows) {
+            foreignKeys.push({
+                constraintName: row.constraint_name,
+                fromTable: row.from_table,
+                fromColumn: row.from_column,
+                toTable: row.to_table,
+                toColumn: row.to_column,
+            });
+        }
+    }
+    else if (dialect === "mysql") {
+        const result = await sql `
+      SELECT
+        CONSTRAINT_NAME,
+        TABLE_NAME,
+        COLUMN_NAME,
+        REFERENCED_TABLE_NAME,
+        REFERENCED_COLUMN_NAME
+      FROM information_schema.KEY_COLUMN_USAGE
+      WHERE REFERENCED_TABLE_NAME IS NOT NULL
+        AND TABLE_SCHEMA = DATABASE()
+    `.execute(db);
+        for (const row of result.rows) {
+            foreignKeys.push({
+                constraintName: row.CONSTRAINT_NAME,
+                fromTable: row.TABLE_NAME,
+                fromColumn: row.COLUMN_NAME,
+                toTable: row.REFERENCED_TABLE_NAME,
+                toColumn: row.REFERENCED_COLUMN_NAME,
+            });
+        }
+    }
+    return foreignKeys;
+}
+async function extractIndexes(db, dialect, tableNames) {
+    const indexes = [];
+    if (dialect === "sqlite") {
+        for (const tableName of tableNames) {
+            const indexList = await sql `PRAGMA index_list(${sql.raw(`"${tableName}"`)})`.execute(db);
+            for (const idx of indexList.rows) {
+                // Skip internal sqlite indexes, but allow sqlite_autoindex_ which are auto-created for UNIQUE constraints
+                if (idx.name.startsWith("sqlite_") && !idx.name.startsWith("sqlite_autoindex_"))
+                    continue;
+                const indexInfo = await sql `PRAGMA index_info(${sql.raw(`"${idx.name}"`)})`.execute(db);
+                indexes.push({
+                    name: idx.name,
+                    table: tableName,
+                    columns: indexInfo.rows.map((r) => r.name),
+                    isUnique: idx.unique === 1,
+                });
+            }
+        }
+    }
+    else if (dialect === "postgres") {
+        const result = await sql `
+      SELECT indexname, tablename, indexdef
+      FROM pg_indexes
+      WHERE schemaname = 'public'
+    `.execute(db);
+        for (const row of result.rows) {
+            const isUnique = row.indexdef.toUpperCase().includes("UNIQUE");
+            const colMatch = row.indexdef.match(/\(([^)]+)\)/);
+            const columns = colMatch
+                ? colMatch[1].split(",").map((c) => c.trim().replace(/"/g, ""))
+                : [];
+            indexes.push({
+                name: row.indexname,
+                table: row.tablename,
+                columns,
+                isUnique,
+            });
+        }
+    }
+    else if (dialect === "mysql") {
+        for (const tableName of tableNames) {
+            const result = await sql `SHOW INDEX FROM ${sql.raw(`\`${tableName}\``)}`.execute(db);
+            const byName = new Map();
+            for (const row of result.rows) {
+                if (!byName.has(row.Key_name)) {
+                    byName.set(row.Key_name, { columns: [], isUnique: row.Non_unique === 0 });
+                }
+                byName.get(row.Key_name).columns.push(row.Column_name);
+            }
+            for (const [name, info] of byName) {
+                indexes.push({
+                    name,
+                    table: tableName,
+                    columns: info.columns,
+                    isUnique: info.isUnique,
+                });
+            }
+        }
+    }
+    return indexes;
+}
+async function extractPrimaryKeys(db, dialect, tableNames) {
+    const primaryKeys = [];
+    if (dialect === "sqlite") {
+        for (const tableName of tableNames) {
+            const tableInfo = await sql `PRAGMA table_info(${sql.raw(`"${tableName}"`)})`.execute(db);
+            const pkColumns = tableInfo.rows
+                .filter((row) => row.pk > 0)
+                .sort((a, b) => a.pk - b.pk)
+                .map((row) => row.name);
+            if (pkColumns.length > 0) {
+                primaryKeys.push({ table: tableName, columns: pkColumns });
+            }
+        }
+    }
+    else if (dialect === "postgres") {
+        const result = await sql `
+      SELECT
+        tc.table_name,
+        kcu.column_name,
+        kcu.ordinal_position
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_schema = 'public'
+      ORDER BY tc.table_name, kcu.ordinal_position
+    `.execute(db);
+        const byTable = new Map();
+        for (const row of result.rows) {
+            if (!byTable.has(row.table_name)) {
+                byTable.set(row.table_name, []);
+            }
+            byTable.get(row.table_name).push(row.column_name);
+        }
+        for (const [table, columns] of byTable) {
+            primaryKeys.push({ table, columns });
+        }
+    }
+    else if (dialect === "mysql") {
+        for (const tableName of tableNames) {
+            const result = await sql `SHOW INDEX FROM ${sql.raw(`\`${tableName}\``)} WHERE Key_name = 'PRIMARY'`.execute(db);
+            const columns = result.rows
+                .sort((a, b) => a.Seq_in_index - b.Seq_in_index)
+                .map((row) => row.Column_name);
+            if (columns.length > 0) {
+                primaryKeys.push({ table: tableName, columns });
+            }
+        }
+    }
+    return primaryKeys;
+}
+export async function pullSchema(options) {
+    const { db, destroy } = await createKyselyAdapter({
+        dialect: options.dialect,
+        connectionUrl: options.connectionUrl,
+        databasePath: options.databasePath,
+    });
+    try {
+        const tables = await db.introspection.getTables({ withInternalKyselyTables: false });
+        const filtered = tables.filter((table) => !table.isView && !isInternalTable(table.name));
+        const tableNames = filtered.map((t) => t.name);
+        const allTables = new Set(tableNames);
+        const foreignKeys = await extractForeignKeys(db, options.dialect);
+        const indexes = await extractIndexes(db, options.dialect, tableNames);
+        const primaryKeys = await extractPrimaryKeys(db, options.dialect, tableNames);
+        const blocks = filtered.map((table) => buildModelBlock({
+            table,
+            foreignKeys,
+            indexes,
+            primaryKeys,
+            allTables,
+        }));
+        const schema = [buildDatasourceBlock(options.dialect), ...blocks].join("\n\n");
+        await fs.mkdir(path.dirname(options.outputPath), { recursive: true });
+        await fs.writeFile(options.outputPath, schema.trimEnd() + "\n", "utf-8");
+        return {
+            outputPath: options.outputPath,
+            schema,
+            tableCount: filtered.length,
+        };
+    }
+    finally {
+        await destroy();
+    }
+}

package/dist/schema/introspect.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Schema introspection utilities
+ *
+ * Provides functionality to introspect ZenStack schemas and databases,
+ * extracting model and field information for code generation.
+ */
+export interface FieldInfo {
+    /** Field name */
+    name: string;
+    /** Field type (String, Int, Boolean, etc.) */
+    type: string;
+    /** Whether the field is optional */
+    isOptional: boolean;
+    /** Whether the field is an array */
+    isArray: boolean;
+    /** Whether this is a relation field */
+    isRelation: boolean;
+    /** Whether this is the primary key */
+    isId: boolean;
+    /** Whether the field has a default value */
+    hasDefault: boolean;
+    /** Whether the field is unique */
+    isUnique: boolean;
+    /** Related model name (for relations) */
+    relationModel?: string;
+}
+export interface ModelInfo {
+    /** Model name */
+    name: string;
+    /** Table name in database */
+    tableName: string;
+    /** Model fields */
+    fields: FieldInfo[];
+}
+export interface SchemaInfo {
+    /** All models in the schema */
+    models: ModelInfo[];
+    /** Schema version or hash */
+    version: string;
+}
+interface IntrospectOptions {
+    /** Path to ZenStack schema file */
+    schemaPath?: string;
+    /** Database connection URL (for database introspection) */
+    databaseUrl?: string;
+    /** Output path for generated schema */
+    outputPath?: string;
+}
+/**
+ * Introspect schema from file or database
+ */
+export declare function introspectSchema(options: IntrospectOptions): Promise<SchemaInfo>;
+export {};
+//# sourceMappingURL=introspect.d.ts.map

package/dist/schema/introspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../../src/schema/introspect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,MAAM,WAAW,SAAS;IACxB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,UAAU,EAAE,OAAO,CAAC;IACpB,oCAAoC;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,uCAAuC;IACvC,UAAU,EAAE,OAAO,CAAC;IACpB,sCAAsC;IACtC,IAAI,EAAE,OAAO,CAAC;IACd,4CAA4C;IAC5C,UAAU,EAAE,OAAO,CAAC;IACpB,kCAAkC;IAClC,QAAQ,EAAE,OAAO,CAAC;IAClB,yCAAyC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB;IACnB,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,+BAA+B;IAC/B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,iBAAiB;IACzB,mCAAmC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uCAAuC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAoED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,CAUtF"}

package/dist/schema/introspect.js

@@ -0,0 +1,75 @@
+/**
+ * Schema introspection utilities
+ *
+ * Provides functionality to introspect ZenStack schemas and databases,
+ * extracting model and field information for code generation.
+ */
+import * as fs from "fs/promises";
+/**
+ * Parse a .zmodel file and extract schema information
+ * This is a simplified parser - in production, you'd use ZenStack's AST
+ */
+async function parseZModelFile(schemaPath) {
+    const content = await fs.readFile(schemaPath, "utf-8");
+    const models = [];
+    // Simple regex-based parser for demonstration
+    // In production, integrate with ZenStack's parser
+    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g;
+    const fieldRegex = /^\s*(\w+)\s+(\w+)(\[\])?\s*(\?)?\s*(.*?)$/gm;
+    let modelMatch;
+    while ((modelMatch = modelRegex.exec(content)) !== null) {
+        const modelName = modelMatch[1];
+        const modelBody = modelMatch[2];
+        const fields = [];
+        let fieldMatch;
+        const fieldPattern = /^\s*(\w+)\s+(\w+)(\[\])?\s*(\?)?(.*)$/gm;
+        while ((fieldMatch = fieldPattern.exec(modelBody)) !== null) {
+            const [, name, type, isArray, isOptional, modifiers] = fieldMatch;
+            // Skip if it looks like a directive
+            if (name.startsWith("@@") || name.startsWith("//"))
+                continue;
+            const isId = modifiers?.includes("@id") || false;
+            const hasDefault = modifiers?.includes("@default") || false;
+            const isUnique = modifiers?.includes("@unique") || isId;
+            const isRelation = modifiers?.includes("@relation") || false;
+            fields.push({
+                name,
+                type,
+                isOptional: !!isOptional,
+                isArray: !!isArray,
+                isRelation,
+                isId,
+                hasDefault,
+                isUnique,
+                relationModel: isRelation ? type : undefined,
+            });
+        }
+        models.push({
+            name: modelName,
+            tableName: modelName.toLowerCase(),
+            fields,
+        });
+    }
+    // Generate a simple version hash
+    const version = Buffer.from(content).toString("base64").slice(0, 8);
+    return { models, version };
+}
+/**
+ * Introspect a database and generate schema information
+ */
+async function introspectDatabase(databaseUrl) {
+    void databaseUrl;
+    throw new Error("Database introspection is not supported.");
+}
+/**
+ * Introspect schema from file or database
+ */
+export async function introspectSchema(options) {
+    if (options.schemaPath) {
+        return parseZModelFile(options.schemaPath);
+    }
+    if (options.databaseUrl) {
+        return introspectDatabase(options.databaseUrl);
+    }
+    throw new Error("Either schemaPath or databaseUrl must be provided");
+}

package/dist/schema/pull.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Database pull utilities
+ *
+ * Uses Kysely introspection to generate a ZenStack schema from a live database.
+ */
+import { type KyselyDialect } from "../sql/kysely-adapter.js";
+export interface PullOptions {
+    /** Database dialect */
+    dialect: KyselyDialect;
+    /** Database connection URL */
+    connectionUrl?: string;
+    /** SQLite database path (for SQLite dialect) */
+    databasePath?: string;
+    /** Output path for schema */
+    outputPath: string;
+}
+export interface PullResult {
+    outputPath: string;
+    schema: string;
+    tableCount: number;
+}
+export declare function pullSchema(options: PullOptions): Promise<PullResult>;
+//# sourceMappingURL=pull.d.ts.map

package/dist/schema/pull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../src/schema/pull.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEnF,MAAM,WAAW,WAAW;IAC1B,uBAAuB;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,8BAA8B;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gDAAgD;IAChD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAmfD,wBAAsB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAwC1E"}