forge-sql-orm 1.0.30 → 1.1.31

package/dist-cli/cli.mjs

@@ -5,98 +5,148 @@ import inquirer from "inquirer";
 import fs from "fs";
 import path from "path";
 import "reflect-metadata";
-import { defineConfig, MongoNamingStrategy, MikroORM } from "@mikro-orm/mysql";
-import { EntityGenerator } from "@mikro-orm/entity-generator";
-const regenerateIndexFile = (outputPath) => {
-  const entitiesDir = path.resolve(outputPath);
-  const indexPath = path.join(entitiesDir, "index.ts");
-  const entityFiles = fs.readdirSync(entitiesDir).filter((file) => file.endsWith(".ts") && file !== "index.ts");
-  const imports = entityFiles.map((file) => {
-    const entityName = path.basename(file, ".ts");
-    return `import { ${entityName} } from "./${entityName}";`;
-  });
-  const indexContent = `${imports.join("\n")}
+import { execSync } from "child_process";
+import mysql from "mysql2/promise";
+import "moment";
+import { PrimaryKeyBuilder } from "drizzle-orm/mysql-core/primary-keys";
+import { IndexBuilder } from "drizzle-orm/mysql-core/indexes";
+import { CheckBuilder } from "drizzle-orm/mysql-core/checks";
+import { ForeignKeyBuilder } from "drizzle-orm/mysql-core/foreign-keys";
+import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
+function replaceMySQLTypes(schemaContent) {
+  const imports = `import { mySqlDateTimeString, mySqlTimeString, mySqlDateString, mySqlTimestampString } from "forge-sql-orm";
 
-export default [${entityFiles.map((file) => path.basename(file, ".ts")).join(", ")}];
 `;
-  fs.writeFileSync(indexPath, indexContent, "utf8");
-  console.log(`✅ Updated index.ts with ${entityFiles.length} entities.`);
-};
+  let modifiedContent = schemaContent.replace(/datetime\(['"]([^'"]+)['"],\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\)/g, "mySqlDateTimeString('$1')").replace(/datetime\(['"]([^'"]+)['"]\)/g, "mySqlDateTimeString('$1')").replace(/datetime\(\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\s*\)/g, "mySqlDateTimeString()").replace(/datetime\(\)/g, "mySqlDateTimeString()").replace(/time\(['"]([^'"]+)['"],\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\)/g, "mySqlTimeString('$1')").replace(/time\(['"]([^'"]+)['"]\)/g, "mySqlTimeString('$1')").replace(/time\(\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\s*\)/g, "mySqlTimeString()").replace(/time\(\)/g, "mySqlTimeString()").replace(/date\(['"]([^'"]+)['"],\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\)/g, "mySqlDateString('$1')").replace(/date\(['"]([^'"]+)['"]\)/g, "mySqlDateString('$1')").replace(/date\(\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\s*\)/g, "mySqlDateString()").replace(/date\(\)/g, "mySqlDateString()").replace(/timestamp\(['"]([^'"]+)['"],\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\)/g, "mySqlTimestampString('$1')").replace(/timestamp\(['"]([^'"]+)['"]\)/g, "mySqlTimestampString('$1')").replace(/timestamp\(\s*{\s*mode:\s*['"]([^'"]+)['"]\s*}\s*\)/g, "mySqlTimestampString()").replace(/timestamp\(\)/g, "mySqlTimestampString()");
+  if (!modifiedContent.includes("import { mySqlDateTimeString")) {
+    modifiedContent = imports + modifiedContent;
+  }
+  return modifiedContent;
+}
 const generateModels = async (options) => {
   try {
-    const ormConfig = defineConfig({
-      host: options.host,
-      port: options.port,
-      user: options.user,
-      password: options.password,
-      dbName: options.dbName,
-      namingStrategy: MongoNamingStrategy,
-      discovery: { warnWhenNoEntities: false },
-      extensions: [EntityGenerator],
-      debug: true
-    });
-    const orm = MikroORM.initSync(ormConfig);
-    console.log(`✅ Connected to ${options.dbName} at ${options.host}:${options.port}`);
-    const onCreatingVersionField = async (metadatas) => {
-      metadatas.forEach((m) => {
-        if (options.versionField) {
-          const versionFieldName = Object.keys(m.properties).find((p) => {
-            return p === options.versionField || m.properties[p]?.name === options.versionField || m.properties[p]?.fieldNames?.find((f) => f === options.versionField);
-          });
-          if (versionFieldName) {
-            const property = m.properties[versionFieldName];
-            if (property.type !== "datetime" && property.type !== "integer" && property.type !== "decimal") {
-              console.warn(
-                `Version field "${property.name}" can be only datetime or integer Table ${m.tableName} but now is "${property.type}"`
-              );
-              return;
-            }
-            if (property.primary) {
-              console.warn(
-                `Version field "${property.name}" can not be primary key Table ${m.tableName}`
-              );
-              return;
-            }
-            if (property.nullable) {
+    const sql = await execSync(
+      `npx drizzle-kit pull --dialect mysql --url mysql://${options.user}:${options.password}@${options.host}:${options.port}/${options.dbName} --out ${options.output}`,
+      { encoding: "utf-8" }
+    );
+    const metaDir = path.join(options.output, "meta");
+    const additionalMetadata = {};
+    if (fs.existsSync(metaDir)) {
+      const snapshotFile = path.join(metaDir, "0000_snapshot.json");
+      if (fs.existsSync(snapshotFile)) {
+        const snapshotData = JSON.parse(fs.readFileSync(snapshotFile, "utf-8"));
+        for (const [tableName, tableData] of Object.entries(snapshotData.tables)) {
+          const table = tableData;
+          const versionField = Object.entries(table.columns).find(
+            ([_, col]) => col.name.toLowerCase() === options.versionField
+          );
+          if (versionField) {
+            const [_, col] = versionField;
+            const fieldType = col.type;
+            const isSupportedType = fieldType === "datetime" || fieldType === "timestamp" || fieldType === "int" || fieldType === "number" || fieldType === "decimal";
+            if (!col.notNull) {
+              console.warn(`Version field "${col.name}" in table ${tableName} is nullable. Versioning may not work correctly.`);
+            } else if (!isSupportedType) {
               console.warn(
-                `Version field "${property.name}" should not be nullable  Table ${m.tableName}`
+                `Version field "${col.name}" in table ${tableName} has unsupported type "${fieldType}". Only datetime, timestamp, int, and decimal types are supported for versioning. Versioning will be skipped.`
               );
-              return;
+            } else {
+              additionalMetadata[tableName] = {
+                tableName,
+                versionField: {
+                  fieldName: col.name
+                }
+              };
             }
-            property.version = true;
           }
         }
-      });
-    };
-    await orm.entityGenerator.generate({
-      entitySchema: true,
-      bidirectionalRelations: true,
-      identifiedReferences: false,
-      forceUndefined: true,
-      undefinedDefaults: true,
-      useCoreBaseEntity: false,
-      onlyPurePivotTables: false,
-      outputPurePivotTables: false,
-      scalarPropertiesForRelations: "always",
-      save: true,
-      path: options.output,
-      onInitialMetadata: onCreatingVersionField
-    });
-    regenerateIndexFile(options.output);
-    console.log(`✅ Entities generated at: ${options.output}`);
+      }
+    }
+    const versionMetadataContent = `/**
+ * This file was auto-generated by forge-sql-orm
+ * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+ * 
+ * DO NOT EDIT THIS FILE MANUALLY
+ * Any changes will be overwritten on next generation
+ */
+ 
+ 
+export * from "./relations";
+export * from "./schema";
+
+export interface VersionFieldMetadata {
+  fieldName: string;
+}
+
+export interface TableMetadata {
+  tableName: string;
+  versionField: VersionFieldMetadata;
+}
+
+export type AdditionalMetadata = Record<string, TableMetadata>;
+
+export const additionalMetadata: AdditionalMetadata = ${JSON.stringify(additionalMetadata, null, 2)};
+`;
+    fs.writeFileSync(path.join(options.output, "index.ts"), versionMetadataContent);
+    const schemaPath = path.join(options.output, "schema.ts");
+    if (fs.existsSync(schemaPath)) {
+      const schemaContent = fs.readFileSync(schemaPath, "utf-8");
+      const modifiedContent = replaceMySQLTypes(schemaContent);
+      fs.writeFileSync(schemaPath, modifiedContent);
+      console.log(`✅ Updated schema types in: ${schemaPath}`);
+    }
+    const migrationDir = path.join(options.output, "migrations");
+    if (fs.existsSync(migrationDir)) {
+      fs.rmSync(migrationDir, { recursive: true, force: true });
+      console.log(`✅ Removed: ${migrationDir}`);
+    }
+    if (fs.existsSync(metaDir)) {
+      const journalFile = path.join(metaDir, "_journal.json");
+      if (fs.existsSync(journalFile)) {
+        const journalData = JSON.parse(fs.readFileSync(journalFile, "utf-8"));
+        for (const entry of journalData.entries) {
+          const sqlFile = path.join(options.output, `${entry.tag}.sql`);
+          if (fs.existsSync(sqlFile)) {
+            fs.rmSync(sqlFile, { force: true });
+            console.log(`✅ Removed SQL file: ${entry.tag}.sql`);
+          }
+        }
+      }
+      fs.rmSync(metaDir, { recursive: true, force: true });
+      console.log(`✅ Removed: ${metaDir}`);
+    }
+    console.log(`✅ Successfully generated models and version metadata`);
     process.exit(0);
   } catch (error) {
-    console.error(`❌ Error generating entities:`, error);
+    console.error(`❌ Error during model generation:`, error);
     process.exit(1);
   }
 };
-function cleanSQLStatement$1(sql) {
+const loadMigrationVersion$1 = async (migrationPath) => {
+  try {
+    const migrationCountFilePath = path.resolve(path.join(migrationPath, "migrationCount.ts"));
+    if (!fs.existsSync(migrationCountFilePath)) {
+      return 0;
+    }
+    const { MIGRATION_VERSION } = await import(migrationCountFilePath);
+    console.log(`✅ Current migration version: ${MIGRATION_VERSION}`);
+    return MIGRATION_VERSION;
+  } catch (error) {
+    console.error(`❌ Error loading migrationCount:`, error);
+    process.exit(1);
+  }
+};
+function cleanSQLStatement(sql) {
+  sql = sql.replace(/create\s+table\s+(\w+)/gi, "create table if not exists $1");
+  sql = sql.replace(/create\s+index\s+(\w+)/gi, "create index if not exists $1");
+  sql = sql.replace(/alter\s+table\s+(\w+)\s+add\s+index\s+(\w+)/gi, "alter table $1 add index if not exists $2");
+  sql = sql.replace(/alter\s+table\s+(\w+)\s+add\s+constraint\s+(\w+)/gi, "alter table $1 add constraint if not exists $2");
   return sql.replace(/\s+default\s+character\s+set\s+utf8mb4\s+engine\s*=\s*InnoDB;?/gi, "").trim();
 }
-function generateMigrationFile$1(createStatements, version) {
+function generateMigrationFile$2(createStatements, version) {
   const versionPrefix = `v${version}_MIGRATION`;
   const migrationLines = createStatements.map(
-    (stmt, index) => `        .enqueue("${versionPrefix}${index}", "${cleanSQLStatement$1(stmt)}")`
+    (stmt, index) => `        .enqueue("${versionPrefix}${index}", "${cleanSQLStatement(stmt).replace(/\s+/g, " ")}")`
     // eslint-disable-line no-useless-escape
   ).join("\n");
   return `import { MigrationRunner } from "@forge/sql/out/migration";
@@ -106,7 +156,7 @@ export default (migrationRunner: MigrationRunner): MigrationRunner => {
 ${migrationLines};
 };`;
 }
-function saveMigrationFiles$1(migrationCode, version, outputDir) {
+function saveMigrationFiles$2(migrationCode, version, outputDir) {
   if (!fs.existsSync(outputDir)) {
     fs.mkdirSync(outputDir, { recursive: true });
   }
@@ -138,62 +188,38 @@ export default async (
   console.log(`✅ Migration count file updated: ${migrationCountPath}`);
   console.log(`✅ Migration index file created: ${indexFilePath}`);
 }
-const extractCreateStatements$1 = (schema) => {
-  const statements = schema.split(";").map((s) => s.trim());
+const extractCreateStatements = (schema) => {
+  const statements = schema.split(/--> statement-breakpoint|;/).map((s) => s.trim()).filter((s) => s.length > 0);
   return statements.filter(
-    (stmt) => stmt.startsWith("create table") || stmt.startsWith("alter table") && stmt.includes("add index") || stmt.startsWith("primary")
+    (stmt) => stmt.toLowerCase().startsWith("create table") || stmt.toLowerCase().startsWith("alter table") || stmt.toLowerCase().includes("add index") || stmt.toLowerCase().includes("add unique index") || stmt.toLowerCase().includes("add constraint")
   );
 };
-const loadEntities$1 = async (entitiesPath) => {
-  try {
-    const indexFilePath = path.resolve(path.join(entitiesPath, "index.ts"));
-    if (!fs.existsSync(indexFilePath)) {
-      console.error(`❌ Error: index.ts not found in ${indexFilePath}`);
-      process.exit(1);
-    }
-    const { default: entities } = await import(indexFilePath);
-    console.log(`✅ Loaded ${entities.length} entities from ${entitiesPath}`);
-    return entities;
-  } catch (error) {
-    console.error(`❌ Error loading index.ts from ${entitiesPath}:`, error);
-    process.exit(1);
-  }
-};
-const loadMigrationVersion$1 = async (migrationPath) => {
-  try {
-    const migrationCountFilePath = path.resolve(path.join(migrationPath, "migrationCount.ts"));
-    if (!fs.existsSync(migrationCountFilePath)) {
-      return 0;
-    }
-    const { MIGRATION_VERSION } = await import(migrationCountFilePath);
-    console.log(`✅ Current migration version: ${MIGRATION_VERSION}`);
-    return MIGRATION_VERSION;
-  } catch (error) {
-    console.error(`❌ Error loading migrationCount:`, error);
-    process.exit(1);
-  }
-};
 const createMigration = async (options) => {
   try {
     let version = await loadMigrationVersion$1(options.output);
     if (version > 0) {
-      console.error(`❌ Error: Migration has already been created.`);
-      process.exit(1);
+      if (options.force) {
+        console.warn(`⚠️ Warning: Migration already exists. Creating new migration with force flag...`);
+      } else {
+        console.error(`❌ Error: Migration has already been created. Use --force flag to override.`);
+        process.exit(1);
+      }
     }
     version = 1;
-    const entities = await loadEntities$1(options.entitiesPath);
-    const orm = MikroORM.initSync({
-      host: options.host,
-      port: options.port,
-      user: options.user,
-      password: options.password,
-      dbName: options.dbName,
-      entities
-    });
-    const createSchemaSQL = await orm.schema.getCreateSchemaSQL({ wrap: true });
-    const statements = extractCreateStatements$1(createSchemaSQL);
-    const migrationFile = generateMigrationFile$1(statements, version);
-    saveMigrationFiles$1(migrationFile, version, options.output);
+    await execSync(
+      `npx drizzle-kit generate --name=init --dialect mysql --out ${options.output} --schema ${options.entitiesPath}`,
+      { encoding: "utf-8" }
+    );
+    const initSqlFile = path.join(options.output, "0000_init.sql");
+    const sql = fs.readFileSync(initSqlFile, "utf-8");
+    const createStatements = extractCreateStatements(sql);
+    const migrationFile = generateMigrationFile$2(createStatements, 1);
+    saveMigrationFiles$2(migrationFile, 1, options.output);
+    fs.rmSync(initSqlFile, { force: true });
+    console.log(`✅ Removed SQL file: ${initSqlFile}`);
+    let metaDir = path.join(options.output, "meta");
+    fs.rmSync(metaDir, { recursive: true, force: true });
+    console.log(`✅ Removed: ${metaDir}`);
     console.log(`✅ Migration successfully created!`);
     process.exit(0);
   } catch (error) {
@@ -201,13 +227,64 @@ const createMigration = async (options) => {
     process.exit(1);
   }
 };
-function cleanSQLStatement(sql) {
-  return sql.replace(/\s+default\s+character\s+set\s+utf8mb4\s+engine\s*=\s*InnoDB;?/gi, "").trim();
+function getTableMetadata(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 extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));
+  const foreignKeysSymbol = symbols.find((s) => s.toString().includes("MySqlInlineForeignKeys)"));
+  const builders = {
+    indexes: [],
+    checks: [],
+    foreignKeys: [],
+    primaryKeys: [],
+    uniqueConstraints: [],
+    extras: []
+  };
+  if (foreignKeysSymbol) {
+    const foreignKeys = table[foreignKeysSymbol];
+    if (foreignKeys) {
+      for (const foreignKey of foreignKeys) {
+        builders.foreignKeys.push(foreignKey);
+      }
+    }
+  }
+  if (extraSymbol) {
+    const extraConfigBuilder = table[extraSymbol];
+    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
+      const configBuilders = extraConfigBuilder(table);
+      let configBuildersArray = [];
+      if (!Array.isArray(configBuilders)) {
+        configBuildersArray = Object.values(configBuilders);
+      } else {
+        configBuildersArray = configBuilders;
+      }
+      configBuildersArray.forEach((builder) => {
+        if (builder instanceof IndexBuilder) {
+          builders.indexes.push(builder);
+        } else if (builder instanceof CheckBuilder) {
+          builders.checks.push(builder);
+        } else if (builder instanceof ForeignKeyBuilder) {
+          builders.foreignKeys.push(builder);
+        } else if (builder instanceof PrimaryKeyBuilder) {
+          builders.primaryKeys.push(builder);
+        } else if (builder instanceof UniqueConstraintBuilder) {
+          builders.uniqueConstraints.push(builder);
+        }
+        builders.extras.push(builder);
+      });
+    }
+  }
+  return {
+    tableName: nameSymbol ? table[nameSymbol] : "",
+    columns: columnsSymbol ? table[columnsSymbol] : {},
+    ...builders
+  };
 }
-function generateMigrationFile(createStatements, version) {
+function generateMigrationFile$1(createStatements, version) {
   const versionPrefix = `v${version}_MIGRATION`;
   const migrationLines = createStatements.map(
-    (stmt, index) => `        .enqueue("${versionPrefix}${index}", "${cleanSQLStatement(stmt)}")`
+    (stmt, index) => `        .enqueue("${versionPrefix}${index}", "${stmt}")`
     // eslint-disable-line no-useless-escape
   ).join("\n");
   return `import { MigrationRunner } from "@forge/sql/out/migration";
@@ -217,7 +294,19 @@ export default (migrationRunner: MigrationRunner): MigrationRunner => {
 ${migrationLines};
 };`;
 }
-function saveMigrationFiles(migrationCode, version, outputDir) {
+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, " "));
+  }
+  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, " "));
+}
+function saveMigrationFiles$1(migrationCode, version, outputDir) {
   if (!fs.existsSync(outputDir)) {
     fs.mkdirSync(outputDir, { recursive: true });
   }
@@ -248,28 +337,8 @@ export default async (
   console.log(`✅ Migration file created: ${migrationFilePath}`);
   console.log(`✅ Migration count file updated: ${migrationCountPath}`);
   console.log(`✅ Migration index file created: ${indexFilePath}`);
+  return true;
 }
-const extractCreateStatements = (schema) => {
-  const statements = schema.split(";").map((s) => s.trim());
-  return statements.filter(
-    (stmt) => stmt.startsWith("create table") || stmt.startsWith("alter table") && stmt.includes("add index") || stmt.startsWith("alter table") && stmt.includes("add") && !stmt.includes("foreign") || stmt.startsWith("alter table") && stmt.includes("modify") && !stmt.includes("foreign")
-  );
-};
-const loadEntities = async (entitiesPath) => {
-  try {
-    const indexFilePath = path.resolve(path.join(entitiesPath, "index.ts"));
-    if (!fs.existsSync(indexFilePath)) {
-      console.error(`❌ Error: index.ts not found in ${entitiesPath}`);
-      process.exit(1);
-    }
-    const { default: entities } = await import(indexFilePath);
-    console.log(`✅ Loaded ${entities.length} entities from ${entitiesPath}`);
-    return entities;
-  } catch (error) {
-    console.error(`❌ Error loading index.ts from ${entitiesPath}:`, error);
-    process.exit(1);
-  }
-};
 const loadMigrationVersion = async (migrationPath) => {
   try {
     const migrationCountFilePath = path.resolve(path.join(migrationPath, "migrationCount.ts"));
@@ -287,9 +356,183 @@ const loadMigrationVersion = async (migrationPath) => {
     process.exit(1);
   }
 };
+async function getDatabaseSchema(connection, dbName) {
+  const [columns] = await connection.execute(`
+    SELECT TABLE_NAME, COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, EXTRA
+    FROM INFORMATION_SCHEMA.COLUMNS
+    WHERE TABLE_SCHEMA = ?
+  `, [dbName]);
+  const [indexes] = await connection.execute(`
+    SELECT TABLE_NAME, INDEX_NAME, COLUMN_NAME, NON_UNIQUE
+    FROM INFORMATION_SCHEMA.STATISTICS
+    WHERE TABLE_SCHEMA = ?
+    ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
+  `, [dbName]);
+  const [foreignKeys] = await connection.execute(`
+    SELECT 
+      TABLE_NAME,
+      COLUMN_NAME,
+      CONSTRAINT_NAME,
+      REFERENCED_TABLE_NAME,
+      REFERENCED_COLUMN_NAME
+    FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+    WHERE TABLE_SCHEMA = ?
+    AND REFERENCED_TABLE_NAME IS NOT NULL
+  `, [dbName]);
+  const schema = {};
+  columns.forEach((row) => {
+    if (!schema[row.TABLE_NAME]) {
+      schema[row.TABLE_NAME] = {
+        columns: {},
+        indexes: {},
+        foreignKeys: {}
+      };
+    }
+    schema[row.TABLE_NAME].columns[row.COLUMN_NAME] = row;
+  });
+  indexes.forEach((row) => {
+    if (!schema[row.TABLE_NAME].indexes[row.INDEX_NAME]) {
+      schema[row.TABLE_NAME].indexes[row.INDEX_NAME] = {
+        columns: [],
+        unique: !row.NON_UNIQUE
+      };
+    }
+    schema[row.TABLE_NAME].indexes[row.INDEX_NAME].columns.push(row.COLUMN_NAME);
+  });
+  foreignKeys.forEach((row) => {
+    if (!schema[row.TABLE_NAME].foreignKeys[row.CONSTRAINT_NAME]) {
+      schema[row.TABLE_NAME].foreignKeys[row.CONSTRAINT_NAME] = {
+        column: row.COLUMN_NAME,
+        referencedTable: row.REFERENCED_TABLE_NAME,
+        referencedColumn: row.REFERENCED_COLUMN_NAME
+      };
+    }
+  });
+  return schema;
+}
+function normalizeMySQLType(mysqlType) {
+  let normalized = mysqlType.replace(/\([^)]*\)/, "").toLowerCase();
+  normalized = normalized.replace(/^mysql/, "");
+  return normalized;
+}
+function getForeignKeyName(fk) {
+  return fk.getName();
+}
+function getIndexName(index) {
+  return index.name;
+}
+function getUniqueConstraintName(uc) {
+  return uc.name;
+}
+function getIndexColumns(index) {
+  return index.columns.map((col) => col.name);
+}
+function generateSchemaChanges(drizzleSchema, dbSchema, schemaModule) {
+  const changes = [];
+  for (const [tableName, dbTable] of Object.entries(dbSchema)) {
+    const drizzleColumns = drizzleSchema[tableName];
+    if (!drizzleColumns) {
+      const columns = Object.entries(dbTable.columns).map(([colName, col]) => {
+        const type = col.COLUMN_TYPE;
+        const nullable = col.IS_NULLABLE === "YES" ? "NULL" : "NOT NULL";
+        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}\` (
+  ${columns}
+);`);
+      for (const [indexName, dbIndex] of Object.entries(dbTable.indexes)) {
+        if (indexName === "PRIMARY") {
+          continue;
+        }
+        const isForeignKeyIndex = dbIndex.columns.some((colName) => {
+          const column = dbTable.columns[colName];
+          return column && column.COLUMN_KEY === "MUL" && column.EXTRA.includes("foreign key");
+        });
+        if (isForeignKeyIndex) {
+          continue;
+        }
+        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});`);
+      }
+      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}\`);`);
+      }
+      continue;
+    }
+    for (const [colName, dbCol] of Object.entries(dbTable.columns)) {
+      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 \`${colName}\` ${type} ${nullable};`);
+        continue;
+      }
+      const normalizedDbType = normalizeMySQLType(dbCol.COLUMN_TYPE);
+      const normalizedDrizzleType = normalizeMySQLType(drizzleCol.getSQLType());
+      if (normalizedDbType !== normalizedDrizzleType) {
+        const type = dbCol.COLUMN_TYPE;
+        const nullable = dbCol.IS_NULLABLE === "YES" ? "NULL" : "NOT NULL";
+        changes.push(`ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${colName}\` ${type} ${nullable};`);
+      }
+    }
+    const table = Object.values(schemaModule).find((t) => {
+      const metadata = getTableMetadata(t);
+      return metadata.tableName === tableName;
+    });
+    if (table) {
+      const metadata = getTableMetadata(table);
+      for (const [indexName, dbIndex] of Object.entries(dbTable.indexes)) {
+        if (indexName === "PRIMARY") {
+          continue;
+        }
+        const isForeignKeyIndex = metadata.foreignKeys.some((fk) => getForeignKeyName(fk) === indexName);
+        if (isForeignKeyIndex) {
+          continue;
+        }
+        const existsUniqIndex = metadata.uniqueConstraints.find((uc) => getUniqueConstraintName(uc) === indexName);
+        let drizzleIndex = metadata.indexes.find((i) => getIndexName(i) === indexName);
+        if (!drizzleIndex && existsUniqIndex) {
+          drizzleIndex = existsUniqIndex;
+        }
+        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});`);
+          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}\`;`);
+          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});`);
+        }
+      }
+      for (const [fkName, dbFK] of Object.entries(dbTable.foreignKeys)) {
+        const drizzleFK = metadata.foreignKeys.find((fk) => getForeignKeyName(fk) === fkName);
+        if (!drizzleFK) {
+          changes.push(`ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${fkName}\` FOREIGN KEY (\`${dbFK.column}\`) REFERENCES \`${dbFK.referencedTable}\` (\`${dbFK.referencedColumn}\`);`);
+          continue;
+        }
+      }
+      for (const drizzleForeignKey of metadata.foreignKeys) {
+        const isDbFk = Object.keys(dbTable.foreignKeys).find((fk) => fk === getForeignKeyName(drizzleForeignKey));
+        if (!isDbFk) {
+          const fkName = getForeignKeyName(drizzleForeignKey);
+          changes.push(`ALTER TABLE \`${tableName}\` DROP FOREIGN KEY \`${fkName}\`;`);
+        }
+      }
+    }
+  }
+  return changes;
+}
 const updateMigration = async (options) => {
   try {
     let version = await loadMigrationVersion(options.output);
+    const prevVersion = version;
     if (version < 1) {
       console.log(
         `⚠️ Initial migration not found. Run "npx forge-sql-orm migrations:create" first.`
@@ -297,226 +540,171 @@ const updateMigration = async (options) => {
       process.exit(0);
     }
     version += 1;
-    const entities = await loadEntities(options.entitiesPath);
-    const orm = MikroORM.initSync({
+    const connection = await mysql.createConnection({
       host: options.host,
       port: options.port,
       user: options.user,
       password: options.password,
-      dbName: options.dbName,
-      entities,
-      debug: true
+      database: options.dbName
     });
-    const createSchemaSQL = await orm.schema.getUpdateSchemaMigrationSQL({ wrap: true });
-    const statements = extractCreateStatements(createSchemaSQL?.down || "");
-    if (statements.length) {
-      const migrationFile = generateMigrationFile(statements, version);
-      saveMigrationFiles(migrationFile, version, options.output);
-      console.log(`✅ Migration successfully updated!`);
-      process.exit(0);
-    } else {
-      console.log(`⚠️ No new migration changes detected.`);
-      process.exit(0);
+    try {
+      const dbSchema = await getDatabaseSchema(connection, options.dbName);
+      const schemaPath = path.resolve(options.entitiesPath, "schema.ts");
+      if (!fs.existsSync(schemaPath)) {
+        throw new Error(`Schema file not found at: ${schemaPath}`);
+      }
+      const schemaModule = await import(schemaPath);
+      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 metadata = getTableMetadata(table);
+        if (metadata.tableName) {
+          const columns = {};
+          Object.entries(metadata.columns).forEach(([name, column]) => {
+            columns[name] = {
+              type: column.dataType,
+              notNull: column.notNull,
+              autoincrement: column.autoincrement,
+              columnType: column.columnType,
+              name: column.name,
+              getSQLType: () => column.getSQLType()
+            };
+          });
+          drizzleSchema[metadata.tableName] = columns;
+        }
+      });
+      if (Object.keys(drizzleSchema).length === 0) {
+        throw new Error(`No valid tables found in schema at: ${schemaPath}`);
+      }
+      console.log("Found tables:", Object.keys(drizzleSchema));
+      const createStatements = filterWithPreviousMigration(generateSchemaChanges(drizzleSchema, dbSchema, schemaModule), prevVersion, options.output);
+      if (createStatements.length) {
+        const migrationFile = generateMigrationFile$1(createStatements, version);
+        if (saveMigrationFiles$1(migrationFile, version, options.output)) {
+          console.log(`✅ Migration successfully updated!`);
+        }
+        process.exit(0);
+      } else {
+        console.log(`⚠️ No new migration changes detected.`);
+        process.exit(0);
+      }
+    } finally {
+      await connection.end();
     }
   } catch (error) {
     console.error(`❌ Error during migration update:`, error);
     process.exit(1);
   }
 };
-const PATCHES = [
-  // 🗑️ Remove unused dialects (mssql, postgres, sqlite) in MikroORM
-  {
-    file: "node_modules/@mikro-orm/knex/MonkeyPatchable.d.ts",
-    deleteLines: [
-      /^.*mssql.*$/gim,
-      /^.*MsSql.*$/gim,
-      /^\s*Postgres.*$/gm,
-      /^.*Sqlite3.*$/gm,
-      /^.*BetterSqlite3.*$/gim
-    ],
-    description: "Removing unused dialects from MonkeyPatchable.d.ts"
-  },
-  {
-    file: "node_modules/@mikro-orm/knex/MonkeyPatchable.js",
-    deleteLines: [
-      /^.*mssql.*$/gim,
-      /^.*MsSql.*$/gim,
-      /^.*postgres.*$/gim,
-      /^.*sqlite.*$/gim,
-      /^.*Sqlite.*$/gim
-    ],
-    description: "Removing unused dialects from MonkeyPatchable.js"
-  },
-  {
-    file: "node_modules/@mikro-orm/knex/dialects/index.js",
-    deleteLines: [/^.*mssql.*$/gim, /^.*MsSql.*$/gim, /^.*postgresql.*$/gim, /^.*sqlite.*$/gim],
-    description: "Removing unused dialects from @mikro-orm/knex/dialects/index.js"
-  },
-  {
-    deleteFolder: "node_modules/@mikro-orm/knex/dialects/mssql",
-    description: "Removing mssql dialect from MikroORM"
-  },
-  {
-    deleteFolder: "node_modules/@mikro-orm/knex/dialects/postgresql",
-    description: "Removing postgresql dialect from MikroORM"
-  },
-  {
-    deleteFolder: "node_modules/@mikro-orm/knex/dialects/sqlite",
-    description: "Removing sqlite dialect from MikroORM"
-  },
-  {
-    deleteFolder: "node_modules/@mikro-orm/mysql/node_modules",
-    description: "Removing node_modules from @mikro-orm/mysql"
-  },
-  {
-    deleteFolder: "node_modules/@mikro-orm/knex/node_modules",
-    description: "Removing node_modules from @mikro-orm/knex"
-  },
-  {
-    deleteFolder: "node_modules/@mikro-orm/core/node_modules",
-    description: "Removing sqlite dialect from MikroORM"
-  },
-  // 🔄 Fix Webpack `Critical dependency: the request of a dependency is an expression`
-  {
-    file: "node_modules/@mikro-orm/core/utils/Configuration.js",
-    search: /dynamicImportProvider:\s*\/\* istanbul ignore next \*\/\s*\(id\) => import\(id\),/g,
-    replace: "dynamicImportProvider: /* istanbul ignore next */ () => Promise.resolve({}),",
-    description: "Fixing dynamic imports in MikroORM Configuration"
-  },
-  {
-    file: "node_modules/@mikro-orm/core/utils/Utils.js",
-    search: /static dynamicImportProvider = \(id\) => import\(id\);/g,
-    replace: "static dynamicImportProvider = () => Promise.resolve({});",
-    description: "Fixing dynamic imports in MikroORM Utils.js"
-  },
-  // 🛑 Remove deprecated `require.extensions` usage
-  {
-    file: "node_modules/@mikro-orm/core/utils/Utils.js",
-    search: /\s\|\|\s*\(require\.extensions\s*&&\s*!!require\.extensions\['\.ts'\]\);\s*/g,
-    replace: ";",
-    description: "Removing deprecated `require.extensions` check in MikroORM"
-  },
-  // 🛠️ Patch Knex to remove `Migrator` and `Seeder`
-  {
-    file: "node_modules/knex/lib/knex-builder/make-knex.js",
-    deleteLines: [
-      /^const \{ Migrator \} = require\('\.\.\/migrations\/migrate\/Migrator'\);$/gm,
-      /^const Seeder = require\('\.\.\/migrations\/seed\/Seeder'\);$/gm
-    ],
-    description: "Removing `Migrator` and `Seeder` requires from make-knex.js"
-  },
-  {
-    file: "node_modules/knex/lib/knex-builder/make-knex.js",
-    search: /\sreturn new Migrator\(this\);/g,
-    replace: "return null;",
-    description: "Replacing `return new Migrator(this);` with `return null;`"
-  },
-  {
-    file: "node_modules/knex/lib/knex-builder/make-knex.js",
-    search: /\sreturn new Seeder\(this\);/g,
-    replace: "return null;",
-    description: "Replacing `return new Seeder(this);` with `return null;`"
-  },
-  {
-    file: "node_modules/knex/lib/dialects/index.js",
-    deleteLines: [
-      /^.*mssql.*$/gim,
-      /^.*MsSql.*$/gim,
-      /^.*postgresql.*$/gim,
-      /^.*sqlite.*$/gim,
-      /^.*oracle.*$/gim,
-      /^.*oracledb.*$/gim,
-      /^.*pgnative.*$/gim,
-      /^.*postgres.*$/gim,
-      /^.*redshift.*$/gim,
-      /^.*sqlite3.*$/gim,
-      /^.*cockroachdb.*$/gim
-    ],
-    description: "Removing unused dialects from @mikro-orm/knex/dialects/index.js"
-  },
-  {
-    file: "node_modules/@mikro-orm/core/utils/Utils.js",
-    search: /\s\|\|\s*\(require\.extensions\s*&&\s*!!require\.extensions\['\.ts'\]\);\s*/g,
-    replace: ";",
-    // Replaces with semicolon to keep syntax valid
-    description: "Removing deprecated `require.extensions` check from MikroORM"
-  },
-  {
-    file: "node_modules/@mikro-orm/core/utils/Utils.js",
-    search: /^.*extensions.*$/gim,
-    replace: "{",
-    // Replaces with semicolon to keep syntax valid
-    description: "Removing deprecated `require.extensions` check from MikroORM"
-  },
-  {
-    file: "node_modules/@mikro-orm/core/utils/Utils.js",
-    search: /^.*package.json.*$/gim,
-    replace: "return 0;",
-    // Replaces with semicolon to keep syntax valid
-    description: "Removing deprecated `require.extensions` check from MikroORM"
-  },
-  {
-    file: "node_modules/@mikro-orm/knex/dialects/mysql/index.js",
-    deleteLines: [/^.*MariaDbKnexDialect.*$/gim],
-    description: "Removing MariaDbKnexDialect"
+function generateMigrationUUID(version) {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.getTime();
+  return `MIGRATION_V${version}_${timestamp}`;
+}
+function generateMigrationFile(createStatements, version) {
+  const uniqId = generateMigrationUUID(version);
+  const migrationLines = createStatements.map(
+    (stmt, index) => `        .enqueue("${uniqId}_${index}", "${stmt}")`
+    // eslint-disable-line no-useless-escape
+  ).join("\n");
+  return `import { MigrationRunner } from "@forge/sql/out/migration";
+
+export default (migrationRunner: MigrationRunner): MigrationRunner => {
+    return migrationRunner
+${migrationLines};
+};`;
+}
+function saveMigrationFiles(migrationCode, version, outputDir) {
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
   }
-];
-function runPostInstallPatch() {
-  console.log("🔧 Applying MikroORM & Knex patches...");
-  PATCHES.forEach(
-    ({ file, search, replace, deleteLines, deleteFile, deleteFolder, description }) => {
-      if (file) {
-        const filePath = path.resolve(file);
-        if (fs.existsSync(filePath)) {
-          let content = fs.readFileSync(filePath, "utf8");
-          let originalContent = content;
-          if (search && replace) {
-            if (typeof search === "string" ? content.includes(search) : search.test(content)) {
-              content = content.replace(search, replace);
-              console.log(`[PATCHED] ${description}`);
-            }
-          }
-          if (deleteLines) {
-            deleteLines.forEach((pattern) => {
-              content = content.split("\n").filter((line) => !pattern.test(line)).join("\n");
-            });
-            if (content !== originalContent) {
-              console.log(`[CLEANED] Removed matching lines in ${file}`);
-            }
-          }
-          if (content !== originalContent) {
-            fs.writeFileSync(filePath, content, "utf8");
-          }
-          if (content.trim() === "") {
-            fs.unlinkSync(filePath);
-            console.log(`[REMOVED] ${filePath} (file is now empty)`);
-          }
-        } else {
-          console.warn(`[WARNING] File not found: ${file}`);
-        }
+  const migrationFilePath = path.join(outputDir, `migrationV${version}.ts`);
+  const migrationCountPath = path.join(outputDir, `migrationCount.ts`);
+  const indexFilePath = path.join(outputDir, `index.ts`);
+  fs.writeFileSync(migrationFilePath, migrationCode);
+  fs.writeFileSync(migrationCountPath, `export const MIGRATION_VERSION = ${version};`);
+  const indexFileContent = `import { MigrationRunner } from "@forge/sql/out/migration";
+import { MIGRATION_VERSION } from "./migrationCount";
+
+export type MigrationType = (
+  migrationRunner: MigrationRunner,
+) => MigrationRunner;
+
+export default async (
+  migrationRunner: MigrationRunner,
+): Promise<MigrationRunner> => {
+  for (let i = 1; i <= MIGRATION_VERSION; i++) {
+    const migrations = (await import(\`./migrationV\${i}\`)) as {
+      default: MigrationType;
+    };
+    migrations.default(migrationRunner);
+  }
+  return migrationRunner;
+};`;
+  fs.writeFileSync(indexFilePath, indexFileContent);
+  console.log(`✅ Migration file created: ${migrationFilePath}`);
+  console.log(`✅ Migration count file updated: ${migrationCountPath}`);
+  console.log(`✅ Migration index file created: ${indexFilePath}`);
+}
+const dropMigration = async (options) => {
+  try {
+    const version = 1;
+    const schemaPath = path.resolve(options.entitiesPath, "schema.ts");
+    if (!fs.existsSync(schemaPath)) {
+      throw new Error(`Schema file not found at: ${schemaPath}`);
+    }
+    const schemaModule = await import(schemaPath);
+    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 (deleteFile) {
-        const deleteFilePath = path.resolve(deleteFile);
-        if (fs.existsSync(deleteFilePath)) {
-          fs.unlinkSync(deleteFilePath);
-          console.log(`[DELETED] ${deleteFilePath} ${description}`);
-        } else {
-          console.log(`[SKIPPED] ${deleteFilePath} ${description}`);
-        }
+    });
+    if (Object.keys(drizzleSchema).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}\`;`);
       }
-      if (deleteFolder) {
-        const deleteFolderPath = path.resolve(deleteFolder);
-        if (fs.existsSync(deleteFolderPath)) {
-          fs.rmSync(deleteFolderPath, { recursive: true, force: true });
-          console.log(`[DELETED] ${deleteFolderPath}  ${description}`);
-        } else {
-          console.log(`[SKIPPED] ${deleteFolderPath} ${description}`);
-        }
+      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}\`;`);
     }
-  );
-  console.log("🎉 MikroORM & Knex patching completed!");
-}
+    dropStatements.push(`DELETE FROM __migrations;`);
+    const migrationFile = generateMigrationFile(dropStatements, version);
+    saveMigrationFiles(migrationFile, version, options.output);
+    console.log(`✅ Migration successfully created!`);
+    process.exit(0);
+  } catch (error) {
+    console.error(`❌ Error during migration creation:`, error);
+    process.exit(1);
+  }
+};
 const ENV_PATH = path.resolve(process.cwd(), ".env");
 dotenv.config({ path: ENV_PATH });
 const saveEnvFile = (config) => {
@@ -630,12 +818,13 @@ program.command("generate:model").description("Generate MikroORM models from the
   );
   await generateModels(config);
 });
-program.command("migrations:create").description("Generate an initial migration for the entire database.").option("--host <string>", "Database host").option("--port <number>", "Database port").option("--user <string>", "Database user").option("--password <string>", "Database password").option("--dbName <string>", "Database name").option("--output <string>", "Output path for migrations").option("--entitiesPath <string>", "Path to the folder containing entities").option("--saveEnv", "Save configuration to .env file").action(async (cmd) => {
+program.command("migrations:create").description("Generate an initial migration for the entire database.").option("--host <string>", "Database host").option("--port <number>", "Database port").option("--user <string>", "Database user").option("--password <string>", "Database password").option("--dbName <string>", "Database name").option("--output <string>", "Output path for migrations").option("--entitiesPath <string>", "Path to the folder containing entities").option("--force", "Force creation even if migrations exist").option("--saveEnv", "Save configuration to .env file").action(async (cmd) => {
   const config = await getConfig(
     cmd,
     "./database/migration",
     () => ({
-      entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIESPATH
+      entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIESPATH,
+      force: cmd.force || false
     }),
     (cfg, questions) => {
       if (!cfg.entitiesPath)
@@ -668,12 +857,24 @@ program.command("migrations:update").description("Generate a migration to update
   );
   await updateMigration(config);
 });
-program.command("patch:mikroorm").description("Patch MikroORM and Knex dependencies to work properly with Forge").action(async () => {
-  console.log("Running MikroORM patch...");
-  await runPostInstallPatch();
-  await runPostInstallPatch();
-  await runPostInstallPatch();
-  console.log("✅ MikroORM patch applied successfully!");
+program.command("migrations:drop").description("Generate a migration to drop all tables and clear migrations history.").option("--host <string>", "Database host").option("--port <number>", "Database port").option("--user <string>", "Database user").option("--password <string>", "Database password").option("--dbName <string>", "Database name").option("--output <string>", "Output path for migrations").option("--entitiesPath <string>", "Path to the folder containing entities").option("--saveEnv", "Save configuration to .env file").action(async (cmd) => {
+  const config = await getConfig(
+    cmd,
+    "./database/migration",
+    () => ({
+      entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIESPATH
+    }),
+    (cfg, questions) => {
+      if (!cfg.entitiesPath)
+        questions.push({
+          type: "input",
+          name: "entitiesPath",
+          message: "Enter the path to entities:",
+          default: "./database/entities"
+        });
+    }
+  );
+  await dropMigration(config);
 });
 program.parse(process.argv);
 //# sourceMappingURL=cli.mjs.map