@xubylele/schema-forge 1.1.1 → 1.2.0

package/README.md

@@ -242,14 +242,14 @@ table profiles {
 
 ```bash
 your-project/
-├── schemaforge/
-│   ├── schema.sf          # Your schema definition (edit this!)
-│   ├── config.json        # Project configuration
-│   └── state.json         # State tracking (auto-generated)
-└── supabase/
-    └── migrations/        # Generated SQL migrations
-        ├── 20240101120000-initial.sql
-        └── 20240101120100-add-user-avatar.sql
++-- schemaforge/
+|   +-- schema.sf          # Your schema definition (edit this!)
+|   +-- config.json        # Project configuration
+|   \-- state.json         # State tracking (auto-generated)
+\-- supabase/
+  \-- migrations/        # Generated SQL migrations
+    +-- 20240101120000-initial.sql
+    \-- 20240101120100-add-user-avatar.sql
 ```
 
 ## Configuration

package/dist/cli.js

@@ -29,7 +29,7 @@ var import_commander4 = require("commander");
 // package.json
 var package_default = {
   name: "@xubylele/schema-forge",
-  version: "1.1.1",
+  version: "1.2.0",
   description: "Universal migration generator from schema DSL",
   main: "dist/cli.js",
   type: "commonjs",
@@ -69,6 +69,8 @@ var package_default = {
     node: ">=18.0.0"
   },
   dependencies: {
+    boxen: "^8.0.1",
+    chalk: "^5.6.2",
     commander: "^14.0.3"
   },
   devDependencies: {
@@ -85,14 +87,6 @@ var package_default = {
 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));
@@ -109,6 +103,9 @@ function getColumnNamesFromSchema(dbColumns) {
 function getSortedNames(names) {
   return Array.from(names).sort((a, b) => a.localeCompare(b));
 }
+function normalizeColumnType(type) {
+  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+}
 function diffSchemas(oldState, newSchema) {
   const operations = [];
   const oldTableNames = getTableNamesFromState(oldState);
@@ -126,6 +123,30 @@ function diffSchemas(oldState, newSchema) {
   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;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousType = normalizeColumnType(previousColumn.type);
+      const currentType = normalizeColumnType(column.type);
+      if (previousType !== currentType) {
+        operations.push({
+          kind: "column_type_changed",
+          tableName,
+          columnName: column.name,
+          fromType: previousColumn.type,
+          toType: column.type
+        });
+      }
+    }
+  }
   for (const tableName of commonTableNames) {
     const newTable = newSchema.tables[tableName];
     const oldTable = oldState.tables[tableName];
@@ -171,14 +192,22 @@ function diffSchemas(oldState, newSchema) {
   return { operations };
 }
 
+// src/core/errors.ts
+var SchemaValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SchemaValidationError";
+  }
+};
+
 // 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}`);
+  } catch (error2) {
+    throw new Error(`Failed to create directory ${dirPath}: ${error2}`);
   }
 }
 async function fileExists(filePath) {
@@ -192,8 +221,8 @@ async function fileExists(filePath) {
 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}`);
+  } catch (error2) {
+    throw new Error(`Failed to read file ${filePath}: ${error2}`);
   }
 }
 async function writeTextFile(filePath, content) {
@@ -201,8 +230,8 @@ async function writeTextFile(filePath, content) {
     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}`);
+  } catch (error2) {
+    throw new Error(`Failed to write file ${filePath}: ${error2}`);
   }
 }
 async function readJsonFile(filePath, fallback) {
@@ -213,16 +242,16 @@ async function readJsonFile(filePath, fallback) {
     }
     const content = await readTextFile(filePath);
     return JSON.parse(content);
-  } catch (error) {
-    throw new Error(`Failed to read JSON file ${filePath}: ${error}`);
+  } catch (error2) {
+    throw new Error(`Failed to read JSON file ${filePath}: ${error2}`);
   }
 }
 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}`);
+  } catch (error2) {
+    throw new Error(`Failed to write JSON file ${filePath}: ${error2}`);
   }
 }
 async function findFiles(dirPath, pattern) {
@@ -238,12 +267,53 @@ async function findFiles(dirPath, pattern) {
         results.push(fullPath);
       }
     }
-  } catch (error) {
-    throw new Error(`Failed to find files in ${dirPath}: ${error}`);
+  } catch (error2) {
+    throw new Error(`Failed to find files in ${dirPath}: ${error2}`);
   }
   return results;
 }
 
+// src/utils/output.ts
+var import_boxen = __toESM(require("boxen"));
+var import_chalk = require("chalk");
+var isInteractive = Boolean(process.stdout?.isTTY);
+var colorsEnabled = isInteractive && process.env.FORCE_COLOR !== "0" && !("NO_COLOR" in process.env);
+var color = new import_chalk.Chalk({ level: colorsEnabled ? 3 : 0 });
+var theme = {
+  primary: color.cyanBright,
+  success: color.hex("#00FF88"),
+  warning: color.hex("#FFD166"),
+  error: color.hex("#EF476F"),
+  accent: color.magentaBright
+};
+function success(message) {
+  const text = theme.success(`[OK] ${message}`);
+  if (!isInteractive) {
+    console.log(text);
+    return;
+  }
+  try {
+    console.log(
+      (0, import_boxen.default)(text, {
+        padding: 1,
+        borderColor: "cyan",
+        borderStyle: "round"
+      })
+    );
+  } catch {
+    console.log(text);
+  }
+}
+function info(message) {
+  console.log(theme.primary(message));
+}
+function warning(message) {
+  console.warn(theme.warning(`[WARN] ${message}`));
+}
+function error(message) {
+  console.error(theme.error(`[ERROR] ${message}`));
+}
+
 // src/core/parser.ts
 var SchemaParser = class {
   /**
@@ -253,8 +323,8 @@ var SchemaParser = class {
     try {
       const schema = await readJsonFile(filePath, {});
       return this.normalizeSchema(schema);
-    } catch (error) {
-      throw new Error(`Failed to parse schema file ${filePath}: ${error}`);
+    } catch (error2) {
+      throw new Error(`Failed to parse schema file ${filePath}: ${error2}`);
     }
   }
   /**
@@ -267,8 +337,9 @@ var SchemaParser = class {
       try {
         const schema = await this.parseSchemaFile(file);
         schemas.push(schema);
-      } catch (error) {
-        console.warn(`Warning: Could not parse ${file}:`, error);
+      } catch (error2) {
+        const reason = error2 instanceof Error ? error2.message : String(error2);
+        warning(`Could not parse ${file}: ${reason}`);
       }
     }
     return schemas;
@@ -286,7 +357,7 @@ var SchemaParser = class {
       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`);
+          warning(`Duplicate table '${table.name}' found, using first occurrence`);
         } else {
           mergedTables.push(table);
         }
@@ -330,8 +401,8 @@ var SchemaParser = class {
     try {
       const schema = JSON.parse(jsonString);
       return this.normalizeSchema(schema);
-    } catch (error) {
-      throw new Error(`Failed to parse schema JSON: ${error}`);
+    } catch (error2) {
+      throw new Error(`Failed to parse schema JSON: ${error2}`);
     }
   }
 };
@@ -340,15 +411,26 @@ function parseSchema(source) {
   const lines = source.split("\n");
   const tables = {};
   let currentLine = 0;
-  const validColumnTypes = /* @__PURE__ */ new Set([
+  const validBaseColumnTypes = /* @__PURE__ */ new Set([
     "uuid",
     "varchar",
     "text",
     "int",
+    "bigint",
     "boolean",
     "timestamptz",
     "date"
   ]);
+  function normalizeColumnType2(type) {
+    return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+  }
+  function isValidColumnType2(type) {
+    const normalizedType = normalizeColumnType2(type);
+    if (validBaseColumnTypes.has(normalizedType)) {
+      return true;
+    }
+    return /^varchar\(\d+\)$/.test(normalizedType) || /^numeric\(\d+,\d+\)$/.test(normalizedType);
+  }
   function cleanLine(line) {
     const commentIndex = line.search(/(?:\/\/|#)/);
     if (commentIndex !== -1) {
@@ -372,9 +454,11 @@ function parseSchema(source) {
       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 colType = normalizeColumnType2(tokens[1]);
+    if (!isValidColumnType2(colType)) {
+      throw new Error(
+        `Line ${lineNum}: Invalid column type '${tokens[1]}'. Valid types: ${Array.from(validBaseColumnTypes).join(", ")}, varchar(n), numeric(p,s)`
+      );
     }
     const column = {
       name: colName,
@@ -444,8 +528,8 @@ function parseSchema(source) {
       try {
         const column = parseColumn(cleaned, lineIdx + 1);
         columns.push(column);
-      } catch (error) {
-        throw error;
+      } catch (error2) {
+        throw error2;
       }
       lineIdx++;
     }
@@ -828,7 +912,23 @@ var SchemaValidator = class {
   }
 };
 var defaultValidator = new SchemaValidator();
-var VALID_COLUMN_TYPES = ["uuid", "varchar", "text", "int", "boolean", "timestamptz", "date"];
+var VALID_BASE_COLUMN_TYPES = [
+  "uuid",
+  "varchar",
+  "text",
+  "int",
+  "bigint",
+  "boolean",
+  "timestamptz",
+  "date"
+];
+function isValidColumnType(type) {
+  const normalizedType = type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+  if (VALID_BASE_COLUMN_TYPES.includes(normalizedType)) {
+    return true;
+  }
+  return /^varchar\(\d+\)$/.test(normalizedType) || /^numeric\(\d+,\d+\)$/.test(normalizedType);
+}
 function validateSchema(schema) {
   validateDuplicateTables(schema);
   for (const tableName in schema.tables) {
@@ -841,7 +941,7 @@ function validateDuplicateTables(schema) {
   const seen = /* @__PURE__ */ new Set();
   for (const tableName of tableNames) {
     if (seen.has(tableName)) {
-      throw new Error(`Tabla duplicada: '${tableName}'`);
+      throw new Error(`Duplicate table: '${tableName}'`);
     }
     seen.add(tableName);
   }
@@ -851,15 +951,15 @@ function validateTableColumns(tableName, table, allTables) {
   let primaryKeyCount = 0;
   for (const column of table.columns) {
     if (columnNames.has(column.name)) {
-      throw new Error(`Tabla '${tableName}': columna duplicada '${column.name}'`);
+      throw new Error(`Table '${tableName}': duplicate column '${column.name}'`);
     }
     columnNames.add(column.name);
     if (column.primaryKey) {
       primaryKeyCount++;
     }
-    if (!VALID_COLUMN_TYPES.includes(column.type)) {
+    if (!isValidColumnType(column.type)) {
       throw new Error(
-        `Tabla '${tableName}', columna '${column.name}': tipo '${column.type}' no es v\xE1lido. Tipos soportados: ${VALID_COLUMN_TYPES.join(", ")}`
+        `Table '${tableName}', column '${column.name}': type '${column.type}' is not valid. Supported types: ${VALID_BASE_COLUMN_TYPES.join(", ")}, varchar(n), numeric(p,s)`
       );
     }
     if (column.foreignKey) {
@@ -867,20 +967,20 @@ function validateTableColumns(tableName, table, allTables) {
       const fkColumn = column.foreignKey.column;
       if (!allTables[fkTable]) {
         throw new Error(
-          `Tabla '${tableName}', columna '${column.name}': tabla referenciada '${fkTable}' no existe`
+          `Table '${tableName}', column '${column.name}': referenced table '${fkTable}' does not exist`
         );
       }
       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}'`
+          `Table '${tableName}', column '${column.name}': table '${fkTable}' does not have column '${fkColumn}'`
         );
       }
     }
   }
   if (primaryKeyCount > 1) {
-    throw new Error(`Tabla '${tableName}': solo puede tener una primary key (encontradas ${primaryKeyCount})`);
+    throw new Error(`Table '${tableName}': can only have one primary key (found ${primaryKeyCount})`);
   }
 }
 
@@ -901,6 +1001,12 @@ function generateOperation(operation, provider, sqlConfig) {
       return generateCreateTable(operation.table, provider, sqlConfig);
     case "drop_table":
       return generateDropTable(operation.tableName);
+    case "column_type_changed":
+      return generateAlterColumnType(
+        operation.tableName,
+        operation.columnName,
+        operation.toType
+      );
     case "add_column":
       return generateAddColumn(operation.tableName, operation.column, provider, sqlConfig);
     case "drop_column":
@@ -952,6 +1058,9 @@ function generateAddColumn(tableName, column, provider, sqlConfig) {
 function generateDropColumn(tableName, columnName) {
   return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
 }
+function generateAlterColumnType(tableName, columnName, newType) {
+  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType} USING ${columnName}::${newType};`;
+}
 
 // src/commands/diff.ts
 var REQUIRED_CONFIG_FIELDS = ["schemaFile", "stateFile"];
@@ -962,7 +1071,7 @@ 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.');
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
   }
   const config = await readJsonFile(configPath, {});
   for (const field of REQUIRED_CONFIG_FIELDS) {
@@ -981,16 +1090,16 @@ async function runDiff() {
   const schema = parseSchema(schemaSource);
   try {
     validateSchema(schema);
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new SchemaValidationError(error.message);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw new SchemaValidationError(error2.message);
     }
-    throw error;
+    throw error2;
   }
   const previousState = await loadState(statePath);
   const diff = diffSchemas(previousState, schema);
   if (diff.operations.length === 0) {
-    console.log("No changes detected");
+    success("No changes detected");
     return;
   }
   const sql = generateSql(diff, provider, config.sql);
@@ -1024,7 +1133,7 @@ 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.');
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
   }
   const config = await readJsonFile(configPath, {});
   for (const field of REQUIRED_CONFIG_FIELDS2) {
@@ -1041,23 +1150,23 @@ async function runGenerate(options) {
   }
   const provider = config.provider ?? "postgres";
   if (!config.provider) {
-    console.log("Provider not set; defaulting to postgres.");
+    info("Provider not set; defaulting to postgres.");
   }
-  console.log("Generating SQL...");
+  info("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);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw new SchemaValidationError(error2.message);
     }
-    throw error;
+    throw error2;
   }
   const previousState = await loadState(statePath);
   const diff = diffSchemas(previousState, schema);
   if (diff.operations.length === 0) {
-    console.log("No changes detected");
+    info("No changes detected");
     return;
   }
   const sql = generateSql(diff, provider, config.sql);
@@ -1069,7 +1178,7 @@ async function runGenerate(options) {
   await writeTextFile(migrationPath, sql + "\n");
   const nextState = await schemaToState(schema);
   await saveState(statePath, nextState);
-  console.log(`\u2713 SQL generated successfully: ${migrationPath}`);
+  success(`SQL generated successfully: ${migrationPath}`);
 }
 
 // src/commands/init.ts
@@ -1078,29 +1187,29 @@ 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");
+    error("schemaforge/ directory already exists");
+    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`);
+    error(`${schemaFilePath} already exists`);
     process.exit(1);
   }
   if (await fileExists(configPath)) {
-    console.error(`Error: ${configPath} already exists`);
+    error(`${configPath} already exists`);
     process.exit(1);
   }
   if (await fileExists(statePath)) {
-    console.error(`Error: ${statePath} already exists`);
+    error(`${statePath} already exists`);
     process.exit(1);
   }
-  console.log("Initializing schema project...");
+  info("Initializing schema project...");
   await ensureDir(schemaForgeDir);
   const schemaContent = `# SchemaForge schema definition
-# Run: schemaforge generate
+# Run: schema-forge generate
 
 table users {
   id uuid pk
@@ -1108,7 +1217,7 @@ table users {
 }
 `;
   await writeTextFile(schemaFilePath, schemaContent);
-  console.log(`\u2713 Created ${schemaFilePath}`);
+  success(`Created ${schemaFilePath}`);
   const config = {
     provider: "supabase",
     outputDir: "supabase/migrations",
@@ -1120,57 +1229,57 @@ table users {
     }
   };
   await writeJsonFile(configPath, config);
-  console.log(`\u2713 Created ${configPath}`);
+  success(`Created ${configPath}`);
   const state = {
     version: 1,
     tables: {}
   };
   await writeJsonFile(statePath, state);
-  console.log(`\u2713 Created ${statePath}`);
+  success(`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");
+  success(`Created ${outputDir}`);
+  success("Project initialized successfully");
+  info("Next steps:");
+  info("  1. Edit schemaforge/schema.sf to define your schema");
+  info("  2. Run: schema-forge 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);
+program.name("schema-forge").description("CLI tool for schema management and SQL generation").version(package_default.version);
+function handleError(error2) {
+  if (error2 instanceof SchemaValidationError) {
+    error(error2.message);
     process.exitCode = 2;
     return;
   }
-  if (error instanceof Error) {
-    console.error(error.message);
+  if (error2 instanceof Error) {
+    error(error2.message);
   } else {
-    console.error("Unexpected error");
+    error("Unexpected error");
   }
   process.exitCode = 1;
 }
 program.command("init").description("Initialize a new schema project").action(async () => {
   try {
     await runInit();
-  } catch (error) {
-    handleError(error);
+  } catch (error2) {
+    handleError(error2);
   }
 });
 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);
+  } catch (error2) {
+    handleError(error2);
   }
 });
 program.command("diff").description("Compare two schema versions and generate migration SQL").action(async () => {
   try {
     await runDiff();
-  } catch (error) {
-    handleError(error);
+  } catch (error2) {
+    handleError(error2);
   }
 });
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xubylele/schema-forge",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Universal migration generator from schema DSL",
   "main": "dist/cli.js",
   "type": "commonjs",
@@ -40,6 +40,8 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
     "commander": "^14.0.3"
   },
   "devDependencies": {
@@ -50,4 +52,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   }
-}
+}