fragment-ts 1.0.43 → 1.0.45

package/src/cli/commands/migrate.command.ts

@@ -3,22 +3,19 @@ import * as fs from "fs-extra";
 import * as path from "path";
 import chalk from "chalk";
 import ora from "ora";
-import { execSync, spawn } from "child_process";
-import { TypeORMModule } from "../../typeorm/typeorm-module";
 import { DataSource } from "typeorm";
+import { TypeORMModule } from "../../typeorm/typeorm-module";
 import { ConfigUtils } from "../../shared/config.utils";
-import { EnvUtils } from "../../shared/env.utils";
+import { TsConfigUtils } from "../../shared/tsconfig.utils";
+import { globSync } from "glob";
 
 export class MigrateCommand {
   private static tsNodeAvailable: boolean | null = null;
-  private static tsConfigExists: boolean | null = null;
 
   static register(program: Command): void {
     program
       .command("migrate")
-      .description(
-        "Run all pending migrations (auto-detect TypeScript/JavaScript)",
-      )
+      .description("Run all pending migrations")
       .action(async () => {
         await this.runMigrations();
       });
@@ -95,257 +92,208 @@ export class MigrateCommand {
       });
   }
 
-  // -----------------------------------------
-  // DETECTION METHODS
-  // -----------------------------------------
-
   /**
-   * Check if ts-node is available in the user's project
+   * Detect if we should use TypeScript or JavaScript
    */
-  private static isTsNodeAvailable(): boolean {
-    if (this.tsNodeAvailable !== null) return this.tsNodeAvailable;
-
-    try {
-      // Check if ts-node is installed in the user's project
-      require.resolve("ts-node");
-      this.tsNodeAvailable = true;
-    } catch {
-      try {
-        // Check if ts-node is installed globally or in parent modules
-        require("ts-node");
-        this.tsNodeAvailable = true;
-      } catch {
-        this.tsNodeAvailable = false;
-      }
-    }
-
-    return this.tsNodeAvailable;
+  private static setupEnvironment(): boolean {
+    return this.shouldUseTypeScript();
   }
 
   /**
-   * Check if tsconfig.json exists
+   * Detect if we should use TypeScript or JavaScript
+   * - Check if tsconfig.json exists AND has decorator support
+   * - Check if TypeScript files exist in include patterns
+   * - Check if ts-node is available
    */
-  private static hasTsConfig(): boolean {
-    if (this.tsConfigExists !== null) return this.tsConfigExists;
-
-    this.tsConfigExists = fs.existsSync(
-      path.join(process.cwd(), "tsconfig.json"),
-    );
-    return this.tsConfigExists;
-  }
-
-  /**
-   * Detect if TypeScript files exist in the project
-   */
-  private static detectProjectType(): "typescript" | "javascript" | "mixed" {
-    const srcDir = path.join(process.cwd(), "src");
-    const hasSrcDir = fs.existsSync(srcDir);
+  private static shouldUseTypeScript(): boolean {
+    if (!TsConfigUtils.exists()) {
+      return false;
+    }
 
-    const hasTsFiles =
-      hasSrcDir && fs.readdirSync(srcDir).some((file) => file.endsWith(".ts"));
+    if (!TsConfigUtils.hasDecoratorSupport()) {
+      return false;
+    }
 
-    const distDir = path.join(process.cwd(), "dist");
-    const hasDistDir = fs.existsSync(distDir);
+    if (!this.isTsNodeAvailable()) {
+      return false;
+    }
 
-    const hasJsFiles =
-      hasDistDir &&
-      fs.readdirSync(distDir).some((file) => file.endsWith(".js"));
+    const includePatterns = TsConfigUtils.getIncludePatterns();
+    const cwd = process.cwd();
 
-    if (hasTsFiles && !hasJsFiles) return "typescript";
-    if (!hasTsFiles && hasJsFiles) return "javascript";
-    if (hasTsFiles && hasJsFiles) return "mixed";
+    for (const pattern of includePatterns) {
+      try {
+        const files = globSync(pattern, { cwd });
+        if (
+          files.some(
+            (file: string) => file.endsWith(".ts") && !file.endsWith(".d.ts"),
+          )
+        ) {
+          return true;
+        }
+      } catch {
+        // Ignore glob errors
+      }
+    }
 
-    // Default to checking for tsconfig
-    return this.hasTsConfig() ? "typescript" : "javascript";
+    return false;
   }
 
-  /**
-   * Determine whether to use TypeScript or JavaScript for migrations
-   */
-  private static shouldUseTypeScript(): boolean {
-    const projectType = this.detectProjectType();
-    const tsNodeAvailable = this.isTsNodeAvailable();
-
-    // Use the same logic as EnvUtils for consistency
-    const isDevMode = EnvUtils.isDevelopmentMode();
-
-    // In development mode with ts-node available, use TypeScript
-    if (isDevMode && tsNodeAvailable) {
-      return true;
+  private static isTsNodeAvailable(): boolean {
+    if (this.tsNodeAvailable !== null) {
+      return this.tsNodeAvailable;
     }
 
-    // In production mode, always use JavaScript
-    if (!isDevMode) {
-      return false;
+    try {
+      require.resolve("ts-node");
+      this.tsNodeAvailable = true;
+    } catch {
+      this.tsNodeAvailable = false;
     }
 
-    // Fallback to project type detection
-    return projectType === "typescript" && tsNodeAvailable;
+    return this.tsNodeAvailable;
   }
 
-  /**
-   * Register ts-node if needed
-   */
   private static registerTsNodeIfNeeded(useTypeScript: boolean): void {
-    if (!useTypeScript) return;
-
-    try {
-      // Register ts-node for TypeScript support
-      require("ts-node/register");
-
-      // If tsconfig-paths is available, register it too
-      try {
-        require("tsconfig-paths/register");
-      } catch {
-        // tsconfig-paths not available, that's okay
-      }
-
-      console.log(chalk.gray("📝 Using ts-node for TypeScript migrations"));
-    } catch (error) {
-      console.error(
-        chalk.yellow(
-          "⚠️  Failed to register ts-node. Falling back to JavaScript.",
-        ),
-      );
+    if (useTypeScript && this.isTsNodeAvailable()) {
+      require("ts-node").register({
+        transpileOnly: true,
+        compilerOptions: {
+          module: "commonjs",
+        },
+      });
     }
   }
 
   /**
-   * Get entity paths from fragment.json config
+   * Get entity and migration paths based on current mode
+   * Uses fragment.json config when available, otherwise infers from tsconfig
    */
-  private static getEntityPathsFromConfig(): string[] {
+  private static getPaths(useTypeScript: boolean): {
+    entities: string[];
+    migrations: string[];
+    seeds: string;
+  } {
     const dbConfig = ConfigUtils.getDatabaseConfig();
-    return dbConfig.entities || [];
-  }
 
-  /**
-   * Get migration paths from fragment.json config
-   */
-  private static getMigrationPathsFromConfig(): string[] {
-    const dbConfig = ConfigUtils.getDatabaseConfig();
-    return dbConfig.migrations || [];
-  }
+    const resolveExtension = (pattern: string): string => {
+      return useTypeScript
+        ? pattern.replace(/\.js$/, ".ts")
+        : pattern.replace(/\.ts$/, ".js");
+    };
+
+    if (dbConfig.entities || dbConfig.migrations) {
+      const entities = dbConfig.entities
+        ? dbConfig.entities.map(resolveExtension)
+        : [useTypeScript ? "src/**/*.entity.ts" : "dist/**/*.entity.js"];
+
+      const migrations = dbConfig.migrations
+        ? dbConfig.migrations.map(resolveExtension)
+        : [
+            useTypeScript
+              ? "src/migrations/**/*.ts"
+              : "dist/migrations/**/*.js",
+          ];
+
+      const migrationDir = this.extractMigrationDirectory(
+        migrations[0],
+        useTypeScript,
+      );
+      const seedsDir = path.join(migrationDir, "..", "seeds");
 
-  /**
-   * Get resolved entity paths based on current mode
-   */
-  private static getResolvedEntityPaths(useTypeScript: boolean): string[] {
-    const configPaths = this.getEntityPathsFromConfig();
-
-    if (configPaths.length > 0) {
-      // Use configured paths but resolve based on current mode
-      return configPaths.map((pattern) => {
-        if (useTypeScript) {
-          return pattern.replace(/\.js$/, ".ts");
-        } else {
-          return pattern.replace(/\.ts$/, ".js");
-        }
-      });
+      return { entities, migrations, seeds: seedsDir };
     }
 
-    // Fallback to default paths
-    return useTypeScript ? ["src/**/*.entity.ts"] : ["dist/**/*.entity.js"];
+    const rootDir = TsConfigUtils.getRootDir();
+    const outDir = TsConfigUtils.getOutDir();
+
+    const entities = [
+      useTypeScript ? `${rootDir}/**/*.entity.ts` : `${outDir}/**/*.entity.js`,
+    ];
+    const migrations = [
+      useTypeScript
+        ? `${rootDir}/migrations/**/*.ts`
+        : `${outDir}/migrations/**/*.js`,
+    ];
+    const seeds = useTypeScript ? `${rootDir}/seeds` : `${outDir}/seeds`;
+
+    return { entities, migrations, seeds };
   }
 
   /**
-   * Get resolved migration paths based on current mode
+   * Extract the actual directory path from a glob pattern for file creation
    */
-  private static getResolvedMigrationPaths(useTypeScript: boolean): string[] {
-    const configPaths = this.getMigrationPathsFromConfig();
-
-    if (configPaths.length > 0) {
-      // Use configured paths but resolve based on current mode
-      return configPaths.map((pattern) => {
-        if (useTypeScript) {
-          return pattern.replace(/\.js$/, ".ts");
-        } else {
-          return pattern.replace(/\.ts$/, ".js");
-        }
-      });
+  private static extractMigrationDirectory(
+    pattern: string,
+    useTypeScript: boolean,
+  ): string {
+    if (pattern.includes("/**/*")) {
+      return pattern.split("/**/*")[0];
     }
 
-    // Fallback to default paths
-    return useTypeScript
-      ? ["src/migrations/**/*.ts"]
-      : ["dist/migrations/**/*.js"];
-  }
+    if (pattern.includes("/*.")) {
+      return pattern.split("/*")[0];
+    }
+
+    if (pattern.endsWith(".ts") || pattern.endsWith(".js")) {
+      return path.dirname(pattern);
+    }
 
-  // -----------------------------------------
-  // MIGRATION GENERATE
-  // -----------------------------------------
+    return useTypeScript ? "src/migrations" : "dist/migrations";
+  }
 
   private static async generateMigration(
     nameOrPath: string | undefined,
     options: { name?: string },
   ): Promise<void> {
-    const useTypeScript = this.shouldUseTypeScript();
-    const spinner = ora("Generating migration...").start();
+    const useTypeScript = this.setupEnvironment();
+    const spinner = ora(
+      `Generating ${useTypeScript ? "TypeScript" : "JavaScript"} migration...`,
+    ).start();
     let dataSource: DataSource | null = null;
 
     try {
-      // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with paths from fragment.json config
-      const configOverride = {
-        entities: this.getResolvedEntityPaths(useTypeScript),
-        migrations: this.getResolvedMigrationPaths(useTypeScript),
-      };
+      const { entities, migrations } = this.getPaths(useTypeScript);
+      const configOverride = { entities, migrations };
 
       dataSource = await TypeORMModule.initialize(configOverride);
       if (!dataSource?.isInitialized) {
         throw new Error("Failed to initialize DataSource");
       }
 
-      // Verify entities are loaded
       this.verifyEntities(dataSource);
 
-      // Setup migrations directory from config
-      const migrationPaths = this.getResolvedMigrationPaths(useTypeScript);
-      const migrationsDir = path.dirname(
-        migrationPaths[0].replace("/**/*", ""),
+      const migrationsPattern = migrations[0];
+      const migrationsDir = this.extractMigrationDirectory(
+        migrationsPattern,
+        useTypeScript,
       );
       await fs.ensureDir(migrationsDir);
 
       const existingMigrations = fs.existsSync(migrationsDir)
         ? fs
             .readdirSync(migrationsDir)
-            .filter((f) => f.endsWith(useTypeScript ? ".ts" : ".js"))
+            .filter(
+              (f: string) =>
+                f.endsWith(useTypeScript ? ".ts" : ".js") &&
+                !f.endsWith(".d.ts"),
+            )
         : [];
-
       const isFirstMigration = existingMigrations.length === 0;
 
-      // Generate schema SQL by comparing entities with database
       spinner.text = "Analyzing schema changes...";
       const sqlInMemory = await dataSource.driver.createSchemaBuilder().log();
-
       const upQueries = sqlInMemory.upQueries || [];
       const downQueries = sqlInMemory.downQueries || [];
       const hasChanges = upQueries.length > 0;
 
-      // Handle no changes scenario
       if (!hasChanges && !isFirstMigration) {
         spinner.info("No schema changes detected. Migration not generated.");
         return;
       }
 
-      if (!hasChanges && isFirstMigration) {
-        const helpMessage = useTypeScript
-          ? "  - Your entities are in the correct location\n" +
-            "  - Entity paths in fragment.json are correct\n" +
-            "  - Entities are decorated with @Entity()"
-          : "  - Your entities are compiled (run 'npm run build')\n" +
-            "  - Entity paths in fragment.json point to dist/**/*.entity.js\n" +
-            "  - Entities are decorated with @Entity()";
-
-        spinner.warn(
-          "No schema changes detected on first migration. Check that:\n" +
-            helpMessage,
-        );
-        return;
-      }
-
-      // Determine migration name
       const migrationName =
         options.name ||
         (nameOrPath ? path.basename(nameOrPath).replace(/\.ts$/, "") : null) ||
@@ -353,18 +301,10 @@ export class MigrateCommand {
 
       const timestamp = Date.now();
       const className = `${migrationName}${timestamp}`;
-
-      // Build queries
-      spinner.text = "Building migration file...";
-      const upStatements = upQueries.map((query) => {
-        return this.buildQueryStatement(query);
-      });
-
-      const downStatements = downQueries.map((query) => {
-        return this.buildQueryStatement(query);
-      });
-
-      // Generate migration file content
+      const upStatements = upQueries.map((q) => this.buildQueryStatement(q));
+      const downStatements = downQueries.map((q) =>
+        this.buildQueryStatement(q),
+      );
       const migrationContent = this.buildMigrationTemplate(
         className,
         upStatements,
@@ -372,193 +312,51 @@ export class MigrateCommand {
         isFirstMigration,
       );
 
-      // Write migration file using config directory
       const fileExt = useTypeScript ? ".ts" : ".js";
       const fileName = `${timestamp}-${migrationName}${fileExt}`;
       const filePath = path.join(migrationsDir, fileName);
-
       await fs.writeFile(filePath, migrationContent, "utf-8");
 
-      const fileType = useTypeScript ? "TypeScript" : "JavaScript";
       spinner.succeed(
-        `${fileType} migration generated: ${chalk.cyan(fileName)}\n` +
-          `  ${chalk.gray("Location:")} ${filePath}\n` +
-          `  ${chalk.gray("Queries:")} ${upQueries.length} up, ${downQueries.length} down\n` +
-          `  ${chalk.gray("Mode:")} ${useTypeScript ? "TypeScript (ts-node)" : "JavaScript"}`,
+        `${useTypeScript ? "TypeScript" : "JavaScript"} migration generated: ${chalk.cyan(fileName)}`,
       );
     } catch (error) {
       spinner.fail("Migration generation failed");
-
-      if (error instanceof Error) {
-        console.error(chalk.red("\n❌ Error: " + error.message));
-
-        if (error.message.includes("Cannot find module") && useTypeScript) {
-          console.error(
-            chalk.yellow(
-              "\n💡 Tip: Try one of these solutions:\n" +
-                "  1. Install ts-node: npm install -D ts-node\n" +
-                "  2. Compile your project first: npm run build\n" +
-                "  3. Ensure your entities are in src/**/*.entity.ts",
-            ),
-          );
-        }
-
-        if (error.stack) {
-          console.error(chalk.gray("\nStack trace:"));
-          console.error(chalk.gray(error.stack));
-        }
-      } else {
-        console.error(chalk.red(String(error)));
-      }
-
+      console.error(
+        chalk.red(error instanceof Error ? error.message : String(error)),
+      );
       process.exit(1);
     } finally {
       if (dataSource?.isInitialized) {
         try {
           await dataSource.destroy();
-        } catch (err) {
-          // Ignore cleanup errors
-        }
+        } catch {}
       }
     }
   }
 
-  /**
-   * Verify entities are loaded and provide helpful debugging
-   */
-  private static verifyEntities(dataSource: DataSource): void {
-    const entities = dataSource.entityMetadatas;
-
-    if (entities.length === 0) {
-      throw new Error(
-        "No entities found! Make sure:\n" +
-          "  1. Your entities are decorated with @Entity()\n" +
-          "  2. Entity paths in fragment.json are correct\n" +
-          "  3. For JavaScript mode: run 'npm run build' to compile\n" +
-          "  4. For TypeScript mode: entities should be in src/**/*.entity.ts",
-      );
-    }
-
-    console.log(chalk.gray(`\n📦 Loaded ${entities.length} entity/entities:`));
-    entities.forEach((entity) => {
-      console.log(chalk.gray(`   - ${entity.name} (${entity.tableName})`));
-    });
-    console.log();
-  }
-
-  /**
-   * Build a single query statement with proper escaping
-   */
-  private static buildQueryStatement(query: {
-    query: string;
-    parameters?: any[];
-  }): string {
-    // Escape backslashes, backticks, and dollar signs for template literals
-    let sql = query.query
-      .replace(/\\/g, "\\\\") // Escape backslashes first
-      .replace(/`/g, "\\`") // Escape backticks
-      .replace(/\$/g, "\\$") // Escape dollar signs
-      .replace(/\r\n/g, " ") // Remove Windows line breaks
-      .replace(/\n/g, " ") // Remove Unix line breaks
-      .replace(/\s+/g, " ") // Collapse multiple spaces
-      .trim();
-
-    // Handle parameters if present
-    if (query.parameters && query.parameters.length > 0) {
-      const params = JSON.stringify(query.parameters);
-      return `await queryRunner.query(\`${sql}\`, ${params});`;
-    }
-
-    return `await queryRunner.query(\`${sql}\`);`;
-  }
-
-  // -----------------------------------------
-  // MIGRATION EXECUTION METHODS
-  // -----------------------------------------
-
   private static async runMigrations(): Promise<void> {
-    const useTypeScript = this.shouldUseTypeScript();
-    const spinner = ora("Running migrations...").start();
+    const useTypeScript = this.setupEnvironment();
+    const spinner = ora(
+      `Running ${useTypeScript ? "TypeScript" : "JavaScript"} migrations...`,
+    ).start();
     let dataSource: DataSource | null = null;
 
     try {
-      // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
-
-      // Initialize DataSource with paths from fragment.json config
-      const configOverride = {
-        entities: this.getResolvedEntityPaths(useTypeScript),
-        migrations: this.getResolvedMigrationPaths(useTypeScript),
-      };
+      const { entities, migrations } = this.getPaths(useTypeScript);
+      const configOverride = { entities, migrations };
 
       dataSource = await TypeORMModule.initialize(configOverride);
-
-      // Check if migrations exist using config paths
-      const migrationPaths = this.getResolvedMigrationPaths(useTypeScript);
-      const migrationsDir = path.dirname(
-        migrationPaths[0].replace("/**/*", ""),
-      );
-      const fileExt = useTypeScript ? ".ts" : ".js";
-
-      const hasMigrations =
-        fs.existsSync(migrationsDir) &&
-        fs.readdirSync(migrationsDir).filter((f) => f.endsWith(fileExt))
-          .length > 0;
-
-      if (!hasMigrations) {
-        const mode = useTypeScript ? "TypeScript" : "JavaScript";
-        spinner.info(
-          `No ${mode.toLowerCase()} migrations found in ${migrationsDir}.`,
-        );
-
-        if (useTypeScript && this.hasJavaScriptMigrations()) {
-          console.log(
-            chalk.yellow(
-              `\n💡 JavaScript migrations found. Try:\n` +
-                `  1. fragment migrate:run (in JavaScript mode)\n` +
-                `  2. Or compile your TypeScript: npm run build`,
-            ),
-          );
-        } else if (!useTypeScript && this.hasTypeScriptMigrations()) {
-          console.log(
-            chalk.yellow(
-              `\n💡 TypeScript migrations found. Try:\n` +
-                `  1. Install ts-node: npm install -D ts-node\n` +
-                `  2. Then run: fragment migrate:run\n` +
-                `  3. Or compile first: npm run build`,
-            ),
-          );
-        }
-
-        return;
-      }
-
-      const mode = useTypeScript ? "TypeScript" : "JavaScript";
-      spinner.text = `Running ${mode} migrations...`;
-
       await TypeORMModule.runMigrations();
-      spinner.succeed(`${mode} migrations completed successfully`);
+      spinner.succeed(
+        `${useTypeScript ? "TypeScript" : "JavaScript"} migrations completed successfully`,
+      );
     } catch (error) {
       spinner.fail("Migration failed");
-
-      if (error instanceof Error) {
-        if (error.message.includes("Cannot find module") && useTypeScript) {
-          console.error(chalk.red("\n❌ TypeScript module not found."));
-          console.error(
-            chalk.yellow(
-              "\n💡 Try one of these solutions:\n" +
-                "  1. Install ts-node: npm install -D ts-node\n" +
-                "  2. Compile your TypeScript: npm run build\n" +
-                "  3. Check that your migration files are in src/migrations/*.ts",
-            ),
-          );
-        } else {
-          console.error(chalk.red(error.message));
-        }
-      } else {
-        console.error(chalk.red(String(error)));
-      }
-
+      console.error(
+        chalk.red(error instanceof Error ? error.message : String(error)),
+      );
       process.exit(1);
     } finally {
       if (dataSource?.isInitialized) {
@@ -568,20 +366,13 @@ export class MigrateCommand {
   }
 
   private static async createMigration(name: string): Promise<void> {
-    // Always create TypeScript migrations
-    const useTypeScript = true;
+    const useTypeScript = this.setupEnvironment();
     const spinner = ora("Creating TypeScript migration...").start();
-
     try {
+      const { migrations } = this.getPaths(true);
+      const migrationsDir = this.extractMigrationDirectory(migrations[0], true);
       const timestamp = Date.now();
-      const fileExt = useTypeScript ? ".ts" : ".js";
-
-      // Get migration directory from config
-      const migrationPaths = this.getResolvedMigrationPaths(useTypeScript);
-      const migrationsDir = path.dirname(
-        migrationPaths[0].replace("/**/*", ""),
-      );
-      const fileName = `${timestamp}-${name}${fileExt}`;
+      const fileName = `${timestamp}-${name}.ts`;
       const filePath = path.join(migrationsDir, fileName);
 
       const content = `import { MigrationInterface, QueryRunner } from 'typeorm';
@@ -595,16 +386,7 @@ export class ${name}${timestamp} implements MigrationInterface {
 
       await fs.ensureDir(path.dirname(filePath));
       await fs.writeFile(filePath, content);
-
       spinner.succeed(`TypeScript migration created: ${fileName}`);
-      console.log(
-        chalk.gray(
-          `\n💡 Note: Migration created as TypeScript file.\n` +
-            `   To use it, either:\n` +
-            `   1. Install ts-node: npm install -D ts-node\n` +
-            `   2. Or compile to JavaScript: npm run build`,
-        ),
-      );
     } catch (error) {
       spinner.fail("Failed to create migration");
       console.error(
@@ -615,25 +397,22 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async revertMigration(): Promise<void> {
-    const useTypeScript = this.shouldUseTypeScript();
-    const spinner = ora("Reverting migration...").start();
+    const useTypeScript = this.setupEnvironment();
+    const spinner = ora(
+      `Reverting ${useTypeScript ? "TypeScript" : "JavaScript"} migration...`,
+    ).start();
     let dataSource: DataSource | null = null;
 
     try {
-      // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
-
-      // Initialize DataSource with paths from fragment.json config
-      const configOverride = {
-        entities: this.getResolvedEntityPaths(useTypeScript),
-        migrations: this.getResolvedMigrationPaths(useTypeScript),
-      };
+      const { entities, migrations } = this.getPaths(useTypeScript);
+      const configOverride = { entities, migrations };
 
       dataSource = await TypeORMModule.initialize(configOverride);
       await TypeORMModule.revertMigration();
-
-      const mode = useTypeScript ? "TypeScript" : "JavaScript";
-      spinner.succeed(`${mode} migration reverted successfully`);
+      spinner.succeed(
+        `${useTypeScript ? "TypeScript" : "JavaScript"} migration reverted successfully`,
+      );
     } catch (error) {
       spinner.fail("Revert failed");
       console.error(
@@ -648,26 +427,23 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async refreshMigrations(): Promise<void> {
-    const useTypeScript = this.shouldUseTypeScript();
-    const spinner = ora("Refreshing migrations...").start();
+    const useTypeScript = this.setupEnvironment();
+    const spinner = ora(
+      `Refreshing ${useTypeScript ? "TypeScript" : "JavaScript"} migrations...`,
+    ).start();
     let dataSource: DataSource | null = null;
 
     try {
-      // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
-
-      // Initialize DataSource with paths from fragment.json config
-      const configOverride = {
-        entities: this.getResolvedEntityPaths(useTypeScript),
-        migrations: this.getResolvedMigrationPaths(useTypeScript),
-      };
+      const { entities, migrations } = this.getPaths(useTypeScript);
+      const configOverride = { entities, migrations };
 
       dataSource = await TypeORMModule.initialize(configOverride);
       await TypeORMModule.dropSchema();
       await TypeORMModule.runMigrations();
-
-      const mode = useTypeScript ? "TypeScript" : "JavaScript";
-      spinner.succeed(`${mode} migrations refreshed successfully`);
+      spinner.succeed(
+        `${useTypeScript ? "TypeScript" : "JavaScript"} migrations refreshed successfully`,
+      );
     } catch (error) {
       spinner.fail("Refresh failed");
       console.error(
@@ -682,18 +458,13 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async showStatus(): Promise<void> {
-    const useTypeScript = this.shouldUseTypeScript();
+    const useTypeScript = this.setupEnvironment();
     let dataSource: DataSource | null = null;
 
     try {
-      // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
-
-      // Initialize DataSource with paths from fragment.json config
-      const configOverride = {
-        entities: this.getResolvedEntityPaths(useTypeScript),
-        migrations: this.getResolvedMigrationPaths(useTypeScript),
-      };
+      const { entities, migrations } = this.getPaths(useTypeScript);
+      const configOverride = { entities, migrations };
 
       dataSource = await TypeORMModule.initialize(configOverride);
       const executedMigrations = await dataSource.query(
@@ -718,16 +489,16 @@ export class ${name}${timestamp} implements MigrationInterface {
         });
       }
 
-      // Show migration directory from config
-      const migrationPaths = this.getResolvedMigrationPaths(useTypeScript);
-      const migrationsDir = path.dirname(
-        migrationPaths[0].replace("/**/*", ""),
+      const migrationsPattern = migrations[0];
+      const migrationsDir = this.extractMigrationDirectory(
+        migrationsPattern,
+        useTypeScript,
       );
       const fileExt = useTypeScript ? ".ts" : ".js";
       if (fs.existsSync(migrationsDir)) {
         const files = fs
           .readdirSync(migrationsDir)
-          .filter((f) => f.endsWith(fileExt));
+          .filter((f: string) => f.endsWith(fileExt));
         console.log(
           chalk.blue(
             `\n  Available ${mode.toLowerCase()} migration files: ${files.length}`,
@@ -735,11 +506,7 @@ export class ${name}${timestamp} implements MigrationInterface {
         );
       }
 
-      // Show detection info
-      console.log(chalk.gray(`\n  Mode detection:`));
-      console.log(
-        chalk.gray(`    - Environment mode: ${EnvUtils.getEnvironmentMode()}`),
-      );
+      console.log(chalk.gray(`\n  Configuration:`));
       console.log(
         chalk.gray(`    - ts-node available: ${this.isTsNodeAvailable()}`),
       );
@@ -761,18 +528,16 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async syncSchema(): Promise<void> {
-    const useTypeScript = this.shouldUseTypeScript();
-    const spinner = ora("Synchronizing schema...").start();
+    const useTypeScript = this.setupEnvironment();
+    const spinner = ora(
+      `Synchronizing ${useTypeScript ? "TypeScript" : "JavaScript"} schema...`,
+    ).start();
     let dataSource: DataSource | null = null;
 
     try {
-      // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
-
-      // Initialize DataSource with entity paths from config
-      const configOverride = {
-        entities: this.getResolvedEntityPaths(useTypeScript),
-      };
+      const { entities } = this.getPaths(useTypeScript);
+      const configOverride = { entities };
 
       dataSource = await TypeORMModule.initialize(configOverride);
       await TypeORMModule.syncSchema();
@@ -791,18 +556,16 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async dropSchema(): Promise<void> {
-    const useTypeScript = this.shouldUseTypeScript();
-    const spinner = ora("Dropping schema...").start();
+    const useTypeScript = this.setupEnvironment();
+    const spinner = ora(
+      `Dropping ${useTypeScript ? "TypeScript" : "JavaScript"} schema...`,
+    ).start();
     let dataSource: DataSource | null = null;
 
     try {
-      // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
-
-      // Initialize DataSource with entity paths from config
-      const configOverride = {
-        entities: this.getResolvedEntityPaths(useTypeScript),
-      };
+      const { entities } = this.getPaths(useTypeScript);
+      const configOverride = { entities };
 
       dataSource = await TypeORMModule.initialize(configOverride);
       await TypeORMModule.dropSchema();
@@ -821,47 +584,33 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async runSeeds(): Promise<void> {
-    const spinner = ora("Running seeds...").start();
-
+    const useTypeScript = this.setupEnvironment();
+    const spinner = ora(
+      `Running ${useTypeScript ? "TypeScript" : "JavaScript"} seeds...`,
+    ).start();
     try {
-      // Try TypeScript first if available
-      const useTypeScript = this.shouldUseTypeScript();
-
-      // Get seed directory from config or default
-      const dbConfig = ConfigUtils.getDatabaseConfig();
-      let seedsDir = "";
+      const { seeds: seedsDir } = this.getPaths(useTypeScript);
 
-      if (dbConfig.subscribers && dbConfig.subscribers.length > 0) {
-        // Infer seeds directory from subscribers or migrations
-        const migrationPaths = this.getResolvedMigrationPaths(useTypeScript);
-        seedsDir = path.join(path.dirname(migrationPaths[0]), "..", "seeds");
-      } else {
-        // seedsDir = useTypeScript
-        //   ? path.join(process.cwd(), "src", "seeds")
-        //   : path.join(process.cwd(), "dist", "seeds");
-        throw new Error("No seeds directory found");
+      if (!fs.existsSync(seedsDir)) {
+        spinner.info(`No seeds directory found at ${seedsDir}`);
+        return;
       }
 
-      if (fs.existsSync(seedsDir)) {
-        const files = fs.readdirSync(seedsDir);
+      const files = fs.readdirSync(seedsDir);
+      for (const file of files) {
+        const isTsFile = file.endsWith(".ts") && !file.endsWith(".d.ts");
+        const isJsFile = file.endsWith(".js");
 
-        for (const file of files) {
-          if (useTypeScript && file.endsWith(".ts")) {
-            // For TypeScript, we need to register ts-node
+        if ((useTypeScript && isTsFile) || (!useTypeScript && isJsFile)) {
+          if (useTypeScript) {
             this.registerTsNodeIfNeeded(true);
-            const seedModule = require(path.join(seedsDir, file));
-            if (seedModule.default?.run) {
-              await seedModule.default.run();
-            }
-          } else if (!useTypeScript && file.endsWith(".js")) {
-            const seedModule = require(path.join(seedsDir, file));
-            if (seedModule.default?.run) {
-              await seedModule.default.run();
-            }
+          }
+          const seedModule = require(path.join(seedsDir, file));
+          if (seedModule.default?.run) {
+            await seedModule.default.run();
           }
         }
       }
-
       spinner.succeed("Seeds completed successfully");
     } catch (error) {
       spinner.fail("Seed failed");
@@ -873,21 +622,10 @@ export class ${name}${timestamp} implements MigrationInterface {
   }
 
   private static async createSeed(name: string): Promise<void> {
-    // Always create TypeScript seeds
+    const useTypeScript = this.setupEnvironment();
     const spinner = ora("Creating TypeScript seed...").start();
-
     try {
-      // Get seed directory from config or default
-      const dbConfig = ConfigUtils.getDatabaseConfig();
-      let seedsDir = "";
-
-      if (dbConfig.subscribers && dbConfig.subscribers.length > 0) {
-        const migrationPaths = this.getResolvedMigrationPaths(true);
-        seedsDir = path.join(path.dirname(migrationPaths[0]), "..", "seeds");
-      } else {
-        seedsDir = path.join(process.cwd(), "src", "seeds");
-      }
-
+      const { seeds: seedsDir } = this.getPaths(true);
       const fileName = `${name}.seed.ts`;
       const filePath = path.join(seedsDir, fileName);
 
@@ -895,12 +633,10 @@ export class ${name}${timestamp} implements MigrationInterface {
   static async run() {
     console.log('Running ${name} seed...');
   }
-}
-`;
+}`;
 
       await fs.ensureDir(path.dirname(filePath));
       await fs.writeFile(filePath, content);
-
       spinner.succeed(`TypeScript seed created: ${fileName}`);
     } catch (error) {
       spinner.fail("Failed to create seed");
@@ -911,51 +647,38 @@ export class ${name}${timestamp} implements MigrationInterface {
     }
   }
 
-  // Keep existing helper methods unchanged
-  private static hasTypeScriptMigrations(): boolean {
-    const srcMigrationsDir = path.join(process.cwd(), "src", "migrations");
-
-    if (!fs.existsSync(srcMigrationsDir)) return false;
-
-    const tsFiles = fs
-      .readdirSync(srcMigrationsDir)
-      .filter((file) => file.endsWith(".ts"));
-
-    return tsFiles.length > 0;
-  }
-
-  private static hasJavaScriptMigrations(): boolean {
-    const distMigrationsDir = path.join(process.cwd(), "dist", "migrations");
-
-    if (!fs.existsSync(distMigrationsDir)) return false;
-
-    const jsFiles = fs
-      .readdirSync(distMigrationsDir)
-      .filter((file) => file.endsWith(".js"));
-
-    return jsFiles.length > 0;
+  private static verifyEntities(dataSource: DataSource): void {
+    const entities = dataSource.entityMetadatas;
+    if (entities.length === 0) {
+      throw new Error("No entities found!");
+    }
+    console.log(chalk.gray(`\n📦 Loaded ${entities.length} entity/entities:`));
+    entities.forEach((entity) => {
+      console.log(chalk.gray(`   - ${entity.name} (${entity.tableName})`));
+    });
+    console.log();
   }
 
-  private static findEntityFiles(dir: string, files: string[] = []): string[] {
-    const items = fs.readdirSync(dir);
-
-    for (const item of items) {
-      const fullPath = path.join(dir, item);
-      const stat = fs.statSync(fullPath);
+  private static buildQueryStatement(query: {
+    query: string;
+    parameters?: any[];
+  }): string {
+    let sql = query.query
+      .replace(/\\/g, "\\\\")
+      .replace(/`/g, "\\`")
+      .replace(/\$/g, "\\$")
+      .replace(/\r\n/g, " ")
+      .replace(/\n/g, " ")
+      .replace(/\s+/g, " ")
+      .trim();
 
-      if (stat.isDirectory()) {
-        this.findEntityFiles(fullPath, files);
-      } else if (item.endsWith(".entity.js")) {
-        files.push(fullPath.replace(process.cwd(), "."));
-      }
+    if (query.parameters && query.parameters.length > 0) {
+      const params = JSON.stringify(query.parameters);
+      return `await queryRunner.query(\`${sql}\`, ${params});`;
     }
-
-    return files;
+    return `await queryRunner.query(\`${sql}\`);`;
   }
 
-  /**
-   * Build the complete migration file template
-   */
   private static buildMigrationTemplate(
     className: string,
     upStatements: string[],
@@ -966,20 +689,14 @@ export class ${name}${timestamp} implements MigrationInterface {
       upStatements.length > 0
         ? upStatements.map((s) => `    ${s}`).join("\n")
         : "    // No changes";
-
     const downBody =
       downStatements.length > 0
         ? downStatements.map((s) => `    ${s}`).join("\n")
         : "    // No changes";
 
-    const comment = isFirstMigration
-      ? "  // Initial migration - creates all tables\n"
-      : "";
-
-    return `import { MigrationInterface, QueryRunner } from "typeorm";
+    return `import { MigrationInterface, QueryRunner } from "fragment-ts";
 
 export class ${className} implements MigrationInterface {
-${comment}
   public async up(queryRunner: QueryRunner): Promise<void> {
 ${upBody}
   }
@@ -987,7 +704,6 @@ ${upBody}
   public async down(queryRunner: QueryRunner): Promise<void> {
 ${downBody}
   }
-}
-`;
+}`;
   }
 }