forge-sql-orm 2.0.4 → 2.0.6

package/dist-cli/cli.js

@@ -8,8 +8,11 @@ const path = require("path");
 require("reflect-metadata");
 const child_process = require("child_process");
 const mysql = require("mysql2/promise");
-require("moment");
+const moment = require("moment");
 const uniqueConstraint = require("drizzle-orm/mysql-core/unique-constraint");
+require("@forge/sql");
+const mysqlCore = require("drizzle-orm/mysql-core");
+const moment$1 = require("moment/moment.js");
 function replaceMySQLTypes(schemaContent) {
   const imports = `import { forgeDateTimeString, forgeTimeString, forgeDateString, forgeTimestampString } from "forge-sql-orm";
 
@@ -224,6 +227,13 @@ const createMigration = async (options) => {
     process.exit(1);
   }
 };
+const parseDateTime = (value, format) => {
+  const m = moment(value, format, true);
+  if (!m.isValid()) {
+    return moment(value).toDate();
+  }
+  return m.toDate();
+};
 function processForeignKeys(table, foreignKeysSymbol, extraSymbol) {
   const foreignKeys = [];
   if (foreignKeysSymbol) {
@@ -306,6 +316,17 @@ function getTableMetadata(table) {
     ...builders
   };
 }
+function generateDropTableStatements(tables) {
+  const dropStatements = [];
+  tables.forEach((table) => {
+    const tableMetadata = getTableMetadata(table);
+    if (tableMetadata.tableName) {
+      dropStatements.push(`DROP TABLE IF EXISTS \`${tableMetadata.tableName}\`;`);
+    }
+  });
+  dropStatements.push(`DELETE FROM __migrations;`);
+  return dropStatements;
+}
 function generateMigrationFile$1(createStatements, version) {
   const versionPrefix = `v${version}_MIGRATION`;
   const migrationLines = createStatements.map(
@@ -483,7 +504,7 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
         }
         const columns2 = dbIndex.columns.map((col) => `\`${col}\``).join(", ");
         const unique = dbIndex.unique ? "UNIQUE " : "";
-        changes.push(`CREATE if not exists ${unique}INDEX   \`${indexName}\` ON \`${tableName}\` (${columns2});`);
+        changes.push(`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}\`);`);
@@ -528,7 +549,7 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
         if (!drizzleIndex) {
           const columns = dbIndex.columns.map((col) => `\`${col}\``).join(", ");
           const unique = dbIndex.unique ? "UNIQUE " : "";
-          changes.push(`CREATE if not exists ${unique}INDEX \`${indexName}\` ON \`${tableName}\` (${columns});`);
+          changes.push(`CREATE ${unique}INDEX if not exists \`${indexName}\` ON \`${tableName}\` (${columns});`);
           continue;
         }
         const dbColumns = dbIndex.columns.join(", ");
@@ -537,7 +558,7 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
           changes.push(`DROP INDEX \`${indexName}\` ON \`${tableName}\`;`);
           const columns = dbIndex.columns.map((col) => `\`${col}\``).join(", ");
           const unique = dbIndex.unique ? "UNIQUE " : "";
-          changes.push(`CREATE if not exists  ${unique}INDEX \`${indexName}\` ON \`${tableName}\` (${columns});`);
+          changes.push(`CREATE  ${unique}INDEX if not exists \`${indexName}\` ON \`${tableName}\` (${columns});`);
         }
       }
       for (const [fkName, dbFK] of Object.entries(dbTable.foreignKeys)) {
@@ -554,7 +575,13 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
         });
         if (!isDbFk) {
           const fkName = getForeignKeyName(drizzleForeignKey);
-          changes.push(`ALTER TABLE \`${tableName}\` DROP FOREIGN KEY \`${fkName}\`;`);
+          if (fkName) {
+            changes.push(`ALTER TABLE \`${tableName}\` DROP FOREIGN KEY \`${fkName}\`;`);
+          } else {
+            const columns = drizzleForeignKey?.columns;
+            const columnNames = columns?.length ? columns.map((c) => c.name).join(", ") : "unknown columns";
+            console.warn(`⚠️ Drizzle model for table '${tableName}' does not provide a name for FOREIGN KEY constraint on columns: ${columnNames}`);
+          }
         }
       }
     }
@@ -564,8 +591,7 @@ function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
 const updateMigration = async (options) => {
   try {
     let version = await loadMigrationVersion(options.output);
-    version = 2;
-    const prevVersion = 1;
+    const prevVersion = version;
     if (version < 1) {
       console.log(
         `⚠️ Initial migration not found. Run "npx forge-sql-orm migrations:create" first.`
@@ -632,6 +658,53 @@ const updateMigration = async (options) => {
     process.exit(1);
   }
 };
+mysqlCore.customType({
+  dataType() {
+    return "datetime";
+  },
+  toDriver(value) {
+    return moment$1(value).format("YYYY-MM-DDTHH:mm:ss.SSS");
+  },
+  fromDriver(value) {
+    const format = "YYYY-MM-DDTHH:mm:ss.SSS";
+    return parseDateTime(value, format);
+  }
+});
+mysqlCore.customType({
+  dataType() {
+    return "timestamp";
+  },
+  toDriver(value) {
+    return moment$1(value).format("YYYY-MM-DDTHH:mm:ss.SSS");
+  },
+  fromDriver(value) {
+    const format = "YYYY-MM-DDTHH:mm:ss.SSS";
+    return parseDateTime(value, format);
+  }
+});
+mysqlCore.customType({
+  dataType() {
+    return "date";
+  },
+  toDriver(value) {
+    return moment$1(value).format("YYYY-MM-DD");
+  },
+  fromDriver(value) {
+    const format = "YYYY-MM-DD";
+    return parseDateTime(value, format);
+  }
+});
+mysqlCore.customType({
+  dataType() {
+    return "time";
+  },
+  toDriver(value) {
+    return moment$1(value).format("HH:mm:ss.SSS");
+  },
+  fromDriver(value) {
+    return parseDateTime(value, "HH:mm:ss.SSS");
+  }
+});
 function generateMigrationUUID(version) {
   const now = /* @__PURE__ */ new Date();
   const timestamp = now.getTime();
@@ -693,42 +766,16 @@ const dropMigration = async (options) => {
     if (!schemaModule) {
       throw new Error(`Invalid schema file at: ${schemaPath}. Schema must export tables.`);
     }
-    const drizzleSchema = {};
     const tables = Object.values(schemaModule);
-    tables.forEach((table) => {
-      const symbols = Object.getOwnPropertySymbols(table);
-      const nameSymbol = symbols.find((s) => s.toString().includes("Name"));
-      const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));
-      const indexesSymbol = symbols.find((s) => s.toString().includes("Indexes"));
-      const foreignKeysSymbol = symbols.find((s) => s.toString().includes("ForeignKeys"));
-      if (table && nameSymbol && columnsSymbol) {
-        drizzleSchema[table[nameSymbol]] = {
-          // @ts-ignore
-          columns: table[columnsSymbol],
-          // @ts-ignore
-          indexes: indexesSymbol ? table[indexesSymbol] || {} : {},
-          // @ts-ignore
-          foreignKeys: foreignKeysSymbol ? table[foreignKeysSymbol] || {} : {}
-        };
-      }
-    });
-    if (Object.keys(drizzleSchema).length === 0) {
+    if (tables.length === 0) {
       throw new Error(`No valid tables found in schema at: ${schemaPath}`);
     }
-    console.log("Found tables:", Object.keys(drizzleSchema));
-    const dropStatements = [];
-    for (const [tableName, tableInfo] of Object.entries(drizzleSchema)) {
-      for (const fk of Object.values(tableInfo.foreignKeys)) {
-        const fkName = fk.getName();
-        dropStatements.push(`ALTER TABLE \`${tableName}\` DROP FOREIGN KEY \`${fkName}\`;`);
-      }
-      for (const [indexName, index] of Object.entries(tableInfo.indexes)) {
-        if (indexName === "PRIMARY") continue;
-        dropStatements.push(`DROP INDEX \`${indexName}\` ON \`${tableName}\`;`);
-      }
-      dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
-    }
-    dropStatements.push(`DELETE FROM __migrations;`);
+    const tableNames = tables.map((table) => {
+      const metadata = getTableMetadata(table);
+      return metadata.tableName;
+    }).filter(Boolean);
+    console.log("Found tables:", tableNames);
+    const dropStatements = generateDropTableStatements(tables);
     const migrationFile = generateMigrationFile(dropStatements, version);
     saveMigrationFiles(migrationFile, version, options.output);
     console.log(`✅ Migration successfully created!`);