fragment-ts 1.0.34 → 1.0.35

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

@@ -6,6 +6,8 @@ import ora from "ora";
 import { execSync, spawn } from "child_process";
 import { TypeORMModule } from "../../typeorm/typeorm-module";
 import { DataSource } from "typeorm";
+import { ConfigUtils } from "../../shared/config.utils";
+import { EnvUtils } from "../../shared/env.utils";
 
 export class MigrateCommand {
   private static tsNodeAvailable: boolean | null = null;
@@ -157,58 +159,28 @@ export class MigrateCommand {
     return this.hasTsConfig() ? "typescript" : "javascript";
   }
 
-  /**
-   * Check for TypeScript migration files
-   */
-  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;
-  }
-
-  /**
-   * Check for JavaScript migration files
-   */
-  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;
-  }
-
   /**
    * Determine whether to use TypeScript or JavaScript for migrations
    */
   private static shouldUseTypeScript(): boolean {
     const projectType = this.detectProjectType();
-    const hasTsMigrations = this.hasTypeScriptMigrations();
-    const hasJsMigrations = this.hasJavaScriptMigrations();
     const tsNodeAvailable = this.isTsNodeAvailable();
 
-    // If we have TypeScript migrations but no JavaScript migrations,
-    // and ts-node is available, use TypeScript
-    if (hasTsMigrations && !hasJsMigrations && tsNodeAvailable) {
+    // 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;
     }
 
-    // If project is clearly TypeScript-only and ts-node is available
-    if (projectType === "typescript" && tsNodeAvailable) {
-      return true;
+    // In production mode, always use JavaScript
+    if (!isDevMode) {
+      return false;
     }
 
-    // Default to JavaScript
-    return false;
+    // Fallback to project type detection
+    return projectType === "typescript" && tsNodeAvailable;
   }
 
   /**
@@ -239,34 +211,63 @@ export class MigrateCommand {
   }
 
   /**
-   * Get migration directory based on project type
+   * Get entity paths from fragment.json config
    */
-  private static getMigrationDirectory(useTypeScript: boolean): string {
-    return useTypeScript
-      ? path.join(process.cwd(), "src", "migrations")
-      : path.join(process.cwd(), "dist", "migrations");
+  private static getEntityPathsFromConfig(): string[] {
+    const dbConfig = ConfigUtils.getDatabaseConfig();
+    return dbConfig.entities || [];
   }
 
   /**
-   * Get migration file extension based on project type
+   * Get migration paths from fragment.json config
    */
-  private static getMigrationExtension(useTypeScript: boolean): string {
-    return useTypeScript ? ".ts" : ".js";
+  private static getMigrationPathsFromConfig(): string[] {
+    const dbConfig = ConfigUtils.getDatabaseConfig();
+    return dbConfig.migrations || [];
   }
 
   /**
-   * Get entity paths for TypeORM configuration
+   * Get resolved entity paths based on current mode
    */
-  private static getEntityPaths(useTypeScript: boolean): string[] {
+  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");
+        }
+      });
+    }
+
+    // Fallback to default paths
     return useTypeScript ? ["src/**/*.entity.ts"] : ["dist/**/*.entity.js"];
   }
 
   /**
-   * Get migration paths for TypeORM configuration
+   * Get resolved migration paths based on current mode
    */
-  private static getMigrationPaths(useTypeScript: boolean): string[] {
-    const migrationDir = this.getMigrationDirectory(useTypeScript);
-    return [`${migrationDir}/**/*${this.getMigrationExtension(useTypeScript)}`];
+  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");
+        }
+      });
+    }
+
+    // Fallback to default paths
+    return useTypeScript
+      ? ["src/migrations/**/*.ts"]
+      : ["dist/migrations/**/*.js"];
   }
 
   // -----------------------------------------
@@ -285,10 +286,10 @@ export class MigrateCommand {
       // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with appropriate paths
+      // Initialize DataSource with paths from fragment.json config
       const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
-        migrations: this.getMigrationPaths(useTypeScript),
+        entities: this.getResolvedEntityPaths(useTypeScript),
+        migrations: this.getResolvedMigrationPaths(useTypeScript),
       };
 
       dataSource = await TypeORMModule.initialize(configOverride);
@@ -299,16 +300,17 @@ export class MigrateCommand {
       // Verify entities are loaded
       this.verifyEntities(dataSource);
 
-      // Setup migrations directory
-      const migrationsDir = this.getMigrationDirectory(useTypeScript);
+      // Setup migrations directory from config
+      const migrationPaths = this.getResolvedMigrationPaths(useTypeScript);
+      const migrationsDir = path.dirname(
+        migrationPaths[0].replace("/**/*", ""),
+      );
       await fs.ensureDir(migrationsDir);
 
       const existingMigrations = fs.existsSync(migrationsDir)
         ? fs
             .readdirSync(migrationsDir)
-            .filter((f) =>
-              f.endsWith(this.getMigrationExtension(useTypeScript)),
-            )
+            .filter((f) => f.endsWith(useTypeScript ? ".ts" : ".js"))
         : [];
 
       const isFirstMigration = existingMigrations.length === 0;
@@ -370,8 +372,8 @@ export class MigrateCommand {
         isFirstMigration,
       );
 
-      // Write migration file
-      const fileExt = this.getMigrationExtension(useTypeScript);
+      // Write migration file using config directory
+      const fileExt = useTypeScript ? ".ts" : ".js";
       const fileName = `${timestamp}-${migrationName}${fileExt}`;
       const filePath = path.join(migrationsDir, fileName);
 
@@ -483,17 +485,20 @@ export class MigrateCommand {
       // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with appropriate paths
+      // Initialize DataSource with paths from fragment.json config
       const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
-        migrations: this.getMigrationPaths(useTypeScript),
+        entities: this.getResolvedEntityPaths(useTypeScript),
+        migrations: this.getResolvedMigrationPaths(useTypeScript),
       };
 
       dataSource = await TypeORMModule.initialize(configOverride);
 
-      // Check if migrations exist
-      const migrationsDir = this.getMigrationDirectory(useTypeScript);
-      const fileExt = this.getMigrationExtension(useTypeScript);
+      // 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) &&
@@ -569,9 +574,14 @@ export class MigrateCommand {
 
     try {
       const timestamp = Date.now();
-      const fileExt = this.getMigrationExtension(useTypeScript);
+      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 migrationsDir = this.getMigrationDirectory(useTypeScript);
       const filePath = path.join(migrationsDir, fileName);
 
       const content = `import { MigrationInterface, QueryRunner } from 'typeorm';
@@ -613,10 +623,10 @@ export class ${name}${timestamp} implements MigrationInterface {
       // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with appropriate paths
+      // Initialize DataSource with paths from fragment.json config
       const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
-        migrations: this.getMigrationPaths(useTypeScript),
+        entities: this.getResolvedEntityPaths(useTypeScript),
+        migrations: this.getResolvedMigrationPaths(useTypeScript),
       };
 
       dataSource = await TypeORMModule.initialize(configOverride);
@@ -646,10 +656,10 @@ export class ${name}${timestamp} implements MigrationInterface {
       // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with appropriate paths
+      // Initialize DataSource with paths from fragment.json config
       const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
-        migrations: this.getMigrationPaths(useTypeScript),
+        entities: this.getResolvedEntityPaths(useTypeScript),
+        migrations: this.getResolvedMigrationPaths(useTypeScript),
       };
 
       dataSource = await TypeORMModule.initialize(configOverride);
@@ -679,10 +689,10 @@ export class ${name}${timestamp} implements MigrationInterface {
       // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with appropriate paths
+      // Initialize DataSource with paths from fragment.json config
       const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
-        migrations: this.getMigrationPaths(useTypeScript),
+        entities: this.getResolvedEntityPaths(useTypeScript),
+        migrations: this.getResolvedMigrationPaths(useTypeScript),
       };
 
       dataSource = await TypeORMModule.initialize(configOverride);
@@ -708,8 +718,12 @@ export class ${name}${timestamp} implements MigrationInterface {
         });
       }
 
-      const migrationsDir = this.getMigrationDirectory(useTypeScript);
-      const fileExt = this.getMigrationExtension(useTypeScript);
+      // Show migration directory from config
+      const migrationPaths = this.getResolvedMigrationPaths(useTypeScript);
+      const migrationsDir = path.dirname(
+        migrationPaths[0].replace("/**/*", ""),
+      );
+      const fileExt = useTypeScript ? ".ts" : ".js";
       if (fs.existsSync(migrationsDir)) {
         const files = fs
           .readdirSync(migrationsDir)
@@ -724,7 +738,7 @@ export class ${name}${timestamp} implements MigrationInterface {
       // Show detection info
       console.log(chalk.gray(`\n  Mode detection:`));
       console.log(
-        chalk.gray(`    - Project type: ${this.detectProjectType()}`),
+        chalk.gray(`    - Environment mode: ${EnvUtils.getEnvironmentMode()}`),
       );
       console.log(
         chalk.gray(`    - ts-node available: ${this.isTsNodeAvailable()}`),
@@ -755,9 +769,9 @@ export class ${name}${timestamp} implements MigrationInterface {
       // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with appropriate paths
+      // Initialize DataSource with entity paths from config
       const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
+        entities: this.getResolvedEntityPaths(useTypeScript),
       };
 
       dataSource = await TypeORMModule.initialize(configOverride);
@@ -785,9 +799,9 @@ export class ${name}${timestamp} implements MigrationInterface {
       // Register ts-node if using TypeScript
       this.registerTsNodeIfNeeded(useTypeScript);
 
-      // Initialize DataSource with appropriate paths
+      // Initialize DataSource with entity paths from config
       const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
+        entities: this.getResolvedEntityPaths(useTypeScript),
       };
 
       dataSource = await TypeORMModule.initialize(configOverride);
@@ -812,9 +826,21 @@ export class ${name}${timestamp} implements MigrationInterface {
     try {
       // Try TypeScript first if available
       const useTypeScript = this.shouldUseTypeScript();
-      const seedsDir = useTypeScript
-        ? path.join(process.cwd(), "src", "seeds")
-        : path.join(process.cwd(), "dist", "seeds");
+
+      // Get seed directory from config or default
+      const dbConfig = ConfigUtils.getDatabaseConfig();
+      let seedsDir = "";
+
+      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)) {
         const files = fs.readdirSync(seedsDir);
@@ -851,8 +877,19 @@ export class ${name}${timestamp} implements MigrationInterface {
     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 fileName = `${name}.seed.ts`;
-      const filePath = path.join(process.cwd(), "src", "seeds", fileName);
+      const filePath = path.join(seedsDir, fileName);
 
       const content = `export default class ${name}Seed {
   static async run() {
@@ -874,119 +911,29 @@ export class ${name}${timestamp} implements MigrationInterface {
     }
   }
 
-  private static async checkDatabase(): Promise<void> {
-    console.log(chalk.blue("\n🔍 Database Diagnostic Check\n"));
-    let dataSource: DataSource | null = null;
-
-    try {
-      // Check fragment.json
-      const configPath = path.join(process.cwd(), "fragment.json");
-      if (!fs.existsSync(configPath)) {
-        console.log(chalk.yellow("⚠️  fragment.json not found"));
-      } else {
-        console.log(chalk.green("✓ fragment.json found"));
-        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-        console.log(
-          chalk.gray(
-            `   Database type: ${config.database?.type || "not specified"}`,
-          ),
-        );
-        console.log(
-          chalk.gray(
-            `   Entity paths: ${JSON.stringify(config.database?.entities || "default")}`,
-          ),
-        );
-      }
-
-      // Check project type
-      const projectType = this.detectProjectType();
-      console.log(chalk.green(`\n✓ Project type: ${projectType}`));
-
-      // Check ts-node availability
-      const tsNodeAvailable = this.isTsNodeAvailable();
-      console.log(chalk.green(`✓ ts-node available: ${tsNodeAvailable}`));
-
-      // Check what migration files exist
-      const hasTsMigrations = this.hasTypeScriptMigrations();
-      const hasJsMigrations = this.hasJavaScriptMigrations();
-      console.log(chalk.green(`✓ TypeScript migrations: ${hasTsMigrations}`));
-      console.log(chalk.green(`✓ JavaScript migrations: ${hasJsMigrations}`));
-
-      // Determine what mode would be used
-      const useTypeScript = this.shouldUseTypeScript();
-      console.log(
-        chalk.cyan(
-          `\n🎯 Would use: ${useTypeScript ? "TypeScript (ts-node)" : "JavaScript"}`,
-        ),
-      );
-
-      // Try to connect
-      console.log(chalk.blue("\n📡 Attempting database connection..."));
+  // Keep existing helper methods unchanged
+  private static hasTypeScriptMigrations(): boolean {
+    const srcMigrationsDir = path.join(process.cwd(), "src", "migrations");
 
-      // Register ts-node if needed
-      this.registerTsNodeIfNeeded(useTypeScript);
+    if (!fs.existsSync(srcMigrationsDir)) return false;
 
-      // Initialize with appropriate paths
-      const configOverride = {
-        entities: this.getEntityPaths(useTypeScript),
-        migrations: this.getMigrationPaths(useTypeScript),
-      };
+    const tsFiles = fs
+      .readdirSync(srcMigrationsDir)
+      .filter((file) => file.endsWith(".ts"));
 
-      dataSource = await TypeORMModule.initialize(configOverride);
-      console.log(chalk.green("✓ Database connection successful"));
+    return tsFiles.length > 0;
+  }
 
-      // Check loaded entities
-      const entities = dataSource.entityMetadatas;
-      console.log(chalk.blue(`\n📦 Loaded Entities: ${entities.length}`));
+  private static hasJavaScriptMigrations(): boolean {
+    const distMigrationsDir = path.join(process.cwd(), "dist", "migrations");
 
-      if (entities.length === 0) {
-        console.log(chalk.red("✗ No entities loaded by TypeORM!"));
-        console.log(chalk.yellow("\nPossible issues:"));
-        if (useTypeScript) {
-          console.log(
-            chalk.yellow("  1. Entity files not in src/**/*.entity.ts"),
-          );
-          console.log(chalk.yellow("  2. Missing @Entity() decorator"));
-          console.log(chalk.yellow("  3. ts-node not working properly"));
-        } else {
-          console.log(
-            chalk.yellow("  1. Entity files not compiled (run npm run build)"),
-          );
-          console.log(
-            chalk.yellow("  2. Entity paths in fragment.json incorrect"),
-          );
-          console.log(chalk.yellow("  3. Missing @Entity() decorator"));
-        }
-      } else {
-        entities.forEach((entity) => {
-          console.log(chalk.cyan(`\n  ${entity.name}:`));
-          console.log(chalk.gray(`    Table: ${entity.tableName}`));
-          console.log(chalk.gray(`    Columns: ${entity.columns.length}`));
-        });
-      }
+    if (!fs.existsSync(distMigrationsDir)) return false;
 
-      // Check database tables
-      console.log(chalk.blue("\n🗄️  Checking database tables..."));
-      const queryRunner = dataSource.createQueryRunner();
-      try {
-        const tables = await queryRunner.getTables();
-        console.log(chalk.green(`✓ Database has ${tables.length} table(s):`));
-        tables.forEach((t) => console.log(chalk.gray(`   - ${t.name}`)));
-      } finally {
-        await queryRunner.release();
-      }
+    const jsFiles = fs
+      .readdirSync(distMigrationsDir)
+      .filter((file) => file.endsWith(".js"));
 
-      console.log(chalk.green("\n✅ Database check complete!\n"));
-    } catch (error) {
-      console.log(chalk.red("\n❌ Error during check:"));
-      console.error(
-        chalk.red(error instanceof Error ? error.message : String(error)),
-      );
-    } finally {
-      if (dataSource?.isInitialized) {
-        await dataSource.destroy();
-      }
-    }
+    return jsFiles.length > 0;
   }
 
   private static findEntityFiles(dir: string, files: string[] = []): string[] {