forge-sql-orm 1.0.15 → 1.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-sql-orm",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Mikro-ORM integration for Forge-SQL in Atlassian Forge applications.",
   "main": "dist/ForgeSQLORM.js",
   "module": "dist/ForgeSQLORM.mjs",
@@ -74,7 +74,7 @@
   },
   "files": [
     "dist",
-    "dist-cli",
+    "scripts",
     "src",
     "node_modules",
     "tsconfig.json",
@@ -90,6 +90,6 @@
     "@forge/sql": "^2.4.0"
   },
   "bin": {
-    "forge-sql-orm": "dist-cli/forgeSqlCLI.js"
+    "forge-sql-orm": "scripts/forgeSqlCLI.js"
   }
 }

package/scripts/actions/PatchPostinstall.ts

@@ -0,0 +1,201 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Automates patches for MikroORM and Knex to fix Webpack issues.
+ * - Removes problematic `require()` calls.
+ * - Deletes unnecessary files and folders.
+ * - Fixes dynamic imports (`import(id)`) in MikroORM.
+ */
+
+interface Patch {
+    file?: string; // File to modify (optional)
+    search?: RegExp; // Regex pattern to find problematic code
+    replace?: string; // Replacement string for problematic code
+    deleteLines?: RegExp[]; // List of regex patterns to remove specific lines
+    description: string; // Description of the patch
+    deleteFile?: string; // Path of the file to delete (optional)
+    deleteFolder?: string; // Path of the folder to delete (optional)
+}
+
+const PATCHES: Patch[] = [
+    // 🗑️ 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"
+    },
+
+];
+
+
+
+
+
+/**
+ * Runs the MikroORM & Knex patching logic.
+ */
+export 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;
+
+                // 🔄 Replace text
+                if (search && replace) {
+                    if (typeof search === "string" ? content.includes(search) : search.test(content)) {
+                        content = content.replace(search, replace);
+                        console.log(`[PATCHED] ${description}`);
+                    }
+                }
+
+                // 🗑️ Remove matching lines
+                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}`);
+                    }
+                }
+
+                // 💾 Save changes only if file was modified
+                if (content !== originalContent) {
+                    fs.writeFileSync(filePath, content, "utf8");
+                }
+
+                // 🚮 Remove empty files
+                if (content.trim() === "") {
+                    fs.unlinkSync(filePath);
+                    console.log(`[REMOVED] ${filePath} (file is now empty)`);
+                }
+            } else {
+                console.warn(`[WARNING] File not found: ${file}`);
+            }
+        }
+
+        // 🚮 Delete specific files
+        if (deleteFile) {
+            const deleteFilePath = path.resolve(__dirname, "../", deleteFile);
+            if (fs.existsSync(deleteFilePath)) {
+                fs.unlinkSync(deleteFilePath);
+                console.log(`[DELETED] ${description}`);
+            }
+        }
+
+        // 🚮 Delete entire folders
+        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!");
+}

package/scripts/actions/generate-models.ts

@@ -0,0 +1,65 @@
+import "reflect-metadata";
+import path from "path";
+import fs from "fs";
+import {defineConfig, MikroORM, MongoNamingStrategy} from "@mikro-orm/mysql";
+import {EntityGenerator} from "@mikro-orm/entity-generator";
+
+const regenerateIndexFile = (outputPath: string) => {
+  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")}\n\nexport default [${entityFiles.map((file) => path.basename(file, ".ts")).join(", ")}];\n`;
+
+  fs.writeFileSync(indexPath, indexContent, "utf8");
+  console.log(`✅ Updated index.ts with ${entityFiles.length} entities.`);
+};
+
+export const generateModels = async (options: any) => {
+  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,
+    }) as Parameters<typeof MikroORM.initSync>[0];
+
+    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);
+  }
+};

package/scripts/actions/migrations-create.ts

@@ -0,0 +1,193 @@
+import "reflect-metadata";
+import fs from "fs";
+import path from "path";
+import {MikroORM} from "@mikro-orm/mysql";
+import { execSync } from 'child_process';
+import { rmSync } from 'fs';
+
+/**
+ * Cleans SQL statements by removing unnecessary database options.
+ * @param sql - The raw SQL statement.
+ * @returns The cleaned SQL statement.
+ */
+function cleanSQLStatement(sql: string): string {
+  return sql.replace(/\s+default\s+character\s+set\s+utf8mb4\s+engine\s*=\s*InnoDB;?/gi, "").trim();
+}
+
+/**
+ * Generates a migration file using the provided SQL statements.
+ * @param createStatements - Array of SQL statements.
+ * @param version - Migration version number.
+ * @returns TypeScript migration file content.
+ */
+function generateMigrationFile(createStatements: string[], version: number): string {
+  const versionPrefix = `v${version}_MIGRATION`;
+
+  // Clean each SQL statement and generate migration lines with .enqueue()
+  const migrationLines = createStatements
+    .map(
+      (stmt, index) =>
+        `        .enqueue("${versionPrefix}${index}", \"${cleanSQLStatement(stmt)}\")`, // eslint-disable-line no-useless-escape
+    )
+    .join("\n");
+
+  // Migration template
+  return `import { MigrationRunner } from "@forge/sql/out/migration";
+
+export default (migrationRunner: MigrationRunner): MigrationRunner => {
+    return migrationRunner
+${migrationLines};
+};`;
+}
+
+/**
+ * Saves the generated migration file along with `migrationCount.ts` and `index.ts`.
+ * @param migrationCode - The migration code to be written to the file.
+ * @param version - Migration version number.
+ * @param outputDir - Directory where the migration files will be saved.
+ */
+function saveMigrationFiles(migrationCode: string, version: number, outputDir: string) {
+  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`);
+
+  // Write the migration file
+  fs.writeFileSync(migrationFilePath, migrationCode);
+
+  // Write the migration count file
+  fs.writeFileSync(migrationCountPath, `export const MIGRATION_VERSION = ${version};`);
+
+  // Generate the migration index file
+  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}`);
+}
+
+/**
+ * Extracts only the relevant SQL statements for migration.
+ * @param schema - The full database schema as SQL.
+ * @returns Filtered list of SQL statements.
+ */
+const extractCreateStatements = (schema: string): string[] => {
+  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"),
+  );
+};
+
+/**
+ * Dynamically loads `entities` from `index.ts` in the specified directory.
+ * @param entitiesPath - Path to the directory containing `index.ts`.
+ * @returns Array of entity classes.
+ */
+const loadEntities = async (entitiesPath: string) => {
+  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);
+  }
+};
+
+/**
+ * Loads the current migration version from `migrationCount.ts`.
+ * @param migrationPath - Path to the migration folder.
+ * @returns The latest migration version.
+ */
+const loadMigrationVersion = async (migrationPath: string): Promise<number> => {
+  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 as number;
+  } catch (error) {
+    console.error(`❌ Error loading migrationCount:`, error);
+    process.exit(1);
+  }
+};
+
+/**
+ * Creates a full database migration.
+ * @param options - Database connection settings and output paths.
+ */
+export const createMigration = async (options: any) => {
+  try {
+    let version = await loadMigrationVersion(options.output);
+
+    if (version > 0) {
+      console.error(`❌ Error: Migration has already been created.`);
+      process.exit(1);
+    }
+
+    // Start from version 1 if no previous migrations exist
+    version = 1;
+
+    // Load entities dynamically from index.ts
+    const entities = await loadEntities(options.entitiesPath);
+
+    // Initialize MikroORM
+    const orm = MikroORM.initSync({
+      host: options.host,
+      port: options.port,
+      user: options.user,
+      password: options.password,
+      dbName: options.dbName,
+      entities: entities,
+    });
+
+    // Generate SQL schema
+    const createSchemaSQL = await orm.schema.getCreateSchemaSQL({ wrap: true });
+    const statements = extractCreateStatements(createSchemaSQL);
+
+    // Generate and save migration files
+    const migrationFile = generateMigrationFile(statements, 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);
+  }
+};

package/scripts/actions/migrations-update.ts

@@ -0,0 +1,200 @@
+import "reflect-metadata";
+import fs from "fs";
+import path from "path";
+import {MikroORM} from "@mikro-orm/mysql";
+
+/**
+ * Cleans SQL statements by removing unnecessary database options.
+ * @param sql - The raw SQL statement.
+ * @returns The cleaned SQL statement.
+ */
+function cleanSQLStatement(sql: string): string {
+  return sql.replace(/\s+default\s+character\s+set\s+utf8mb4\s+engine\s*=\s*InnoDB;?/gi, "").trim();
+}
+
+/**
+ * Generates a migration file using the provided SQL statements.
+ * @param createStatements - Array of SQL statements.
+ * @param version - Migration version number.
+ * @returns TypeScript migration file content.
+ */
+function generateMigrationFile(createStatements: string[], version: number): string {
+  const versionPrefix = `v${version}_MIGRATION`;
+
+  // Clean each SQL statement and generate migration lines with .enqueue()
+  const migrationLines = createStatements
+    .map(
+      (stmt, index) =>
+        `        .enqueue("${versionPrefix}${index}", \"${cleanSQLStatement(stmt)}\")`, // eslint-disable-line no-useless-escape
+    )
+    .join("\n");
+
+  // Migration template
+  return `import { MigrationRunner } from "@forge/sql/out/migration";
+
+export default (migrationRunner: MigrationRunner): MigrationRunner => {
+    return migrationRunner
+${migrationLines};
+};`;
+}
+
+/**
+ * Saves the generated migration file along with `migrationCount.ts` and `index.ts`.
+ * @param migrationCode - The migration code to be written to the file.
+ * @param version - Migration version number.
+ * @param outputDir - Directory where the migration files will be saved.
+ */
+function saveMigrationFiles(migrationCode: string, version: number, outputDir: string) {
+  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`);
+
+  // Write the migration file
+  fs.writeFileSync(migrationFilePath, migrationCode);
+
+  // Write the migration count file
+  fs.writeFileSync(migrationCountPath, `export const MIGRATION_VERSION = ${version};`);
+
+  // Generate the migration index file
+  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}`);
+}
+
+/**
+ * Extracts only the relevant SQL statements for migration.
+ * @param schema - The full database schema as SQL.
+ * @returns Filtered list of SQL statements.
+ */
+const extractCreateStatements = (schema: string): string[] => {
+  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")),
+  );
+};
+
+/**
+ * Dynamically loads `entities` from `index.ts` in the specified directory.
+ * @param entitiesPath - Path to the directory containing `index.ts`.
+ * @returns Array of entity classes.
+ */
+const loadEntities = async (entitiesPath: string) => {
+  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);
+  }
+};
+
+/**
+ * Loads the current migration version from `migrationCount.ts`.
+ * @param migrationPath - Path to the migration folder.
+ * @returns The latest migration version.
+ */
+const loadMigrationVersion = async (migrationPath: string): Promise<number> => {
+  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 as number;
+  } catch (error) {
+    console.error(`❌ Error loading migrationCount:`, error);
+    process.exit(1);
+  }
+};
+
+/**
+ * Updates an existing database migration by generating schema modifications.
+ * @param options - Database connection settings and output paths.
+ */
+export const updateMigration = async (options: any) => {
+  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;
+
+    // Load entities dynamically from index.ts
+    const entities = await loadEntities(options.entitiesPath);
+
+    // Initialize MikroORM
+    const orm = MikroORM.initSync({
+      host: options.host,
+      port: options.port,
+      user: options.user,
+      password: options.password,
+      dbName: options.dbName,
+      entities,
+      debug: true,
+    });
+
+    // Generate SQL schema updates
+    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);
+  }
+};