zenstack-kit 0.1.1

package/dist/init-prompts.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Interactive prompts for the init command using ink
+ */
+export type InitChoice = "skip" | "reinitialize" | "baseline" | "create_initial";
+/**
+ * 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>;
+//# sourceMappingURL=init-prompts.d.ts.map

package/dist/init-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-prompts.d.ts","sourceRoot":"","sources":["../src/init-prompts.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,cAAc,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAsCjF;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,UAAU,CAAC,CAyBhE;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,CAyB3D"}

package/dist/init-prompts.js

@@ -0,0 +1,64 @@
+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();
+    });
+}

package/dist/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/introspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../src/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/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/kysely-adapter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Kysely database adapter
+ *
+ * Provides utilities to create Kysely instances configured for use
+ * with ZenStack-generated types.
+ */
+import type { Kysely } from "kysely";
+export type KyselyDialect = "sqlite" | "postgres" | "mysql";
+export interface KyselyAdapterOptions {
+    /** Database dialect */
+    dialect: KyselyDialect;
+    /** Database connection URL */
+    connectionUrl?: string;
+    /** SQLite database path (for SQLite dialect) */
+    databasePath?: string;
+    /** Connection pool settings */
+    pool?: {
+        min?: number;
+        max?: number;
+    };
+}
+export interface KyselyAdapter<DB> {
+    /** The Kysely instance */
+    db: Kysely<DB>;
+    /** Destroy the connection pool */
+    destroy: () => Promise<void>;
+}
+/**
+ * Creates a Kysely adapter for use with ZenStack schemas
+ *
+ * @example
+ * ```ts
+ * import { createKyselyAdapter } from "zenstack-kit";
+ * import type { Database } from "./generated/kysely-types";
+ *
+ * const { db, destroy } = await createKyselyAdapter<Database>({
+ *   dialect: "postgres",
+ *   connectionUrl: process.env.DATABASE_URL,
+ * });
+ *
+ * // Use db for queries
+ * const users = await db.selectFrom("user").selectAll().execute();
+ *
+ * // Clean up
+ * await destroy();
+ * ```
+ */
+export declare function createKyselyAdapter<DB>(options: KyselyAdapterOptions): Promise<KyselyAdapter<DB>>;
+//# sourceMappingURL=kysely-adapter.d.ts.map

package/dist/kysely-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-adapter.d.ts","sourceRoot":"","sources":["../src/kysely-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAW,MAAM,QAAQ,CAAC;AAE9C,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC;AAE5D,MAAM,WAAW,oBAAoB;IACnC,uBAAuB;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,8BAA8B;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gDAAgD;IAChD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,IAAI,CAAC,EAAE;QACL,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED,MAAM,WAAW,aAAa,CAAC,EAAE;IAC/B,0BAA0B;IAC1B,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IACf,kCAAkC;IAClC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,mBAAmB,CAAC,EAAE,EAC1C,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,CAwD5B"}

package/dist/kysely-adapter.js

@@ -0,0 +1,74 @@
+/**
+ * Kysely database adapter
+ *
+ * Provides utilities to create Kysely instances configured for use
+ * with ZenStack-generated types.
+ */
+/**
+ * Creates a Kysely adapter for use with ZenStack schemas
+ *
+ * @example
+ * ```ts
+ * import { createKyselyAdapter } from "zenstack-kit";
+ * import type { Database } from "./generated/kysely-types";
+ *
+ * const { db, destroy } = await createKyselyAdapter<Database>({
+ *   dialect: "postgres",
+ *   connectionUrl: process.env.DATABASE_URL,
+ * });
+ *
+ * // Use db for queries
+ * const users = await db.selectFrom("user").selectAll().execute();
+ *
+ * // Clean up
+ * await destroy();
+ * ```
+ */
+export async function createKyselyAdapter(options) {
+    // Dynamic imports based on dialect to avoid bundling unused drivers
+    let dialect;
+    switch (options.dialect) {
+        case "sqlite": {
+            const { default: Database } = await import("better-sqlite3");
+            const { SqliteDialect } = await import("kysely");
+            dialect = new SqliteDialect({
+                database: new Database(options.databasePath || ":memory:"),
+            });
+            break;
+        }
+        case "postgres": {
+            // Note: User needs to install pg package
+            const { Pool } = await import("pg");
+            const { PostgresDialect } = await import("kysely");
+            dialect = new PostgresDialect({
+                pool: new Pool({
+                    connectionString: options.connectionUrl,
+                    min: options.pool?.min ?? 2,
+                    max: options.pool?.max ?? 10,
+                }),
+            });
+            break;
+        }
+        case "mysql": {
+            // Note: User needs to install mysql2 package
+            const mysql = await import("mysql2");
+            const { MysqlDialect } = await import("kysely");
+            dialect = new MysqlDialect({
+                pool: mysql.createPool({
+                    uri: options.connectionUrl,
+                }),
+            });
+            break;
+        }
+        default:
+            throw new Error(`Unsupported dialect: ${options.dialect}`);
+    }
+    const { Kysely } = await import("kysely");
+    const db = new Kysely({ dialect });
+    return {
+        db,
+        destroy: async () => {
+            await db.destroy();
+        },
+    };
+}

package/dist/migrate-apply.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Apply migrations using Kysely's migrator
+ */
+import type { KyselyDialect } from "./kysely-adapter.js";
+export interface ApplyMigrationsOptions {
+    migrationsFolder: string;
+    dialect: KyselyDialect;
+    connectionUrl?: string;
+    databasePath?: string;
+}
+export interface ApplyMigrationsResult {
+    results: Array<{
+        migrationName: string;
+        status: string;
+    }>;
+}
+export declare function applyMigrations(options: ApplyMigrationsOptions): Promise<ApplyMigrationsResult>;
+//# sourceMappingURL=migrate-apply.d.ts.map

package/dist/migrate-apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-apply.d.ts","sourceRoot":"","sources":["../src/migrate-apply.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,aAAa,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC1D;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA4DrG"}

package/dist/migrate-apply.js

@@ -0,0 +1,61 @@
+/**
+ * Apply migrations using Kysely's migrator
+ */
+import * as path from "path";
+import { createKyselyAdapter } from "./kysely-adapter.js";
+export async function applyMigrations(options) {
+    const databasePath = options.databasePath ??
+        (options.dialect === "sqlite" ? resolveSqlitePath(options.connectionUrl) : undefined);
+    const { db, destroy } = await createKyselyAdapter({
+        dialect: options.dialect,
+        connectionUrl: options.connectionUrl,
+        databasePath,
+    });
+    try {
+        const { Migrator } = await import("kysely");
+        const fs = await import("fs/promises");
+        const { default: jiti } = await import("jiti");
+        const loader = jiti(import.meta.url, { interopDefault: true });
+        const provider = {
+            async getMigrations() {
+                const entries = await fs.readdir(options.migrationsFolder);
+                const files = entries
+                    .filter((file) => /\.(ts|js|mjs|cjs)$/.test(file))
+                    .sort((a, b) => a.localeCompare(b));
+                const migrations = {};
+                for (const file of files) {
+                    const filePath = path.join(options.migrationsFolder, file);
+                    const mod = loader(filePath);
+                    const migration = mod.default ?? mod;
+                    if (!migration?.up || !migration?.down) {
+                        throw new Error(`Migration file is missing up/down exports: ${file}`);
+                    }
+                    migrations[path.parse(file).name] = migration;
+                }
+                return migrations;
+            },
+        };
+        const migrator = new Migrator({ db, provider });
+        const { error, results } = await migrator.migrateToLatest();
+        if (error) {
+            throw error;
+        }
+        return {
+            results: results?.map((result) => ({
+                migrationName: result.migrationName,
+                status: result.status,
+            })) ?? [],
+        };
+    }
+    finally {
+        await destroy();
+    }
+}
+function resolveSqlitePath(url) {
+    if (!url)
+        return undefined;
+    if (url.startsWith("file:")) {
+        return url.slice("file:".length);
+    }
+    return url;
+}

package/dist/migrate.d.ts

@@ -0,0 +1,108 @@
+/**
+ * High-level programmatic API for zenstack-kit migrations
+ *
+ * This module provides a simple interface for applying migrations from code,
+ * useful for running migrations during application startup or in CI/CD pipelines.
+ *
+ * @example
+ * ```typescript
+ * import { migrate } from "zenstack-kit";
+ *
+ * // Apply migrations using config file
+ * await migrate();
+ *
+ * // Apply migrations with explicit options
+ * await migrate({
+ *   migrationsFolder: "./prisma/migrations",
+ *   dialect: "postgres",
+ *   connectionUrl: process.env.DATABASE_URL,
+ * });
+ *
+ * // Preview migrations without applying
+ * const result = await migrate({ preview: true });
+ * console.log("Pending migrations:", result.pending);
+ * ```
+ */
+import { type ApplyPrismaMigrationsResult, type PreviewPrismaMigrationsResult } from "./migrations/prisma.js";
+import type { KyselyDialect } from "./sql/kysely-adapter.js";
+export interface MigrateOptions {
+    /**
+     * Path to migrations folder.
+     * If not provided, will be read from config file.
+     */
+    migrationsFolder?: string;
+    /**
+     * Database dialect: "sqlite", "postgres", or "mysql"
+     * If not provided, will be read from config file.
+     */
+    dialect?: KyselyDialect;
+    /**
+     * Database connection URL (for postgres/mysql).
+     * If not provided, will be read from config file.
+     */
+    connectionUrl?: string;
+    /**
+     * SQLite database file path.
+     * If not provided, will be read from config file.
+     */
+    databasePath?: string;
+    /**
+     * Migrations table name.
+     * @default "_prisma_migrations"
+     */
+    migrationsTable?: string;
+    /**
+     * Migrations schema (PostgreSQL only).
+     * @default "public"
+     */
+    migrationsSchema?: string;
+    /**
+     * If true, preview pending migrations without applying them.
+     * @default false
+     */
+    preview?: boolean;
+    /**
+     * Current working directory for config resolution.
+     * @default process.cwd()
+     */
+    cwd?: string;
+}
+export type MigrateResult = (ApplyPrismaMigrationsResult & {
+    mode: "apply";
+}) | (PreviewPrismaMigrationsResult & {
+    mode: "preview";
+});
+/**
+ * Apply or preview database migrations programmatically.
+ *
+ * This function can be used in application code to run migrations during startup,
+ * or in scripts and CI/CD pipelines.
+ *
+ * @param options - Migration options. If not provided, reads from config file.
+ * @returns Result of migration apply or preview operation.
+ * @throws Error if migrations fail or required configuration is missing.
+ *
+ * @example
+ * ```typescript
+ * // Run migrations on app startup
+ * import { migrate } from "zenstack-kit";
+ *
+ * async function main() {
+ *   const result = await migrate();
+ *   console.log(`Applied ${result.applied.length} migrations`);
+ *
+ *   // Start your app...
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Preview in development
+ * const preview = await migrate({ preview: true });
+ * if (preview.pending.length > 0) {
+ *   console.log("Pending migrations:", preview.pending.map(m => m.name));
+ * }
+ * ```
+ */
+export declare function migrate(options?: MigrateOptions): Promise<MigrateResult>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../src/migrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAGL,KAAK,2BAA2B,EAChC,KAAK,6BAA6B,EACnC,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG7D,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IAExB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,aAAa,GACrB,CAAC,2BAA2B,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,GACjD,CAAC,6BAA6B,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAsFlF"}

package/dist/migrate.js

@@ -0,0 +1,127 @@
+/**
+ * High-level programmatic API for zenstack-kit migrations
+ *
+ * This module provides a simple interface for applying migrations from code,
+ * useful for running migrations during application startup or in CI/CD pipelines.
+ *
+ * @example
+ * ```typescript
+ * import { migrate } from "zenstack-kit";
+ *
+ * // Apply migrations using config file
+ * await migrate();
+ *
+ * // Apply migrations with explicit options
+ * await migrate({
+ *   migrationsFolder: "./prisma/migrations",
+ *   dialect: "postgres",
+ *   connectionUrl: process.env.DATABASE_URL,
+ * });
+ *
+ * // Preview migrations without applying
+ * const result = await migrate({ preview: true });
+ * console.log("Pending migrations:", result.pending);
+ * ```
+ */
+import { loadConfig } from "./config/loader.js";
+import { applyPrismaMigrations, previewPrismaMigrations, } from "./migrations/prisma.js";
+import * as path from "path";
+/**
+ * Apply or preview database migrations programmatically.
+ *
+ * This function can be used in application code to run migrations during startup,
+ * or in scripts and CI/CD pipelines.
+ *
+ * @param options - Migration options. If not provided, reads from config file.
+ * @returns Result of migration apply or preview operation.
+ * @throws Error if migrations fail or required configuration is missing.
+ *
+ * @example
+ * ```typescript
+ * // Run migrations on app startup
+ * import { migrate } from "zenstack-kit";
+ *
+ * async function main() {
+ *   const result = await migrate();
+ *   console.log(`Applied ${result.applied.length} migrations`);
+ *
+ *   // Start your app...
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Preview in development
+ * const preview = await migrate({ preview: true });
+ * if (preview.pending.length > 0) {
+ *   console.log("Pending migrations:", preview.pending.map(m => m.name));
+ * }
+ * ```
+ */
+export async function migrate(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    // Load config if options not fully provided
+    let migrationsFolder = options.migrationsFolder;
+    let dialect = options.dialect;
+    let connectionUrl = options.connectionUrl;
+    let databasePath = options.databasePath;
+    if (!migrationsFolder || !dialect) {
+        const loaded = await loadConfig(cwd);
+        if (loaded) {
+            const { config, configDir } = loaded;
+            if (!migrationsFolder) {
+                const relativeFolder = config.migrations?.migrationsFolder ?? "./prisma/migrations";
+                migrationsFolder = path.resolve(configDir, relativeFolder);
+            }
+            if (!dialect) {
+                dialect = (config.dialect ?? "sqlite");
+            }
+            if (!connectionUrl && !databasePath) {
+                const dbCredentials = config.dbCredentials;
+                if (dialect === "sqlite") {
+                    databasePath = dbCredentials?.file;
+                }
+                else {
+                    connectionUrl = dbCredentials?.url;
+                }
+            }
+        }
+    }
+    // Validate required options
+    if (!migrationsFolder) {
+        throw new Error("migrationsFolder is required. Provide it in options or create a zenstack-kit.config.ts file.");
+    }
+    if (!dialect) {
+        throw new Error("dialect is required. Provide it in options or create a zenstack-kit.config.ts file.");
+    }
+    if (dialect !== "sqlite" && !connectionUrl) {
+        throw new Error("connectionUrl is required for postgres/mysql. Provide it in options or in your config file.");
+    }
+    const migrationsTable = options.migrationsTable ?? "_prisma_migrations";
+    const migrationsSchema = options.migrationsSchema ?? "public";
+    // Preview mode
+    if (options.preview) {
+        const result = await previewPrismaMigrations({
+            migrationsFolder,
+            dialect,
+            connectionUrl,
+            databasePath,
+            migrationsTable,
+            migrationsSchema,
+        });
+        return { ...result, mode: "preview" };
+    }
+    // Apply mode
+    const result = await applyPrismaMigrations({
+        migrationsFolder,
+        dialect,
+        connectionUrl,
+        databasePath,
+        migrationsTable,
+        migrationsSchema,
+    });
+    if (result.failed) {
+        throw new Error(`Migration failed: ${result.failed.migrationName} - ${result.failed.error}`);
+    }
+    return { ...result, mode: "apply" };
+}