forge-sql-orm 1.0.5 → 1.0.7

package/dist-cli/cli.mjs

@@ -0,0 +1,573 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import dotenv from "dotenv";
+import inquirer from "inquirer";
+import "reflect-metadata";
+import { defineConfig, EntityGenerator, MongoNamingStrategy, MikroORM } from "@mikro-orm/mysql";
+import "@forge/sql";
+import "moment";
+import "@mikro-orm/entity-generator";
+import path from "path";
+import fs from "fs";
+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")}
+
+export default [${entityFiles.map((file) => path.basename(file, ".ts")).join(", ")}];
+`;
+  fs.writeFileSync(indexPath, indexContent, "utf8");
+  console.log(`✅ Updated index.ts with ${entityFiles.length} entities.`);
+};
+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}`);
+    await orm.entityGenerator.generate({
+      entitySchema: true,
+      bidirectionalRelations: false,
+      identifiedReferences: false,
+      forceUndefined: true,
+      undefinedDefaults: true,
+      useCoreBaseEntity: false,
+      onlyPurePivotTables: false,
+      outputPurePivotTables: false,
+      scalarPropertiesForRelations: "always",
+      save: true,
+      path: options.output
+    });
+    regenerateIndexFile(options.output);
+    console.log(`✅ Entities generated at: ${options.output}`);
+    process.exit(0);
+  } catch (error) {
+    console.error(`❌ Error generating entities:`, error);
+    process.exit(1);
+  }
+};
+function cleanSQLStatement$1(sql) {
+  return sql.replace(/\s+default\s+character\s+set\s+utf8mb4\s+engine\s*=\s*InnoDB;?/gi, "").trim();
+}
+function generateMigrationFile$1(createStatements, version) {
+  const versionPrefix = `v${version}_MIGRATION`;
+  const migrationLines = createStatements.map(
+    (stmt, index) => `        .enqueue("${versionPrefix}${index}", "${cleanSQLStatement$1(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$1(migrationCode, version, outputDir) {
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  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 extractCreateStatements$1 = (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("primary")
+  );
+};
+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 ${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$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);
+    }
+    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,
+      debug: true
+    });
+    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);
+    console.log(`✅ Migration successfully created!`);
+    process.exit(0);
+  } catch (error) {
+    console.error(`❌ Error during migration creation:`, error);
+    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 generateMigrationFile(createStatements, version) {
+  const versionPrefix = `v${version}_MIGRATION`;
+  const migrationLines = createStatements.map(
+    (stmt, index) => `        .enqueue("${versionPrefix}${index}", "${cleanSQLStatement(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 });
+  }
+  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 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"));
+    if (!fs.existsSync(migrationCountFilePath)) {
+      console.warn(
+        `⚠️ Warning: migrationCount.ts not found in ${migrationCountFilePath}, assuming no previous migrations.`
+      );
+      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 updateMigration = async (options) => {
+  try {
+    let version = await loadMigrationVersion(options.output);
+    if (version < 1) {
+      console.log(
+        `⚠️ Initial migration not found. Run "npx forge-sql-orm migrations:create" first.`
+      );
+      process.exit(0);
+    }
+    version += 1;
+    const entities = await loadEntities(options.entitiesPath);
+    const orm = MikroORM.initSync({
+      host: options.host,
+      port: options.port,
+      user: options.user,
+      password: options.password,
+      dbName: options.dbName,
+      entities,
+      debug: true
+    });
+    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);
+    }
+  } 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"
+  },
+  // 🔄 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;`"
+  },
+  // 🔄 Patch for MikroORM Entity Generator to use 'forge-sql-orm'
+  {
+    file: "node_modules/@mikro-orm/entity-generator/SourceFile.js",
+    search: /^.* from '@mikro-orm.*$/gim,
+    replace: "            }).join(', '))} } from 'forge-sql-orm';`);",
+    description: "Replacing entity generator imports with 'forge-sql-orm'"
+  },
+  {
+    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 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}`);
+      }
+    }
+    if (deleteFile) {
+      const deleteFilePath = path.resolve(__dirname, "../", deleteFile);
+      if (fs.existsSync(deleteFilePath)) {
+        fs.unlinkSync(deleteFilePath);
+        console.log(`[DELETED] ${description}`);
+      }
+    }
+    if (deleteFolder) {
+      const deleteFolderPath = path.resolve(__dirname, "../", deleteFolder);
+      if (fs.existsSync(deleteFolderPath)) {
+        fs.rmSync(deleteFolderPath, { recursive: true, force: true });
+        console.log(`[DELETED] ${description}`);
+      }
+    }
+  });
+  console.log("🎉 MikroORM & Knex patching completed!");
+}
+dotenv.config();
+const askMissingParams = async (config, defaultOutput, customAskMissingParams) => {
+  const questions = [];
+  if (!config.host)
+    questions.push({
+      type: "input",
+      name: "host",
+      message: "Enter database host:",
+      default: "localhost"
+    });
+  if (!config.port)
+    questions.push({
+      type: "input",
+      name: "port",
+      message: "Enter database port:",
+      default: "3306",
+      validate: (input) => !isNaN(parseInt(input, 10))
+    });
+  if (!config.user)
+    questions.push({
+      type: "input",
+      name: "user",
+      message: "Enter database user:",
+      default: "root"
+    });
+  if (!config.password)
+    questions.push({
+      type: "password",
+      name: "password",
+      message: "Enter database password:",
+      mask: "*"
+    });
+  if (!config.dbName)
+    questions.push({
+      type: "input",
+      name: "dbName",
+      message: "Enter database name:"
+    });
+  if (!config.output)
+    questions.push({
+      type: "input",
+      name: "output",
+      message: "Enter output path:",
+      default: defaultOutput
+    });
+  if (customAskMissingParams) {
+    customAskMissingParams(config, questions);
+  }
+  if (questions.length > 0) {
+    const answers = await inquirer.prompt(questions);
+    return { ...config, ...answers, port: parseInt(answers.port, 10) };
+  }
+  return config;
+};
+const getConfig = async (cmd, defaultOutput, customConfig, customAskMissingParams) => {
+  let config = {
+    host: cmd.host || process.env.FORGE_SQL_ORM_HOST,
+    port: cmd.port ? parseInt(cmd.port, 10) : process.env.FORGE_SQL_ORM_PORT ? parseInt(process.env.FORGE_SQL_ORM_PORT, 10) : void 0,
+    user: cmd.user || process.env.FORGE_SQL_ORM_USER,
+    password: cmd.password || process.env.FORGE_SQL_ORM_PASSWORD,
+    dbName: cmd.dbName || process.env.FORGE_SQL_ORM_DBNAME,
+    output: cmd.output || process.env.FORGE_SQL_ORM_OUTPUT
+  };
+  if (customConfig) {
+    config = { ...config, ...customConfig() };
+  }
+  return await askMissingParams(config, defaultOutput, customAskMissingParams);
+};
+const program = new Command();
+program.version("1.0.0");
+program.command("generate:model").description("Generate MikroORM models from the 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 entities").action(async (cmd) => {
+  const config = await getConfig(cmd, "./database/entities");
+  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").action(async (cmd) => {
+  const config = await getConfig(
+    cmd,
+    "./database/migration",
+    () => ({
+      entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIES_PATH
+    }),
+    (cfg, questions) => {
+      if (!cfg.entitiesPath)
+        questions.push({
+          type: "input",
+          name: "entitiesPath",
+          message: "Enter the path to entities:",
+          default: "./database/entities"
+        });
+    }
+  );
+  await createMigration(config);
+});
+program.command("migrations:update").description("Generate a migration to update the database schema.").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").action(async (cmd) => {
+  const config = await getConfig(
+    cmd,
+    "./database/migration",
+    () => ({
+      entitiesPath: cmd.entitiesPath || process.env.FORGE_SQL_ORM_ENTITIES_PATH
+    }),
+    (cfg, questions) => {
+      if (!cfg.entitiesPath)
+        questions.push({
+          type: "input",
+          name: "entitiesPath",
+          message: "Enter the path to entities:",
+          default: "./database/entities"
+        });
+    }
+  );
+  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.parse(process.argv);
+//# sourceMappingURL=cli.mjs.map