fragment-ts 1.0.43 → 1.0.44

package/dist/cli/commands/migrate.command.js

@@ -43,12 +43,13 @@ const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const typeorm_module_1 = require("../../typeorm/typeorm-module");
 const config_utils_1 = require("../../shared/config.utils");
-const env_utils_1 = require("../../shared/env.utils");
+const tsconfig_utils_1 = require("../../shared/tsconfig.utils");
+const glob_1 = require("glob");
 class MigrateCommand {
     static register(program) {
         program
             .command("migrate")
-            .description("Run all pending migrations (auto-detect TypeScript/JavaScript)")
+            .description("Run all pending migrations")
             .action(async () => {
             await this.runMigrations();
         });
@@ -114,255 +115,169 @@ class MigrateCommand {
             await this.createSeed(name);
         });
     }
-    // -----------------------------------------
-    // DETECTION METHODS
-    // -----------------------------------------
     /**
-     * Check if ts-node is available in the user's project
+     * Detect if we should use TypeScript or JavaScript
      */
-    static isTsNodeAvailable() {
-        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;
+    static setupEnvironment() {
+        return this.shouldUseTypeScript();
     }
     /**
-     * Check if tsconfig.json exists
-     */
-    static hasTsConfig() {
-        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
-     */
-    static detectProjectType() {
-        const srcDir = path.join(process.cwd(), "src");
-        const hasSrcDir = fs.existsSync(srcDir);
-        const hasTsFiles = hasSrcDir && fs.readdirSync(srcDir).some((file) => file.endsWith(".ts"));
-        const distDir = path.join(process.cwd(), "dist");
-        const hasDistDir = fs.existsSync(distDir);
-        const hasJsFiles = hasDistDir &&
-            fs.readdirSync(distDir).some((file) => file.endsWith(".js"));
-        if (hasTsFiles && !hasJsFiles)
-            return "typescript";
-        if (!hasTsFiles && hasJsFiles)
-            return "javascript";
-        if (hasTsFiles && hasJsFiles)
-            return "mixed";
-        // Default to checking for tsconfig
-        return this.hasTsConfig() ? "typescript" : "javascript";
-    }
-    /**
-     * Determine whether to use TypeScript or JavaScript for migrations
+     * 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
      */
     static shouldUseTypeScript() {
-        const projectType = this.detectProjectType();
-        const tsNodeAvailable = this.isTsNodeAvailable();
-        // Use the same logic as EnvUtils for consistency
-        const isDevMode = env_utils_1.EnvUtils.isDevelopmentMode();
-        // In development mode with ts-node available, use TypeScript
-        if (isDevMode && tsNodeAvailable) {
-            return true;
-        }
-        // In production mode, always use JavaScript
-        if (!isDevMode) {
+        if (!tsconfig_utils_1.TsConfigUtils.exists()) {
             return false;
         }
-        // Fallback to project type detection
-        return projectType === "typescript" && tsNodeAvailable;
-    }
-    /**
-     * Register ts-node if needed
-     */
-    static registerTsNodeIfNeeded(useTypeScript) {
-        if (!useTypeScript)
-            return;
-        try {
-            // Register ts-node for TypeScript support
-            require("ts-node/register");
-            // If tsconfig-paths is available, register it too
+        if (!tsconfig_utils_1.TsConfigUtils.hasDecoratorSupport()) {
+            return false;
+        }
+        if (!this.isTsNodeAvailable()) {
+            return false;
+        }
+        const includePatterns = tsconfig_utils_1.TsConfigUtils.getIncludePatterns();
+        const cwd = process.cwd();
+        for (const pattern of includePatterns) {
             try {
-                require("tsconfig-paths/register");
+                const files = (0, glob_1.globSync)(pattern, { cwd });
+                if (files.some((file) => file.endsWith(".ts") && !file.endsWith(".d.ts"))) {
+                    return true;
+                }
             }
             catch {
-                // tsconfig-paths not available, that's okay
+                // Ignore glob errors
             }
-            console.log(chalk_1.default.gray("📝 Using ts-node for TypeScript migrations"));
         }
-        catch (error) {
-            console.error(chalk_1.default.yellow("⚠️  Failed to register ts-node. Falling back to JavaScript."));
+        return false;
+    }
+    static isTsNodeAvailable() {
+        if (this.tsNodeAvailable !== null) {
+            return this.tsNodeAvailable;
+        }
+        try {
+            require.resolve("ts-node");
+            this.tsNodeAvailable = true;
         }
+        catch {
+            this.tsNodeAvailable = false;
+        }
+        return this.tsNodeAvailable;
     }
-    /**
-     * Get entity paths from fragment.json config
-     */
-    static getEntityPathsFromConfig() {
-        const dbConfig = config_utils_1.ConfigUtils.getDatabaseConfig();
-        return dbConfig.entities || [];
+    static registerTsNodeIfNeeded(useTypeScript) {
+        if (useTypeScript && this.isTsNodeAvailable()) {
+            require("ts-node").register({
+                transpileOnly: true,
+                compilerOptions: {
+                    module: "commonjs",
+                },
+            });
+        }
     }
     /**
-     * Get migration paths from fragment.json config
+     * Get entity and migration paths based on current mode
+     * Uses fragment.json config when available, otherwise infers from tsconfig
      */
-    static getMigrationPathsFromConfig() {
+    static getPaths(useTypeScript) {
         const dbConfig = config_utils_1.ConfigUtils.getDatabaseConfig();
-        return dbConfig.migrations || [];
+        const resolveExtension = (pattern) => {
+            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");
+            return { entities, migrations, seeds: seedsDir };
+        }
+        const rootDir = tsconfig_utils_1.TsConfigUtils.getRootDir();
+        const outDir = tsconfig_utils_1.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 entity paths based on current mode
+     * Extract the actual directory path from a glob pattern for file creation
      */
-    static getResolvedEntityPaths(useTypeScript) {
-        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");
-                }
-            });
+    static extractMigrationDirectory(pattern, useTypeScript) {
+        if (pattern.includes("/**/*")) {
+            return pattern.split("/**/*")[0];
         }
-        // Fallback to default paths
-        return useTypeScript ? ["src/**/*.entity.ts"] : ["dist/**/*.entity.js"];
-    }
-    /**
-     * Get resolved migration paths based on current mode
-     */
-    static getResolvedMigrationPaths(useTypeScript) {
-        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");
-                }
-            });
+        if (pattern.includes("/*.")) {
+            return pattern.split("/*")[0];
         }
-        // Fallback to default paths
-        return useTypeScript
-            ? ["src/migrations/**/*.ts"]
-            : ["dist/migrations/**/*.js"];
+        if (pattern.endsWith(".ts") || pattern.endsWith(".js")) {
+            return path.dirname(pattern);
+        }
+        return useTypeScript ? "src/migrations" : "dist/migrations";
     }
-    // -----------------------------------------
-    // MIGRATION GENERATE
-    // -----------------------------------------
     static async generateMigration(nameOrPath, options) {
-        const useTypeScript = this.shouldUseTypeScript();
-        const spinner = (0, ora_1.default)("Generating migration...").start();
+        const useTypeScript = this.setupEnvironment();
+        const spinner = (0, ora_1.default)(`Generating ${useTypeScript ? "TypeScript" : "JavaScript"} migration...`).start();
         let dataSource = 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 typeorm_module_1.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) => 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) ||
                 (isFirstMigration ? "InitialMigration" : "Migration");
             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, downStatements, 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_1.default.cyan(fileName)}\n` +
-                `  ${chalk_1.default.gray("Location:")} ${filePath}\n` +
-                `  ${chalk_1.default.gray("Queries:")} ${upQueries.length} up, ${downQueries.length} down\n` +
-                `  ${chalk_1.default.gray("Mode:")} ${useTypeScript ? "TypeScript (ts-node)" : "JavaScript"}`);
+            spinner.succeed(`${useTypeScript ? "TypeScript" : "JavaScript"} migration generated: ${chalk_1.default.cyan(fileName)}`);
         }
         catch (error) {
             spinner.fail("Migration generation failed");
-            if (error instanceof Error) {
-                console.error(chalk_1.default.red("\n❌ Error: " + error.message));
-                if (error.message.includes("Cannot find module") && useTypeScript) {
-                    console.error(chalk_1.default.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_1.default.gray("\nStack trace:"));
-                    console.error(chalk_1.default.gray(error.stack));
-                }
-            }
-            else {
-                console.error(chalk_1.default.red(String(error)));
-            }
+            console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
             process.exit(1);
         }
         finally {
@@ -370,111 +285,25 @@ class MigrateCommand {
                 try {
                     await dataSource.destroy();
                 }
-                catch (err) {
-                    // Ignore cleanup errors
-                }
+                catch { }
             }
         }
     }
-    /**
-     * Verify entities are loaded and provide helpful debugging
-     */
-    static verifyEntities(dataSource) {
-        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_1.default.gray(`\n📦 Loaded ${entities.length} entity/entities:`));
-        entities.forEach((entity) => {
-            console.log(chalk_1.default.gray(`   - ${entity.name} (${entity.tableName})`));
-        });
-        console.log();
-    }
-    /**
-     * Build a single query statement with proper escaping
-     */
-    static buildQueryStatement(query) {
-        // 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
-    // -----------------------------------------
     static async runMigrations() {
-        const useTypeScript = this.shouldUseTypeScript();
-        const spinner = (0, ora_1.default)("Running migrations...").start();
+        const useTypeScript = this.setupEnvironment();
+        const spinner = (0, ora_1.default)(`Running ${useTypeScript ? "TypeScript" : "JavaScript"} migrations...`).start();
         let dataSource = 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 typeorm_module_1.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_1.default.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_1.default.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 typeorm_module_1.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_1.default.red("\n❌ TypeScript module not found."));
-                    console.error(chalk_1.default.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_1.default.red(error.message));
-                }
-            }
-            else {
-                console.error(chalk_1.default.red(String(error)));
-            }
+            console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
             process.exit(1);
         }
         finally {
@@ -484,16 +313,13 @@ class MigrateCommand {
         }
     }
     static async createMigration(name) {
-        // Always create TypeScript migrations
-        const useTypeScript = true;
+        const useTypeScript = this.setupEnvironment();
         const spinner = (0, ora_1.default)("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';
 
@@ -506,10 +332,6 @@ 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_1.default.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");
@@ -518,21 +340,16 @@ export class ${name}${timestamp} implements MigrationInterface {
         }
     }
     static async revertMigration() {
-        const useTypeScript = this.shouldUseTypeScript();
-        const spinner = (0, ora_1.default)("Reverting migration...").start();
+        const useTypeScript = this.setupEnvironment();
+        const spinner = (0, ora_1.default)(`Reverting ${useTypeScript ? "TypeScript" : "JavaScript"} migration...`).start();
         let dataSource = 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 typeorm_module_1.TypeORMModule.initialize(configOverride);
             await typeorm_module_1.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");
@@ -546,22 +363,17 @@ export class ${name}${timestamp} implements MigrationInterface {
         }
     }
     static async refreshMigrations() {
-        const useTypeScript = this.shouldUseTypeScript();
-        const spinner = (0, ora_1.default)("Refreshing migrations...").start();
+        const useTypeScript = this.setupEnvironment();
+        const spinner = (0, ora_1.default)(`Refreshing ${useTypeScript ? "TypeScript" : "JavaScript"} migrations...`).start();
         let dataSource = 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 typeorm_module_1.TypeORMModule.initialize(configOverride);
             await typeorm_module_1.TypeORMModule.dropSchema();
             await typeorm_module_1.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");
@@ -575,16 +387,12 @@ export class ${name}${timestamp} implements MigrationInterface {
         }
     }
     static async showStatus() {
-        const useTypeScript = this.shouldUseTypeScript();
+        const useTypeScript = this.setupEnvironment();
         let dataSource = 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 typeorm_module_1.TypeORMModule.initialize(configOverride);
             const executedMigrations = await dataSource.query(`SELECT * FROM migrations ORDER BY timestamp DESC`);
             const mode = useTypeScript ? "TypeScript" : "JavaScript";
@@ -598,9 +406,8 @@ export class ${name}${timestamp} implements MigrationInterface {
                     console.log(`    ${chalk_1.default.cyan(m.name)} - ${new Date(m.timestamp).toLocaleString()}`);
                 });
             }
-            // 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
@@ -608,9 +415,7 @@ export class ${name}${timestamp} implements MigrationInterface {
                     .filter((f) => f.endsWith(fileExt));
                 console.log(chalk_1.default.blue(`\n  Available ${mode.toLowerCase()} migration files: ${files.length}`));
             }
-            // Show detection info
-            console.log(chalk_1.default.gray(`\n  Mode detection:`));
-            console.log(chalk_1.default.gray(`    - Environment mode: ${env_utils_1.EnvUtils.getEnvironmentMode()}`));
+            console.log(chalk_1.default.gray(`\n  Configuration:`));
             console.log(chalk_1.default.gray(`    - ts-node available: ${this.isTsNodeAvailable()}`));
             console.log(chalk_1.default.gray(`    - Using: ${useTypeScript ? "TypeScript" : "JavaScript"}`));
         }
@@ -625,16 +430,13 @@ export class ${name}${timestamp} implements MigrationInterface {
         }
     }
     static async syncSchema() {
-        const useTypeScript = this.shouldUseTypeScript();
-        const spinner = (0, ora_1.default)("Synchronizing schema...").start();
+        const useTypeScript = this.setupEnvironment();
+        const spinner = (0, ora_1.default)(`Synchronizing ${useTypeScript ? "TypeScript" : "JavaScript"} schema...`).start();
         let dataSource = 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 typeorm_module_1.TypeORMModule.initialize(configOverride);
             await typeorm_module_1.TypeORMModule.syncSchema();
             spinner.succeed("Schema synchronized");
@@ -651,16 +453,13 @@ export class ${name}${timestamp} implements MigrationInterface {
         }
     }
     static async dropSchema() {
-        const useTypeScript = this.shouldUseTypeScript();
-        const spinner = (0, ora_1.default)("Dropping schema...").start();
+        const useTypeScript = this.setupEnvironment();
+        const spinner = (0, ora_1.default)(`Dropping ${useTypeScript ? "TypeScript" : "JavaScript"} schema...`).start();
         let dataSource = 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 typeorm_module_1.TypeORMModule.initialize(configOverride);
             await typeorm_module_1.TypeORMModule.dropSchema();
             spinner.succeed("Schema dropped");
@@ -677,40 +476,25 @@ export class ${name}${timestamp} implements MigrationInterface {
         }
     }
     static async runSeeds() {
-        const spinner = (0, ora_1.default)("Running seeds...").start();
+        const useTypeScript = this.setupEnvironment();
+        const spinner = (0, ora_1.default)(`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 = config_utils_1.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");
+            const { seeds: seedsDir } = this.getPaths(useTypeScript);
+            if (!fs.existsSync(seedsDir)) {
+                spinner.info(`No seeds directory found at ${seedsDir}`);
+                return;
             }
-            if (fs.existsSync(seedsDir)) {
-                const files = fs.readdirSync(seedsDir);
-                for (const file of files) {
-                    if (useTypeScript && file.endsWith(".ts")) {
-                        // For TypeScript, we need to register ts-node
+            const files = fs.readdirSync(seedsDir);
+            for (const file of files) {
+                const isTsFile = file.endsWith(".ts") && !file.endsWith(".d.ts");
+                const isJsFile = file.endsWith(".js");
+                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();
                     }
                 }
             }
@@ -723,27 +507,17 @@ export class ${name}${timestamp} implements MigrationInterface {
         }
     }
     static async createSeed(name) {
-        // Always create TypeScript seeds
+        const useTypeScript = this.setupEnvironment();
         const spinner = (0, ora_1.default)("Creating TypeScript seed...").start();
         try {
-            // Get seed directory from config or default
-            const dbConfig = config_utils_1.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);
             const content = `export default class ${name}Seed {
   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}`);
@@ -754,42 +528,32 @@ export class ${name}${timestamp} implements MigrationInterface {
             process.exit(1);
         }
     }
-    // Keep existing helper methods unchanged
-    static hasTypeScriptMigrations() {
-        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;
-    }
-    static hasJavaScriptMigrations() {
-        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;
+    static verifyEntities(dataSource) {
+        const entities = dataSource.entityMetadatas;
+        if (entities.length === 0) {
+            throw new Error("No entities found!");
+        }
+        console.log(chalk_1.default.gray(`\n📦 Loaded ${entities.length} entity/entities:`));
+        entities.forEach((entity) => {
+            console.log(chalk_1.default.gray(`   - ${entity.name} (${entity.tableName})`));
+        });
+        console.log();
     }
-    static findEntityFiles(dir, files = []) {
-        const items = fs.readdirSync(dir);
-        for (const item of items) {
-            const fullPath = path.join(dir, item);
-            const stat = fs.statSync(fullPath);
-            if (stat.isDirectory()) {
-                this.findEntityFiles(fullPath, files);
-            }
-            else if (item.endsWith(".entity.js")) {
-                files.push(fullPath.replace(process.cwd(), "."));
-            }
+    static buildQueryStatement(query) {
+        let sql = query.query
+            .replace(/\\/g, "\\\\")
+            .replace(/`/g, "\\`")
+            .replace(/\$/g, "\\$")
+            .replace(/\r\n/g, " ")
+            .replace(/\n/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        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
-     */
     static buildMigrationTemplate(className, upStatements, downStatements, isFirstMigration) {
         const upBody = upStatements.length > 0
             ? upStatements.map((s) => `    ${s}`).join("\n")
@@ -797,13 +561,9 @@ export class ${name}${timestamp} implements MigrationInterface {
         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}
   }
@@ -811,11 +571,9 @@ ${upBody}
   public async down(queryRunner: QueryRunner): Promise<void> {
 ${downBody}
   }
-}
-`;
+}`;
     }
 }
 exports.MigrateCommand = MigrateCommand;
 MigrateCommand.tsNodeAvailable = null;
-MigrateCommand.tsConfigExists = null;
 //# sourceMappingURL=migrate.command.js.map