zenstack-kit 0.1.1

package/dist/cli/commands.js

@@ -0,0 +1,308 @@
+/**
+ * Command implementations for zenstack-kit CLI
+ *
+ * These functions contain the core logic and can be tested independently
+ * from the CLI/UI layer.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { loadConfig } from "../config/loader.js";
+import { pullSchema } from "../schema/pull.js";
+import { createPrismaMigration, applyPrismaMigrations, previewPrismaMigrations, hasPrismaSchemaChanges, hasSnapshot, scanMigrationFolders, writeMigrationLog, initializeSnapshot, createInitialMigration, detectPotentialRenames, } from "../migrations/prisma.js";
+export class CommandError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CommandError";
+    }
+}
+/**
+ * Load and validate config, returning resolved paths
+ */
+export async function resolveConfig(ctx) {
+    const loaded = await loadConfig(ctx.cwd);
+    if (!loaded) {
+        throw new CommandError("No zenstack-kit config file found.");
+    }
+    const { config, configDir } = loaded;
+    const relativeSchemaPath = ctx.options.schema || config.schema || "./schema.zmodel";
+    const relativeOutputPath = ctx.options.migrations || config.migrations?.migrationsFolder || "./prisma/migrations";
+    const dialect = (ctx.options.dialect || config.dialect || "sqlite");
+    // Resolve paths relative to config file location
+    const schemaPath = path.resolve(configDir, relativeSchemaPath);
+    const outputPath = path.resolve(configDir, relativeOutputPath);
+    return { config, schemaPath, outputPath, dialect };
+}
+/**
+ * Validate that the schema file exists (schemaPath should be absolute)
+ */
+export function validateSchemaExists(schemaPath) {
+    if (!fs.existsSync(schemaPath)) {
+        throw new CommandError(`ZenStack schema file not found: ${schemaPath}`);
+    }
+}
+/**
+ * Get connection URL from config based on dialect
+ */
+export function getConnectionUrl(config, dialect) {
+    const dbCredentials = config.dbCredentials;
+    return dialect === "sqlite"
+        ? dbCredentials?.file
+        : dbCredentials?.url;
+}
+/**
+ * migrate:generate command
+ */
+export async function runMigrateGenerate(ctx) {
+    const { config, schemaPath, outputPath, dialect } = await resolveConfig(ctx);
+    validateSchemaExists(schemaPath);
+    const snapshotExists = await hasSnapshot(outputPath);
+    if (!snapshotExists) {
+        throw new CommandError("No snapshot found. Run 'zenstack-kit init' first.");
+    }
+    ctx.log("info", "Generating migration...");
+    const hasChanges = await hasPrismaSchemaChanges({
+        schemaPath,
+        outputPath,
+    });
+    if (!hasChanges) {
+        ctx.log("warning", "No schema changes detected");
+        return;
+    }
+    // Detect potential renames and prompt user to disambiguate
+    const potentialRenames = await detectPotentialRenames({ schemaPath, outputPath });
+    const renameTables = [];
+    const renameColumns = [];
+    // Prompt for table renames
+    for (const rename of potentialRenames.tables) {
+        if (ctx.promptTableRename) {
+            const choice = await ctx.promptTableRename(rename.from, rename.to);
+            if (choice === "rename") {
+                renameTables.push(rename);
+            }
+        }
+    }
+    // Prompt for column renames
+    for (const rename of potentialRenames.columns) {
+        if (ctx.promptColumnRename) {
+            const choice = await ctx.promptColumnRename(rename.table, rename.from, rename.to);
+            if (choice === "rename") {
+                renameColumns.push(rename);
+            }
+        }
+    }
+    const name = ctx.options.name || "migration";
+    const migration = await createPrismaMigration({
+        name,
+        schemaPath,
+        outputPath,
+        dialect,
+        renameTables: renameTables.length > 0 ? renameTables : undefined,
+        renameColumns: renameColumns.length > 0 ? renameColumns : undefined,
+    });
+    if (!migration) {
+        ctx.log("warning", "No schema changes detected");
+        return;
+    }
+    ctx.log("success", `Migration created: ${migration.folderName}/migration.sql`);
+    ctx.log("info", `Path: ${migration.folderPath}`);
+}
+/**
+ * migrate:apply command
+ */
+export async function runMigrateApply(ctx) {
+    const { config, outputPath, dialect } = await resolveConfig(ctx);
+    const connectionUrl = getConnectionUrl(config, dialect);
+    const migrationsTable = ctx.options.table || config.migrations?.migrationsTable || "_prisma_migrations";
+    const migrationsSchema = ctx.options.dbSchema ||
+        config.migrations?.migrationsSchema ||
+        "public";
+    const snapshotExists = await hasSnapshot(outputPath);
+    if (!snapshotExists) {
+        throw new CommandError("No snapshot found. Run 'zenstack-kit init' first.");
+    }
+    const migrations = await scanMigrationFolders(outputPath);
+    if (migrations.length === 0) {
+        throw new CommandError("No migrations found.");
+    }
+    if (dialect !== "sqlite" && !connectionUrl) {
+        throw new CommandError("Database connection URL is required for non-sqlite dialects.");
+    }
+    const databasePath = dialect === "sqlite" ? connectionUrl : undefined;
+    // Preview mode - show pending migrations without applying
+    if (ctx.options.preview) {
+        ctx.log("info", "Preview mode - showing pending migrations:");
+        const preview = await previewPrismaMigrations({
+            migrationsFolder: outputPath,
+            dialect,
+            connectionUrl,
+            databasePath,
+            migrationsTable,
+            migrationsSchema,
+        });
+        if (preview.pending.length === 0) {
+            ctx.log("warning", "No pending migrations");
+            if (preview.alreadyApplied.length > 0) {
+                ctx.log("info", `${preview.alreadyApplied.length} migration(s) already applied`);
+            }
+            return;
+        }
+        for (const migration of preview.pending) {
+            ctx.log("info", `Pending: ${migration.name}`);
+            ctx.log("info", `SQL:\n${migration.sql}`);
+        }
+        return;
+    }
+    ctx.log("info", "Applying migrations...");
+    const result = await applyPrismaMigrations({
+        migrationsFolder: outputPath,
+        dialect,
+        connectionUrl,
+        databasePath,
+        migrationsTable,
+        migrationsSchema,
+    });
+    if (result.applied.length === 0 && !result.failed) {
+        ctx.log("warning", "No pending migrations");
+        if (result.alreadyApplied.length > 0) {
+            ctx.log("info", `${result.alreadyApplied.length} migration(s) already applied`);
+        }
+        return;
+    }
+    for (const item of result.applied) {
+        ctx.log("success", `Applied: ${item.migrationName} (${item.duration}ms)`);
+    }
+    if (result.failed) {
+        throw new CommandError(`Migration failed: ${result.failed.migrationName} - ${result.failed.error}`);
+    }
+}
+/**
+ * init command
+ */
+export async function runInit(ctx) {
+    const { config, schemaPath, outputPath, dialect } = await resolveConfig(ctx);
+    validateSchemaExists(schemaPath);
+    const snapshotExists = await hasSnapshot(outputPath);
+    const existingMigrations = await scanMigrationFolders(outputPath);
+    // CASE A: Snapshot already exists
+    if (snapshotExists) {
+        if (!ctx.promptSnapshotExists) {
+            throw new CommandError("Snapshot already exists and no prompt handler provided.");
+        }
+        const choice = await ctx.promptSnapshotExists();
+        if (choice === "skip") {
+            ctx.log("warning", "Skipped - no changes made");
+            return;
+        }
+        ctx.log("info", "Reinitializing...");
+        const result = await initializeSnapshot({ schemaPath, outputPath });
+        const migrations = await scanMigrationFolders(outputPath);
+        await writeMigrationLog(outputPath, migrations);
+        ctx.log("success", `Snapshot recreated: ${result.snapshotPath}`);
+        ctx.log("success", `Migration log rebuilt with ${migrations.length} migration(s)`);
+        ctx.log("info", `${result.tableCount} table(s) captured`);
+        return;
+    }
+    // CASE B: No snapshot but migrations exist (takeover mode)
+    if (existingMigrations.length > 0) {
+        ctx.log("info", "Initializing snapshot...");
+        ctx.log("warning", `Found ${existingMigrations.length} existing migration(s) without snapshot.`);
+        ctx.log("info", "Taking over from existing migrations...");
+        for (const migration of existingMigrations) {
+            ctx.log("info", `${migration.name} (${migration.checksum.slice(0, 8)}...)`);
+        }
+        const result = await initializeSnapshot({ schemaPath, outputPath });
+        await writeMigrationLog(outputPath, existingMigrations);
+        ctx.log("success", `Snapshot created: ${result.snapshotPath}`);
+        ctx.log("success", `Migration log created with ${existingMigrations.length} migration(s)`);
+        ctx.log("info", `${result.tableCount} table(s) captured`);
+        return;
+    }
+    // CASE C: Fresh init (no snapshot, no migrations)
+    let choice;
+    if (ctx.options.baseline) {
+        choice = "baseline";
+    }
+    else if (ctx.options.createInitial) {
+        choice = "create_initial";
+    }
+    else if (ctx.promptFreshInit) {
+        choice = await ctx.promptFreshInit();
+    }
+    else {
+        throw new CommandError("Fresh init requires --baseline or --create-initial flag, or a prompt handler.");
+    }
+    if (choice === "baseline") {
+        ctx.log("info", "Creating baseline snapshot...");
+        const result = await initializeSnapshot({ schemaPath, outputPath });
+        await writeMigrationLog(outputPath, []);
+        ctx.log("success", `Snapshot created: ${result.snapshotPath}`);
+        ctx.log("success", "Empty migration log created");
+        ctx.log("info", `${result.tableCount} table(s) captured`);
+        ctx.log("info", "Baselined. Future changes will generate migrations.");
+        return;
+    }
+    // Create initial migration
+    ctx.log("info", "Creating initial migration...");
+    const migration = await createInitialMigration({
+        name: "init",
+        schemaPath,
+        outputPath,
+        dialect,
+    });
+    ctx.log("success", `Initial migration created: ${migration.folderName}/migration.sql`);
+    ctx.log("info", `Path: ${migration.folderPath}`);
+    ctx.log("info", "Run migrate:apply to set up the database.");
+}
+/**
+ * pull command
+ */
+export async function runPull(ctx) {
+    const { config, dialect, outputPath: migrationsPath } = await resolveConfig(ctx);
+    const connectionUrl = getConnectionUrl(config, dialect);
+    if (dialect !== "sqlite" && !connectionUrl) {
+        throw new CommandError("Database connection URL is required for non-sqlite dialects.");
+    }
+    const databasePath = dialect === "sqlite" ? connectionUrl : undefined;
+    const schemaOutputPath = ctx.options.output || config.schema || "./schema.zmodel";
+    // Check for existing files that would be affected
+    const existingFiles = [];
+    if (fs.existsSync(schemaOutputPath)) {
+        existingFiles.push(`Schema: ${schemaOutputPath}`);
+    }
+    const snapshotExists = await hasSnapshot(migrationsPath);
+    if (snapshotExists) {
+        existingFiles.push(`Snapshot: ${migrationsPath}/meta/_snapshot.json`);
+    }
+    const migrations = await scanMigrationFolders(migrationsPath);
+    if (migrations.length > 0) {
+        existingFiles.push(`Migrations: ${migrations.length} migration(s) in ${migrationsPath}`);
+    }
+    // If there are existing files and not using --force, ask for confirmation
+    if (existingFiles.length > 0 && !ctx.options.force) {
+        ctx.log("warning", "The following files/directories already exist:");
+        for (const file of existingFiles) {
+            ctx.log("info", `  ${file}`);
+        }
+        if (!ctx.promptPullConfirm) {
+            throw new CommandError("Existing schema/migrations found. Use --force to overwrite, or provide a prompt handler.");
+        }
+        const confirmed = await ctx.promptPullConfirm(existingFiles);
+        if (!confirmed) {
+            ctx.log("warning", "Aborted - no changes made");
+            return;
+        }
+    }
+    ctx.log("info", "Pulling schema from database...");
+    const result = await pullSchema({
+        dialect,
+        connectionUrl,
+        databasePath,
+        outputPath: schemaOutputPath,
+    });
+    ctx.log("success", `Schema generated: ${result.outputPath}`);
+    ctx.log("info", `${result.tableCount} table(s) introspected`);
+    // If we have existing migrations, warn about resetting
+    if (snapshotExists || migrations.length > 0) {
+        ctx.log("warning", "You should run 'zenstack-kit init' to reset the snapshot after reviewing the schema.");
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * zenstack-kit CLI - Database tooling for ZenStack schemas
+ *
+ * Commands:
+ *   migrate:generate  Generate a new SQL migration
+ *   migrate:apply     Apply pending migrations
+ *   init              Initialize snapshot from existing schema
+ *   pull              Introspect database and generate schema
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;GAQG"}

package/dist/cli/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * zenstack-kit CLI - Database tooling for ZenStack schemas
+ *
+ * Commands:
+ *   migrate:generate  Generate a new SQL migration
+ *   migrate:apply     Apply pending migrations
+ *   init              Initialize snapshot from existing schema
+ *   pull              Introspect database and generate schema
+ */
+import { runCli } from "./app.js";
+runCli();

package/dist/cli/prompt-provider.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=prompt-provider.d.ts.map

package/dist/cli/prompt-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-provider.d.ts","sourceRoot":"","sources":["../../src/cli/prompt-provider.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/cli/prompt-provider.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/cli/prompts.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Interactive prompts for the init command using ink
+ */
+export type InitChoice = "skip" | "reinitialize" | "baseline" | "create_initial";
+export type ConfirmChoice = "yes" | "no";
+/**
+ * Prompt user when snapshot already exists (Case A)
+ */
+export declare function promptSnapshotExists(): Promise<InitChoice>;
+/**
+ * Prompt user for fresh init when no migrations exist (Case C)
+ */
+export declare function promptFreshInit(): Promise<InitChoice>;
+/**
+ * Prompt user to confirm overwriting existing files during pull
+ */
+export declare function promptPullConfirm(existingFiles: string[]): Promise<boolean>;
+export type RenameChoice = "rename" | "delete_create";
+/**
+ * Prompt user to disambiguate a potential table rename
+ */
+export declare function promptTableRename(from: string, to: string): Promise<RenameChoice>;
+/**
+ * Prompt user to disambiguate a potential column rename
+ */
+export declare function promptColumnRename(table: string, from: string, to: string): Promise<RenameChoice>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/cli/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/cli/prompts.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,cAAc,GAAG,UAAU,GAAG,gBAAgB,CAAC;AACjF,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,IAAI,CAAC;AAsCzC;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,UAAU,CAAC,CAyBhE;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,CAyB3D;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CA+BjF;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,eAAe,CAAC;AAEtD;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAyBvF;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,YAAY,CAAC,CAyBvB"}

package/dist/cli/prompts.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Interactive prompts for the init command using ink
+ */
+import { useState } from "react";
+import { render, Box, Text } from "ink";
+import SelectInput from "ink-select-input";
+function SelectPrompt({ message, items, onSelect }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const handleSelect = (item) => {
+        onSelect(item.value);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: "? " }), _jsx(Text, { children: message })] }), _jsx(SelectInput, { items: items, onSelect: handleSelect, onHighlight: (item) => {
+                    const idx = items.findIndex((i) => i.value === item.value);
+                    if (idx !== -1)
+                        setSelectedIndex(idx);
+                } }), items[selectedIndex]?.description && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["  ", items[selectedIndex].description] }) }))] }));
+}
+/**
+ * Prompt user when snapshot already exists (Case A)
+ */
+export async function promptSnapshotExists() {
+    return new Promise((resolve) => {
+        const { unmount, waitUntilExit } = render(_jsx(SelectPrompt, { message: "Snapshot already exists. What would you like to do?", items: [
+                {
+                    label: "Skip",
+                    value: "skip",
+                    description: "Do nothing and exit",
+                },
+                {
+                    label: "Reinitialize",
+                    value: "reinitialize",
+                    description: "Overwrite snapshot and rebuild migration log from existing migrations",
+                },
+            ], onSelect: (value) => {
+                unmount();
+                resolve(value);
+            } }));
+        waitUntilExit();
+    });
+}
+/**
+ * Prompt user for fresh init when no migrations exist (Case C)
+ */
+export async function promptFreshInit() {
+    return new Promise((resolve) => {
+        const { unmount, waitUntilExit } = render(_jsx(SelectPrompt, { message: "No migrations found. What would you like to do?", items: [
+                {
+                    label: "Baseline only",
+                    value: "baseline",
+                    description: "Create snapshot only - use when database already matches schema",
+                },
+                {
+                    label: "Create initial migration",
+                    value: "create_initial",
+                    description: "Create snapshot + initial migration - use when database is empty",
+                },
+            ], onSelect: (value) => {
+                unmount();
+                resolve(value);
+            } }));
+        waitUntilExit();
+    });
+}
+/**
+ * Prompt user to confirm overwriting existing files during pull
+ */
+export async function promptPullConfirm(existingFiles) {
+    return new Promise((resolve) => {
+        const { unmount, waitUntilExit } = render(_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "yellow", children: "\u26A0 " }), _jsx(Text, { children: "Existing files will be affected. Continue?" })] }), _jsx(SelectPrompt, { message: "", items: [
+                        {
+                            label: "No, abort",
+                            value: "no",
+                            description: "Cancel and keep existing files",
+                        },
+                        {
+                            label: "Yes, continue",
+                            value: "yes",
+                            description: "Overwrite schema file (migrations will not be deleted)",
+                        },
+                    ], onSelect: (value) => {
+                        unmount();
+                        resolve(value === "yes");
+                    } })] }));
+        waitUntilExit();
+    });
+}
+/**
+ * Prompt user to disambiguate a potential table rename
+ */
+export async function promptTableRename(from, to) {
+    return new Promise((resolve) => {
+        const { unmount, waitUntilExit } = render(_jsx(SelectPrompt, { message: `Table "${from}" was removed and "${to}" was added. Is this a rename?`, items: [
+                {
+                    label: `Rename "${from}" to "${to}"`,
+                    value: "rename",
+                    description: "Preserve data by renaming the table",
+                },
+                {
+                    label: `Delete "${from}" and create "${to}"`,
+                    value: "delete_create",
+                    description: "Drop the old table and create a new one (data will be lost)",
+                },
+            ], onSelect: (value) => {
+                unmount();
+                resolve(value);
+            } }));
+        waitUntilExit();
+    });
+}
+/**
+ * Prompt user to disambiguate a potential column rename
+ */
+export async function promptColumnRename(table, from, to) {
+    return new Promise((resolve) => {
+        const { unmount, waitUntilExit } = render(_jsx(SelectPrompt, { message: `Column "${from}" was removed and "${to}" was added in table "${table}". Is this a rename?`, items: [
+                {
+                    label: `Rename "${from}" to "${to}"`,
+                    value: "rename",
+                    description: "Preserve data by renaming the column",
+                },
+                {
+                    label: `Delete "${from}" and create "${to}"`,
+                    value: "delete_create",
+                    description: "Drop the old column and create a new one (data will be lost)",
+                },
+            ], onSelect: (value) => {
+                unmount();
+                resolve(value);
+            } }));
+        waitUntilExit();
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * zenstack-kit CLI - Database tooling for ZenStack schemas
+ *
+ * Commands:
+ *   migrate:generate  Generate a new SQL migration
+ *   migrate:apply     Apply pending migrations
+ *   init              Initialize snapshot from existing schema
+ *   pull              Introspect database and generate schema
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA;;;;;;;;GAQG"}