zenstack-kit 0.1.1

package/dist/sql-compiler.js

@@ -0,0 +1,243 @@
+/**
+ * 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);
+        builder = builder.addColumn(column.name, sql.raw(columnType), (cb) => {
+            if (column.notNull) {
+                cb = cb.notNull();
+            }
+            if (column.default !== undefined) {
+                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);
+    return (db.schema
+        .alterTable(tableName)
+        .addColumn(column.name, sql.raw(columnType), (cb) => {
+        if (column.notNull) {
+            cb = cb.notNull();
+        }
+        if (column.default !== undefined) {
+            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) {
+    // 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/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "zenstack-kit",
+  "version": "0.1.1",
+  "description": "Drizzle-kit like CLI tooling for ZenStack schemas with Kysely support",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "zenstack-kit": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "pnpm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "zenstack",
+    "kysely",
+    "drizzle-kit",
+    "typescript",
+    "orm",
+    "migrations",
+    "database",
+    "cli",
+    "schema"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/olup/zenstack-kit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/olup/zenstack-kit/issues"
+  },
+  "homepage": "https://github.com/olup/zenstack-kit#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@zenstackhq/orm": ">=3.0.0",
+    "kysely": ">=0.27.0"
+  },
+  "dependencies": {
+    "@zenstackhq/language": "^3.1.0",
+    "chalk": "^5.3.0",
+    "ink": "^6.6.0",
+    "ink-select-input": "^6.2.0",
+    "jiti": "^2.4.2",
+    "react": "^19.2.3"
+  },
+  "devDependencies": {
+    "@testcontainers/postgresql": "^10.18.0",
+    "@types/node": "^22.0.0",
+    "@types/pg": "^8.11.10",
+    "@types/react": "^19.2.7",
+    "@zenstackhq/cli": "^3.1.0",
+    "@zenstackhq/orm": "^3.1.0",
+    "better-sqlite3": "^12.5.0",
+    "kysely": "^0.28.9",
+    "pg": "^8.13.1",
+    "prisma": "^7.2.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}