forge-sql-orm-cli 1.0.0

package/src/actions/migrations-create.ts

@@ -0,0 +1,213 @@
+import "reflect-metadata";
+import fs from "fs";
+import path from "path";
+
+import { execSync } from "child_process";
+
+/**
+ * Options for migration creation
+ */
+export interface CreateMigrationOptions {
+  output: string;
+  entitiesPath: string;
+  force?: boolean;
+}
+
+/**
+ * Loads the current migration version from `migrationCount.ts`.
+ * @param migrationPath - Path to the migration folder.
+ * @returns The latest migration version.
+ */
+export const loadMigrationVersion = async (migrationPath: string): Promise<number> => {
+  try {
+    const migrationCountFilePath = path.resolve(path.join(migrationPath, "migrationCount.ts"));
+    if (!fs.existsSync(migrationCountFilePath)) {
+      console.log(`✅ Current migration version: 0`);
+      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);
+  }
+};
+
+/**
+ * Cleans SQL statements by removing unnecessary database options.
+ * @param sql - The raw SQL statement.
+ * @returns The cleaned SQL statement.
+ */
+export function cleanSQLStatement(sql: string): string {
+  // Add IF NOT EXISTS to CREATE TABLE statements
+  sql = sql.replace(/create\s+table\s+(\w+)/gi, "create table if not exists $1");
+
+  // Add IF NOT EXISTS to CREATE INDEX statements
+  sql = sql.replace(/create\s+index\s+(\w+)/gi, "create index if not exists $1");
+
+  // Add IF NOT EXISTS to ADD INDEX statements
+  sql = sql.replace(
+    /alter\s+table\s+(\w+)\s+add\s+index\s+(\w+)/gi,
+    "alter table $1 add index if not exists $2",
+  );
+
+  // Add IF NOT EXISTS to ADD CONSTRAINT statements
+  sql = sql.replace(
+    /alter\s+table\s+(\w+)\s+add\s+constraint\s+(\w+)/gi,
+    "alter table $1 add constraint if not exists $2",
+  );
+
+  // Remove unnecessary database options
+  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.
+ */
+export 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).replace(/\s+/g, " ")}")`,
+    )
+    .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.
+ */
+export 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.
+ */
+export const extractCreateStatements = (schema: string): string[] => {
+  // Split by statement-breakpoint and semicolon
+  const statements = schema
+    .split(/--> statement-breakpoint|;/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+
+  return statements.filter(
+    (stmt) =>
+      stmt.toLowerCase().startsWith("create table") ||
+      stmt.toLowerCase().startsWith("alter table") ||
+      stmt.toLowerCase().includes("add index") ||
+      stmt.toLowerCase().includes("create index") ||
+      stmt.toLowerCase().includes("add unique index") ||
+      stmt.toLowerCase().includes("add constraint"),
+  );
+};
+
+/**
+ * Creates a full database migration.
+ * @param options - Database connection settings and output paths.
+ */
+export const createMigration = async (options: CreateMigrationOptions) => {
+  try {
+    let version = await loadMigrationVersion(options.output);
+
+    if (version > 0) {
+      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);
+      }
+    }
+
+    // Start from version 1 if no previous migrations exist
+    version = 1;
+    // Generate SQL using drizzle-kit
+    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");
+
+    // Extract and clean statements
+    const createStatements = extractCreateStatements(sql);
+
+    // Generate and save migration files
+    const migrationFile = generateMigrationFile(createStatements, 1);
+    saveMigrationFiles(migrationFile, 1, options.output);
+
+    fs.rmSync(initSqlFile, { force: true });
+    console.log(`✅ Removed SQL file: ${initSqlFile}`);
+    // Remove meta directory after processing
+    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) {
+    console.error(`❌ Error during migration creation:`, error);
+    process.exit(1);
+  }
+};

package/src/actions/migrations-drops.ts

@@ -0,0 +1,139 @@
+import "reflect-metadata";
+import fs from "fs";
+import path from "path";
+import { MySqlTable, TableConfig } from "drizzle-orm/mysql-core";
+import { getTableMetadata, generateDropTableStatements } from "forge-sql-orm";
+
+/**
+ * Generates a migration ID using current date
+ * @returns Migration ID string with current date
+ */
+function generateMigrationUUID(version: number): string {
+  const now = new Date();
+  const timestamp = now.getTime();
+  return `MIGRATION_V${version}_${timestamp}`;
+}
+
+/**
+ * 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 uniqId = generateMigrationUUID(version);
+  // Clean each SQL statement and generate migration lines with .enqueue()
+  const migrationLines = createStatements
+    .map(
+      (stmt, index) => `        .enqueue("${uniqId}_${index}", \"${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}`);
+}
+
+/**
+ * Creates a full database migration.
+ * @param options - Database connection settings and output paths.
+ */
+export const dropMigration = async (options: any) => {
+  try {
+    // Start from version 1 if no previous migrations exist
+    const version = 1;
+
+    // Import Drizzle schema using absolute path
+    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.`);
+    }
+
+    // Get all exports that are tables
+    const tables = Object.values(schemaModule) as MySqlTable<TableConfig>[];
+
+    if (tables.length === 0) {
+      throw new Error(`No valid tables found in schema at: ${schemaPath}`);
+    }
+
+    // Get table names for logging
+    const tableNames = tables
+      .map((table) => {
+        const metadata = getTableMetadata(table);
+        return metadata.tableName;
+      })
+      .filter(Boolean);
+
+    console.log("Found tables:", tableNames);
+
+    // Generate drop statements
+    const dropStatements = generateDropTableStatements(tables);
+
+    // Generate and save migration files
+    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);
+  }
+};