create-stackkit-app 0.4.4 → 0.4.6

package/dist/lib/create-project.js

@@ -8,30 +8,108 @@ const chalk_1 = __importDefault(require("chalk"));
 const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
-const ora_1 = __importDefault(require("ora"));
 const path_1 = __importDefault(require("path"));
 const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
-const file_utils_1 = require("./utils/file-utils");
 const git_utils_1 = require("./utils/git-utils");
 const js_conversion_1 = require("./utils/js-conversion");
-const module_utils_1 = require("./utils/module-utils");
+const logger_1 = require("./utils/logger");
+const code_generator_1 = require("./code-generator");
+const framework_utils_1 = require("./framework-utils");
 const package_utils_1 = require("./utils/package-utils");
-async function createProject(projectName) {
-    // eslint-disable-next-line no-console
-    console.log(chalk_1.default.bold.cyan("\n Create StackKit App\n"));
-    const config = await getProjectConfig(projectName);
+const module_discovery_1 = require("./utils/module-discovery");
+async function createProject(projectName, options) {
+    logger_1.logger.newLine();
+    logger_1.logger.log(chalk_1.default.bold.cyan("Create StackKit App"));
+    logger_1.logger.newLine();
+    const config = await getProjectConfig(projectName, options);
     const targetDir = path_1.default.join(process.cwd(), config.projectName);
     if (await fs_extra_1.default.pathExists(targetDir)) {
-        // eslint-disable-next-line no-console
-        console.log(chalk_1.default.red(`\n✖ Directory "${config.projectName}" already exists`));
-        // eslint-disable-next-line no-console
-        console.log(chalk_1.default.gray("Please choose a different name or remove the existing directory.\n"));
+        logger_1.logger.error(`Directory "${config.projectName}" already exists`);
+        logger_1.logger.log(chalk_1.default.gray("Please choose a different name or remove the existing directory.\n"));
         process.exit(1);
     }
-    await generateProject(config, targetDir);
+    await generateProject(config, targetDir, options);
     showNextSteps(config);
 }
-async function getProjectConfig(projectName) {
+async function getProjectConfig(projectName, options) {
+    // Discover available modules
+    const modulesDir = path_1.default.join(__dirname, "..", "..", "modules");
+    const discoveredModules = await (0, module_discovery_1.discoverModules)(modulesDir);
+    if (options && Object.keys(options).length > 0) {
+        if (options.yes || options.y) {
+            return {
+                projectName: projectName || "my-app",
+                framework: "nextjs",
+                database: "prisma",
+                prismaProvider: "postgresql",
+                auth: "better-auth",
+                language: "typescript",
+                packageManager: "pnpm",
+            };
+        }
+        // Validate options using discovered modules
+        const validFrameworks = discoveredModules.frameworks.map(f => f.name);
+        const framework = options.framework || options.f;
+        if (framework && !validFrameworks.includes(framework)) {
+            throw new Error(`Invalid framework: ${framework}. Valid options: ${validFrameworks.join(', ')}`);
+        }
+        const validDatabases = (0, module_discovery_1.getValidDatabaseOptions)(discoveredModules.databases);
+        // Also allow base database names like 'prisma', 'mongoose'
+        const validBaseDatabases = discoveredModules.databases.map(db => db.name);
+        const allValidDatabases = [...validDatabases, ...validBaseDatabases];
+        const db = options.database || options.d;
+        if (db && !allValidDatabases.includes(db)) {
+            throw new Error(`Invalid database: ${db}. Valid options: ${allValidDatabases.filter((v, i, arr) => arr.indexOf(v) === i).join(', ')}`);
+        }
+        const validAuth = (0, module_discovery_1.getValidAuthOptions)(discoveredModules.auth);
+        const authOpt = options.auth || options.a;
+        if (authOpt && !validAuth.includes(authOpt)) {
+            throw new Error(`Invalid auth: ${authOpt}. Valid options: ${validAuth.join(', ')}`);
+        }
+        const validLanguages = ['typescript', 'javascript'];
+        const language = options.language || options.l;
+        if (language && !validLanguages.includes(language)) {
+            throw new Error(`Invalid language: ${language}. Valid options: ${validLanguages.join(', ')}`);
+        }
+        const validPackageManagers = ['pnpm', 'npm', 'yarn', 'bun'];
+        const pm = options.packageManager || options.p;
+        if (pm && !validPackageManagers.includes(pm)) {
+            throw new Error(`Invalid package manager: ${pm}. Valid options: ${validPackageManagers.join(', ')}`);
+        }
+        let database = "none";
+        let prismaProvider;
+        if (db && db !== "none") {
+            const parsed = (0, module_discovery_1.parseDatabaseOption)(db);
+            database = parsed.database;
+            prismaProvider = parsed.provider;
+        }
+        let auth = "none";
+        if (authOpt && authOpt !== "none") {
+            auth = authOpt;
+        }
+        const finalFramework = (framework || "nextjs");
+        if (finalFramework === "react-vite") {
+            database = "none";
+            prismaProvider = undefined;
+        }
+        // Validate auth compatibility
+        if (auth === "authjs" && (database !== "prisma" || finalFramework !== "nextjs")) {
+            throw new Error("Auth.js is only supported with Next.js and Prisma database");
+        }
+        if (auth === "better-auth" && database === "none" && finalFramework !== "react-vite") {
+            throw new Error("Better Auth requires a database for server frameworks");
+        }
+        return {
+            projectName: projectName || "my-app",
+            framework: finalFramework,
+            database,
+            prismaProvider,
+            auth,
+            language: (language || "typescript"),
+            packageManager: (pm || "pnpm"),
+        };
+    }
+    // Use discovered modules for interactive prompts
     const answers = (await inquirer_1.default.prompt([
         {
             type: "input",
@@ -54,26 +132,21 @@ async function getProjectConfig(projectName) {
             type: "list",
             name: "framework",
             message: "Select framework:",
-            choices: [
-                { name: "Next.js", value: "nextjs" },
-                { name: "Express.js", value: "express" },
-                { name: "React (Vite)", value: "react-vite" },
-            ],
+            choices: discoveredModules.frameworks.map(f => ({
+                name: f.displayName,
+                value: f.name
+            })),
         },
         {
             type: "list",
             name: "database",
             message: "Select database/ORM:",
             when: (answers) => answers.framework !== "react-vite",
-            choices: [
-                { name: "Prisma", value: "prisma" },
-                { name: "Mongoose + MongoDB", value: "mongoose-mongodb" },
-                { name: "None", value: "none" },
-            ],
+            choices: (answers) => (0, module_discovery_1.getDatabaseChoices)(discoveredModules.databases, answers.framework),
         },
         {
             type: "list",
-            name: "dbProvider",
+            name: "prismaProvider",
             message: "Select database provider for Prisma:",
             when: (answers) => answers.database === "prisma",
             choices: [
@@ -87,34 +160,8 @@ async function getProjectConfig(projectName) {
             type: "list",
             name: "auth",
             message: "Select authentication:",
-            when: (answers) => answers.database !== "none" || answers.framework === "react-vite",
-            choices: (answers) => {
-                if (answers.framework === "react-vite") {
-                    return [
-                        { name: "Better Auth", value: "better-auth" },
-                        { name: "Clerk", value: "clerk" },
-                        { name: "None", value: "none" },
-                    ];
-                }
-                // Next.js apps
-                if (answers.framework === "nextjs") {
-                    return [
-                        { name: "Better Auth", value: "better-auth" },
-                        { name: "Clerk", value: "clerk" },
-                        { name: "None", value: "none" },
-                    ];
-                }
-                // Express apps
-                if (answers.framework === "express") {
-                    return [
-                        { name: "Better Auth", value: "better-auth" },
-                        { name: "Clerk", value: "clerk" },
-                        { name: "None", value: "none" },
-                    ];
-                }
-                // Default - no auth
-                return [{ name: "None", value: "none" }];
-            },
+            when: (answers) => (answers.database !== "none" || answers.framework === "react-vite"),
+            choices: (answers) => (0, module_discovery_1.getCompatibleAuthOptions)(discoveredModules.auth, answers.framework, answers.database || "none"),
         },
         {
             type: "list",
@@ -139,20 +186,21 @@ async function getProjectConfig(projectName) {
             default: "pnpm",
         },
     ]));
+    const parsedDb = answers.database ? (0, module_discovery_1.parseDatabaseOption)(answers.database) : { database: 'none' };
     return {
         projectName: (projectName || answers.projectName),
         framework: answers.framework,
         database: (answers.framework === "react-vite"
             ? "none"
-            : answers.database),
-        dbProvider: answers.dbProvider,
-        auth: answers.auth || "none",
+            : parsedDb.database),
+        prismaProvider: answers.prismaProvider || parsedDb.provider,
+        auth: (answers.auth || "none"),
         language: answers.language,
         packageManager: answers.packageManager,
     };
 }
-async function generateProject(config, targetDir) {
-    const copySpinner = (0, ora_1.default)("Creating project files...").start();
+async function generateProject(config, targetDir, options) {
+    const copySpinner = logger_1.logger.startSpinner("Creating project files...");
     let postInstallCommands = [];
     try {
         postInstallCommands = await composeTemplate(config, targetDir);
@@ -163,18 +211,20 @@ async function generateProject(config, targetDir) {
         throw error;
     }
     // Install dependencies
-    const installSpinner = (0, ora_1.default)("Installing dependencies...").start();
-    try {
-        await (0, package_utils_1.installDependencies)(targetDir, config.packageManager);
-        installSpinner.succeed("Dependencies installed");
-    }
-    catch (error) {
-        installSpinner.fail("Failed to install dependencies");
-        throw error;
+    if (options?.install !== false && !options?.['skip-install']) {
+        const installSpinner = logger_1.logger.startSpinner("Installing dependencies...");
+        try {
+            await (0, package_utils_1.installDependencies)(targetDir, config.packageManager);
+            installSpinner.succeed("Dependencies installed");
+        }
+        catch (error) {
+            installSpinner.fail("Failed to install dependencies");
+            throw error;
+        }
     }
     // Run post-install commands
     if (postInstallCommands.length > 0) {
-        const postInstallSpinner = (0, ora_1.default)("Running post-install commands...").start();
+        const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
         try {
             for (const command of postInstallCommands) {
                 (0, child_process_1.execSync)(command, { cwd: targetDir, stdio: "pipe" });
@@ -187,19 +237,41 @@ async function generateProject(config, targetDir) {
         }
     }
     // Initialize git
-    const gitSpinner = (0, ora_1.default)("Initializing git repository...").start();
-    try {
-        await (0, git_utils_1.initGit)(targetDir);
-        gitSpinner.succeed("Git repository initialized");
-    }
-    catch {
-        gitSpinner.warn("Failed to initialize git repository");
+    if (options?.git !== false && !options?.['no-git']) {
+        const gitSpinner = logger_1.logger.startSpinner("Initializing git repository...");
+        try {
+            await (0, git_utils_1.initGit)(targetDir);
+            gitSpinner.succeed("Git repository initialized");
+        }
+        catch {
+            gitSpinner.warn("Failed to initialize git repository");
+        }
     }
 }
 async function composeTemplate(config, targetDir) {
     const templatesDir = path_1.default.join(__dirname, "..", "..", "templates");
+    const modulesDir = path_1.default.join(__dirname, "..", "..", "modules");
     await fs_extra_1.default.ensureDir(targetDir);
-    await (0, file_utils_1.copyBaseFramework)(templatesDir, targetDir, config.framework);
+    // Load framework configuration
+    const frameworkConfig = await framework_utils_1.FrameworkUtils.loadFrameworkConfig(config.framework, templatesDir);
+    // Initialize advanced code generator
+    const generator = new code_generator_1.AdvancedCodeGenerator(frameworkConfig);
+    await generator.loadGenerators(modulesDir);
+    // Generate project using advanced code generator
+    const features = [];
+    const postInstallCommands = await generator.generate({
+        framework: config.framework,
+        database: config.database === 'none' ? undefined : config.database,
+        auth: config.auth === 'none' ? undefined : config.auth,
+        prismaProvider: config.prismaProvider,
+    }, features, targetDir);
+    // Update project name in package.json
+    const packageJsonPath = path_1.default.join(targetDir, "package.json");
+    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+        packageJson.name = config.projectName;
+        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
     // Ensure .env exists: if .env.example was copied from the template, create .env from it
     try {
         const envExamplePath = path_1.default.join(targetDir, ".env.example");
@@ -212,32 +284,18 @@ async function composeTemplate(config, targetDir) {
     catch {
         // non-fatal
     }
-    const postInstallCommands = [];
-    if (config.database !== "none") {
-        const dbPostInstall = await (0, module_utils_1.mergeDatabaseConfig)(templatesDir, targetDir, config.database, config.framework, config.dbProvider);
-        postInstallCommands.push(...dbPostInstall);
-    }
-    if (config.auth !== "none") {
-        await (0, module_utils_1.mergeAuthConfig)(templatesDir, targetDir, config.framework, config.auth, config.database, config.dbProvider);
-    }
-    const packageJsonPath = path_1.default.join(targetDir, "package.json");
-    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
-        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
-        packageJson.name = config.projectName;
-        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-    }
     if (config.language === "javascript") {
         await (0, js_conversion_1.convertToJavaScript)(targetDir, config.framework);
     }
+    // For now, return empty array as post-install commands are handled by the generator
     return postInstallCommands;
 }
 function showNextSteps(config) {
-    // eslint-disable-next-line no-console
-    console.log(chalk_1.default.green.bold(`\n✓ Created ${config.projectName}\n`));
-    // eslint-disable-next-line no-console
-    console.log(chalk_1.default.bold("Next steps:"));
-    // eslint-disable-next-line no-console
-    console.log(chalk_1.default.cyan(`  cd ${config.projectName}`));
-    // eslint-disable-next-line no-console
-    console.log(chalk_1.default.cyan(`  ${config.packageManager} run dev\n`));
+    logger_1.logger.newLine();
+    logger_1.logger.success(`Created ${config.projectName}`);
+    logger_1.logger.newLine();
+    logger_1.logger.log("Next steps:");
+    logger_1.logger.log(`  cd ${config.projectName}`);
+    logger_1.logger.log(`  ${config.packageManager} run dev`);
+    logger_1.logger.newLine();
 }

package/dist/lib/framework-utils.d.ts

@@ -0,0 +1,22 @@
+export interface FrameworkConfig {
+    name: string;
+    displayName: string;
+    compatibility: {
+        databases: string[];
+        auth: string[];
+    };
+}
+export interface ModuleConfig {
+    name: string;
+    displayName: string;
+    type: 'database' | 'auth';
+    compatibility?: {
+        frameworks?: string[];
+        databases?: string[];
+    };
+}
+export declare class FrameworkUtils {
+    private static frameworkConfigs;
+    static loadFrameworkConfig(frameworkName: string, templatesDir: string): Promise<FrameworkConfig>;
+    static isCompatible(framework: string, database?: string, auth?: string): boolean;
+}

package/dist/lib/framework-utils.js

@@ -0,0 +1,74 @@
+"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.FrameworkUtils = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class FrameworkUtils {
+    static async loadFrameworkConfig(frameworkName, templatesDir) {
+        const configPath = path.join(templatesDir, frameworkName, 'template.json');
+        if (await fs.pathExists(configPath)) {
+            const config = await fs.readJson(configPath);
+            this.frameworkConfigs.set(frameworkName, config);
+            return config;
+        }
+        // Default config if no template.json exists
+        const defaultConfig = {
+            name: frameworkName,
+            displayName: frameworkName.charAt(0).toUpperCase() + frameworkName.slice(1),
+            compatibility: {
+                databases: ['prisma', 'mongoose'],
+                auth: ['better-auth', 'authjs'],
+            },
+        };
+        this.frameworkConfigs.set(frameworkName, defaultConfig);
+        return defaultConfig;
+    }
+    static isCompatible(framework, database, auth) {
+        const config = this.frameworkConfigs.get(framework);
+        if (!config)
+            return true; // Assume compatible if no config
+        if (database && !config.compatibility.databases.includes(database)) {
+            return false;
+        }
+        if (auth && !config.compatibility.auth.includes(auth)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.FrameworkUtils = FrameworkUtils;
+FrameworkUtils.frameworkConfigs = new Map();

package/dist/lib/utils/logger.d.ts

@@ -0,0 +1,16 @@
+import { Ora } from "ora";
+export declare class Logger {
+    private spinner;
+    info(message: string): void;
+    success(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    log(message: string): void;
+    newLine(): void;
+    startSpinner(text: string): Ora;
+    stopSpinner(success?: boolean, text?: string): void;
+    updateSpinner(text: string): void;
+    header(text: string): void;
+    footer(): void;
+}
+export declare const logger: Logger;

package/dist/lib/utils/logger.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+class Logger {
+    constructor() {
+        this.spinner = null;
+    }
+    info(message) {
+        process.stdout.write(chalk_1.default.blue("ℹ") + " " + message + "\n");
+    }
+    success(message) {
+        process.stdout.write(chalk_1.default.green("✔") + " " + message + "\n");
+    }
+    error(message) {
+        process.stderr.write(chalk_1.default.red("✖") + " " + message + "\n");
+    }
+    warn(message) {
+        process.stdout.write(chalk_1.default.yellow("⚠") + " " + message + "\n");
+    }
+    log(message) {
+        process.stdout.write(message + "\n");
+    }
+    newLine() {
+        process.stdout.write("\n");
+    }
+    startSpinner(text) {
+        this.spinner = (0, ora_1.default)(text).start();
+        return this.spinner;
+    }
+    stopSpinner(success = true, text) {
+        if (this.spinner) {
+            if (success) {
+                this.spinner.succeed(text);
+            }
+            else {
+                this.spinner.fail(text);
+            }
+            this.spinner = null;
+        }
+    }
+    updateSpinner(text) {
+        if (this.spinner) {
+            this.spinner.text = text;
+        }
+    }
+    header(text) {
+        process.stdout.write(chalk_1.default.bold.cyan(text) + "\n");
+    }
+    footer() {
+        process.stdout.write("\n");
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();

package/dist/lib/utils/module-discovery.d.ts

@@ -0,0 +1,62 @@
+export interface ModuleMetadata {
+    name: string;
+    displayName: string;
+    description: string;
+    category: string;
+    provider?: string;
+    supportedFrameworks?: string[];
+    databaseAdapters?: Record<string, unknown>;
+    frameworkConfigs?: Record<string, unknown>;
+    dependencies?: Record<string, unknown>;
+    devDependencies?: Record<string, unknown>;
+    envVars?: Record<string, unknown>;
+    patches?: unknown[];
+    postInstall?: string[];
+    compatibility?: {
+        databases?: string[];
+        auth?: string[];
+        languages?: string[];
+    };
+    framework?: string;
+    files?: string[];
+    scripts?: Record<string, string>;
+    jsScripts?: Record<string, string>;
+}
+export interface DiscoveredModules {
+    frameworks: ModuleMetadata[];
+    databases: ModuleMetadata[];
+    auth: ModuleMetadata[];
+}
+/**
+ * Discover all available modules from the modules directory
+ */
+export declare function discoverModules(modulesDir: string): Promise<DiscoveredModules>;
+/**
+ * Get valid database options for CLI
+ */
+export declare function getValidDatabaseOptions(databases: ModuleMetadata[]): string[];
+/**
+ * Get valid auth options for CLI
+ */
+export declare function getValidAuthOptions(authModules: ModuleMetadata[]): string[];
+/**
+ * Parse database option into database name and provider
+ */
+export declare function parseDatabaseOption(dbOption: string): {
+    database: string;
+    provider?: string;
+};
+/**
+ * Get compatible auth options for given framework and database
+ */
+export declare function getCompatibleAuthOptions(authModules: ModuleMetadata[], framework: string, database: string): Array<{
+    name: string;
+    value: string;
+}>;
+/**
+ * Get database choices for inquirer prompts
+ */
+export declare function getDatabaseChoices(databases: ModuleMetadata[], framework: string): Array<{
+    name: string;
+    value: string;
+}>;