stackkit 0.1.3 → 0.1.5

package/dist/lib/generation/code-generator.js

@@ -37,6 +37,7 @@ exports.AdvancedCodeGenerator = void 0;
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const package_root_1 = require("../utils/package-root");
+const generator_utils_1 = require("./generator-utils");
 class AdvancedCodeGenerator {
     constructor(frameworkConfig) {
         this.generators = new Map();
@@ -44,28 +45,18 @@ class AdvancedCodeGenerator {
         this.frameworkConfig = frameworkConfig;
     }
     async loadGenerators(modulesPath) {
-        const moduleTypes = ['auth', 'database'];
+        const moduleTypes = ["auth", "database"];
         for (const type of moduleTypes) {
             const typePath = path.join(modulesPath, type);
             if (await fs.pathExists(typePath)) {
                 const modules = await fs.readdir(typePath);
                 for (const moduleName of modules) {
-                    const generatorPath = path.join(typePath, moduleName, 'generator.json');
+                    const generatorPath = path.join(typePath, moduleName, "generator.json");
                     if (await fs.pathExists(generatorPath)) {
                         try {
                             const config = await fs.readJson(generatorPath);
-                            const modulePath = path.join(typePath, moduleName, 'module.json');
-                            if (await fs.pathExists(modulePath)) {
-                                try {
-                                    const moduleConfig = await fs.readJson(modulePath);
-                                    if (moduleConfig.postInstall && Array.isArray(moduleConfig.postInstall)) {
-                                        config.postInstall = moduleConfig.postInstall;
-                                    }
-                                }
-                                catch {
-                                    // Silently skip if module.json is invalid
-                                }
-                            }
+                            const modulePath = path.join(typePath, moduleName);
+                            await (0, generator_utils_1.mergeModuleIntoGeneratorConfig)(config, modulePath);
                             this.generators.set(`${type}:${moduleName}`, config);
                         }
                         catch {
@@ -80,10 +71,10 @@ class AdvancedCodeGenerator {
         if (!condition)
             return true;
         for (const [key, value] of Object.entries(condition)) {
-            if (key === 'features') {
+            if (key === "features") {
                 const requiredFeatures = value;
                 const contextFeatures = context.features || [];
-                if (!requiredFeatures.every(feature => contextFeatures.includes(feature))) {
+                if (!requiredFeatures.every((feature) => contextFeatures.includes(feature))) {
                     return false;
                 }
             }
@@ -110,19 +101,19 @@ class AdvancedCodeGenerator {
         // Process the rest of the template with the extended context
         content = this.processTemplateRecursive(content, templateContext);
         // Remove leading newlines that might be left from {{#var}} removal
-        content = content.replace(/^\n+/, '');
+        content = content.replace(/^\n+/, "");
         // Reduce multiple consecutive newlines to maximum 2
-        content = content.replace(/\n{3,}/g, '\n\n');
+        content = content.replace(/\n{3,}/g, "\n\n");
         return content;
     }
     processVariableDefinitions(content, context) {
         let result = content;
         let index = 0;
         while (true) {
-            const varStart = result.indexOf('{{#var ', index);
+            const varStart = result.indexOf("{{#var ", index);
             if (varStart === -1)
                 break;
-            const equalsIndex = result.indexOf('=', varStart);
+            const equalsIndex = result.indexOf("=", varStart);
             if (equalsIndex === -1)
                 break;
             const varNameMatch = result.substring(varStart + 7, equalsIndex).trim();
@@ -134,11 +125,11 @@ class AdvancedCodeGenerator {
             const valueStart = equalsIndex + 1;
             let valueEnd = valueStart;
             for (let i = valueStart; i < result.length; i++) {
-                if (result[i] === '{' && result[i + 1] === '{') {
+                if (result[i] === "{" && result[i + 1] === "{") {
                     braceCount++;
                     i++; // Skip next character
                 }
-                else if (result[i] === '}' && result[i + 1] === '}') {
+                else if (result[i] === "}" && result[i + 1] === "}") {
                     braceCount--;
                     if (braceCount === 0) {
                         valueEnd = i;
@@ -155,71 +146,74 @@ class AdvancedCodeGenerator {
             const processedValue = this.processTemplateRecursive(varValue, context);
             context[varNameMatch] = processedValue;
             // Remove the variable definition
-            result = result.replace(fullMatch, '');
+            result = result.replace(fullMatch, "");
             index = varStart;
         }
         return result;
     }
     processTemplateRecursive(content, context) {
-        content = content.replace(/\{\{#if\s+([^}\s]+)\s+([^}\s]+)\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (match, varName, operator, expectedValue, blockContent) => {
+        content = content.replace(/\{\{#if\s+([^}\s]+)\s+([^}\s]+)\s+([^}]+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (match, varName, operator, expectedValue, blockContent, elseContent) => {
             const actualVal = context[varName.trim()];
-            const cleanExpectedVal = expectedValue.trim().replace(/['"]/g, '');
+            const cleanExpectedVal = expectedValue.trim().replace(/['"]/g, "");
             let conditionMet = false;
             switch (operator) {
-                case '==':
-                case '===':
+                case "==":
+                case "===":
                     conditionMet = actualVal === cleanExpectedVal;
                     break;
-                case '!=':
-                case '!==':
+                case "!=":
+                case "!==":
                     conditionMet = actualVal !== cleanExpectedVal;
                     break;
-                case 'includes':
+                case "includes":
                     conditionMet = Array.isArray(actualVal) && actualVal.includes(cleanExpectedVal);
                     break;
-                case 'startsWith':
-                    conditionMet = typeof actualVal === 'string' && actualVal.startsWith(cleanExpectedVal);
+                case "startsWith":
+                    conditionMet = typeof actualVal === "string" && actualVal.startsWith(cleanExpectedVal);
                     break;
-                case 'endsWith':
-                    conditionMet = typeof actualVal === 'string' && actualVal.endsWith(cleanExpectedVal);
+                case "endsWith":
+                    conditionMet = typeof actualVal === "string" && actualVal.endsWith(cleanExpectedVal);
                     break;
             }
-            return conditionMet ? this.processTemplateRecursive(blockContent, context).replace(/^\n+/, '').replace(/\n+$/, '') : '';
+            const contentToProcess = conditionMet ? blockContent : (elseContent || "");
+            return this.processTemplateRecursive(contentToProcess, context)
+                .replace(/^\n+/, "")
+                .replace(/\n+$/, "");
         });
         // Handle simple conditional blocks {{#if condition}}...{{/if}} (backward compatibility)
-        content = content.replace(/\{\{#if\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (match, condition, blockContent) => {
-            const conditionParts = condition.split('==');
+        content = content.replace(/\{\{#if\s+([^}]+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (match, condition, blockContent, elseContent) => {
+            const conditionParts = condition.split("==");
             if (conditionParts.length === 2) {
-                const [varName, expectedValue] = conditionParts.map((s) => s.trim().replace(/['"]/g, ''));
-                if (context[varName] === expectedValue) {
-                    return this.processTemplateRecursive(blockContent, context).replace(/^\n+/, '').replace(/\n+$/, '');
-                }
-                return '';
+                const [varName, expectedValue] = conditionParts.map((s) => s.trim().replace(/['"]/g, ""));
+                const contentToProcess = context[varName] === expectedValue ? blockContent : (elseContent || "");
+                return this.processTemplateRecursive(contentToProcess, context)
+                    .replace(/^\n+/, "")
+                    .replace(/\n+$/, "");
             }
-            const conditionFunc = condition.split('.');
-            if (conditionFunc.length === 2 && conditionFunc[1] === 'includes') {
-                const [arrayName, item] = conditionFunc[0].split('(');
-                const itemValue = item.replace(')', '').replace(/['"]/g, '');
+            const conditionFunc = condition.split(".");
+            if (conditionFunc.length === 2 && conditionFunc[1] === "includes") {
+                const [arrayName, item] = conditionFunc[0].split("(");
+                const itemValue = item.replace(")", "").replace(/['"]/g, "");
                 const array = context[arrayName] || [];
-                if (Array.isArray(array) && array.includes(itemValue)) {
-                    return this.processTemplateRecursive(blockContent, context).replace(/^\n+/, '').replace(/\n+$/, '');
-                }
-                return '';
+                const contentToProcess = Array.isArray(array) && array.includes(itemValue) ? blockContent : (elseContent || "");
+                return this.processTemplateRecursive(contentToProcess, context)
+                    .replace(/^\n+/, "")
+                    .replace(/\n+$/, "");
             }
-            return '';
+            return "";
         });
         // Handle switch statements {{#switch variable}}...{{/switch}}
         content = content.replace(/\{\{#switch\s+([^}]+)\}\}([\s\S]*?)\{\{\/switch\}\}/g, (match, varName, switchContent) => {
             const actualVal = context[varName.trim()];
             // Parse cases
-            const caseRegex = /\{\{#case\s+([^}]+)\}\}([\s\S]*?)(?=\{\{#case|\{\{\/switch\})/g;
-            let result = '';
-            let defaultCase = '';
+            const caseRegex = /\{\{#case\s+([^}]+)\}\}([\s\S]*?)(?=\{\{#case|\{\{\/case\}|\{\{\/switch\})/g;
+            let result = "";
+            let defaultCase = "";
             let caseMatch;
             while ((caseMatch = caseRegex.exec(switchContent)) !== null) {
                 const [, caseValue, caseContent] = caseMatch;
-                const cleanCaseValue = caseValue.trim().replace(/['"]/g, '');
-                if (cleanCaseValue === 'default') {
+                const cleanCaseValue = caseValue.trim().replace(/['"]/g, "");
+                if (cleanCaseValue === "default") {
                     defaultCase = caseContent;
                 }
                 else if (actualVal === cleanCaseValue) {
@@ -227,7 +221,7 @@ class AdvancedCodeGenerator {
                     break;
                 }
             }
-            return result || defaultCase || '';
+            return result || defaultCase || "";
         });
         // Handle variable replacement with advanced expressions
         content = content.replace(/\{\{([^}]+)\}\}/g, (match, varExpr) => {
@@ -240,10 +234,10 @@ class AdvancedCodeGenerator {
                 if (conditionMatch) {
                     const [, varName, expectedVal] = conditionMatch;
                     const cleanVarName = varName.trim();
-                    const cleanExpectedVal = expectedVal.trim().replace(/['"]/g, '');
+                    const cleanExpectedVal = expectedVal.trim().replace(/['"]/g, "");
                     const actualVal = context[cleanVarName];
                     const result = actualVal === cleanExpectedVal ? trueVal.trim() : falseVal.trim();
-                    return result.replace(/['"]/g, ''); // Remove quotes from result
+                    return result.replace(/['"]/g, ""); // Remove quotes from result
                 }
             }
             // Handle switch expressions {{switch variable case1: value1, case2: value2, default: defaultValue}}
@@ -251,21 +245,21 @@ class AdvancedCodeGenerator {
             if (switchMatch) {
                 const [, varName, casesStr] = switchMatch;
                 const actualVal = context[varName.trim()];
-                const cases = casesStr.split(',').map((c) => c.trim());
+                const cases = casesStr.split(",").map((c) => c.trim());
                 for (const caseStr of cases) {
-                    const [caseVal, result] = caseStr.split(':').map((s) => s.trim());
-                    const cleanCaseVal = caseVal.replace(/['"]/g, '');
-                    if (cleanCaseVal === actualVal || cleanCaseVal === 'default') {
-                        return result.replace(/['"]/g, '');
+                    const [caseVal, result] = caseStr.split(":").map((s) => s.trim());
+                    const cleanCaseVal = caseVal.replace(/['"]/g, "");
+                    if (cleanCaseVal === actualVal || cleanCaseVal === "default") {
+                        return result.replace(/['"]/g, "");
                     }
                 }
-                return '';
+                return "";
             }
             // Handle feature flags {{feature:name}}
-            if (trimmedExpr.startsWith('feature:')) {
+            if (trimmedExpr.startsWith("feature:")) {
                 const featureName = trimmedExpr.substring(8);
                 const features = context.features || [];
-                return features.includes(featureName) ? 'true' : 'false';
+                return features.includes(featureName) ? "true" : "false";
             }
             // Handle conditional expressions {{if condition then:value else:value}}
             const conditionalMatch = trimmedExpr.match(/^if\s+(.+?)\s+then:([^,]+),\s*else:(.+)$/);
@@ -275,10 +269,10 @@ class AdvancedCodeGenerator {
                 if (conditionMatch2) {
                     const [, varName, expectedVal] = conditionMatch2;
                     const cleanVarName = varName.trim();
-                    const cleanExpectedVal = expectedVal.trim().replace(/['"]/g, '');
+                    const cleanExpectedVal = expectedVal.trim().replace(/['"]/g, "");
                     const actualVal = context[cleanVarName];
                     const result = actualVal === cleanExpectedVal ? thenVal.trim() : elseVal.trim();
-                    return result.replace(/['"]/g, '');
+                    return result.replace(/['"]/g, "");
                 }
             }
             // Simple variable replacement
@@ -295,21 +289,21 @@ class AdvancedCodeGenerator {
             features,
         };
         // Set default prismaProvider if database is prisma but no provider specified
-        if (selectedModules.database === 'prisma' && !context.prismaProvider) {
-            context.prismaProvider = 'postgresql';
+        if (selectedModules.database === "prisma" && !context.prismaProvider) {
+            context.prismaProvider = "postgresql";
         }
         // Collect all applicable operations
         const applicableOperations = [];
         for (const [key, generator] of this.generators) {
-            const [genType, name] = key.split(':');
+            const [genType, name] = key.split(":");
             // Check if this generator is selected
-            if (genType === 'framework' && name === selectedModules.framework) {
+            if (genType === "framework" && name === selectedModules.framework) {
                 // Framework is always included
             }
-            else if (genType === 'database' && name === selectedModules.database) {
+            else if (genType === "database" && name === selectedModules.database) {
                 // Database is selected
             }
-            else if (genType === 'auth' && name === selectedModules.auth) {
+            else if (genType === "auth" && name === selectedModules.auth) {
                 // Auth is selected
             }
             else {
@@ -350,22 +344,22 @@ class AdvancedCodeGenerator {
         // Process templates in operation content
         const processedOperation = this.processOperationTemplates(operation, context);
         switch (processedOperation.type) {
-            case 'create-file':
+            case "create-file":
                 await this.executeCreateFile(processedOperation, context, outputPath);
                 break;
-            case 'patch-file':
+            case "patch-file":
                 await this.executePatchFile(processedOperation, context, outputPath);
                 break;
-            case 'add-dependency':
+            case "add-dependency":
                 await this.executeAddDependency(processedOperation, context, outputPath);
                 break;
-            case 'add-script':
+            case "add-script":
                 await this.executeAddScript(processedOperation, context, outputPath);
                 break;
-            case 'add-env':
+            case "add-env":
                 await this.executeAddEnv(processedOperation, context, outputPath);
                 break;
-            case 'run-command':
+            case "run-command":
                 this.executeRunCommand(processedOperation, context);
                 break;
             default:
@@ -374,15 +368,15 @@ class AdvancedCodeGenerator {
     }
     async copyTemplate(frameworkName, outputPath) {
         const packageRoot = (0, package_root_1.getPackageRoot)();
-        const templatePath = path.join(packageRoot, 'templates', frameworkName);
+        const templatePath = path.join(packageRoot, "templates", frameworkName);
         if (await fs.pathExists(templatePath)) {
             await fs.copy(templatePath, outputPath, {
                 filter: (src) => {
                     const relativePath = path.relative(templatePath, src);
-                    return relativePath !== 'template.json' &&
-                        relativePath !== 'node_modules' &&
-                        !relativePath.startsWith('node_modules/');
-                }
+                    return (relativePath !== "template.json" &&
+                        relativePath !== "node_modules" &&
+                        !relativePath.startsWith("node_modules/"));
+                },
             });
         }
     }
@@ -403,10 +397,10 @@ class AdvancedCodeGenerator {
         }
         // Process templates in patch operations
         if (processed.operations) {
-            processed.operations = processed.operations.map(op => {
+            processed.operations = processed.operations.map((op) => {
                 const processedOp = { ...op };
                 if (processedOp.imports) {
-                    processedOp.imports = processedOp.imports.map(imp => this.processTemplate(imp, context));
+                    processedOp.imports = processedOp.imports.map((imp) => this.processTemplate(imp, context));
                 }
                 if (processedOp.code) {
                     processedOp.code = this.processTemplate(processedOp.code, context);
@@ -443,19 +437,9 @@ class AdvancedCodeGenerator {
             content = this.processTemplate(operation.content, context);
         }
         else if (operation.source) {
-            // Find the source file path relative to the module/template directory
-            const packageRoot = (0, package_root_1.getPackageRoot)();
-            const modulesPath = path.join(packageRoot, 'modules');
-            const templatesPath = path.join(packageRoot, 'templates');
-            const moduleBasePath = operation.generatorType === 'framework'
-                ? path.join(templatesPath, operation.generator)
-                : path.join(modulesPath, operation.generatorType, operation.generator);
-            const sourcePath = path.join(moduleBasePath, 'files', operation.source);
-            // Check if source file exists
-            if (await fs.pathExists(sourcePath)) {
-                // Read source file
-                content = await fs.readFile(sourcePath, 'utf-8');
-                // Process template content
+            const sourcePath = (0, generator_utils_1.locateOperationSource)(operation.generatorType, operation.generator, operation.source || "");
+            if (sourcePath && (await fs.pathExists(sourcePath))) {
+                content = await fs.readFile(sourcePath, "utf-8");
                 content = this.processTemplate(content, context);
             }
             else {
@@ -466,14 +450,14 @@ class AdvancedCodeGenerator {
             throw new Error(`Create file operation must have either 'content' or 'source' field`);
         }
         // Write destination file
-        await fs.writeFile(destinationPath, content, 'utf-8');
+        await fs.writeFile(destinationPath, content, "utf-8");
     }
     async executePatchFile(operation, context, outputPath) {
         if (!operation.destination)
             return;
         const filePath = path.join(outputPath, this.processTemplate(operation.destination, context));
         // Read existing file
-        let content = await fs.readFile(filePath, 'utf-8');
+        let content = await fs.readFile(filePath, "utf-8");
         if (operation.content) {
             content += this.processTemplate(operation.content, context).trim();
         }
@@ -483,14 +467,16 @@ class AdvancedCodeGenerator {
                 if (!this.evaluateCondition(patchOp.condition, context))
                     continue;
                 switch (patchOp.type) {
-                    case 'add-import':
+                    case "add-import":
                         if (patchOp.imports) {
-                            const imports = patchOp.imports.map(imp => this.processTemplate(imp, context)).join('\n');
+                            const imports = patchOp.imports
+                                .map((imp) => this.processTemplate(imp, context))
+                                .join("\n");
                             // Add imports at the top, after existing imports
-                            const lines = content.split('\n');
+                            const lines = content.split("\n");
                             let insertIndex = 0;
                             for (let i = 0; i < lines.length; i++) {
-                                if (lines[i].trim().startsWith('import') || lines[i].trim() === '') {
+                                if (lines[i].trim().startsWith("import") || lines[i].trim() === "") {
                                     insertIndex = i + 1;
                                 }
                                 else {
@@ -498,59 +484,62 @@ class AdvancedCodeGenerator {
                                 }
                             }
                             lines.splice(insertIndex, 0, imports);
-                            content = lines.join('\n');
+                            content = lines.join("\n");
                         }
                         break;
-                    case 'add-code':
+                    case "add-code":
                         if (patchOp.code && patchOp.after) {
                             const processedCode = this.processTemplate(patchOp.code, context);
                             const afterPattern = this.processTemplate(patchOp.after, context);
                             const index = content.indexOf(afterPattern);
                             if (index !== -1) {
-                                content = content.slice(0, index + afterPattern.length) + processedCode + content.slice(index + afterPattern.length);
+                                content =
+                                    content.slice(0, index + afterPattern.length) +
+                                        processedCode +
+                                        content.slice(index + afterPattern.length);
                             }
                         }
                         break;
-                    case 'replace-code':
+                    case "replace-code":
                         if (patchOp.code && patchOp.replace) {
                             const processedCode = this.processTemplate(patchOp.code, context);
                             const replacePattern = this.processTemplate(patchOp.replace, context);
                             content = content.replace(replacePattern, processedCode);
                         }
                         break;
-                    case 'add-to-top': {
-                        let processedContentTop = '';
+                    case "add-to-top": {
+                        let processedContentTop = "";
                         if (patchOp.content) {
                             processedContentTop = this.processTemplate(patchOp.content, context).trim();
                         }
                         else if (patchOp.source) {
-                            const modulesPath = path.join((0, package_root_1.getPackageRoot)(), 'modules');
-                            const sourcePath = path.join(modulesPath, operation.generatorType, operation.generator, 'files', patchOp.source);
+                            const modulesPath = path.join((0, package_root_1.getPackageRoot)(), "modules");
+                            const sourcePath = path.join(modulesPath, operation.generatorType, operation.generator, "files", patchOp.source);
                             if (await fs.pathExists(sourcePath)) {
-                                processedContentTop = await fs.readFile(sourcePath, 'utf-8');
+                                processedContentTop = await fs.readFile(sourcePath, "utf-8");
                                 processedContentTop = this.processTemplate(processedContentTop, context).trim();
                             }
                         }
                         if (processedContentTop) {
-                            content = processedContentTop + '\n' + content;
+                            content = processedContentTop + "\n" + content;
                         }
                         break;
                     }
-                    case 'add-to-bottom': {
-                        let processedContentBottom = '';
+                    case "add-to-bottom": {
+                        let processedContentBottom = "";
                         if (patchOp.content) {
                             processedContentBottom = this.processTemplate(patchOp.content, context).trim();
                         }
                         else if (patchOp.source) {
-                            const modulesPath = path.join((0, package_root_1.getPackageRoot)(), 'modules');
-                            const sourcePath = path.join(modulesPath, operation.generatorType, operation.generator, 'files', patchOp.source);
+                            const modulesPath = path.join((0, package_root_1.getPackageRoot)(), "modules");
+                            const sourcePath = path.join(modulesPath, operation.generatorType, operation.generator, "files", patchOp.source);
                             if (await fs.pathExists(sourcePath)) {
-                                processedContentBottom = await fs.readFile(sourcePath, 'utf-8');
+                                processedContentBottom = await fs.readFile(sourcePath, "utf-8");
                                 processedContentBottom = this.processTemplate(processedContentBottom, context).trim();
                             }
                         }
                         if (processedContentBottom) {
-                            content = content + '\n' + processedContentBottom;
+                            content = content + "\n" + processedContentBottom;
                         }
                         break;
                     }
@@ -558,44 +547,56 @@ class AdvancedCodeGenerator {
             }
         }
         // Write back the modified content
-        await fs.writeFile(filePath, content, 'utf-8');
+        await fs.writeFile(filePath, content, "utf-8");
     }
     async executeAddDependency(operation, context, outputPath) {
-        const packageJsonPath = path.join(outputPath, 'package.json');
+        const packageJsonPath = path.join(outputPath, "package.json");
         let packageJson = {};
         if (await fs.pathExists(packageJsonPath)) {
             packageJson = await fs.readJson(packageJsonPath);
         }
         if (operation.dependencies) {
-            packageJson.dependencies = { ...(packageJson.dependencies || {}), ...operation.dependencies };
+            packageJson.dependencies = {
+                ...(packageJson.dependencies || {}),
+                ...operation.dependencies,
+            };
         }
         if (operation.devDependencies) {
-            packageJson.devDependencies = { ...(packageJson.devDependencies || {}), ...operation.devDependencies };
+            packageJson.devDependencies = {
+                ...(packageJson.devDependencies || {}),
+                ...operation.devDependencies,
+            };
         }
         await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
     }
     async executeAddScript(operation, context, outputPath) {
-        const packageJsonPath = path.join(outputPath, 'package.json');
+        const packageJsonPath = path.join(outputPath, "package.json");
         let packageJson = {};
         if (await fs.pathExists(packageJsonPath)) {
             packageJson = await fs.readJson(packageJsonPath);
         }
         if (operation.scripts) {
-            packageJson.scripts = { ...(packageJson.scripts || {}), ...operation.scripts };
+            packageJson.scripts = {
+                ...(packageJson.scripts || {}),
+                ...operation.scripts,
+            };
         }
         await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
     }
     async executeAddEnv(operation, context, outputPath) {
-        const envPath = path.join(outputPath, '.env');
-        let envContent = '';
+        const envPath = path.join(outputPath, ".env");
+        let envContent = "";
         if (await fs.pathExists(envPath)) {
-            envContent = await fs.readFile(envPath, 'utf-8');
+            envContent = await fs.readFile(envPath, "utf-8");
         }
         if (operation.envVars) {
-            const envLines = Object.entries(operation.envVars).map(([key, value]) => `${key}=${value}`);
-            envContent += '\n' + envLines.join('\n');
+            const envLines = Object.entries(operation.envVars).map(([key, value]) => {
+                const processedValue = this.processTemplate(value, context);
+                return `${key}=${processedValue}`;
+            });
+            envContent += "\n" + envLines.join("\n");
         }
-        await fs.writeFile(envPath, envContent.trim(), 'utf-8');
+        await fs.writeFile(envPath, envContent.trim(), "utf-8");
     }
     executeRunCommand(operation, context) {
         if (operation.command) {
@@ -605,7 +606,7 @@ class AdvancedCodeGenerator {
         }
     }
     async generatePackageJson(selectedModules, features, outputPath) {
-        const packageJsonPath = path.join(outputPath, 'package.json');
+        const packageJsonPath = path.join(outputPath, "package.json");
         let packageJson = {};
         if (await fs.pathExists(packageJsonPath)) {
             packageJson = await fs.readJson(packageJsonPath);
@@ -615,40 +616,104 @@ class AdvancedCodeGenerator {
         const allDevDeps = {};
         const allScripts = {};
         for (const [key, generator] of this.generators) {
-            const [type, name] = key.split(':');
-            if ((type === 'framework' && name === selectedModules.framework) ||
-                (type === 'database' && name === selectedModules.database) ||
-                (type === 'auth' && name === selectedModules.auth)) {
+            const [type, name] = key.split(":");
+            if ((type === "framework" && name === selectedModules.framework) ||
+                (type === "database" && name === selectedModules.database) ||
+                (type === "auth" && name === selectedModules.auth)) {
                 Object.assign(allDeps, generator.dependencies);
                 Object.assign(allDevDeps, generator.devDependencies);
                 Object.assign(allScripts, generator.scripts);
             }
         }
         // Update package.json
-        packageJson.dependencies = { ...(packageJson.dependencies || {}), ...allDeps };
-        packageJson.devDependencies = { ...(packageJson.devDependencies || {}), ...allDevDeps };
-        packageJson.scripts = { ...(packageJson.scripts || {}), ...allScripts };
+        packageJson.dependencies = {
+            ...(packageJson.dependencies || {}),
+            ...allDeps,
+        };
+        packageJson.devDependencies = {
+            ...(packageJson.devDependencies || {}),
+            ...allDevDeps,
+        };
+        packageJson.scripts = {
+            ...(packageJson.scripts || {}),
+            ...allScripts,
+        };
         await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
     }
+    /**
+     * Apply generators to an existing project directory instead of creating a new template.
+     * This executes applicable operations and updates package.json in-place.
+     */
+    async applyToProject(selectedModules, features, projectPath) {
+        const context = {
+            ...selectedModules,
+            features,
+        };
+        if (selectedModules.database === "prisma" && !context.prismaProvider) {
+            context.prismaProvider = "postgresql";
+        }
+        const applicableOperations = [];
+        for (const [key, generator] of this.generators) {
+            const [genType, name] = key.split(":");
+            if (genType === "framework" && name === selectedModules.framework) {
+                // framework
+            }
+            else if (genType === "database" && name === selectedModules.database) {
+                // database
+            }
+            else if (genType === "auth" && name === selectedModules.auth) {
+                // auth
+            }
+            else {
+                continue;
+            }
+            if (generator.postInstall && Array.isArray(generator.postInstall)) {
+                this.postInstallCommands.push(...generator.postInstall);
+            }
+            const items = generator.operations || [];
+            for (const item of items) {
+                if (this.evaluateCondition(item.condition, context)) {
+                    applicableOperations.push({
+                        ...item,
+                        generator: name,
+                        generatorType: genType,
+                        priority: generator.priority,
+                    });
+                }
+            }
+        }
+        applicableOperations.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+        for (const operation of applicableOperations) {
+            await this.executeOperation(operation, context, projectPath);
+        }
+        await this.generatePackageJson(selectedModules, features, projectPath);
+        return this.postInstallCommands;
+    }
     getAvailableGenerators() {
         const frameworks = [];
         const databases = [];
         const auths = [];
         for (const [key] of this.generators) {
-            const [type, name] = key.split(':');
+            const [type, name] = key.split(":");
             switch (type) {
-                case 'framework':
+                case "framework":
                     frameworks.push(name);
                     break;
-                case 'database':
+                case "database":
                     databases.push(name);
                     break;
-                case 'auth':
+                case "auth":
                     auths.push(name);
                     break;
             }
         }
         return { frameworks, databases, auths };
     }
+    /**
+     * Register a generator config dynamically (used for modules that only provide module.json patches).
+     */
+    registerGenerator(type, name, config) {
+        this.generators.set(`${type}:${name}`, config);
+    }
 }
 exports.AdvancedCodeGenerator = AdvancedCodeGenerator;