kysely-schema 0.1.0

package/dist/index.js

@@ -0,0 +1,573 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ColumnBuilder: () => ColumnBuilder,
+  MigrationGenerator: () => MigrationGenerator,
+  SchemaDiffer: () => SchemaDiffer,
+  TypeGenerator: () => TypeGenerator,
+  column: () => column,
+  configTemplate: () => configTemplate,
+  defineSchema: () => defineSchema,
+  describeOperation: () => describeOperation,
+  operationLabels: () => operationLabels,
+  schemaTemplate: () => schemaTemplate,
+  table: () => table,
+  validateSchema: () => validateSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema/dsl.ts
+var ColumnBuilder = class {
+  def;
+  constructor(init) {
+    this.def = { ...init };
+  }
+  primaryKey() {
+    this.def.primaryKey = true;
+    return this;
+  }
+  notNull() {
+    this.def.notNull = true;
+    return this;
+  }
+  nullable() {
+    this.def.nullable = true;
+    return this;
+  }
+  unique() {
+    this.def.unique = true;
+    return this;
+  }
+  default(value) {
+    this.def.default = value;
+    return this;
+  }
+  references(table2, col) {
+    this.def.references = { table: table2, column: col };
+    return this;
+  }
+  onDelete(action) {
+    this.def.onDelete = action;
+    return this;
+  }
+  onUpdate(action) {
+    this.def.onUpdate = action;
+    return this;
+  }
+  index() {
+    this.def.index = true;
+    return this;
+  }
+  check(expression) {
+    this.def.check = expression;
+    return this;
+  }
+  /** @internal Return the raw column definition. */
+  build() {
+    return { ...this.def };
+  }
+};
+var column = {
+  // Numeric types
+  serial: () => new ColumnBuilder({ type: "serial" }),
+  integer: () => new ColumnBuilder({ type: "integer" }),
+  bigint: () => new ColumnBuilder({ type: "bigint" }),
+  decimal: (precision, scale) => new ColumnBuilder({ type: "decimal", precision, scale }),
+  // Text types
+  text: () => new ColumnBuilder({ type: "text" }),
+  varchar: (length) => new ColumnBuilder({ type: "varchar", length }),
+  // Date / Time types
+  timestamp: () => new ColumnBuilder({ type: "timestamp" }),
+  date: () => new ColumnBuilder({ type: "date" }),
+  time: () => new ColumnBuilder({ type: "time" }),
+  // Boolean
+  boolean: () => new ColumnBuilder({ type: "boolean" }),
+  // JSON
+  json: () => new ColumnBuilder({ type: "json" }),
+  jsonb: () => new ColumnBuilder({ type: "jsonb" }),
+  // Binary
+  binary: () => new ColumnBuilder({ type: "binary" }),
+  // UUID
+  uuid: () => new ColumnBuilder({ type: "uuid" })
+};
+function table(columns) {
+  const built = {};
+  for (const [name, builder] of Object.entries(columns)) {
+    built[name] = builder.build();
+  }
+  return { columns: built, indexes: [] };
+}
+function defineSchema(tables) {
+  return { tables };
+}
+
+// src/schema/validators.ts
+function validateSchema(schema) {
+  const errors = [];
+  const tableNames = Object.keys(schema.tables);
+  for (const [tableName, tableDef] of Object.entries(schema.tables)) {
+    const columnNames = Object.keys(tableDef.columns);
+    if (columnNames.length === 0) {
+      errors.push({
+        table: tableName,
+        message: "Table has no columns defined."
+      });
+    }
+    const pks = columnNames.filter((c) => tableDef.columns[c].primaryKey);
+    if (pks.length === 0) {
+      errors.push({
+        table: tableName,
+        message: "Table has no primary key defined."
+      });
+    }
+    for (const [colName, colDef] of Object.entries(tableDef.columns)) {
+      if (colDef.notNull && colDef.nullable) {
+        errors.push({
+          table: tableName,
+          column: colName,
+          message: "Column cannot be both notNull and nullable."
+        });
+      }
+      if (colDef.references) {
+        if (!tableNames.includes(colDef.references.table)) {
+          errors.push({
+            table: tableName,
+            column: colName,
+            message: `Foreign key references unknown table '${colDef.references.table}'.`
+          });
+        } else {
+          const targetTable = schema.tables[colDef.references.table];
+          if (targetTable && !Object.keys(targetTable.columns).includes(colDef.references.column)) {
+            errors.push({
+              table: tableName,
+              column: colName,
+              message: `Foreign key references unknown column '${colDef.references.column}' in table '${colDef.references.table}'.`
+            });
+          }
+        }
+      }
+      if ((colDef.onDelete || colDef.onUpdate) && !colDef.references) {
+        errors.push({
+          table: tableName,
+          column: colName,
+          message: "onDelete/onUpdate specified without a foreign key reference."
+        });
+      }
+      if (colDef.type === "varchar" && colDef.length !== void 0 && colDef.length <= 0) {
+        errors.push({
+          table: tableName,
+          column: colName,
+          message: "varchar length must be a positive number."
+        });
+      }
+      if (colDef.type === "decimal") {
+        if (colDef.precision !== void 0 && colDef.precision <= 0) {
+          errors.push({
+            table: tableName,
+            column: colName,
+            message: "decimal precision must be a positive number."
+          });
+        }
+        if (colDef.scale !== void 0 && colDef.precision !== void 0 && colDef.scale > colDef.precision) {
+          errors.push({
+            table: tableName,
+            column: colName,
+            message: "decimal scale cannot exceed precision."
+          });
+        }
+      }
+    }
+  }
+  return errors;
+}
+
+// src/generators/migration.ts
+var MigrationGenerator = class {
+  /**
+   * Generate a full CREATE-TABLE migration for the entire schema.
+   */
+  generate(schema, migrationName) {
+    const timestamp = this.generateTimestamp();
+    const filename = `${timestamp}_${this.sanitize(migrationName)}.ts`;
+    const upCode = this.generateUpFunction(schema);
+    const downCode = this.generateDownFunction(schema);
+    const content = [
+      `import { Kysely, sql } from 'kysely';`,
+      ``,
+      `export async function up(db: Kysely<any>): Promise<void> {`,
+      upCode,
+      `}`,
+      ``,
+      `export async function down(db: Kysely<any>): Promise<void> {`,
+      downCode,
+      `}`,
+      ``
+    ].join("\n");
+    return { filename, content };
+  }
+  // ── Private helpers ──────────────────────────────────────────────────────
+  generateUpFunction(schema) {
+    const parts = [];
+    for (const [tableName, tableDef] of Object.entries(schema.tables)) {
+      parts.push(this.generateCreateTable(tableName, tableDef));
+      const indexes = this.generateIndexes(tableName, tableDef);
+      if (indexes) parts.push(indexes);
+    }
+    return parts.join("\n");
+  }
+  generateCreateTable(name, def) {
+    const lines = [];
+    lines.push(`  await db.schema`);
+    lines.push(`    .createTable('${name}')`);
+    for (const [colName, colDef] of Object.entries(def.columns)) {
+      lines.push(this.generateColumnDefinition(colName, colDef));
+    }
+    lines.push(`    .execute();`);
+    return lines.join("\n");
+  }
+  generateColumnDefinition(name, def) {
+    const type = this.mapColumnType(def);
+    const modifiers = this.buildModifiers(def);
+    if (modifiers.length > 0) {
+      return `    .addColumn('${name}', '${type}', (col) => col.${modifiers.join(".")})`;
+    }
+    return `    .addColumn('${name}', '${type}')`;
+  }
+  buildModifiers(def) {
+    const mods = [];
+    if (def.primaryKey) mods.push("primaryKey()");
+    if (def.notNull) mods.push("notNull()");
+    if (def.unique) mods.push("unique()");
+    if (def.default !== void 0) {
+      mods.push(`defaultTo(${this.formatDefaultValue(def.default, def.type)})`);
+    }
+    if (def.references) {
+      mods.push(`references('${def.references.table}.${def.references.column}')`);
+      if (def.onDelete) mods.push(`onDelete('${def.onDelete}')`);
+      if (def.onUpdate) mods.push(`onUpdate('${def.onUpdate}')`);
+    }
+    if (def.check) {
+      mods.push(`check(sql\`${def.check}\`)`);
+    }
+    return mods;
+  }
+  generateDownFunction(schema) {
+    const tables = Object.keys(schema.tables).reverse();
+    return tables.map((t) => `  await db.schema.dropTable('${t}').ifExists().execute();`).join("\n");
+  }
+  generateIndexes(tableName, tableDef) {
+    const lines = [];
+    for (const [colName, colDef] of Object.entries(tableDef.columns)) {
+      if (colDef.index || colDef.references) {
+        lines.push(`  await db.schema`);
+        lines.push(`    .createIndex('${tableName}_${colName}_index')`);
+        lines.push(`    .on('${tableName}')`);
+        lines.push(`    .column('${colName}')`);
+        lines.push(`    .execute();`);
+      }
+    }
+    for (const idx of tableDef.indexes) {
+      const idxName = idx.name || `${tableName}_${idx.columns.join("_")}_index`;
+      lines.push(`  await db.schema`);
+      if (idx.unique) {
+        lines.push(`    .createIndex('${idxName}')`);
+        lines.push(`    .on('${tableName}')`);
+        lines.push(`    .columns([${idx.columns.map((c) => `'${c}'`).join(", ")}])`);
+        lines.push(`    .unique()`);
+      } else {
+        lines.push(`    .createIndex('${idxName}')`);
+        lines.push(`    .on('${tableName}')`);
+        lines.push(`    .columns([${idx.columns.map((c) => `'${c}'`).join(", ")}])`);
+      }
+      lines.push(`    .execute();`);
+    }
+    return lines.length > 0 ? lines.join("\n") : "";
+  }
+  mapColumnType(def) {
+    switch (def.type) {
+      case "varchar":
+        return def.length ? `varchar(${def.length})` : "varchar";
+      case "decimal":
+        if (def.precision !== void 0 && def.scale !== void 0) {
+          return `decimal(${def.precision}, ${def.scale})`;
+        }
+        return "decimal";
+      default:
+        return def.type;
+    }
+  }
+  formatDefaultValue(value, _type) {
+    if (typeof value === "string" && value === "now()") return "sql`now()`";
+    if (typeof value === "string") return `'${value}'`;
+    if (typeof value === "boolean") return value.toString();
+    return String(value);
+  }
+  generateTimestamp() {
+    const now = /* @__PURE__ */ new Date();
+    return now.toISOString().replace(/[-:]/g, "").split(".")[0];
+  }
+  sanitize(name) {
+    return name.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
+  }
+};
+
+// src/generators/types.ts
+var TypeGenerator = class {
+  generate(schema) {
+    const lines = [];
+    lines.push("// Auto-generated by kysely-schema \u2014 DO NOT EDIT");
+    lines.push("");
+    lines.push("import type { Generated, ColumnType } from 'kysely';");
+    lines.push("");
+    for (const [tableName, tableDef] of Object.entries(schema.tables)) {
+      const pascalName = this.toPascalCase(tableName);
+      lines.push(`export interface ${pascalName}Table {`);
+      for (const [colName, colDef] of Object.entries(tableDef.columns)) {
+        const tsType = this.mapToTypeScript(colDef);
+        lines.push(`  ${colName}: ${tsType};`);
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    lines.push("export interface Database {");
+    for (const tableName of Object.keys(schema.tables)) {
+      const pascalName = this.toPascalCase(tableName);
+      lines.push(`  ${tableName}: ${pascalName}Table;`);
+    }
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  }
+  // ── Private helpers ──────────────────────────────────────────────────
+  mapToTypeScript(def) {
+    const baseType = this.baseTypeMap(def.type);
+    let tsType = baseType;
+    if (def.type === "serial") {
+      tsType = `Generated<${baseType}>`;
+    }
+    if (def.default !== void 0 && def.type !== "serial") {
+      tsType = `Generated<${baseType}>`;
+    }
+    if (def.nullable || !def.notNull && !def.primaryKey && def.type !== "serial") {
+      tsType += " | null";
+    }
+    return tsType;
+  }
+  baseTypeMap(type) {
+    const map = {
+      serial: "number",
+      integer: "number",
+      bigint: "string",
+      decimal: "string",
+      text: "string",
+      varchar: "string",
+      timestamp: "Date",
+      date: "Date",
+      time: "string",
+      boolean: "boolean",
+      json: "unknown",
+      jsonb: "unknown",
+      binary: "Buffer",
+      uuid: "string"
+    };
+    return map[type] || "unknown";
+  }
+  toPascalCase(str) {
+    return str.split(/[_\- ]+/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+  }
+};
+
+// src/generators/templates.ts
+var schemaTemplate = `import { defineSchema, table, column } from 'kysely-schema';
+
+export default defineSchema({
+  // Define your tables here. Example:
+  //
+  // user: table({
+  //   id: column.serial().primaryKey(),
+  //   email: column.text().notNull().unique(),
+  //   name: column.text().nullable(),
+  //   createdAt: column.timestamp().default('now()').notNull(),
+  // }),
+});
+`;
+var configTemplate = `import type { KyselySchemaConfig } from 'kysely-schema';
+
+const config: KyselySchemaConfig = {
+  schemaPath: './schema/index.ts',
+  migrationsDir: './migrations',
+  generatedDir: './generated',
+  snapshotDir: './.kysely-schema',
+};
+
+export default config;
+`;
+
+// src/differ/index.ts
+var SchemaDiffer = class {
+  diff(previous, current) {
+    const ops = [];
+    const prevTables = new Set(Object.keys(previous.tables));
+    const currTables = new Set(Object.keys(current.tables));
+    for (const tableName of currTables) {
+      if (!prevTables.has(tableName)) {
+        ops.push({
+          type: "addTable",
+          tableName,
+          table: current.tables[tableName],
+          description: `Create table '${tableName}'`
+        });
+      }
+    }
+    for (const tableName of prevTables) {
+      if (!currTables.has(tableName)) {
+        ops.push({
+          type: "dropTable",
+          tableName,
+          description: `Drop table '${tableName}'`
+        });
+      }
+    }
+    for (const tableName of currTables) {
+      if (!prevTables.has(tableName)) continue;
+      const prevCols = previous.tables[tableName].columns;
+      const currCols = current.tables[tableName].columns;
+      const prevColNames = new Set(Object.keys(prevCols));
+      const currColNames = new Set(Object.keys(currCols));
+      for (const colName of currColNames) {
+        if (!prevColNames.has(colName)) {
+          ops.push({
+            type: "addColumn",
+            tableName,
+            columnName: colName,
+            column: currCols[colName],
+            description: `Add column '${colName}' to table '${tableName}'`
+          });
+        }
+      }
+      for (const colName of prevColNames) {
+        if (!currColNames.has(colName)) {
+          ops.push({
+            type: "dropColumn",
+            tableName,
+            columnName: colName,
+            description: `Drop column '${colName}' from table '${tableName}'`
+          });
+        }
+      }
+      for (const colName of currColNames) {
+        if (!prevColNames.has(colName)) continue;
+        if (!this.columnsEqual(prevCols[colName], currCols[colName])) {
+          ops.push({
+            type: "alterColumn",
+            tableName,
+            columnName: colName,
+            oldColumn: prevCols[colName],
+            newColumn: currCols[colName],
+            description: `Alter column '${colName}' in table '${tableName}'`
+          });
+        }
+      }
+    }
+    return ops;
+  }
+  /**
+   * Generate an ALTER-TABLE migration string from a list of diff operations.
+   */
+  generateAlterMigration(ops) {
+    const upLines = [];
+    const downLines = [];
+    for (const op of ops) {
+      switch (op.type) {
+        case "addTable": {
+          upLines.push(`  await db.schema`);
+          upLines.push(`    .createTable('${op.tableName}')`);
+          for (const [colName, colDef] of Object.entries(op.table.columns)) {
+            upLines.push(`    .addColumn('${colName}', '${colDef.type}')`);
+          }
+          upLines.push(`    .execute();`);
+          downLines.push(`  await db.schema.dropTable('${op.tableName}').ifExists().execute();`);
+          break;
+        }
+        case "dropTable": {
+          upLines.push(`  await db.schema.dropTable('${op.tableName}').ifExists().execute();`);
+          downLines.push(`  // TODO: Recreate table '${op.tableName}'`);
+          break;
+        }
+        case "addColumn": {
+          upLines.push(`  await db.schema.alterTable('${op.tableName}').addColumn('${op.columnName}', '${op.column.type}').execute();`);
+          downLines.push(`  await db.schema.alterTable('${op.tableName}').dropColumn('${op.columnName}').execute();`);
+          break;
+        }
+        case "dropColumn": {
+          upLines.push(`  await db.schema.alterTable('${op.tableName}').dropColumn('${op.columnName}').execute();`);
+          downLines.push(`  // TODO: Re-add column '${op.columnName}' to '${op.tableName}'`);
+          break;
+        }
+        case "alterColumn": {
+          upLines.push(`  await db.schema.alterTable('${op.tableName}').alterColumn('${op.columnName}', (col) => col.setDataType('${op.newColumn.type}')).execute();`);
+          downLines.push(`  await db.schema.alterTable('${op.tableName}').alterColumn('${op.columnName}', (col) => col.setDataType('${op.oldColumn.type}')).execute();`);
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    return {
+      up: upLines.join("\n"),
+      down: downLines.join("\n")
+    };
+  }
+  // ── Private helpers ──────────────────────────────────────────────────
+  columnsEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+  }
+};
+
+// src/differ/operations.ts
+var operationLabels = {
+  addTable: "+ ADD TABLE",
+  dropTable: "- DROP TABLE",
+  addColumn: "+ ADD COLUMN",
+  dropColumn: "- DROP COLUMN",
+  alterColumn: "~ ALTER COLUMN",
+  addIndex: "+ ADD INDEX",
+  dropIndex: "- DROP INDEX"
+};
+function describeOperation(op) {
+  return `${operationLabels[op.type]}: ${op.description}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ColumnBuilder,
+  MigrationGenerator,
+  SchemaDiffer,
+  TypeGenerator,
+  column,
+  configTemplate,
+  defineSchema,
+  describeOperation,
+  operationLabels,
+  schemaTemplate,
+  table,
+  validateSchema
+});