create-stackkit-app 0.4.5 → 0.4.6

package/dist/index.js

@@ -47,7 +47,7 @@ Usage:
 
 Options:
   -f, --framework <framework>    Framework: nextjs, express, react-vite
-  -d, --database <database>      Database: prisma-postgresql, prisma-mongodb, prisma-mysql, prisma-sqlite, mongoose-mongodb, none
+  -d, --database <database>      Database: prisma, mongoose, none
   -a, --auth <auth>              Auth: better-auth, authjs, none
   -l, --language <language>      Language: typescript, javascript
   -p, --package-manager <pm>     Package manager: pnpm, npm, yarn, bun
@@ -58,7 +58,6 @@ Options:
 
 Examples:
   create-stackkit-app my-app --framework nextjs --database prisma-postgresql --auth better-auth
-  create-stackkit-app --help
 `);
 }
 async function main() {

package/dist/lib/code-generator.d.ts

@@ -0,0 +1,80 @@
+import { FrameworkConfig } from './framework-utils';
+export interface GenerationContext {
+    framework: string;
+    database?: string;
+    auth?: string;
+    features?: string[];
+    [key: string]: unknown;
+}
+export interface TemplateCondition {
+    framework?: string;
+    database?: string;
+    auth?: string;
+    features?: string[];
+}
+export interface Operation {
+    type: 'create-file' | 'patch-file' | 'add-dependency' | 'add-script' | 'add-env' | 'run-command';
+    description?: string;
+    condition?: TemplateCondition;
+    priority?: number;
+    source?: string;
+    destination?: string;
+    content?: string;
+    file?: string;
+    operations?: PatchOperation[];
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    envVars?: Record<string, string>;
+    command?: string;
+}
+export interface PatchOperation {
+    type: 'add-import' | 'add-code' | 'replace-code' | 'add-to-top' | 'add-to-bottom';
+    condition?: TemplateCondition;
+    imports?: string[];
+    code?: string;
+    after?: string;
+    before?: string;
+    replace?: string;
+    content?: string;
+}
+export interface GeneratorConfig {
+    name: string;
+    type: 'framework' | 'database' | 'auth';
+    priority: number;
+    operations?: Operation[];
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    envVars?: Record<string, string>;
+}
+export declare class AdvancedCodeGenerator {
+    private generators;
+    private frameworkConfig;
+    private postInstallCommands;
+    constructor(frameworkConfig: FrameworkConfig);
+    loadGenerators(modulesPath: string): Promise<void>;
+    private evaluateCondition;
+    private processTemplate;
+    generate(selectedModules: {
+        framework: string;
+        database?: string;
+        auth?: string;
+        prismaProvider?: string;
+    }, features: string[], outputPath: string): Promise<string[]>;
+    private executeOperation;
+    private copyTemplate;
+    private processOperationTemplates;
+    private executeCreateFile;
+    private executePatchFile;
+    private executeAddDependency;
+    private executeAddScript;
+    private executeAddEnv;
+    private executeRunCommand;
+    private generatePackageJson;
+    getAvailableGenerators(): {
+        frameworks: string[];
+        databases: string[];
+        auths: string[];
+    };
+}

package/dist/lib/code-generator.js

@@ -0,0 +1,541 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvancedCodeGenerator = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+class AdvancedCodeGenerator {
+    constructor(frameworkConfig) {
+        this.generators = new Map();
+        this.postInstallCommands = [];
+        this.frameworkConfig = frameworkConfig;
+    }
+    async loadGenerators(modulesPath) {
+        const moduleTypes = ['auth', 'database'];
+        // Load module generators
+        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');
+                    if (await fs.pathExists(generatorPath)) {
+                        try {
+                            const config = await fs.readJson(generatorPath);
+                            this.generators.set(`${type}:${moduleName}`, config);
+                        }
+                        catch {
+                            // Silently skip invalid generator files
+                        }
+                    }
+                }
+            }
+        }
+    }
+    evaluateCondition(condition, context) {
+        if (!condition)
+            return true;
+        for (const [key, value] of Object.entries(condition)) {
+            if (key === 'features') {
+                const requiredFeatures = value;
+                const contextFeatures = context.features || [];
+                if (!requiredFeatures.every(feature => contextFeatures.includes(feature))) {
+                    return false;
+                }
+            }
+            else {
+                if (context[key] !== value) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    processTemplate(content, context) {
+        // Handle advanced conditional blocks {{#if condition operator value}}...{{/if}}
+        content = content.replace(/\{\{#if\s+([^}\s]+)\s+([^}\s]+)\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (match, varName, operator, expectedValue, blockContent) => {
+            const actualVal = context[varName.trim()];
+            const cleanExpectedVal = expectedValue.trim().replace(/['"]/g, '');
+            let conditionMet = false;
+            switch (operator) {
+                case '==':
+                case '===':
+                    conditionMet = actualVal === cleanExpectedVal;
+                    break;
+                case '!=':
+                case '!==':
+                    conditionMet = actualVal !== cleanExpectedVal;
+                    break;
+                case 'includes':
+                    conditionMet = Array.isArray(actualVal) && actualVal.includes(cleanExpectedVal);
+                    break;
+                case 'startsWith':
+                    conditionMet = typeof actualVal === 'string' && actualVal.startsWith(cleanExpectedVal);
+                    break;
+                case 'endsWith':
+                    conditionMet = typeof actualVal === 'string' && actualVal.endsWith(cleanExpectedVal);
+                    break;
+            }
+            return conditionMet ? this.processTemplate(blockContent, context) : '';
+        });
+        // 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('==');
+            if (conditionParts.length === 2) {
+                const [varName, expectedValue] = conditionParts.map((s) => s.trim().replace(/['"]/g, ''));
+                if (context[varName] === expectedValue) {
+                    return this.processTemplate(blockContent, context);
+                }
+                return '';
+            }
+            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.processTemplate(blockContent, context);
+                }
+                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 = '';
+            let caseMatch;
+            while ((caseMatch = caseRegex.exec(switchContent)) !== null) {
+                const [, caseValue, caseContent] = caseMatch;
+                const cleanCaseValue = caseValue.trim().replace(/['"]/g, '');
+                if (cleanCaseValue === 'default') {
+                    defaultCase = caseContent;
+                }
+                else if (actualVal === cleanCaseValue) {
+                    result = caseContent;
+                    break;
+                }
+            }
+            return result || defaultCase || '';
+        });
+        // Handle variable replacement with advanced expressions
+        content = content.replace(/\{\{([^}]+)\}\}/g, (match, varExpr) => {
+            const trimmedExpr = varExpr.trim();
+            // Handle ternary expressions like framework=='nextjs' ? '@/lib' : '.'
+            const ternaryMatch = trimmedExpr.match(/^(.+?)\s*\?\s*(.+?)\s*:\s*(.+?)$/);
+            if (ternaryMatch) {
+                const [, condition, trueVal, falseVal] = ternaryMatch;
+                const conditionMatch = condition.match(/^(.+?)==(.+)$/);
+                if (conditionMatch) {
+                    const [, varName, expectedVal] = conditionMatch;
+                    const cleanVarName = varName.trim();
+                    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
+                }
+            }
+            // Handle switch expressions {{switch variable case1: value1, case2: value2, default: defaultValue}}
+            const switchMatch = trimmedExpr.match(/^switch\s+([^}\s]+)\s+(.+)$/);
+            if (switchMatch) {
+                const [, varName, casesStr] = switchMatch;
+                const actualVal = context[varName.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, '');
+                    }
+                }
+                return '';
+            }
+            // Handle feature flags {{feature:name}}
+            if (trimmedExpr.startsWith('feature:')) {
+                const featureName = trimmedExpr.substring(8);
+                const features = context.features || [];
+                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:(.+)$/);
+            if (conditionalMatch) {
+                const [, condition, thenVal, elseVal] = conditionalMatch;
+                const conditionMatch2 = condition.match(/^(.+?)==(.+)$/);
+                if (conditionMatch2) {
+                    const [, varName, expectedVal] = conditionMatch2;
+                    const cleanVarName = varName.trim();
+                    const cleanExpectedVal = expectedVal.trim().replace(/['"]/g, '');
+                    const actualVal = context[cleanVarName];
+                    const result = actualVal === cleanExpectedVal ? thenVal.trim() : elseVal.trim();
+                    return result.replace(/['"]/g, '');
+                }
+            }
+            // Simple variable replacement
+            const value = context[trimmedExpr];
+            return value !== undefined ? String(value) : match;
+        });
+        return content;
+    }
+    async generate(selectedModules, features, outputPath) {
+        // First, copy the base template
+        await this.copyTemplate(selectedModules.framework, outputPath);
+        const context = {
+            ...selectedModules,
+            features,
+        };
+        // Add prismaProvider if prismaProvider is specified
+        if (selectedModules.prismaProvider) {
+            context.prismaProvider = selectedModules.prismaProvider;
+        }
+        // Collect all applicable operations
+        const applicableOperations = [];
+        for (const [key, generator] of this.generators) {
+            const [genType, name] = key.split(':');
+            // Check if this generator is selected
+            if (genType === 'framework' && name === selectedModules.framework) {
+                // Framework is always included
+            }
+            else if (genType === 'database' && name === selectedModules.database) {
+                // Database is selected
+            }
+            else if (genType === 'auth' && name === selectedModules.auth) {
+                // Auth is selected
+            }
+            else {
+                continue; // Skip unselected generators
+            }
+            // Handle operations
+            const items = generator.operations || [];
+            for (const item of items) {
+                if (this.evaluateCondition(item.condition, context)) {
+                    applicableOperations.push({
+                        ...item,
+                        generator: name,
+                        generatorType: genType,
+                    });
+                }
+            }
+        }
+        // Sort operations by priority
+        applicableOperations.sort((a, b) => {
+            const priorityA = a.priority || 0;
+            const priorityB = b.priority || 0;
+            return priorityA - priorityB;
+        });
+        // Execute operations
+        for (const operation of applicableOperations) {
+            await this.executeOperation(operation, context, outputPath);
+        }
+        // Generate package.json updates
+        await this.generatePackageJson(selectedModules, features, outputPath);
+        return this.postInstallCommands;
+    }
+    async executeOperation(operation, context, outputPath) {
+        // Process templates in operation content
+        const processedOperation = this.processOperationTemplates(operation, context);
+        switch (processedOperation.type) {
+            case 'create-file':
+                await this.executeCreateFile(processedOperation, context, outputPath);
+                break;
+            case 'patch-file':
+                await this.executePatchFile(processedOperation, context, outputPath);
+                break;
+            case 'add-dependency':
+                await this.executeAddDependency(processedOperation, context, outputPath);
+                break;
+            case 'add-script':
+                await this.executeAddScript(processedOperation, context, outputPath);
+                break;
+            case 'add-env':
+                await this.executeAddEnv(processedOperation, context, outputPath);
+                break;
+            case 'run-command':
+                this.executeRunCommand(processedOperation, context);
+                break;
+            default:
+            // Unknown operation type - skip silently
+        }
+    }
+    async copyTemplate(frameworkName, outputPath) {
+        const templatesPath = path.resolve(__dirname, '..', '..', 'templates');
+        const templatePath = path.join(templatesPath, frameworkName);
+        if (await fs.pathExists(templatePath)) {
+            // Copy all files except template.json and node_modules
+            await fs.copy(templatePath, outputPath, {
+                filter: (src) => {
+                    const relativePath = path.relative(templatePath, src);
+                    return relativePath !== 'template.json' &&
+                        relativePath !== 'node_modules' &&
+                        !relativePath.startsWith('node_modules/');
+                }
+            });
+        }
+    }
+    processOperationTemplates(operation, context) {
+        const processed = { ...operation };
+        // Process templates in string fields
+        if (processed.source) {
+            processed.source = this.processTemplate(processed.source, context);
+        }
+        if (processed.destination) {
+            processed.destination = this.processTemplate(processed.destination, context);
+        }
+        if (processed.content) {
+            processed.content = this.processTemplate(processed.content, context);
+        }
+        if (processed.file) {
+            processed.file = this.processTemplate(processed.file, context);
+        }
+        // Process templates in patch operations
+        if (processed.operations) {
+            processed.operations = processed.operations.map(op => {
+                const processedOp = { ...op };
+                if (processedOp.imports) {
+                    processedOp.imports = processedOp.imports.map(imp => this.processTemplate(imp, context));
+                }
+                if (processedOp.code) {
+                    processedOp.code = this.processTemplate(processedOp.code, context);
+                }
+                if (processedOp.after) {
+                    processedOp.after = this.processTemplate(processedOp.after, context);
+                }
+                if (processedOp.before) {
+                    processedOp.before = this.processTemplate(processedOp.before, context);
+                }
+                if (processedOp.replace) {
+                    processedOp.replace = this.processTemplate(processedOp.replace, context);
+                }
+                if (processedOp.content) {
+                    processedOp.content = this.processTemplate(processedOp.content, context);
+                }
+                return processedOp;
+            });
+        }
+        return processed;
+    }
+    async executeCreateFile(operation, context, outputPath) {
+        if (!operation.destination)
+            return;
+        const destinationPath = path.join(outputPath, this.processTemplate(operation.destination, context));
+        // Ensure directory exists
+        await fs.ensureDir(path.dirname(destinationPath));
+        let content;
+        if (operation.content) {
+            // Use content directly
+            content = this.processTemplate(operation.content, context);
+        }
+        else if (operation.source) {
+            // Find the source file path relative to the module/template directory
+            const modulesPath = path.join(__dirname, '..', '..', 'modules');
+            const templatesPath = path.join(__dirname, '..', '..', '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
+                content = this.processTemplate(content, context);
+            }
+            else {
+                throw new Error(`Source file not found: ${sourcePath}`);
+            }
+        }
+        else {
+            throw new Error(`Create file operation must have either 'content' or 'source' field`);
+        }
+        // Write destination file
+        await fs.writeFile(destinationPath, content, 'utf-8');
+    }
+    async executePatchFile(operation, context, outputPath) {
+        if (!operation.file || !operation.operations)
+            return;
+        const filePath = path.join(outputPath, this.processTemplate(operation.file, context));
+        // Read existing file
+        let content = await fs.readFile(filePath, 'utf-8');
+        // Execute patch operations
+        for (const patchOp of operation.operations) {
+            if (!this.evaluateCondition(patchOp.condition, context))
+                continue;
+            switch (patchOp.type) {
+                case 'add-import':
+                    if (patchOp.imports) {
+                        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');
+                        let insertIndex = 0;
+                        for (let i = 0; i < lines.length; i++) {
+                            if (lines[i].trim().startsWith('import') || lines[i].trim() === '') {
+                                insertIndex = i + 1;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        lines.splice(insertIndex, 0, imports);
+                        content = lines.join('\n');
+                    }
+                    break;
+                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);
+                        }
+                    }
+                    break;
+                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':
+                    if (patchOp.content) {
+                        const processedContent = this.processTemplate(patchOp.content, context);
+                        content = processedContent + '\n' + content;
+                    }
+                    break;
+                case 'add-to-bottom':
+                    if (patchOp.content) {
+                        const processedContent = this.processTemplate(patchOp.content, context);
+                        content = content + '\n' + processedContent;
+                    }
+                    break;
+            }
+        }
+        // Write back the modified content
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+    async executeAddDependency(operation, context, outputPath) {
+        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 };
+        }
+        if (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');
+        let packageJson = {};
+        if (await fs.pathExists(packageJsonPath)) {
+            packageJson = await fs.readJson(packageJsonPath);
+        }
+        if (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 = '';
+        if (await fs.pathExists(envPath)) {
+            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');
+        }
+        await fs.writeFile(envPath, envContent.trim(), 'utf-8');
+    }
+    executeRunCommand(operation, context) {
+        if (operation.command) {
+            // Process template variables in the command
+            const processedCommand = this.processTemplate(operation.command, context);
+            this.postInstallCommands.push(processedCommand);
+        }
+    }
+    async generatePackageJson(selectedModules, features, outputPath) {
+        const packageJsonPath = path.join(outputPath, 'package.json');
+        let packageJson = {};
+        if (await fs.pathExists(packageJsonPath)) {
+            packageJson = await fs.readJson(packageJsonPath);
+        }
+        // Collect dependencies from selected generators
+        const allDeps = {};
+        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)) {
+                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 };
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    getAvailableGenerators() {
+        const frameworks = [];
+        const databases = [];
+        const auths = [];
+        for (const [key] of this.generators) {
+            const [type, name] = key.split(':');
+            switch (type) {
+                case 'framework':
+                    frameworks.push(name);
+                    break;
+                case 'database':
+                    databases.push(name);
+                    break;
+                case 'auth':
+                    auths.push(name);
+                    break;
+            }
+        }
+        return { frameworks, databases, auths };
+    }
+}
+exports.AdvancedCodeGenerator = AdvancedCodeGenerator;