zenstack-kit 0.1.1

package/dist/sql/compiler.js

@@ -0,0 +1,270 @@
+/**
+ * SQL Compiler - Generates raw SQL from schema operations using Kysely's compile()
+ *
+ * Uses Kysely with DummyDriver to compile schema operations to dialect-specific SQL
+ * without requiring a database connection.
+ */
+import { Kysely, DummyDriver, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, PostgresAdapter, PostgresIntrospector, PostgresQueryCompiler, MysqlAdapter, MysqlIntrospector, MysqlQueryCompiler, sql, } from "kysely";
+/**
+ * Create a Kysely instance configured for SQL compilation only (no actual DB connection)
+ */
+function createCompilerDb(dialect) {
+    if (dialect === "sqlite") {
+        return new Kysely({
+            dialect: {
+                createAdapter: () => new SqliteAdapter(),
+                createDriver: () => new DummyDriver(),
+                createIntrospector: (db) => new SqliteIntrospector(db),
+                createQueryCompiler: () => new SqliteQueryCompiler(),
+            },
+        });
+    }
+    else if (dialect === "postgres") {
+        return new Kysely({
+            dialect: {
+                createAdapter: () => new PostgresAdapter(),
+                createDriver: () => new DummyDriver(),
+                createIntrospector: (db) => new PostgresIntrospector(db),
+                createQueryCompiler: () => new PostgresQueryCompiler(),
+            },
+        });
+    }
+    else {
+        return new Kysely({
+            dialect: {
+                createAdapter: () => new MysqlAdapter(),
+                createDriver: () => new DummyDriver(),
+                createIntrospector: (db) => new MysqlIntrospector(db),
+                createQueryCompiler: () => new MysqlQueryCompiler(),
+            },
+        });
+    }
+}
+/**
+ * Compile a CREATE TABLE statement to SQL
+ */
+export function compileCreateTable(model, options) {
+    const db = createCompilerDb(options.dialect);
+    let builder = db.schema.createTable(model.name);
+    for (const column of model.columns) {
+        const columnType = mapColumnType(column.type, options.dialect, {
+            isArray: column.isArray,
+            isAutoincrement: column.isAutoincrement,
+        });
+        builder = builder.addColumn(column.name, sql.raw(columnType), (cb) => {
+            // For SERIAL types in PostgreSQL, NOT NULL is implicit and we don't need defaults
+            const isSerialType = column.isAutoincrement && options.dialect === "postgres";
+            if (column.notNull && !isSerialType) {
+                cb = cb.notNull();
+            }
+            if (column.default !== undefined && !isSerialType) {
+                cb = cb.defaultTo(sql.raw(formatDefault(column.default, options.dialect)));
+            }
+            return cb;
+        });
+    }
+    // Add primary key constraint
+    if (model.primaryKey) {
+        builder = builder.addPrimaryKeyConstraint(model.primaryKey.name, model.primaryKey.columns);
+    }
+    // Add unique constraints
+    for (const unique of model.uniqueConstraints) {
+        builder = builder.addUniqueConstraint(unique.name, unique.columns);
+    }
+    // Add foreign key constraints
+    for (const fk of model.foreignKeys) {
+        builder = builder.addForeignKeyConstraint(fk.name, fk.columns, fk.referencedTable, fk.referencedColumns);
+    }
+    return builder.compile().sql + ";";
+}
+/**
+ * Compile a DROP TABLE statement to SQL
+ */
+export function compileDropTable(tableName, options) {
+    const db = createCompilerDb(options.dialect);
+    return db.schema.dropTable(tableName).ifExists().compile().sql + ";";
+}
+/**
+ * Compile an ADD COLUMN statement to SQL
+ */
+export function compileAddColumn(tableName, column, options) {
+    const db = createCompilerDb(options.dialect);
+    const columnType = mapColumnType(column.type, options.dialect, {
+        isArray: column.isArray,
+        isAutoincrement: column.isAutoincrement,
+    });
+    return (db.schema
+        .alterTable(tableName)
+        .addColumn(column.name, sql.raw(columnType), (cb) => {
+        const isSerialType = column.isAutoincrement && options.dialect === "postgres";
+        if (column.notNull && !isSerialType) {
+            cb = cb.notNull();
+        }
+        if (column.default !== undefined && !isSerialType) {
+            cb = cb.defaultTo(sql.raw(formatDefault(column.default, options.dialect)));
+        }
+        return cb;
+    })
+        .compile().sql + ";");
+}
+/**
+ * Compile a DROP COLUMN statement to SQL
+ */
+export function compileDropColumn(tableName, columnName, options) {
+    const db = createCompilerDb(options.dialect);
+    return db.schema.alterTable(tableName).dropColumn(columnName).compile().sql + ";";
+}
+/**
+ * Compile a RENAME TABLE statement to SQL
+ */
+export function compileRenameTable(fromName, toName, options) {
+    const db = createCompilerDb(options.dialect);
+    return db.schema.alterTable(fromName).renameTo(toName).compile().sql + ";";
+}
+/**
+ * Compile a RENAME COLUMN statement to SQL
+ */
+export function compileRenameColumn(tableName, fromName, toName, options) {
+    const db = createCompilerDb(options.dialect);
+    return (db.schema.alterTable(tableName).renameColumn(fromName, toName).compile().sql + ";");
+}
+/**
+ * Compile a CREATE INDEX statement to SQL
+ */
+export function compileCreateIndex(tableName, indexName, columns, options) {
+    const db = createCompilerDb(options.dialect);
+    let builder = db.schema.createIndex(indexName).on(tableName);
+    for (const col of columns) {
+        builder = builder.column(col);
+    }
+    return builder.compile().sql + ";";
+}
+/**
+ * Compile a DROP INDEX statement to SQL
+ */
+export function compileDropIndex(indexName, options) {
+    const db = createCompilerDb(options.dialect);
+    return db.schema.dropIndex(indexName).compile().sql + ";";
+}
+/**
+ * Compile an ADD CONSTRAINT (unique) statement to SQL
+ */
+export function compileAddUniqueConstraint(tableName, constraintName, columns, options) {
+    const db = createCompilerDb(options.dialect);
+    return (db.schema
+        .alterTable(tableName)
+        .addUniqueConstraint(constraintName, columns)
+        .compile().sql + ";");
+}
+/**
+ * Compile a DROP CONSTRAINT statement to SQL
+ */
+export function compileDropConstraint(tableName, constraintName, options) {
+    const db = createCompilerDb(options.dialect);
+    return (db.schema.alterTable(tableName).dropConstraint(constraintName).compile().sql + ";");
+}
+/**
+ * Compile an ADD FOREIGN KEY CONSTRAINT statement to SQL
+ */
+export function compileAddForeignKeyConstraint(tableName, constraintName, columns, referencedTable, referencedColumns, options) {
+    const db = createCompilerDb(options.dialect);
+    return (db.schema
+        .alterTable(tableName)
+        .addForeignKeyConstraint(constraintName, columns, referencedTable, referencedColumns)
+        .compile().sql + ";");
+}
+/**
+ * Compile an ADD PRIMARY KEY CONSTRAINT statement to SQL
+ */
+export function compileAddPrimaryKeyConstraint(tableName, constraintName, columns, options) {
+    const db = createCompilerDb(options.dialect);
+    return (db.schema
+        .alterTable(tableName)
+        .addPrimaryKeyConstraint(constraintName, columns)
+        .compile().sql + ";");
+}
+/**
+ * Compile ALTER COLUMN statements for type/nullability/default changes
+ */
+export function compileAlterColumn(tableName, columnName, changes, options) {
+    const db = createCompilerDb(options.dialect);
+    const statements = [];
+    if (changes.setType) {
+        const columnType = mapColumnType(changes.setType, options.dialect);
+        statements.push(db.schema
+            .alterTable(tableName)
+            .alterColumn(columnName, (ac) => ac.setDataType(columnType))
+            .compile().sql + ";");
+    }
+    if (changes.setNotNull) {
+        statements.push(db.schema
+            .alterTable(tableName)
+            .alterColumn(columnName, (ac) => ac.setNotNull())
+            .compile().sql + ";");
+    }
+    if (changes.dropNotNull) {
+        statements.push(db.schema
+            .alterTable(tableName)
+            .alterColumn(columnName, (ac) => ac.dropNotNull())
+            .compile().sql + ";");
+    }
+    if (changes.setDefault !== undefined) {
+        statements.push(db.schema
+            .alterTable(tableName)
+            .alterColumn(columnName, (ac) => ac.setDefault(sql.raw(formatDefault(changes.setDefault, options.dialect))))
+            .compile().sql + ";");
+    }
+    if (changes.dropDefault) {
+        statements.push(db.schema
+            .alterTable(tableName)
+            .alterColumn(columnName, (ac) => ac.dropDefault())
+            .compile().sql + ";");
+    }
+    return statements;
+}
+/**
+ * Map our internal type names to dialect-specific SQL types
+ */
+function mapColumnType(type, dialect, options) {
+    const { isArray, isAutoincrement } = options ?? {};
+    // Handle autoincrement for PostgreSQL - use SERIAL/BIGSERIAL types
+    if (isAutoincrement && dialect === "postgres") {
+        if (type === "bigint") {
+            return "bigserial";
+        }
+        return "serial";
+    }
+    // Handle autoincrement for MySQL
+    if (isAutoincrement && dialect === "mysql") {
+        // MySQL uses AUTO_INCREMENT attribute, but we can map to appropriate int type
+        // The actual AUTO_INCREMENT will be added via the modifier
+        return type;
+    }
+    // Handle array types for PostgreSQL
+    if (isArray && dialect === "postgres") {
+        return `${type}[]`;
+    }
+    // Most types are already SQL types from our snapshot, just return as-is
+    // The Kysely compiler will handle dialect-specific adjustments
+    return type;
+}
+/**
+ * Format a default value for SQL
+ */
+function formatDefault(value, dialect) {
+    if (typeof value === "string") {
+        // Check if it's a function call like now() or autoincrement()
+        if (/^\w+\([^)]*\)$/.test(value)) {
+            return value;
+        }
+        // Escape string values
+        return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (typeof value === "boolean") {
+        if (dialect === "sqlite") {
+            return value ? "1" : "0";
+        }
+        return value ? "true" : "false";
+    }
+    return String(value);
+}

package/dist/sql/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/sql/kysely-adapter.d.ts.map

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

@@ -0,0 +1,74 @@
+/**
+ * SQL Compiler - Generates raw SQL from schema operations using Kysely's compile()
+ *
+ * Uses Kysely with DummyDriver to compile schema operations to dialect-specific SQL
+ * without requiring a database connection.
+ */
+import type { KyselyDialect } from "./kysely-adapter.js";
+import type { SchemaTable, SchemaColumn } from "./schema-snapshot.js";
+export interface SqlMigration {
+    up: string[];
+    down: string[];
+}
+export interface CompileSqlOptions {
+    dialect: KyselyDialect;
+}
+/**
+ * Compile a CREATE TABLE statement to SQL
+ */
+export declare function compileCreateTable(model: SchemaTable, options: CompileSqlOptions): string;
+/**
+ * Compile a DROP TABLE statement to SQL
+ */
+export declare function compileDropTable(tableName: string, options: CompileSqlOptions): string;
+/**
+ * Compile an ADD COLUMN statement to SQL
+ */
+export declare function compileAddColumn(tableName: string, column: SchemaColumn, options: CompileSqlOptions): string;
+/**
+ * Compile a DROP COLUMN statement to SQL
+ */
+export declare function compileDropColumn(tableName: string, columnName: string, options: CompileSqlOptions): string;
+/**
+ * Compile a RENAME TABLE statement to SQL
+ */
+export declare function compileRenameTable(fromName: string, toName: string, options: CompileSqlOptions): string;
+/**
+ * Compile a RENAME COLUMN statement to SQL
+ */
+export declare function compileRenameColumn(tableName: string, fromName: string, toName: string, options: CompileSqlOptions): string;
+/**
+ * Compile a CREATE INDEX statement to SQL
+ */
+export declare function compileCreateIndex(tableName: string, indexName: string, columns: string[], options: CompileSqlOptions): string;
+/**
+ * Compile a DROP INDEX statement to SQL
+ */
+export declare function compileDropIndex(indexName: string, options: CompileSqlOptions): string;
+/**
+ * Compile an ADD CONSTRAINT (unique) statement to SQL
+ */
+export declare function compileAddUniqueConstraint(tableName: string, constraintName: string, columns: string[], options: CompileSqlOptions): string;
+/**
+ * Compile a DROP CONSTRAINT statement to SQL
+ */
+export declare function compileDropConstraint(tableName: string, constraintName: string, options: CompileSqlOptions): string;
+/**
+ * Compile an ADD FOREIGN KEY CONSTRAINT statement to SQL
+ */
+export declare function compileAddForeignKeyConstraint(tableName: string, constraintName: string, columns: string[], referencedTable: string, referencedColumns: string[], options: CompileSqlOptions): string;
+/**
+ * Compile an ADD PRIMARY KEY CONSTRAINT statement to SQL
+ */
+export declare function compileAddPrimaryKeyConstraint(tableName: string, constraintName: string, columns: string[], options: CompileSqlOptions): string;
+/**
+ * Compile ALTER COLUMN statements for type/nullability/default changes
+ */
+export declare function compileAlterColumn(tableName: string, columnName: string, changes: {
+    setType?: string;
+    setNotNull?: boolean;
+    dropNotNull?: boolean;
+    setDefault?: string | number | boolean;
+    dropDefault?: boolean;
+}, options: CompileSqlOptions): string[];
+//# sourceMappingURL=sql-compiler.d.ts.map

package/dist/sql-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-compiler.d.ts","sourceRoot":"","sources":["../src/sql-compiler.ts"],"names":[],"mappings":"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"}