forge-sql-orm-cli 2.1.14 → 2.1.16

package/dist-cli/cli.mjs

@@ -9,6 +9,7 @@ import { execSync } from "child_process";
 import mysql from "mysql2/promise";
 import { getTableMetadata, generateDropTableStatements } from "forge-sql-orm";
 import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
+import { v4 } from "uuid";
 function replaceMySQLTypes(schemaContent) {
   const imports = `import { forgeDateTimeString, forgeTimeString, forgeDateString, forgeTimestampString } from "forge-sql-orm";
 
@@ -248,27 +249,152 @@ const createMigration = async (options) => {
     process.exit(1);
   }
 };
+function buildDefault(preMigration) {
+  const def = preMigration.defaultValue;
+  const type = preMigration.type.toLowerCase();
+  if (def === void 0 || def === null) {
+    return "";
+  }
+  if (def === "") {
+    return `''`;
+  }
+  const stringTypes = /* @__PURE__ */ new Set([
+    "char",
+    "varchar",
+    "text",
+    "tinytext",
+    "mediumtext",
+    "longtext",
+    "enum",
+    "set",
+    "binary",
+    "varbinary",
+    "blob"
+  ]);
+  const numericTypes = /* @__PURE__ */ new Set([
+    "tinyint",
+    "smallint",
+    "mediumint",
+    "int",
+    "bigint",
+    "decimal",
+    "float",
+    "double",
+    "bit"
+  ]);
+  const isNumericLiteral = /^[+-]?\d+(\.\d+)?$/.test(def);
+  if (numericTypes.has(type) && isNumericLiteral) {
+    return `${def}`;
+  }
+  if (stringTypes.has(type)) {
+    const escaped = def.replace(/'/g, "''");
+    return `'${escaped}'`;
+  }
+  return `${def}`;
+}
+function generateWarningMessage(tableName, colName, version) {
+  return `⚠️  WARNING: Field \`${tableName}\`.\`${colName}\` requires a default value for existing NULL records.
+   Action required in migration file: migrationV${version}.ts
+   Find the line with: UPDATE \`${tableName}\` SET \`${colName}\` = ?
+   Replace '?' with an actual value (e.g., '' for strings, 0 for numbers, '1970-01-01' for dates)
+   OR remove this migration if it's not needed.`;
+}
+function handleMissingDefaultValue(preMigration, version, migrationLineList) {
+  const warningMsg = generateWarningMessage(preMigration.tableName, preMigration.colName, version);
+  console.warn(warningMsg);
+  migrationLineList.push(`console.error(${JSON.stringify(warningMsg)});`);
+}
+function getUpdateDefaultValue(preMigration, defaultValue) {
+  return defaultValue === "?" ? defaultValue : buildDefault(preMigration);
+}
+function generateUpdateStatement(preMigration, defaultValue) {
+  const updateValue = getUpdateDefaultValue(preMigration, defaultValue);
+  return `UPDATE \`${preMigration.tableName}\` SET \`${preMigration.colName}\` = ${updateValue} WHERE \`${preMigration.colName}\` IS NULL`;
+}
 function generateMigrationFile$1(createStatements, version) {
   const versionPrefix = `v${version}_MIGRATION`;
-  const migrationLines = createStatements.map((stmt, index) => `        .enqueue("${versionPrefix}${index}", "${stmt}")`).join("\n");
+  const migrationLineList = [];
+  createStatements.changes.forEach((change, index) => {
+    if (!change.premigrationId) {
+      migrationLineList.push(
+        `
+migrationRunner.enqueue("${versionPrefix}${index}", "${change.change}")`
+      );
+      return;
+    }
+    const preMigration = createStatements.preMigrations[change.premigrationId];
+    if (!preMigration) {
+      migrationLineList.push(
+        `
+migrationRunner.enqueue("${versionPrefix}${index}", "${change.change}")`
+      );
+      return;
+    }
+    const defaultValue = preMigration.defaultValue === void 0 || preMigration.defaultValue === null ? "?" : preMigration.defaultValue;
+    const needsWarning = defaultValue === "?";
+    if (preMigration.migrationType === "NEW_FIELD_NOT_NULL") {
+      const addColumnStatement = change.change.replace("NOT NULL", "NULL");
+      migrationLineList.push(
+        `
+migrationRunner.enqueue("${versionPrefix}${index}_NULLABLE", "${addColumnStatement}");`
+      );
+      if (needsWarning) {
+        handleMissingDefaultValue(preMigration, version, migrationLineList);
+      }
+      const updateStatement = generateUpdateStatement(preMigration, defaultValue);
+      migrationLineList.push(
+        `
+migrationRunner.enqueue("${versionPrefix}${index}_UPDATE_EXISTS_RECORDS", "${updateStatement}");`
+      );
+      const defaultClause = defaultValue === "?" ? "" : ` DEFAULT ${buildDefault(preMigration)}`;
+      const modifyStatement = `ALTER TABLE \`${preMigration.tableName}\` MODIFY COLUMN IF EXISTS \`${preMigration.colName}\` ${preMigration.type} NOT NULL${defaultClause};`;
+      migrationLineList.push(
+        `
+migrationRunner.enqueue("${versionPrefix}${index}", "${modifyStatement}");`
+      );
+    } else if (preMigration.migrationType === "MODIFY_NOT_NULL") {
+      if (needsWarning) {
+        handleMissingDefaultValue(preMigration, version, migrationLineList);
+      }
+      const updateStatement = generateUpdateStatement(preMigration, defaultValue);
+      migrationLineList.push(
+        `
+migrationRunner.enqueue("${versionPrefix}${index}_UPDATE_EXISTS_RECORDS", "${updateStatement}")`
+      );
+      migrationLineList.push(
+        `
+migrationRunner.enqueue("${versionPrefix}${index}", "${change.change}")`
+      );
+    }
+  });
+  const migrationLines = migrationLineList.join("\n");
   return `import { MigrationRunner } from "@forge/sql/out/migration";
 
-export default (migrationRunner: MigrationRunner): MigrationRunner => {
-    return migrationRunner
+export default (migrationRunner: MigrationRunner): MigrationRunner => { 
 ${migrationLines};
+return migrationRunner;
 };`;
 }
 function filterWithPreviousMigration(newStatements, prevVersion, outputDir) {
   const prevMigrationPath = path.join(outputDir, `migrationV${prevVersion}.ts`);
   if (!fs.existsSync(prevMigrationPath)) {
-    return newStatements.map((s) => s.replace(/\s+/g, " "));
+    return {
+      changes: newStatements.changes.map((s) => ({
+        change: s.change.replace(/\s+/g, " "),
+        premigrationId: s.premigrationId
+      })),
+      preMigrations: newStatements.preMigrations
+    };
   }
   const prevContent = fs.readFileSync(prevMigrationPath, "utf-8");
   const prevStatements = prevContent.split("\n").filter((line) => line.includes(".enqueue(")).map((line) => {
     const match = line.match(/\.enqueue\([^,]+,\s*"([^"]+)"/);
     return match ? match[1].replace(/\s+/g, " ").trim() : "";
   });
-  return newStatements.filter((s) => !prevStatements.includes(s.replace(/\s+/g, " "))).map((s) => s.replace(/\s+/g, " "));
+  return {
+    preMigrations: newStatements.preMigrations,
+    changes: newStatements.changes.filter((s) => !prevStatements.includes(s.change.replace(/\s+/g, " "))).map((s) => ({ change: s.change.replace(/\s+/g, " "), premigrationId: s.premigrationId }))
+  };
 }
 function saveMigrationFiles$1(migrationCode, version, outputDir) {
   if (!fs.existsSync(outputDir)) {
@@ -279,22 +405,23 @@ function saveMigrationFiles$1(migrationCode, version, outputDir) {
   const indexFilePath = path.join(outputDir, `index.ts`);
   fs.writeFileSync(migrationFilePath, migrationCode);
   fs.writeFileSync(migrationCountPath, `export const MIGRATION_VERSION = ${version};`);
+  const importLines = [];
+  const callLines = [];
+  for (let i = 1; i <= version; i++) {
+    importLines.push(`import migrationV${i} from "./migrationV${i}";`);
+    callLines.push(`  migrationV${i}(migrationRunner);`);
+  }
   const indexFileContent = `import { MigrationRunner } from "@forge/sql/out/migration";
-import { MIGRATION_VERSION } from "./migrationCount";
+${importLines.join("\n")}
 
 export type MigrationType = (
   migrationRunner: MigrationRunner,
 ) => MigrationRunner;
 
-export default async (
+export default (
   migrationRunner: MigrationRunner,
-): Promise<MigrationRunner> => {
-  for (let i = 1; i <= MIGRATION_VERSION; i++) {
-    const migrations = (await import(\`./migrationV\${i}\`)) as {
-      default: MigrationType;
-    };
-    migrations.default(migrationRunner);
-  }
+): MigrationRunner => {
+${callLines.join("\n")}
   return migrationRunner;
 };`;
   fs.writeFileSync(indexFilePath, indexFileContent);
@@ -323,7 +450,7 @@ const loadMigrationVersion = async (migrationPath) => {
 async function getDatabaseSchema(connection, dbName) {
   const [columns] = await connection.execute(
     `
-    SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, EXTRA
+    SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, EXTRA, COLUMN_DEFAULT
     FROM INFORMATION_SCHEMA.COLUMNS
     WHERE TABLE_SCHEMA = ?
   `,
@@ -406,6 +533,7 @@ function compareForeignKey(fk, { columns }) {
 }
 function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
   const changes = [];
+  const preMigrations = {};
   for (const [tableName, dbTable] of Object.entries(dbSchema)) {
     const drizzleColumns = drizzleSchema[tableName];
     if (!drizzleColumns) {
@@ -415,9 +543,9 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
         const autoIncrement = col.EXTRA.includes("auto_increment") ? "AUTO_INCREMENT" : "";
         return `\`${colName}\` ${type} ${nullable} ${autoIncrement}`.trim();
       }).join(",\n  ");
-      changes.push(`CREATE TABLE if not exists \`${tableName}\` (
+      changes.push({ change: `CREATE TABLE if not exists \`${tableName}\` (
   ${columns}
-);`);
+);` });
       for (const [indexName, dbIndex] of Object.entries(dbTable.indexes)) {
         if (indexName === "PRIMARY") {
           continue;
@@ -431,14 +559,14 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
         }
         const columns2 = dbIndex.columns.map((col) => `\`${col}\``).join(", ");
         const unique = dbIndex.unique ? "UNIQUE " : "";
-        changes.push(
-          `CREATE  ${unique}INDEX if not exists  \`${indexName}\` ON \`${tableName}\` (${columns2});`
-        );
+        changes.push({
+          change: `CREATE  ${unique}INDEX if not exists  \`${indexName}\` ON \`${tableName}\` (${columns2});`
+        });
       }
       for (const [fkName, dbFK] of Object.entries(dbTable.foreignKeys)) {
-        changes.push(
-          `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${fkName}\` FOREIGN KEY (\`${dbFK.column}\`) REFERENCES \`${dbFK.referencedTable}\` (\`${dbFK.referencedColumn}\`);`
-        );
+        changes.push({
+          change: `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${fkName}\` FOREIGN KEY (\`${dbFK.column}\`) REFERENCES \`${dbFK.referencedTable}\` (\`${dbFK.referencedColumn}\`);`
+        });
       }
       continue;
     }
@@ -446,18 +574,67 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
       const drizzleCol = Object.values(drizzleColumns).find((c) => c.name === colName);
       if (!drizzleCol) {
         const type = dbCol.COLUMN_TYPE;
-        const nullable = dbCol.IS_NULLABLE === "YES" ? "NULL" : "NOT NULL";
-        changes.push(`ALTER TABLE \`${tableName}\` ADD COLUMN IF NOT EXISTS \`${colName}\` ${type} ${nullable};`);
+        const nullable2 = dbCol.IS_NULLABLE === "YES" ? "NULL" : "NOT NULL";
+        let premigrationId = nullable2 === "NOT NULL" ? v4() : void 0;
+        const defaultValue = dbCol.COLUMN_DEFAULT;
+        if (nullable2 === "NOT NULL") {
+          premigrationId = v4();
+          preMigrations[premigrationId] = {
+            tableName,
+            dbTable,
+            colName,
+            type,
+            migrationType: "NEW_FIELD_NOT_NULL",
+            defaultValue
+          };
+        }
+        changes.push({
+          change: `ALTER TABLE \`${tableName}\` ADD COLUMN IF NOT EXISTS \`${colName}\` ${type} ${nullable2} ${defaultValue === void 0 || defaultValue === null ? "" : `DEFAULT ${buildDefault({
+            type,
+            defaultValue
+          })}`};`,
+          premigrationId
+        });
         continue;
       }
       const normalizedDbType = normalizeMySQLType(dbCol.COLUMN_TYPE);
       const normalizedDrizzleType = normalizeMySQLType(drizzleCol.getSQLType());
-      if (normalizedDbType !== normalizedDrizzleType) {
+      const nullable = dbCol.IS_NULLABLE === "YES" ? "NULL" : "NOT NULL";
+      const dbIsNotNull = nullable === "NOT NULL";
+      const drizzleIsNotNull = drizzleCol.notNull;
+      const typeChanged = normalizedDbType !== normalizedDrizzleType;
+      const nullabilityChanged = dbIsNotNull !== drizzleIsNotNull;
+      const hasDrizzleDefault = drizzleCol.default !== null && drizzleCol.default !== void 0;
+      const hasDbDefault = dbCol.COLUMN_DEFAULT !== null && dbCol.COLUMN_DEFAULT !== void 0;
+      const defaultChanged = hasDrizzleDefault && hasDbDefault && drizzleCol.default !== dbCol.COLUMN_DEFAULT;
+      if (typeChanged || nullabilityChanged || defaultChanged) {
         const type = dbCol.COLUMN_TYPE;
-        const nullable = dbCol.IS_NULLABLE === "YES" ? "NULL" : "NOT NULL";
-        changes.push(
-          `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${colName}\` IF EXISTS ${type} ${nullable};`
-        );
+        const defaultValue = dbCol.COLUMN_DEFAULT;
+        let premigrationId = void 0;
+        if (dbIsNotNull && !drizzleIsNotNull) {
+          premigrationId = v4();
+          preMigrations[premigrationId] = {
+            tableName,
+            dbTable,
+            colName,
+            type,
+            migrationType: "MODIFY_NOT_NULL",
+            defaultValue
+          };
+        }
+        let defaultClause = "";
+        if (defaultValue !== void 0 && defaultValue !== null) {
+          const defaultValueObj = {
+            type,
+            defaultValue
+          };
+          defaultClause = ` DEFAULT ${buildDefault(defaultValueObj)}`;
+        }
+        const modifyStatement = `ALTER TABLE \`${tableName}\` MODIFY COLUMN IF EXISTS \`${colName}\` ${type} ${nullable}${defaultClause};`;
+        changes.push({
+          change: modifyStatement,
+          premigrationId
+        });
       }
     }
     const table = Object.values(schemaModule).find((t) => {
@@ -486,20 +663,20 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
         if (!drizzleIndex) {
           const columns = dbIndex.columns.map((col) => `\`${col}\``).join(", ");
           const unique = dbIndex.unique ? "UNIQUE " : "";
-          changes.push(
-            `CREATE ${unique}INDEX if not exists \`${indexName}\` ON \`${tableName}\` (${columns});`
-          );
+          changes.push({
+            change: `CREATE ${unique}INDEX if not exists \`${indexName}\` ON \`${tableName}\` (${columns});`
+          });
           continue;
         }
         const dbColumns = dbIndex.columns.join(", ");
         const drizzleColumns2 = getIndexColumns(drizzleIndex).join(", ");
         if (dbColumns !== drizzleColumns2 || dbIndex.unique !== drizzleIndex instanceof UniqueConstraintBuilder) {
-          changes.push(`DROP INDEX \`${indexName}\` ON \`${tableName}\`;`);
+          changes.push({ change: `DROP INDEX \`${indexName}\` ON \`${tableName}\`;` });
           const columns = dbIndex.columns.map((col) => `\`${col}\``).join(", ");
           const unique = dbIndex.unique ? "UNIQUE " : "";
-          changes.push(
-            `CREATE  ${unique}INDEX if not exists \`${indexName}\` ON \`${tableName}\` (${columns});`
-          );
+          changes.push({
+            change: `CREATE  ${unique}INDEX if not exists \`${indexName}\` ON \`${tableName}\` (${columns});`
+          });
         }
       }
       for (const [fkName, dbFK] of Object.entries(dbTable.foreignKeys)) {
@@ -507,9 +684,9 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
           (fk) => getForeignKeyName(fk) === fkName || compareForeignKey(fk, { columns: [dbFK.column] })
         );
         if (!drizzleFK) {
-          changes.push(
-            `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${fkName}\` FOREIGN KEY (\`${dbFK.column}\`) REFERENCES \`${dbFK.referencedTable}\` (\`${dbFK.referencedColumn}\`);`
-          );
+          changes.push({
+            change: `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${fkName}\` FOREIGN KEY (\`${dbFK.column}\`) REFERENCES \`${dbFK.referencedTable}\` (\`${dbFK.referencedColumn}\`);`
+          });
           continue;
         }
       }
@@ -522,7 +699,9 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
           if (drizzleForeignKey) {
             const fkName = getForeignKeyName(drizzleForeignKey);
             if (fkName) {
-              changes.push(`ALTER TABLE \`${tableName}\` DROP FOREIGN KEY  \`${fkName}\`;`);
+              changes.push({
+                change: `ALTER TABLE \`${tableName}\` DROP FOREIGN KEY  \`${fkName}\`;`
+              });
             } else {
               const columns = drizzleForeignKey.columns;
               const columnNames = columns?.length ? columns.map((c) => c.name).join(", ") : "unknown columns";
@@ -535,7 +714,7 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
       }
     }
   }
-  return changes;
+  return { changes, preMigrations };
 }
 const updateMigration = async (options) => {
   try {
@@ -578,6 +757,7 @@ const updateMigration = async (options) => {
               autoincrement: column.autoincrement,
               columnType: column.columnType,
               name: column.name,
+              default: metadata.columns.email.hasDefault ? String(column.default) : void 0,
               getSQLType: () => column.getSQLType()
             };
           });
@@ -593,7 +773,7 @@ const updateMigration = async (options) => {
         prevVersion,
         options.output
       );
-      if (createStatements.length) {
+      if (createStatements.changes.length) {
         const migrationFile = generateMigrationFile$1(createStatements, version);
         if (saveMigrationFiles$1(migrationFile, version, options.output)) {
           console.log(`✅ Migration successfully updated!`);