@xubylele/schema-forge 0.3.1

package/dist/cli.js

@@ -0,0 +1,1179 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander4 = require("commander");
+
+// package.json
+var package_default = {
+  name: "@xubylele/schema-forge",
+  version: "0.3.1",
+  description: "Universal migration generator from schema DSL",
+  main: "dist/cli.js",
+  type: "commonjs",
+  bin: {
+    schemaforge: "dist/cli.js"
+  },
+  scripts: {
+    build: "tsup src/cli.ts --format cjs --dts",
+    dev: "ts-node src/cli.ts",
+    test: "vitest",
+    prepublishOnly: "npm run build",
+    changeset: "changeset",
+    "version-packages": "changeset version",
+    release: "changeset publish",
+    "publish:public": "npm publish --access public"
+  },
+  keywords: [
+    "cli",
+    "schema",
+    "sql",
+    "generator",
+    "migration",
+    "database"
+  ],
+  author: "Xuby",
+  license: "ISC",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/xubylele/schema-forge.git"
+  },
+  bugs: "https://github.com/xubylele/schema-forge/issues",
+  homepage: "https://github.com/xubylele/schema-forge#readme",
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=18.0.0"
+  },
+  dependencies: {
+    commander: "^14.0.3"
+  },
+  devDependencies: {
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^25.2.3",
+    "ts-node": "^10.9.2",
+    tsup: "^8.5.1",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18"
+  }
+};
+
+// src/commands/diff.ts
+var import_commander = require("commander");
+var import_path4 = __toESM(require("path"));
+
+// src/core/errors.ts
+var SchemaValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SchemaValidationError";
+  }
+};
+
+// src/core/diff.ts
+function getTableNamesFromState(state) {
+  return new Set(Object.keys(state.tables));
+}
+function getTableNamesFromSchema(schema) {
+  return new Set(Object.keys(schema.tables));
+}
+function getColumnNamesFromState(stateColumns) {
+  return new Set(Object.keys(stateColumns));
+}
+function getColumnNamesFromSchema(dbColumns) {
+  return new Set(dbColumns.map((column) => column.name));
+}
+function getSortedNames(names) {
+  return Array.from(names).sort((a, b) => a.localeCompare(b));
+}
+function diffSchemas(oldState, newSchema) {
+  const operations = [];
+  const oldTableNames = getTableNamesFromState(oldState);
+  const newTableNames = getTableNamesFromSchema(newSchema);
+  const sortedNewTableNames = getSortedNames(newTableNames);
+  const sortedOldTableNames = getSortedNames(oldTableNames);
+  for (const tableName of sortedNewTableNames) {
+    if (!oldTableNames.has(tableName)) {
+      operations.push({
+        kind: "create_table",
+        table: newSchema.tables[tableName]
+      });
+    }
+  }
+  const commonTableNames = sortedNewTableNames.filter(
+    (tableName) => oldTableNames.has(tableName)
+  );
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const oldColumnNames = getColumnNamesFromState(oldTable.columns);
+    for (const column of newTable.columns) {
+      if (!oldColumnNames.has(column.name)) {
+        operations.push({
+          kind: "add_column",
+          tableName,
+          column
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const newColumnNames = getColumnNamesFromSchema(newTable.columns);
+    for (const columnName of Object.keys(oldTable.columns)) {
+      if (!newColumnNames.has(columnName)) {
+        operations.push({
+          kind: "drop_column",
+          tableName,
+          columnName
+        });
+      }
+    }
+  }
+  for (const tableName of sortedOldTableNames) {
+    if (!newTableNames.has(tableName)) {
+      operations.push({
+        kind: "drop_table",
+        tableName
+      });
+    }
+  }
+  return { operations };
+}
+
+// src/core/fs.ts
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+async function ensureDir(dirPath) {
+  try {
+    await import_fs.promises.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    throw new Error(`Failed to create directory ${dirPath}: ${error}`);
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await import_fs.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextFile(filePath) {
+  try {
+    return await import_fs.promises.readFile(filePath, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error}`);
+  }
+}
+async function writeTextFile(filePath, content) {
+  try {
+    const dir = import_path.default.dirname(filePath);
+    await ensureDir(dir);
+    await import_fs.promises.writeFile(filePath, content, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to write file ${filePath}: ${error}`);
+  }
+}
+async function readJsonFile(filePath, fallback) {
+  try {
+    const exists = await fileExists(filePath);
+    if (!exists) {
+      return fallback;
+    }
+    const content = await readTextFile(filePath);
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to read JSON file ${filePath}: ${error}`);
+  }
+}
+async function writeJsonFile(filePath, data) {
+  try {
+    const content = JSON.stringify(data, null, 2);
+    await writeTextFile(filePath, content);
+  } catch (error) {
+    throw new Error(`Failed to write JSON file ${filePath}: ${error}`);
+  }
+}
+async function findFiles(dirPath, pattern) {
+  const results = [];
+  try {
+    const items = await import_fs.promises.readdir(dirPath, { withFileTypes: true });
+    for (const item of items) {
+      const fullPath = import_path.default.join(dirPath, item.name);
+      if (item.isDirectory()) {
+        const subResults = await findFiles(fullPath, pattern);
+        results.push(...subResults);
+      } else if (item.isFile() && pattern.test(item.name)) {
+        results.push(fullPath);
+      }
+    }
+  } catch (error) {
+    throw new Error(`Failed to find files in ${dirPath}: ${error}`);
+  }
+  return results;
+}
+
+// src/core/parser.ts
+var SchemaParser = class {
+  /**
+   * Parse a schema from a JSON file
+   */
+  async parseSchemaFile(filePath) {
+    try {
+      const schema = await readJsonFile(filePath, {});
+      return this.normalizeSchema(schema);
+    } catch (error) {
+      throw new Error(`Failed to parse schema file ${filePath}: ${error}`);
+    }
+  }
+  /**
+   * Parse multiple schema files from a directory
+   */
+  async parseSchemaDirectory(dirPath) {
+    const schemaFiles = await findFiles(dirPath, /\.schema\.json$/);
+    const schemas = [];
+    for (const file of schemaFiles) {
+      try {
+        const schema = await this.parseSchemaFile(file);
+        schemas.push(schema);
+      } catch (error) {
+        console.warn(`Warning: Could not parse ${file}:`, error);
+      }
+    }
+    return schemas;
+  }
+  /**
+   * Merge multiple schemas into one
+   */
+  mergeSchemas(schemas) {
+    if (schemas.length === 0) {
+      throw new Error("Cannot merge empty schema array");
+    }
+    const baseSchema = schemas[0];
+    const mergedTables = [];
+    for (const schema of schemas) {
+      for (const table of schema.tables) {
+        const existingIndex = mergedTables.findIndex((t) => t.name === table.name);
+        if (existingIndex >= 0) {
+          console.warn(`Warning: Duplicate table '${table.name}' found, using first occurrence`);
+        } else {
+          mergedTables.push(table);
+        }
+      }
+    }
+    return {
+      version: baseSchema.version,
+      database: baseSchema.database,
+      tables: mergedTables
+    };
+  }
+  /**
+   * Normalize schema to ensure consistent structure
+   */
+  normalizeSchema(schema) {
+    return {
+      version: schema.version || "1.0.0",
+      database: schema.database || "postgres",
+      tables: schema.tables.map((table) => ({
+        ...table,
+        fields: table.fields.map((field) => ({
+          ...field,
+          required: field.required ?? false,
+          unique: field.unique ?? false
+        })),
+        indexes: table.indexes || [],
+        constraints: table.constraints || []
+      }))
+    };
+  }
+  /**
+   * Convert schema to JSON string
+   */
+  schemaToJson(schema, pretty = true) {
+    return pretty ? JSON.stringify(schema, null, 2) : JSON.stringify(schema);
+  }
+  /**
+   * Parse schema from JSON string
+   */
+  parseSchemaString(jsonString) {
+    try {
+      const schema = JSON.parse(jsonString);
+      return this.normalizeSchema(schema);
+    } catch (error) {
+      throw new Error(`Failed to parse schema JSON: ${error}`);
+    }
+  }
+};
+var defaultParser = new SchemaParser();
+function parseSchema(source) {
+  const lines = source.split("\n");
+  const tables = {};
+  let currentLine = 0;
+  const validColumnTypes = /* @__PURE__ */ new Set([
+    "uuid",
+    "varchar",
+    "text",
+    "int",
+    "boolean",
+    "timestamptz",
+    "date"
+  ]);
+  function cleanLine(line) {
+    const commentIndex = line.search(/(?:\/\/|#)/);
+    if (commentIndex !== -1) {
+      line = line.substring(0, commentIndex);
+    }
+    return line.trim();
+  }
+  function parseForeignKey(fkRef, lineNum) {
+    const parts = fkRef.split(".");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new Error(`Line ${lineNum}: Invalid foreign key format '${fkRef}'. Expected format: table.column`);
+    }
+    return {
+      table: parts[0],
+      column: parts[1]
+    };
+  }
+  function parseColumn(line, lineNum) {
+    const tokens = line.split(/\s+/).filter((t) => t.length > 0);
+    if (tokens.length < 2) {
+      throw new Error(`Line ${lineNum}: Invalid column definition. Expected: <name> <type> [modifiers...]`);
+    }
+    const colName = tokens[0];
+    const colType = tokens[1];
+    if (!validColumnTypes.has(colType)) {
+      throw new Error(`Line ${lineNum}: Invalid column type '${colType}'. Valid types: ${Array.from(validColumnTypes).join(", ")}`);
+    }
+    const column = {
+      name: colName,
+      type: colType
+    };
+    let i = 2;
+    while (i < tokens.length) {
+      const modifier = tokens[i];
+      switch (modifier) {
+        case "pk":
+          column.primaryKey = true;
+          i++;
+          break;
+        case "unique":
+          column.unique = true;
+          i++;
+          break;
+        case "nullable":
+          column.nullable = true;
+          i++;
+          break;
+        case "default":
+          i++;
+          if (i >= tokens.length) {
+            throw new Error(`Line ${lineNum}: 'default' modifier requires a value`);
+          }
+          column.default = tokens[i];
+          i++;
+          break;
+        case "fk":
+          i++;
+          if (i >= tokens.length) {
+            throw new Error(`Line ${lineNum}: 'fk' modifier requires a table.column reference`);
+          }
+          column.foreignKey = parseForeignKey(tokens[i], lineNum);
+          i++;
+          break;
+        default:
+          throw new Error(`Line ${lineNum}: Unknown modifier '${modifier}'`);
+      }
+    }
+    return column;
+  }
+  function parseTableBlock(startLine) {
+    const firstLine = cleanLine(lines[startLine]);
+    const match = firstLine.match(/^table\s+(\w+)\s*\{?\s*$/);
+    if (!match) {
+      throw new Error(`Line ${startLine + 1}: Invalid table definition. Expected: table <name> {`);
+    }
+    const tableName = match[1];
+    if (tables[tableName]) {
+      throw new Error(`Line ${startLine + 1}: Duplicate table definition '${tableName}'`);
+    }
+    const columns = [];
+    let lineIdx = startLine + 1;
+    let foundClosingBrace = false;
+    while (lineIdx < lines.length) {
+      const cleaned = cleanLine(lines[lineIdx]);
+      if (!cleaned) {
+        lineIdx++;
+        continue;
+      }
+      if (cleaned === "}") {
+        foundClosingBrace = true;
+        break;
+      }
+      try {
+        const column = parseColumn(cleaned, lineIdx + 1);
+        columns.push(column);
+      } catch (error) {
+        throw error;
+      }
+      lineIdx++;
+    }
+    if (!foundClosingBrace) {
+      throw new Error(`Line ${startLine + 1}: Table '${tableName}' block not closed (missing '}')`);
+    }
+    tables[tableName] = {
+      name: tableName,
+      columns
+    };
+    return lineIdx;
+  }
+  while (currentLine < lines.length) {
+    const cleaned = cleanLine(lines[currentLine]);
+    if (!cleaned) {
+      currentLine++;
+      continue;
+    }
+    if (cleaned.startsWith("table ")) {
+      currentLine = parseTableBlock(currentLine);
+    } else {
+      throw new Error(`Line ${currentLine + 1}: Unexpected content '${cleaned}'. Expected table definition.`);
+    }
+    currentLine++;
+  }
+  return { tables };
+}
+
+// src/core/paths.ts
+var import_path2 = __toESM(require("path"));
+function getProjectRoot(cwd = process.cwd()) {
+  return cwd;
+}
+function getSchemaForgeDir(root) {
+  return import_path2.default.join(root, "schemaforge");
+}
+function getSchemaFilePath(root, config) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  const fileName = config?.schemaFile || "schema.sf";
+  return import_path2.default.join(schemaForgeDir, fileName);
+}
+function getConfigPath(root) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  return import_path2.default.join(schemaForgeDir, "config.json");
+}
+function getStatePath(root, config) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  const fileName = config?.stateFile || "state.json";
+  return import_path2.default.join(schemaForgeDir, fileName);
+}
+
+// src/core/state-manager.ts
+var import_path3 = __toESM(require("path"));
+var StateManager = class {
+  constructor(root = process.cwd()) {
+    this.config = null;
+    this.root = root;
+  }
+  /**
+   * Initialize a new SchemaForge project
+   */
+  async initializeProject(directory = ".", force = false) {
+    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
+    if (await fileExists(configPath) && !force) {
+      throw new Error("SchemaForge project already initialized. Use --force to overwrite.");
+    }
+    const defaultConfig = {
+      version: "1.0.0",
+      database: "postgres",
+      schemaDir: "schemas",
+      outputDir: "output",
+      migrationDir: "migrations"
+    };
+    await writeJsonFile(configPath, defaultConfig);
+    await ensureDir(import_path3.default.join(directory, defaultConfig.schemaDir));
+    await ensureDir(import_path3.default.join(directory, defaultConfig.outputDir));
+    await ensureDir(import_path3.default.join(directory, defaultConfig.migrationDir));
+    const exampleSchema = {
+      version: "1.0.0",
+      database: "postgres",
+      tables: [
+        {
+          name: "users",
+          fields: [
+            { name: "id", type: "uuid", required: true, unique: true },
+            { name: "email", type: "string", required: true, unique: true, length: 255 },
+            { name: "name", type: "string", required: true, length: 255 },
+            { name: "created_at", type: "datetime", required: true }
+          ],
+          indexes: [
+            { name: "idx_users_email", fields: ["email"], unique: true }
+          ]
+        }
+      ]
+    };
+    const exampleSchemaPath = import_path3.default.join(
+      directory,
+      defaultConfig.schemaDir,
+      "example.schema.json"
+    );
+    await writeJsonFile(exampleSchemaPath, exampleSchema);
+    this.config = defaultConfig;
+  }
+  /**
+   * Load configuration from file
+   */
+  async loadConfig(directory = ".") {
+    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
+    if (!await fileExists(configPath)) {
+      throw new Error('SchemaForge project not initialized. Run "schemaforge init" first.');
+    }
+    this.config = await readJsonFile(configPath, {});
+    return this.config;
+  }
+  /**
+   * Save configuration to file
+   */
+  async saveConfig(config, directory = ".") {
+    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
+    await writeJsonFile(configPath, config);
+    this.config = config;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    if (!this.config) {
+      throw new Error("No configuration loaded");
+    }
+    this.config = { ...this.config, ...updates };
+  }
+  /**
+   * Check if project is initialized
+   */
+  async isInitialized(directory = ".") {
+    const configPath = import_path3.default.join(directory, "schemaforge.config.json");
+    return await fileExists(configPath);
+  }
+  /**
+   * Get schema directory path
+   */
+  getSchemaDir() {
+    if (!this.config) {
+      throw new Error("No configuration loaded");
+    }
+    return import_path3.default.join(this.root, this.config.schemaDir);
+  }
+  /**
+   * Get output directory path
+   */
+  getOutputDir() {
+    if (!this.config) {
+      throw new Error("No configuration loaded");
+    }
+    return import_path3.default.join(this.root, this.config.outputDir);
+  }
+  /**
+   * Get migration directory path
+   */
+  getMigrationDir() {
+    if (!this.config) {
+      throw new Error("No configuration loaded");
+    }
+    return import_path3.default.join(this.root, this.config.migrationDir);
+  }
+};
+async function schemaToState(schema) {
+  const tables = {};
+  for (const [tableName, table] of Object.entries(schema.tables)) {
+    const columns = {};
+    for (const column of table.columns) {
+      columns[column.name] = {
+        type: column.type,
+        ...column.primaryKey !== void 0 && { primaryKey: column.primaryKey },
+        ...column.unique !== void 0 && { unique: column.unique },
+        ...column.nullable !== void 0 && { nullable: column.nullable },
+        ...column.default !== void 0 && { default: column.default },
+        ...column.foreignKey !== void 0 && { foreignKey: column.foreignKey }
+      };
+    }
+    tables[tableName] = { columns };
+  }
+  return {
+    version: 1,
+    tables
+  };
+}
+async function loadState(statePath) {
+  return await readJsonFile(statePath, { version: 1, tables: {} });
+}
+async function saveState(statePath, state) {
+  const dirPath = import_path3.default.dirname(statePath);
+  await ensureDir(dirPath);
+  await writeJsonFile(statePath, state);
+}
+var defaultStateManager = new StateManager();
+
+// src/core/validator.ts
+var SchemaValidator = class {
+  /**
+   * Validate a complete schema
+   */
+  validateSchema(schema) {
+    const errors = [];
+    if (!schema.version) {
+      errors.push({
+        path: "schema.version",
+        message: "Schema version is required",
+        severity: "error"
+      });
+    }
+    if (!schema.database) {
+      errors.push({
+        path: "schema.database",
+        message: "Database type is required",
+        severity: "error"
+      });
+    }
+    if (!schema.tables || schema.tables.length === 0) {
+      errors.push({
+        path: "schema.tables",
+        message: "Schema must contain at least one table",
+        severity: "error"
+      });
+    }
+    if (schema.tables) {
+      const tableNames = /* @__PURE__ */ new Set();
+      for (let i = 0; i < schema.tables.length; i++) {
+        const table = schema.tables[i];
+        const tableErrors = this.validateTable(table, i);
+        errors.push(...tableErrors);
+        if (tableNames.has(table.name)) {
+          errors.push({
+            path: `schema.tables[${i}].name`,
+            message: `Duplicate table name: ${table.name}`,
+            severity: "error"
+          });
+        }
+        tableNames.add(table.name);
+      }
+      errors.push(...this.validateReferences(schema));
+    }
+    return {
+      valid: errors.filter((e) => e.severity === "error").length === 0,
+      errors
+    };
+  }
+  /**
+   * Validate a table
+   */
+  validateTable(table, tableIndex) {
+    const errors = [];
+    const basePath = `schema.tables[${tableIndex}]`;
+    if (!table.name || table.name.trim() === "") {
+      errors.push({
+        path: `${basePath}.name`,
+        message: "Table name is required",
+        severity: "error"
+      });
+    }
+    if (table.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table.name)) {
+      errors.push({
+        path: `${basePath}.name`,
+        message: `Invalid table name '${table.name}': must start with letter or underscore and contain only alphanumeric characters and underscores`,
+        severity: "error"
+      });
+    }
+    if (!table.fields || table.fields.length === 0) {
+      errors.push({
+        path: `${basePath}.fields`,
+        message: `Table '${table.name}' must have at least one field`,
+        severity: "error"
+      });
+    }
+    if (table.fields) {
+      const fieldNames = /* @__PURE__ */ new Set();
+      for (let i = 0; i < table.fields.length; i++) {
+        const field = table.fields[i];
+        const fieldErrors = this.validateField(field, basePath, i);
+        errors.push(...fieldErrors);
+        if (fieldNames.has(field.name)) {
+          errors.push({
+            path: `${basePath}.fields[${i}].name`,
+            message: `Duplicate field name: ${field.name}`,
+            severity: "error"
+          });
+        }
+        fieldNames.add(field.name);
+      }
+    }
+    return errors;
+  }
+  /**
+   * Validate a field
+   */
+  validateField(field, tablePath, fieldIndex) {
+    const errors = [];
+    const basePath = `${tablePath}.fields[${fieldIndex}]`;
+    if (!field.name || field.name.trim() === "") {
+      errors.push({
+        path: `${basePath}.name`,
+        message: "Field name is required",
+        severity: "error"
+      });
+    }
+    if (field.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(field.name)) {
+      errors.push({
+        path: `${basePath}.name`,
+        message: `Invalid field name '${field.name}': must start with letter or underscore and contain only alphanumeric characters and underscores`,
+        severity: "error"
+      });
+    }
+    if (!field.type) {
+      errors.push({
+        path: `${basePath}.type`,
+        message: "Field type is required",
+        severity: "error"
+      });
+    }
+    if (field.type === "enum") {
+      if (!field.enumValues || field.enumValues.length === 0) {
+        errors.push({
+          path: `${basePath}.enumValues`,
+          message: "Enum type requires enumValues array",
+          severity: "error"
+        });
+      }
+    }
+    if (field.type === "string" && field.length && field.length <= 0) {
+      errors.push({
+        path: `${basePath}.length`,
+        message: "String length must be greater than 0",
+        severity: "error"
+      });
+    }
+    return errors;
+  }
+  /**
+   * Validate foreign key references
+   */
+  validateReferences(schema) {
+    const errors = [];
+    const tableNames = new Set(schema.tables.map((t) => t.name));
+    for (let i = 0; i < schema.tables.length; i++) {
+      const table = schema.tables[i];
+      for (let j = 0; j < table.fields.length; j++) {
+        const field = table.fields[j];
+        if (field.references) {
+          const refTable = field.references.table;
+          const refField = field.references.field;
+          if (!tableNames.has(refTable)) {
+            errors.push({
+              path: `schema.tables[${i}].fields[${j}].references.table`,
+              message: `Referenced table '${refTable}' does not exist`,
+              severity: "error"
+            });
+          } else {
+            const referencedTable = schema.tables.find((t) => t.name === refTable);
+            if (referencedTable) {
+              const referencedField = referencedTable.fields.find((f) => f.name === refField);
+              if (!referencedField) {
+                errors.push({
+                  path: `schema.tables[${i}].fields[${j}].references.field`,
+                  message: `Referenced field '${refField}' does not exist in table '${refTable}'`,
+                  severity: "error"
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return errors;
+  }
+};
+var defaultValidator = new SchemaValidator();
+var VALID_COLUMN_TYPES = ["uuid", "varchar", "text", "int", "boolean", "timestamptz", "date"];
+function validateSchema(schema) {
+  validateDuplicateTables(schema);
+  for (const tableName in schema.tables) {
+    const table = schema.tables[tableName];
+    validateTableColumns(tableName, table, schema.tables);
+  }
+}
+function validateDuplicateTables(schema) {
+  const tableNames = Object.keys(schema.tables);
+  const seen = /* @__PURE__ */ new Set();
+  for (const tableName of tableNames) {
+    if (seen.has(tableName)) {
+      throw new Error(`Tabla duplicada: '${tableName}'`);
+    }
+    seen.add(tableName);
+  }
+}
+function validateTableColumns(tableName, table, allTables) {
+  const columnNames = /* @__PURE__ */ new Set();
+  let primaryKeyCount = 0;
+  for (const column of table.columns) {
+    if (columnNames.has(column.name)) {
+      throw new Error(`Tabla '${tableName}': columna duplicada '${column.name}'`);
+    }
+    columnNames.add(column.name);
+    if (column.primaryKey) {
+      primaryKeyCount++;
+    }
+    if (!VALID_COLUMN_TYPES.includes(column.type)) {
+      throw new Error(
+        `Tabla '${tableName}', columna '${column.name}': tipo '${column.type}' no es v\xE1lido. Tipos soportados: ${VALID_COLUMN_TYPES.join(", ")}`
+      );
+    }
+    if (column.foreignKey) {
+      const fkTable = column.foreignKey.table;
+      const fkColumn = column.foreignKey.column;
+      if (!allTables[fkTable]) {
+        throw new Error(
+          `Tabla '${tableName}', columna '${column.name}': tabla referenciada '${fkTable}' no existe`
+        );
+      }
+      const referencedTable = allTables[fkTable];
+      const columnExists = referencedTable.columns.some((col) => col.name === fkColumn);
+      if (!columnExists) {
+        throw new Error(
+          `Tabla '${tableName}', columna '${column.name}': tabla '${fkTable}' no tiene columna '${fkColumn}'`
+        );
+      }
+    }
+  }
+  if (primaryKeyCount > 1) {
+    throw new Error(`Tabla '${tableName}': solo puede tener una primary key (encontradas ${primaryKeyCount})`);
+  }
+}
+
+// src/generator/sql-generator.ts
+function generateSql(diff, provider, sqlConfig) {
+  const statements = [];
+  for (const operation of diff.operations) {
+    const sql = generateOperation(operation, provider, sqlConfig);
+    if (sql) {
+      statements.push(sql);
+    }
+  }
+  return statements.join("\n\n");
+}
+function generateOperation(operation, provider, sqlConfig) {
+  switch (operation.kind) {
+    case "create_table":
+      return generateCreateTable(operation.table, provider, sqlConfig);
+    case "drop_table":
+      return generateDropTable(operation.tableName);
+    case "add_column":
+      return generateAddColumn(operation.tableName, operation.column, provider, sqlConfig);
+    case "drop_column":
+      return generateDropColumn(operation.tableName, operation.columnName);
+  }
+}
+function generateCreateTable(table, provider, sqlConfig) {
+  const columnDefs = table.columns.map(
+    (col) => generateColumnDefinition(col, provider, sqlConfig)
+  );
+  const lines = ["CREATE TABLE " + table.name + " ("];
+  columnDefs.forEach((colDef, index) => {
+    const isLast = index === columnDefs.length - 1;
+    lines.push("  " + colDef + (isLast ? "" : ","));
+  });
+  lines.push(");");
+  return lines.join("\n");
+}
+function generateColumnDefinition(column, provider, sqlConfig) {
+  const parts = [column.name, column.type];
+  if (column.foreignKey) {
+    parts.push(
+      `references ${column.foreignKey.table}(${column.foreignKey.column})`
+    );
+  }
+  if (column.primaryKey) {
+    parts.push("primary key");
+  }
+  if (column.unique) {
+    parts.push("unique");
+  }
+  if (column.nullable === false) {
+    parts.push("not null");
+  }
+  if (column.default !== void 0) {
+    parts.push("default " + column.default);
+  } else if (column.type === "uuid" && column.primaryKey && provider === "supabase") {
+    parts.push("default gen_random_uuid()");
+  }
+  return parts.join(" ");
+}
+function generateDropTable(tableName) {
+  return `DROP TABLE ${tableName};`;
+}
+function generateAddColumn(tableName, column, provider, sqlConfig) {
+  const colDef = generateColumnDefinition(column, provider, sqlConfig);
+  return `ALTER TABLE ${tableName} ADD COLUMN ${colDef};`;
+}
+function generateDropColumn(tableName, columnName) {
+  return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+}
+
+// src/commands/diff.ts
+var REQUIRED_CONFIG_FIELDS = ["schemaFile", "stateFile"];
+function resolveConfigPath(root, targetPath) {
+  return import_path4.default.isAbsolute(targetPath) ? targetPath : import_path4.default.join(root, targetPath);
+}
+async function runDiff() {
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schemaforge init" first.');
+  }
+  const config = await readJsonFile(configPath, {});
+  for (const field of REQUIRED_CONFIG_FIELDS) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
+    }
+  }
+  const schemaPath = resolveConfigPath(root, config.schemaFile);
+  const statePath = resolveConfigPath(root, config.stateFile);
+  if (config.provider && config.provider !== "postgres" && config.provider !== "supabase") {
+    throw new Error(`Unsupported provider '${config.provider}'.`);
+  }
+  const provider = config.provider ?? "postgres";
+  const schemaSource = await readTextFile(schemaPath);
+  const schema = parseSchema(schemaSource);
+  try {
+    validateSchema(schema);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new SchemaValidationError(error.message);
+    }
+    throw error;
+  }
+  const previousState = await loadState(statePath);
+  const diff = diffSchemas(previousState, schema);
+  if (diff.operations.length === 0) {
+    console.log("No changes detected");
+    return;
+  }
+  const sql = generateSql(diff, provider, config.sql);
+  console.log(sql);
+}
+
+// src/commands/generate.ts
+var import_commander2 = require("commander");
+var import_path5 = __toESM(require("path"));
+
+// src/core/utils.ts
+function nowTimestamp() {
+  const date = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return String(date.getFullYear()) + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
+}
+function slugifyName(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "migration";
+}
+
+// src/commands/generate.ts
+var REQUIRED_CONFIG_FIELDS2 = [
+  "schemaFile",
+  "stateFile",
+  "outputDir"
+];
+function resolveConfigPath2(root, targetPath) {
+  return import_path5.default.isAbsolute(targetPath) ? targetPath : import_path5.default.join(root, targetPath);
+}
+async function runGenerate(options) {
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schemaforge init" first.');
+  }
+  const config = await readJsonFile(configPath, {});
+  for (const field of REQUIRED_CONFIG_FIELDS2) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
+    }
+  }
+  const schemaPath = resolveConfigPath2(root, config.schemaFile);
+  const statePath = resolveConfigPath2(root, config.stateFile);
+  const outputDir = resolveConfigPath2(root, config.outputDir);
+  if (config.provider && config.provider !== "postgres" && config.provider !== "supabase") {
+    throw new Error(`Unsupported provider '${config.provider}'.`);
+  }
+  const provider = config.provider ?? "postgres";
+  if (!config.provider) {
+    console.log("Provider not set; defaulting to postgres.");
+  }
+  console.log("Generating SQL...");
+  const schemaSource = await readTextFile(schemaPath);
+  const schema = parseSchema(schemaSource);
+  try {
+    validateSchema(schema);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new SchemaValidationError(error.message);
+    }
+    throw error;
+  }
+  const previousState = await loadState(statePath);
+  const diff = diffSchemas(previousState, schema);
+  if (diff.operations.length === 0) {
+    console.log("No changes detected");
+    return;
+  }
+  const sql = generateSql(diff, provider, config.sql);
+  const timestamp = nowTimestamp();
+  const slug = slugifyName(options.name ?? "migration");
+  const fileName = `${timestamp}-${slug}.sql`;
+  await ensureDir(outputDir);
+  const migrationPath = import_path5.default.join(outputDir, fileName);
+  await writeTextFile(migrationPath, sql + "\n");
+  const nextState = await schemaToState(schema);
+  await saveState(statePath, nextState);
+  console.log(`\u2713 SQL generated successfully: ${migrationPath}`);
+}
+
+// src/commands/init.ts
+var import_commander3 = require("commander");
+async function runInit() {
+  const root = getProjectRoot();
+  const schemaForgeDir = getSchemaForgeDir(root);
+  if (await fileExists(schemaForgeDir)) {
+    console.error("Error: schemaforge/ directory already exists");
+    console.error("Please remove it or run init in a different directory");
+    process.exit(1);
+  }
+  const schemaFilePath = getSchemaFilePath(root);
+  const configPath = getConfigPath(root);
+  const statePath = getStatePath(root);
+  if (await fileExists(schemaFilePath)) {
+    console.error(`Error: ${schemaFilePath} already exists`);
+    process.exit(1);
+  }
+  if (await fileExists(configPath)) {
+    console.error(`Error: ${configPath} already exists`);
+    process.exit(1);
+  }
+  if (await fileExists(statePath)) {
+    console.error(`Error: ${statePath} already exists`);
+    process.exit(1);
+  }
+  console.log("Initializing schema project...");
+  await ensureDir(schemaForgeDir);
+  const schemaContent = `# SchemaForge schema definition
+# Run: schemaforge generate
+
+table users {
+  id uuid pk
+  created_at timestamptz default now()
+}
+`;
+  await writeTextFile(schemaFilePath, schemaContent);
+  console.log(`\u2713 Created ${schemaFilePath}`);
+  const config = {
+    provider: "supabase",
+    outputDir: "supabase/migrations",
+    schemaFile: "schemaforge/schema.sf",
+    stateFile: "schemaforge/state.json",
+    sql: {
+      uuidDefault: "gen_random_uuid()",
+      timestampDefault: "now()"
+    }
+  };
+  await writeJsonFile(configPath, config);
+  console.log(`\u2713 Created ${configPath}`);
+  const state = {
+    version: 1,
+    tables: {}
+  };
+  await writeJsonFile(statePath, state);
+  console.log(`\u2713 Created ${statePath}`);
+  const outputDir = "supabase/migrations";
+  await ensureDir(outputDir);
+  console.log(`\u2713 Created ${outputDir}`);
+  console.log("\n\u2713 Project initialized successfully");
+  console.log("Next steps:");
+  console.log("  1. Edit schemaforge/schema.sf to define your schema");
+  console.log("  2. Run: schemaforge generate");
+}
+
+// src/cli.ts
+var program = new import_commander4.Command();
+program.name("schemaforge").description("CLI tool for schema management and SQL generation").version(package_default.version);
+function handleError(error) {
+  if (error instanceof SchemaValidationError) {
+    console.error(error.message);
+    process.exitCode = 2;
+    return;
+  }
+  if (error instanceof Error) {
+    console.error(error.message);
+  } else {
+    console.error("Unexpected error");
+  }
+  process.exitCode = 1;
+}
+program.command("init").description("Initialize a new schema project").action(async () => {
+  try {
+    await runInit();
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("generate").description("Generate SQL from schema files").option("--name <string>", "Schema name to generate").action(async (options) => {
+  try {
+    await runGenerate(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("diff").description("Compare two schema versions and generate migration SQL").action(async () => {
+  try {
+    await runDiff();
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}