forge-sql-orm 2.0.5 → 2.0.6

package/dist-cli/cli.mjs

@@ -7,8 +7,11 @@ import path from "path";
 import "reflect-metadata";
 import { execSync } from "child_process";
 import mysql from "mysql2/promise";
-import "moment";
+import moment from "moment";
 import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
+import "@forge/sql";
+import { customType } from "drizzle-orm/mysql-core";
+import moment$1 from "moment/moment.js";
 function replaceMySQLTypes(schemaContent) {
   const imports = `import { forgeDateTimeString, forgeTimeString, forgeDateString, forgeTimestampString } from "forge-sql-orm";
 
@@ -223,6 +226,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) {
@@ -305,6 +315,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(
@@ -482,7 +503,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}\`);`);
@@ -527,7 +548,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(", ");
@@ -536,7 +557,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)) {
@@ -636,6 +657,53 @@ const updateMigration = async (options) => {
     process.exit(1);
   }
 };
+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);
+  }
+});
+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);
+  }
+});
+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);
+  }
+});
+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();
@@ -697,42 +765,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!`);