create-stackkit-app 0.4.4 → 0.4.5

package/README.md

@@ -12,7 +12,7 @@ Interactive wizard helps you choose:
 
 - **Framework**: Next.js, Express, or React + Vite
 - **Database**: Prisma (PostgreSQL/MongoDB), Mongoose (MongoDB)
-- **Authentication**: Better Auth, Clerk
+- **Authentication**: Better Auth, Auth.js
 - **Package manager**: pnpm, npm, or yarn
 
 ## Quick Start

package/dist/index.js

@@ -2,15 +2,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const create_project_1 = require("./lib/create-project");
+const logger_1 = require("./lib/utils/logger");
+function parseArgs(args) {
+    const options = {};
+    let projectName;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            showHelp();
+            process.exit(0);
+        }
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            if (args[i + 1] && !args[i + 1].startsWith('--')) {
+                options[key] = args[i + 1];
+                i++;
+            }
+            else {
+                options[key] = true;
+            }
+        }
+        else if (arg.startsWith('-') && arg.length === 2) {
+            const key = arg.slice(1);
+            if (args[i + 1] && !args[i + 1].startsWith('-')) {
+                options[key] = args[i + 1];
+                i++;
+            }
+            else {
+                options[key] = true;
+            }
+        }
+        else if (!projectName) {
+            projectName = arg;
+        }
+    }
+    return { projectName, options };
+}
+function showHelp() {
+    logger_1.logger.log(`
+Create StackKit App
+
+Usage:
+  create-stackkit-app [project-name] [options]
+
+Options:
+  -f, --framework <framework>    Framework: nextjs, express, react-vite
+  -d, --database <database>      Database: prisma-postgresql, prisma-mongodb, prisma-mysql, prisma-sqlite, mongoose-mongodb, 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
+  --skip-install                 Skip dependency installation
+  --no-git                       Skip git initialization
+  -y, --yes                      Use default options
+  -h, --help                     Show this help
+
+Examples:
+  create-stackkit-app my-app --framework nextjs --database prisma-postgresql --auth better-auth
+  create-stackkit-app --help
+`);
+}
 async function main() {
     const args = process.argv.slice(2);
-    const projectName = args[0];
+    const { projectName, options } = parseArgs(args);
     try {
-        await (0, create_project_1.createProject)(projectName);
+        await (0, create_project_1.createProject)(projectName, options);
     }
     catch (error) {
-        // eslint-disable-next-line no-console
-        console.error("Error:", error.message);
+        logger_1.logger.error(`Error: ${error.message}`);
         process.exit(1);
     }
 }

package/dist/lib/create-project.d.ts

@@ -1 +1,20 @@
-export declare function createProject(projectName?: string): Promise<void>;
+interface CliOptions {
+    framework?: string;
+    f?: string;
+    database?: string;
+    d?: string;
+    auth?: string;
+    a?: string;
+    language?: string;
+    l?: string;
+    packageManager?: string;
+    p?: string;
+    install?: boolean;
+    'skip-install'?: boolean;
+    git?: boolean;
+    'no-git'?: boolean;
+    yes?: boolean;
+    y?: boolean;
+}
+export declare function createProject(projectName?: string, options?: CliOptions): Promise<void>;
+export {};

package/dist/lib/create-project.js

@@ -8,30 +8,111 @@ 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 logger_1 = require("./utils/logger");
 const module_utils_1 = require("./utils/module-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);
+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) {
+    if (options && Object.keys(options).length > 0) {
+        if (options.yes || options.y) {
+            return {
+                projectName: projectName || "my-app",
+                framework: "nextjs",
+                database: "prisma",
+                dbProvider: "postgresql",
+                auth: "better-auth",
+                language: "typescript",
+                packageManager: "pnpm",
+            };
+        }
+        // Validate options
+        const validFrameworks = ['nextjs', 'express', 'react-vite'];
+        const framework = options.framework || options.f;
+        if (framework && !validFrameworks.includes(framework)) {
+            throw new Error(`Invalid framework: ${framework}. Valid options: ${validFrameworks.join(', ')}`);
+        }
+        const validDatabases = ['prisma-postgresql', 'prisma-mongodb', 'prisma-mysql', 'prisma-sqlite', 'mongoose-mongodb', 'none'];
+        const db = options.database || options.d;
+        if (db && !validDatabases.includes(db)) {
+            throw new Error(`Invalid database: ${db}. Valid options: ${validDatabases.join(', ')}`);
+        }
+        const validAuth = ['better-auth', 'authjs', 'none'];
+        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 dbProvider;
+        if (db && db !== "none") {
+            if (db.startsWith("prisma-")) {
+                database = "prisma";
+                const provider = db.split("-")[1];
+                if (!["postgresql", "mongodb", "mysql", "sqlite"].includes(provider)) {
+                    throw new Error(`Invalid Prisma provider: ${provider}`);
+                }
+                dbProvider = provider;
+            }
+            else if (db === "mongoose-mongodb") {
+                database = "mongoose";
+            }
+            else {
+                throw new Error(`Unsupported database: ${db}`);
+            }
+        }
+        let auth = "none";
+        if (authOpt && authOpt !== "none") {
+            auth = authOpt;
+        }
+        const finalFramework = (framework || "nextjs");
+        if (finalFramework === "react-vite") {
+            database = "none";
+            dbProvider = 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,
+            dbProvider,
+            auth,
+            language: (language || "typescript"),
+            packageManager: (pm || "pnpm"),
+        };
+    }
     const answers = (await inquirer_1.default.prompt([
         {
             type: "input",
@@ -67,7 +148,7 @@ async function getProjectConfig(projectName) {
             when: (answers) => answers.framework !== "react-vite",
             choices: [
                 { name: "Prisma", value: "prisma" },
-                { name: "Mongoose + MongoDB", value: "mongoose-mongodb" },
+                { name: "Mongoose (MongoDB)", value: "mongoose" },
                 { name: "None", value: "none" },
             ],
         },
@@ -87,32 +168,33 @@ async function getProjectConfig(projectName) {
             type: "list",
             name: "auth",
             message: "Select authentication:",
-            when: (answers) => answers.database !== "none" || answers.framework === "react-vite",
+            when: (answers) => (answers.database !== "none" || answers.framework === "react-vite") && answers.database !== "mongoose",
             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") {
+                if (answers.database === "mongoose") {
+                    return [
+                        { name: "Better Auth", value: "better-auth" },
+                        { name: "None", value: "none" },
+                    ];
+                }
+                if (answers.framework === "nextjs" && answers.database === "prisma") {
                     return [
                         { name: "Better Auth", value: "better-auth" },
-                        { name: "Clerk", value: "clerk" },
+                        { name: "Auth.js", value: "authjs" },
                         { name: "None", value: "none" },
                     ];
                 }
-                // Express apps
-                if (answers.framework === "express") {
+                if (answers.framework === "express" && answers.database === "prisma") {
                     return [
                         { name: "Better Auth", value: "better-auth" },
-                        { name: "Clerk", value: "clerk" },
                         { name: "None", value: "none" },
                     ];
                 }
-                // Default - no auth
                 return [{ name: "None", value: "none" }];
             },
         },
@@ -146,13 +228,13 @@ async function getProjectConfig(projectName) {
             ? "none"
             : answers.database),
         dbProvider: answers.dbProvider,
-        auth: answers.auth || "none",
+        auth: answers.database === "mongoose" ? "better-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 +245,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,13 +271,15 @@ 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) {
@@ -232,12 +318,11 @@ async function composeTemplate(config, targetDir) {
     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/utils/config-utils.js

@@ -23,11 +23,66 @@ async function applyFrameworkPatches(targetDir, patches) {
     for (const [filename, patchConfig] of Object.entries(patches)) {
         const filePath = (0, path_1.join)(targetDir, filename);
         if (await fs_extra_1.default.pathExists(filePath)) {
-            const fileContent = await fs_extra_1.default.readJson(filePath);
             if (patchConfig && typeof patchConfig === "object" && "merge" in patchConfig) {
+                const fileContent = await fs_extra_1.default.readJson(filePath);
                 const merged = deepMerge(fileContent, patchConfig.merge);
                 await fs_extra_1.default.writeJson(filePath, merged, { spaces: 2 });
             }
+            else if (patchConfig && typeof patchConfig === "object" && "replace" in patchConfig) {
+                let fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+                const replaceConfig = patchConfig;
+                for (const [oldStr, newStr] of Object.entries(replaceConfig.replace)) {
+                    fileContent = fileContent.replace(new RegExp(oldStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newStr);
+                }
+                await fs_extra_1.default.writeFile(filePath, fileContent);
+            }
+            else if (patchConfig &&
+                typeof patchConfig === "object" &&
+                ("operations" in patchConfig ||
+                    ("type" in patchConfig && patchConfig.type === "patch-file"))) {
+                let fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+                const operations = patchConfig.operations;
+                for (const operation of operations) {
+                    if (operation && typeof operation === "object" && "type" in operation) {
+                        const op = operation;
+                        if (op.type === "add-import" && "imports" in op && Array.isArray(op.imports)) {
+                            const imports = op.imports;
+                            // Add imports at the top after existing imports
+                            const importLines = imports.join("\n");
+                            // Find the last import statement
+                            const lines = fileContent.split("\n");
+                            let lastImportIndex = -1;
+                            for (let i = 0; i < lines.length; i++) {
+                                if (lines[i].trim().startsWith("import")) {
+                                    lastImportIndex = i;
+                                }
+                                else if (lines[i].trim() !== "" && !lines[i].trim().startsWith("//")) {
+                                    break;
+                                }
+                            }
+                            if (lastImportIndex >= 0) {
+                                lines.splice(lastImportIndex + 1, 0, "", importLines);
+                                fileContent = lines.join("\n");
+                            }
+                        }
+                        else if (op.type === "add-code" && "after" in op && "code" in op) {
+                            const after = op.after;
+                            const code = op.code;
+                            const afterIndex = fileContent.indexOf(after);
+                            if (afterIndex >= 0) {
+                                const insertPos = afterIndex + after.length;
+                                fileContent = fileContent.slice(0, insertPos) + code + fileContent.slice(insertPos);
+                            }
+                        }
+                        else if (op.type === "replace" && "oldString" in op && "newString" in op) {
+                            const oldString = op.oldString;
+                            const newString = op.newString;
+                            fileContent = fileContent.replace(oldString, newString);
+                        }
+                    }
+                }
+                await fs_extra_1.default.writeFile(filePath, fileContent);
+            }
         }
     }
 }

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();