stackkit 0.1.2 → 0.1.4

package/README.md

@@ -19,6 +19,8 @@ npx stackkit create my-app
 ## Add Features to Existing Project
 
 ```bash
+npx stackkit add
+# or non-interactive
 npx stackkit add auth
 npx stackkit add database
 ```
@@ -32,10 +34,10 @@ npx stackkit doctor
 ## Supported Technologies
 
 - **Frameworks**: Next.js, React, Express
-- **Databases**: Prisma (PostgreSQL, MySQL, SQLite), Mongoose (MongoDB)
+- **Databases**: Prisma (PostgreSQL, MongoDB, MySQL, SQLite), Mongoose (MongoDB)
 - **Auth**: Better Auth, Auth.js
 
 ## Documentation
 
-- [StackKit Docs](https://stack-kit.com)[https://stackkit.tariqul.dev]
+- [StackKit Docs](https://stackkit.tariqul.dev)
 - [GitHub Repository](https://github.com/tariqul420/stackkit)

package/dist/cli/add.d.ts

@@ -3,6 +3,7 @@ interface AddOptions {
     force?: boolean;
     dryRun?: boolean;
     install?: boolean;
+    yes?: boolean;
 }
-export declare function addCommand(module: string, options: AddOptions): Promise<void>;
+export declare function addCommand(module?: string, options?: AddOptions): Promise<void>;
 export {};

package/dist/cli/add.js

@@ -9,24 +9,95 @@ const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const path_1 = __importDefault(require("path"));
+const code_generator_1 = require("../lib/generation/code-generator");
 const detect_1 = require("../lib/project/detect");
 const env_editor_1 = require("../lib/env/env-editor");
 const files_1 = require("../lib/fs/files");
 const logger_1 = require("../lib/ui/logger");
 const package_manager_1 = require("../lib/pm/package-manager");
-const database_config_1 = require("../lib/database/database-config");
+const package_root_1 = require("../lib/utils/package-root");
+const framework_utils_1 = require("../lib/framework/framework-utils");
+const generator_utils_1 = require("../lib/generation/generator-utils");
 async function addCommand(module, options) {
     try {
         const projectRoot = process.cwd();
         const spinner = logger_1.logger.startSpinner("Detecting project...");
         const projectInfo = await (0, detect_1.detectProjectInfo)(projectRoot);
         spinner.succeed(`Detected ${projectInfo.framework} (${projectInfo.router} router, ${projectInfo.language})`);
-        const moduleMetadata = await loadModuleMetadata(path_1.default.join(__dirname, "..", "..", "..", "modules"), module, options.provider);
+        const config = await getAddConfig(module, options, projectInfo);
+        await addModuleToProject(projectRoot, projectInfo, config, options);
+        logger_1.logger.newLine();
+        logger_1.logger.success(`Added ${chalk_1.default.bold(config.displayName)}`);
+        logger_1.logger.newLine();
+        if (config.metadata.envVars && config.metadata.envVars.length > 0) {
+            logger_1.logger.log("Next: Fill in environment variables in .env");
+        }
+        logger_1.logger.newLine();
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to add module: ${error.message}`);
+        if (error instanceof Error && error.stack) {
+            logger_1.logger.log(chalk_1.default.gray(error.stack));
+        }
+        process.exit(1);
+    }
+}
+async function getAddConfig(module, options, projectInfo) {
+    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), 'modules');
+    const argv = process.argv.slice(2);
+    const addIndex = argv.indexOf('add');
+    const argsAfterAdd = addIndex >= 0 ? argv.slice(addIndex + 1) : [];
+    const flagsProvided = argsAfterAdd.some(arg => arg.startsWith('-'));
+    const optionsProvided = flagsProvided || !!(options && (options.yes || options.provider || options.force || options.dryRun));
+    if (optionsProvided) {
+        if (!module) {
+            throw new Error("Module name is required when using flags");
+        }
+        if (module === "database" || module === "auth") {
+            if (module === "database") {
+                if (!options?.provider) {
+                    throw new Error("Provider is required for database. Use --provider <provider>");
+                }
+                let baseProvider = options.provider;
+                let adapterProvider = options.provider;
+                if (options.provider.includes('-')) {
+                    const parts = options.provider.split('-');
+                    baseProvider = parts[0]; // e.g., "prisma"
+                    adapterProvider = options.provider; // e.g., "prisma-postgresql"
+                }
+                const moduleMetadata = await loadModuleMetadata(modulesDir, baseProvider, baseProvider);
+                if (!moduleMetadata) {
+                    throw new Error(`Database provider "${baseProvider}" not found`);
+                }
+                return {
+                    module: "database",
+                    provider: adapterProvider,
+                    displayName: `${moduleMetadata.displayName} (${adapterProvider.split('-')[1] || adapterProvider})`,
+                    metadata: moduleMetadata,
+                };
+            }
+            else if (module === "auth") {
+                const provider = options?.provider || "better-auth";
+                const moduleMetadata = await loadModuleMetadata(modulesDir, provider, provider);
+                if (!moduleMetadata) {
+                    throw new Error(`Auth provider "${provider}" not found`);
+                }
+                return {
+                    module: "auth",
+                    provider,
+                    displayName: moduleMetadata.displayName,
+                    metadata: moduleMetadata,
+                };
+            }
+        }
+        const moduleMetadata = await loadModuleMetadata(modulesDir, module, options?.provider);
         if (!moduleMetadata) {
-            logger_1.logger.error(`Module "${module}" not found`);
-            process.exit(1);
+            throw new Error(`Module "${module}" not found`);
+        }
+        let selectedProvider = options?.provider;
+        if (!selectedProvider && moduleMetadata.category !== module) {
+            selectedProvider = module;
         }
-        let selectedProvider = options.provider;
         if (moduleMetadata.category === "database" && !selectedProvider) {
             if (typeof moduleMetadata.dependencies === "object" && "providers" in moduleMetadata.dependencies) {
                 const providers = Object.keys(moduleMetadata.dependencies.providers || {});
@@ -43,111 +114,272 @@ async function addCommand(module, options) {
                 }
             }
         }
-        const mergedDeps = {};
-        const mergedDevDeps = {};
-        if (moduleMetadata.frameworkConfigs?.shared?.dependencies) {
-            Object.assign(mergedDeps, moduleMetadata.frameworkConfigs.shared.dependencies);
+        if (projectInfo && !moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
+            throw new Error(`Module "${module}" does not support ${projectInfo.framework}. Supported: ${moduleMetadata.supportedFrameworks.join(", ")}`);
         }
-        if (moduleMetadata.frameworkConfigs?.shared?.devDependencies) {
-            Object.assign(mergedDevDeps, moduleMetadata.frameworkConfigs.shared.devDependencies);
+        return {
+            module,
+            provider: selectedProvider,
+            displayName: moduleMetadata.displayName,
+            metadata: moduleMetadata,
+        };
+    }
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "category",
+            message: "What would you like to add?",
+            choices: [
+                { name: "Database", value: "database" },
+                { name: "Authentication", value: "auth" },
+            ],
+        },
+    ]);
+    const category = answers.category;
+    if (category === "database") {
+        const dbAnswers = await inquirer_1.default.prompt([
+            {
+                type: "list",
+                name: "database",
+                message: "Select database:",
+                choices: [
+                    { name: "Prisma", value: "prisma" },
+                    { name: "Mongoose", value: "mongoose" },
+                ],
+            },
+        ]);
+        const selectedDb = dbAnswers.database;
+        if (selectedDb === "prisma") {
+            const providerAnswers = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "provider",
+                    message: "Select Prisma provider:",
+                    choices: [
+                        { name: "PostgreSQL", value: "postgresql" },
+                        { name: "MongoDB", value: "mongodb" },
+                        { name: "MySQL", value: "mysql" },
+                        { name: "SQLite", value: "sqlite" },
+                    ],
+                },
+            ]);
+            return {
+                module: "database",
+                provider: "prisma",
+                displayName: `Prisma (${providerAnswers.provider})`,
+                metadata: await loadModuleMetadata(modulesDir, "prisma", "prisma"),
+            };
         }
-        if (selectedProvider && moduleMetadata.databaseAdapters?.providers?.[selectedProvider]?.dependencies) {
-            Object.assign(mergedDeps, moduleMetadata.databaseAdapters.providers[selectedProvider].dependencies);
+        else {
+            return {
+                module: "database",
+                provider: "mongoose",
+                displayName: "Mongoose",
+                metadata: await loadModuleMetadata(modulesDir, "mongoose", "mongoose"),
+            };
         }
-        if (selectedProvider && moduleMetadata.databaseAdapters?.providers?.[selectedProvider]?.devDependencies) {
-            Object.assign(mergedDevDeps, moduleMetadata.databaseAdapters.providers[selectedProvider].devDependencies);
+    }
+    else if (category === "auth") {
+        const authAnswers = await inquirer_1.default.prompt([
+            {
+                type: "list",
+                name: "auth",
+                message: "Select authentication:",
+                choices: [
+                    { name: "Better Auth", value: "better-auth" },
+                    { name: "Auth.js", value: "authjs" },
+                ],
+            },
+        ]);
+        const selectedAuth = authAnswers.auth;
+        const metadata = await loadModuleMetadata(modulesDir, selectedAuth, selectedAuth);
+        if (!metadata) {
+            throw new Error(`Auth provider "${selectedAuth}" not found`);
         }
-        moduleMetadata.dependencies = mergedDeps;
-        moduleMetadata.devDependencies = mergedDevDeps;
-        const variables = {};
-        if (selectedProvider) {
-            variables.provider = selectedProvider;
-            variables.connectionString = database_config_1.DATABASE_CONNECTION_STRINGS[selectedProvider] || "";
+        if (projectInfo && !metadata.supportedFrameworks.includes(projectInfo.framework)) {
+            throw new Error(`Auth provider "${selectedAuth}" does not support ${projectInfo.framework}`);
         }
-        if (!moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
-            logger_1.logger.error(`Module "${module}" does not support ${projectInfo.framework}. Supported: ${moduleMetadata.supportedFrameworks.join(", ")}`);
-            process.exit(1);
+        return {
+            module: "auth",
+            provider: selectedAuth,
+            displayName: selectedAuth === "better-auth" ? "Better Auth" : "Auth.js",
+            metadata,
+        };
+    }
+    throw new Error("Invalid selection");
+}
+async function addModuleToProject(projectRoot, projectInfo, config, options) {
+    const moduleMetadata = config.metadata;
+    const selectedProvider = config.provider;
+    if (config.module === "auth" && projectInfo.hasAuth && !options?.force) {
+        logger_1.logger.warn("Auth library already detected in this project");
+        const { proceed } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "proceed",
+                message: "Continue anyway? (use --force to skip this prompt)",
+                default: false,
+            },
+        ]);
+        if (!proceed) {
+            logger_1.logger.info("Cancelled");
+            return;
         }
-        if (module === "auth" && projectInfo.hasAuth && !options.force) {
-            logger_1.logger.warn("Auth library already detected in this project");
-            const { proceed } = await inquirer_1.default.prompt([
-                {
-                    type: "confirm",
-                    name: "proceed",
-                    message: "Continue anyway? (use --force to skip this prompt)",
-                    default: false,
-                },
-            ]);
-            if (!proceed) {
-                logger_1.logger.info("Cancelled");
-                process.exit(0);
+    }
+    if (options?.dryRun) {
+        logger_1.logger.warn("Dry run mode - no changes will be made");
+        logger_1.logger.newLine();
+    }
+    const moduleBasePath = await findModulePath(path_1.default.join((0, package_root_1.getPackageRoot)(), 'modules'), config.module, config.provider);
+    if (moduleBasePath) {
+        const frameworkConfig = await framework_utils_1.FrameworkUtils.loadFrameworkConfig(projectInfo.framework, path_1.default.join((0, package_root_1.getPackageRoot)(), 'templates'));
+        const gen = new code_generator_1.AdvancedCodeGenerator(frameworkConfig);
+        await gen.loadGenerators(path_1.default.join((0, package_root_1.getPackageRoot)(), 'modules'));
+        const moduleName = path_1.default.basename(moduleBasePath);
+        const available = gen.getAvailableGenerators();
+        const alreadyRegistered = (config.module === 'database' && available.databases.includes(moduleName)) || (config.module === 'auth' && available.auths.includes(moduleName));
+        if (!alreadyRegistered) {
+            const ops = [];
+            if (Array.isArray(moduleMetadata.patches)) {
+                for (const p of moduleMetadata.patches) {
+                    if (p.type === 'create-file') {
+                        ops.push({ type: 'create-file', source: p.source, destination: p.destination, condition: p.condition });
+                    }
+                }
+            }
+            if (ops.length > 0) {
+                gen.registerGenerator(config.module, moduleName, {
+                    name: moduleName,
+                    type: config.module,
+                    priority: 0,
+                    operations: ops,
+                    dependencies: {},
+                });
             }
         }
-        if (options.dryRun) {
-            logger_1.logger.warn("Dry run mode - no changes will be made");
-            logger_1.logger.newLine();
+        const selectedModules = { framework: projectInfo.framework };
+        if (config.module === 'database' && config.provider) {
+            if (config.provider.startsWith('prisma-')) {
+                selectedModules.database = 'prisma';
+                selectedModules.prismaProvider = config.provider.split('-')[1];
+            }
+            else {
+                selectedModules.database = config.provider;
+            }
         }
-        await applyModulePatches(projectRoot, projectInfo, moduleMetadata, path_1.default.join(__dirname, "..", "..", "modules"), module, options);
-        if (moduleMetadata.frameworkPatches && !options.dryRun) {
-            await applyFrameworkPatches(projectRoot, moduleMetadata.frameworkPatches, projectInfo.framework);
+        if (config.module === 'auth' && config.provider) {
+            selectedModules.auth = config.provider;
         }
-        if (moduleMetadata.postInstall && moduleMetadata.postInstall.length > 0 && !options.dryRun) {
-            const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
+        const postInstall = await gen.applyToProject(selectedModules, [], projectRoot);
+        if (postInstall && postInstall.length > 0 && !options?.dryRun) {
+            const postInstallSpinner = logger_1.logger.startSpinner('Running post-install commands...');
             try {
-                for (const command of moduleMetadata.postInstall) {
-                    (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: "pipe" });
+                for (const command of postInstall) {
+                    (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: 'pipe' });
                 }
-                postInstallSpinner.succeed("Post-install commands completed");
+                postInstallSpinner.succeed('Post-install commands completed');
             }
             catch (error) {
-                postInstallSpinner.fail("Failed to run post-install commands");
+                postInstallSpinner.fail('Failed to run post-install commands');
                 throw error;
             }
         }
-        if (Object.keys(mergedDeps).length > 0 && options.install !== false) {
-            const deps = Object.entries(mergedDeps).map(([name, version]) => `${name}@${version}`);
-            if (!options.dryRun) {
-                await (0, package_manager_1.addDependencies)(projectRoot, projectInfo.packageManager, deps, false);
+        if (!options?.dryRun && options?.install !== false) {
+            const installSpinner = logger_1.logger.startSpinner('Installing dependencies...');
+            try {
+                await (0, package_manager_1.installDependencies)(projectRoot, projectInfo.packageManager);
+                installSpinner.succeed('Dependencies installed');
             }
-            else {
-                logger_1.logger.info(`Would add dependencies: ${deps.join(", ")}`);
+            catch (err) {
+                installSpinner.fail('Failed to install dependencies');
+                throw err;
             }
         }
-        if (Object.keys(mergedDevDeps).length > 0 && options.install !== false) {
-            const devDeps = Object.entries(mergedDevDeps).map(([name, version]) => `${name}@${version}`);
-            if (!options.dryRun) {
-                await (0, package_manager_1.addDependencies)(projectRoot, projectInfo.packageManager, devDeps, true);
-            }
-            else {
-                logger_1.logger.info(`Would add dev dependencies: ${devDeps.join(", ")}`);
-            }
+        return;
+    }
+    const mergedDeps = {};
+    const mergedDevDeps = {};
+    if (moduleMetadata.frameworkConfigs?.shared?.dependencies) {
+        Object.assign(mergedDeps, moduleMetadata.frameworkConfigs.shared.dependencies);
+    }
+    if (moduleMetadata.frameworkConfigs?.shared?.devDependencies) {
+        Object.assign(mergedDevDeps, moduleMetadata.frameworkConfigs.shared.devDependencies);
+    }
+    // Adapter-specific dependencies are applied via generator metadata; frameworkConfigs still merge above.
+    // Do not mutate the loaded module metadata here; use mergedDeps/mergedDevDeps for installation.
+    const variables = {};
+    if (selectedProvider) {
+        variables.provider = selectedProvider;
+    }
+    if (moduleMetadata.envVars) {
+        const envArray = Array.isArray(moduleMetadata.envVars)
+            ? moduleMetadata.envVars
+            : Object.entries(moduleMetadata.envVars).map(([k, v]) => ({ key: k, value: String(v) }));
+        for (const ev of envArray) {
+            if (ev.key && typeof ev.value === 'string')
+                variables[ev.key] = ev.value;
         }
-        if (moduleMetadata.envVars && moduleMetadata.envVars.length > 0) {
-            const processedEnvVars = moduleMetadata.envVars.map((envVar) => ({
-                ...envVar,
-                value: envVar.value?.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match),
-            }));
-            if (!options.dryRun) {
-                await (0, env_editor_1.addEnvVariables)(projectRoot, processedEnvVars, { force: options.force });
+        for (let pass = 0; pass < 5; pass++) {
+            let changed = false;
+            for (const ev of envArray) {
+                if (!ev.key || typeof ev.value !== 'string')
+                    continue;
+                const resolved = ev.value.replace(/\{\{(\w+)\}\}/g, (_m, k) => variables[k] ?? _m);
+                if (variables[ev.key] !== resolved) {
+                    variables[ev.key] = resolved;
+                    changed = true;
+                }
             }
-            else {
-                logger_1.logger.log(`  ${chalk_1.default.dim("~")} .env.example`);
+            if (!changed)
+                break;
+        }
+    }
+    await applyModulePatches(projectRoot, projectInfo, moduleMetadata, path_1.default.join((0, package_root_1.getPackageRoot)(), "modules"), config.module, options || {});
+    if (moduleMetadata.frameworkPatches && !options?.dryRun) {
+        await applyFrameworkPatches(projectRoot, moduleMetadata.frameworkPatches, projectInfo.framework);
+    }
+    if (moduleMetadata.postInstall && moduleMetadata.postInstall.length > 0 && !options?.dryRun) {
+        const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
+        try {
+            for (const command of moduleMetadata.postInstall) {
+                (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: "pipe" });
             }
+            postInstallSpinner.succeed("Post-install commands completed");
         }
-        logger_1.logger.newLine();
-        logger_1.logger.success(`Added ${chalk_1.default.bold(moduleMetadata.displayName)}`);
-        logger_1.logger.newLine();
-        if (moduleMetadata.envVars && moduleMetadata.envVars.some((v) => v.required)) {
-            logger_1.logger.log("Next: Fill in environment variables in .env");
+        catch (error) {
+            postInstallSpinner.fail("Failed to run post-install commands");
+            throw error;
         }
-        logger_1.logger.newLine();
     }
-    catch (error) {
-        logger_1.logger.error(`Failed to add module: ${error.message}`);
-        if (error instanceof Error && error.stack) {
-            logger_1.logger.log(chalk_1.default.gray(error.stack));
+    if (Object.keys(mergedDeps).length > 0 && options?.install !== false) {
+        const deps = Object.entries(mergedDeps).map(([name, version]) => `${name}@${version}`);
+        if (!options?.dryRun) {
+            await (0, package_manager_1.addDependencies)(projectRoot, projectInfo.packageManager, deps, false);
+        }
+        else {
+            logger_1.logger.info(`Would add dependencies: ${deps.join(", ")}`);
+        }
+    }
+    if (Object.keys(mergedDevDeps).length > 0 && options?.install !== false) {
+        const devDeps = Object.entries(mergedDevDeps).map(([name, version]) => `${name}@${version}`);
+        if (!options?.dryRun) {
+            await (0, package_manager_1.addDependencies)(projectRoot, projectInfo.packageManager, devDeps, true);
+        }
+        else {
+            logger_1.logger.info(`Would add dev dependencies: ${devDeps.join(", ")}`);
+        }
+    }
+    if (moduleMetadata.envVars && moduleMetadata.envVars.length > 0) {
+        const processedEnvVars = moduleMetadata.envVars.map((envVar) => ({
+            ...envVar,
+            value: envVar.value?.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match),
+        }));
+        if (!options?.dryRun) {
+            await (0, env_editor_1.addEnvVariables)(projectRoot, processedEnvVars, { force: options?.force });
+        }
+        else {
+            logger_1.logger.log(`  ${chalk_1.default.dim("~")} .env.example`);
         }
-        process.exit(1);
     }
 }
 async function loadModuleMetadata(modulesDir, moduleName, provider) {
@@ -170,40 +402,16 @@ async function loadModuleMetadata(modulesDir, moduleName, provider) {
             if (await fs_extra_1.default.pathExists(metadataPath)) {
                 const metadata = await fs_extra_1.default.readJSON(metadataPath);
                 if (provider && moduleDir === provider) {
-                    return await loadGeneratorAndMerge(metadata, modulePath);
+                    return await (0, generator_utils_1.mergeGeneratorIntoModuleMetadata)(metadata, modulePath);
                 }
-                if (!provider && metadata.category === moduleName) {
-                    return await loadGeneratorAndMerge(metadata, modulePath);
+                if (!provider && (metadata.category === moduleName || moduleDir === moduleName)) {
+                    return await (0, generator_utils_1.mergeGeneratorIntoModuleMetadata)(metadata, modulePath);
                 }
             }
         }
     }
     return null;
 }
-async function loadGeneratorAndMerge(metadata, modulePath) {
-    const generatorPath = path_1.default.join(modulePath, "generator.json");
-    if (await fs_extra_1.default.pathExists(generatorPath)) {
-        const generator = await fs_extra_1.default.readJSON(generatorPath);
-        // Merge envVars, dependencies, etc.
-        if (generator.envVars) {
-            metadata.envVars = metadata.envVars || [];
-            for (const [key, value] of Object.entries(generator.envVars)) {
-                metadata.envVars.push({ key, value: value, description: `Environment variable for ${key}`, required: true });
-            }
-        }
-        if (generator.dependencies) {
-            metadata.dependencies = { ...metadata.dependencies, ...generator.dependencies };
-        }
-        if (generator.devDependencies) {
-            metadata.devDependencies = { ...metadata.devDependencies, ...generator.devDependencies };
-        }
-        if (generator.scripts) {
-            // Perhaps add to metadata, but currently not used
-        }
-        // For operations, perhaps add to patches or something, but for now, keep manual
-    }
-    return metadata;
-}
 async function applyModulePatches(projectRoot, projectInfo, moduleMetadata, modulesDir, moduleName, options) {
     if (!moduleMetadata.patches || !Array.isArray(moduleMetadata.patches)) {
         return;