stackkit 0.1.9 → 0.2.1

package/dist/cli/list.js

@@ -7,6 +7,8 @@ exports.listCommand = listCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+const module_discovery_1 = require("../lib/discovery/module-discovery");
+const shared_1 = require("../lib/discovery/shared");
 const logger_1 = require("../lib/ui/logger");
 const package_root_1 = require("../lib/utils/package-root");
 async function listCommand(options) {
@@ -34,6 +36,14 @@ async function listCommand(options) {
         if (showModules) {
             const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules");
             const modules = await getAvailableModules(modulesDir);
+            // Discover modules to derive provider lists dynamically
+            let discovered;
+            try {
+                discovered = await (0, module_discovery_1.discoverModules)(path_1.default.join((0, package_root_1.getPackageRoot)(), "modules"));
+            }
+            catch {
+                discovered = { frameworks: [], databases: [], auth: [] };
+            }
             if (modules.length > 0) {
                 hasModules = true;
                 logger_1.logger.log(chalk_1.default.bold.magenta("MODULES"));
@@ -68,7 +78,33 @@ async function listCommand(options) {
                                 : isLastMod
                                     ? "│       └──"
                                     : "│       ├──";
-                            logger_1.logger.log(`  ${chalk_1.default.gray(providerPrefix)} ${chalk_1.default.dim("Providers: PostgreSQL, MongoDB, MySQL, SQLite")}`);
+                            // Compute provider names from discovered database choices
+                            const choices = (0, module_discovery_1.getDatabaseChoices)(discovered.databases || [], "nextjs");
+                            const prismaProviders = choices
+                                .filter((c) => c.value.startsWith("prisma-"))
+                                .map((c) => {
+                                const m = c.name.match(/\(([^)]+)\)/);
+                                return m ? m[1] : c.name;
+                            });
+                            const providersText = prismaProviders.length > 0
+                                ? prismaProviders.join(", ")
+                                : (() => {
+                                    const detected = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)()).map((p) => {
+                                        if (p === "postgresql")
+                                            return "PostgreSQL";
+                                        if (p === "mongodb")
+                                            return "MongoDB";
+                                        if (p === "mysql")
+                                            return "MySQL";
+                                        if (p === "sqlite")
+                                            return "SQLite";
+                                        return p;
+                                    });
+                                    return detected.length > 0
+                                        ? detected.join(", ")
+                                        : "PostgreSQL, MongoDB, MySQL, SQLite";
+                                })();
+                            logger_1.logger.log(`  ${chalk_1.default.gray(providerPrefix)} ${chalk_1.default.dim(`Providers: ${providersText}`)}`);
                         }
                     });
                 });

package/dist/index.js

@@ -1,15 +1,113 @@
 #!/usr/bin/env node
 "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 });
 const commander_1 = require("commander");
-const create_1 = require("./cli/create");
+const fs = __importStar(require("fs"));
+const fs_1 = require("fs");
+const path_1 = require("path");
 const add_1 = require("./cli/add");
+const create_1 = require("./cli/create");
 const doctor_1 = require("./cli/doctor");
 const list_1 = require("./cli/list");
+const shared_1 = require("./lib/discovery/shared");
 const logger_1 = require("./lib/ui/logger");
-const fs_1 = require("fs");
-const path_1 = require("path");
+const package_root_1 = require("./lib/utils/package-root");
 const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, "../package.json"), "utf-8"));
+function buildOptionHints() {
+    try {
+        const pkgRoot = (0, package_root_1.getPackageRoot)();
+        const modulesDir = (0, path_1.join)(pkgRoot, "modules");
+        const dbs = [];
+        const auths = [];
+        if (fs.existsSync((0, path_1.join)(modulesDir, "database"))) {
+            for (const d of fs.readdirSync((0, path_1.join)(modulesDir, "database"))) {
+                const moduleJson = (0, path_1.join)(modulesDir, "database", d, "module.json");
+                if (fs.existsSync(moduleJson)) {
+                    try {
+                        const m = JSON.parse((0, fs_1.readFileSync)(moduleJson, "utf-8"));
+                        if (m && m.name === "prisma") {
+                            try {
+                                const providers = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
+                                if (providers.length > 0) {
+                                    for (const p of providers)
+                                        dbs.push(`prisma-${p}`);
+                                }
+                                else {
+                                    dbs.push("prisma");
+                                }
+                            }
+                            catch {
+                                dbs.push("prisma");
+                            }
+                        }
+                        else if (m && m.name) {
+                            dbs.push(m.name);
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+        if (fs.existsSync((0, path_1.join)(modulesDir, "auth"))) {
+            for (const a of fs.readdirSync((0, path_1.join)(modulesDir, "auth"))) {
+                const moduleJson = (0, path_1.join)(modulesDir, "auth", a, "module.json");
+                if (fs.existsSync(moduleJson)) {
+                    try {
+                        const m = JSON.parse((0, fs_1.readFileSync)(moduleJson, "utf-8"));
+                        if (m && m.name)
+                            auths.push(m.name);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+        return {
+            databaseHint: dbs.length > 0 ? dbs.join(", ") : "prisma, mongoose, none",
+            authHint: auths.length > 0 ? auths.join(", ") : "better-auth, authjs, none",
+        };
+    }
+    catch {
+        return { databaseHint: "prisma, mongoose, none", authHint: "better-auth, authjs, none" };
+    }
+}
+const hints = buildOptionHints();
 const program = new commander_1.Command();
 program
     .name("stackkit")
@@ -37,9 +135,9 @@ program
     .description("Create a new StackKit project")
     .usage("[project-name] [options]")
     .option("-f, --framework <framework>", "Framework: nextjs, express, react")
-    .option("-d, --database <database>", "Database: prisma, mongoose, none")
-    .option("--prisma-provider <provider>", "Prisma provider: postgresql, mongodb, mysql, sqlite")
-    .option("-a, --auth <auth>", "Auth: better-auth, authjs, none")
+    .option("-d, --database <database>", `Database: ${hints.databaseHint}`)
+    .option("--prisma-provider <provider>", "Prisma provider")
+    .option("-a, --auth <auth>", `Auth: ${hints.authHint}`)
     .option("-l, --language <language>", "Language: typescript, javascript")
     .option("-p, --package-manager <pm>", "Package manager: pnpm, npm, yarn, bun")
     .option("--skip-install", "Skip dependency installation")

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

@@ -38,13 +38,6 @@ export declare function getValidDatabaseOptions(databases: ModuleMetadata[]): st
  * 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
  */

package/dist/lib/discovery/module-discovery.js

@@ -6,12 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.discoverModules = discoverModules;
 exports.getValidDatabaseOptions = getValidDatabaseOptions;
 exports.getValidAuthOptions = getValidAuthOptions;
-exports.parseDatabaseOption = parseDatabaseOption;
 exports.getCompatibleAuthOptions = getCompatibleAuthOptions;
 exports.getDatabaseChoices = getDatabaseChoices;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const package_root_1 = require("../utils/package-root");
+const shared_1 = require("./shared");
 /**
  * Discover all available modules from the modules directory
  */
@@ -119,11 +119,17 @@ function getValidDatabaseOptions(databases) {
     const options = ["none"];
     for (const db of databases) {
         if (db.name === "prisma") {
-            // For Prisma, add provider-specific options
-            options.push("prisma-postgresql", "prisma-mongodb", "prisma-mysql", "prisma-sqlite");
+            const providers = (0, shared_1.getPrismaProvidersFromGenerator)();
+            if (providers.length > 0) {
+                for (const p of providers)
+                    options.push(`prisma-${p}`);
+            }
+            else {
+                options.push("prisma");
+            }
         }
         else if (db.name === "mongoose") {
-            options.push("mongoose", "mongoose");
+            options.push("mongoose");
         }
         else {
             // For other databases, add the name directly
@@ -142,22 +148,7 @@ function getValidAuthOptions(authModules) {
     }
     return options;
 }
-/**
- * Parse database option into database name and provider
- */
-function parseDatabaseOption(dbOption) {
-    if (dbOption === "none") {
-        return { database: "none" };
-    }
-    if (dbOption.startsWith("prisma-")) {
-        const provider = dbOption.split("-")[1];
-        return { database: "prisma", provider };
-    }
-    if (dbOption === "mongoose" || dbOption === "mongoose") {
-        return { database: "mongoose" };
-    }
-    return { database: dbOption };
-}
+// parseDatabaseOption moved to shared helpers
 /**
  * Get compatible auth options for given framework and database
  */
@@ -168,11 +159,13 @@ function getCompatibleAuthOptions(authModules, framework, database) {
         if (auth.supportedFrameworks && !auth.supportedFrameworks.includes(framework)) {
             continue;
         }
+        // Normalize database option (handle prisma-<provider> values)
+        const parsedDb = (0, shared_1.parseDatabaseOption)(database || "").database;
         // Special compatibility rules
-        if (auth.name === "authjs" && (database !== "prisma" || framework !== "nextjs")) {
+        if (auth.name === "authjs" && (parsedDb !== "prisma" || framework !== "nextjs")) {
             continue;
         }
-        if (auth.name === "better-auth" && database === "none" && framework !== "react") {
+        if (auth.name === "better-auth" && parsedDb === "none" && framework !== "react") {
             continue;
         }
         compatible.push({
@@ -195,7 +188,17 @@ function getDatabaseChoices(databases, framework) {
             continue;
         }
         if (db.name === "prisma") {
-            choices.push({ name: "Prisma (PostgreSQL)", value: "prisma-postgresql" }, { name: "Prisma (MongoDB)", value: "prisma-mongodb" }, { name: "Prisma (MySQL)", value: "prisma-mysql" }, { name: "Prisma (SQLite)", value: "prisma-sqlite" });
+            const providers = (0, shared_1.getPrismaProvidersFromGenerator)();
+            if (providers.length > 0) {
+                for (const p of providers)
+                    choices.push({
+                        name: `Prisma (${p.charAt(0).toUpperCase() + p.slice(1)})`,
+                        value: `prisma-${p}`,
+                    });
+            }
+            else {
+                choices.push({ name: "Prisma", value: "prisma" });
+            }
         }
         else if (db.name === "mongoose") {
             choices.push({ name: "Mongoose", value: "mongoose" });

package/dist/lib/discovery/shared.d.ts

@@ -0,0 +1,6 @@
+export declare function parseDatabaseOption(dbOption: string): {
+    database: string;
+    provider?: string;
+};
+export declare function getPrismaProvidersFromGenerator(modulesDir?: string): string[];
+export declare function isPrismaOption(value: string): boolean;

package/dist/lib/discovery/shared.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDatabaseOption = parseDatabaseOption;
+exports.getPrismaProvidersFromGenerator = getPrismaProvidersFromGenerator;
+exports.isPrismaOption = isPrismaOption;
+const path_1 = __importDefault(require("path"));
+const package_root_1 = require("../utils/package-root");
+function parseDatabaseOption(dbOption) {
+    if (!dbOption)
+        return { database: "none" };
+    if (dbOption === "none")
+        return { database: "none" };
+    if (dbOption.startsWith("prisma-")) {
+        const provider = dbOption.split("-")[1];
+        return { database: "prisma", provider };
+    }
+    if (dbOption === "prisma")
+        return { database: "prisma" };
+    if (dbOption === "mongoose")
+        return { database: "mongoose" };
+    return { database: dbOption };
+}
+function getPrismaProvidersFromGenerator(modulesDir) {
+    const pkgRoot = modulesDir || (0, package_root_1.getPackageRoot)();
+    const genPath = path_1.default.join(pkgRoot, "modules", "database", "prisma", "generator.json");
+    try {
+        const gen = require(genPath);
+        const providers = new Set();
+        if (Array.isArray(gen.operations)) {
+            for (const op of gen.operations) {
+                if (op.condition && op.condition.prismaProvider)
+                    providers.add(String(op.condition.prismaProvider));
+            }
+        }
+        return Array.from(providers);
+    }
+    catch {
+        return [];
+    }
+}
+function isPrismaOption(value) {
+    if (!value)
+        return false;
+    if (value === "prisma")
+        return true;
+    return value.startsWith("prisma-");
+}

package/dist/lib/framework/framework-utils.js

@@ -45,15 +45,55 @@ class FrameworkUtils {
             this.frameworkConfigs.set(frameworkName, config);
             return config;
         }
-        // Default config if no template.json exists
+        // Derive compatibility dynamically from available modules if possible
         const defaultConfig = {
             name: frameworkName,
             displayName: frameworkName.charAt(0).toUpperCase() + frameworkName.slice(1),
             compatibility: {
-                databases: ["prisma", "mongoose"],
-                auth: ["better-auth", "authjs"],
+                databases: [],
+                auth: [],
             },
         };
+        try {
+            const modulesDir = path.join(templatesDir, "..", "modules");
+            const dbDir = path.join(modulesDir, "database");
+            const authDir = path.join(modulesDir, "auth");
+            if (await fs.pathExists(dbDir)) {
+                const dbs = await fs.readdir(dbDir);
+                for (const d of dbs) {
+                    const moduleJson = path.join(dbDir, d, "module.json");
+                    if (await fs.pathExists(moduleJson)) {
+                        try {
+                            const m = await fs.readJson(moduleJson);
+                            if (m && m.name)
+                                defaultConfig.compatibility.databases.push(m.name);
+                        }
+                        catch {
+                            // ignore malformed
+                        }
+                    }
+                }
+            }
+            if (await fs.pathExists(authDir)) {
+                const auths = await fs.readdir(authDir);
+                for (const a of auths) {
+                    const moduleJson = path.join(authDir, a, "module.json");
+                    if (await fs.pathExists(moduleJson)) {
+                        try {
+                            const m = await fs.readJson(moduleJson);
+                            if (m && m.name)
+                                defaultConfig.compatibility.auth.push(m.name);
+                        }
+                        catch {
+                            // ignore malformed
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore discovery errors and leave empty lists
+        }
         this.frameworkConfigs.set(frameworkName, defaultConfig);
         return defaultConfig;
     }

package/dist/lib/pm/package-manager.js

@@ -20,41 +20,32 @@ async function detectPackageManager(cwd) {
     }
 }
 async function installDependencies(cwd, pm) {
-    const args = [];
-    if (pm === "npm") {
-        args.push("install");
-    }
-    else if (pm === "yarn") {
-        args.push("install");
-    }
-    else if (pm === "pnpm") {
-        args.push("install");
-    }
-    else if (pm === "bun") {
-        args.push("install");
-    }
-    await (0, execa_1.default)(pm, args, { cwd, stdio: "pipe" });
+    const args = ["install"];
+    const stdio = "pipe";
+    await (0, execa_1.default)(pm, args, { cwd, stdio });
 }
 async function addDependencies(cwd, pm, packages, dev = false) {
     if (packages.length === 0)
         return;
     const spinner = logger_1.logger.startSpinner(`Adding ${dev ? "dev " : ""}dependencies: ${packages.join(", ")}...`);
     try {
-        const args = [];
-        if (pm === "npm") {
-            args.push("install", dev ? "--save-dev" : "--save", ...packages);
+        const stdio = "pipe";
+        let args = [];
+        switch (pm) {
+            case "npm":
+                args = ["install", ...(dev ? ["--save-dev"] : []), ...packages];
+                break;
+            case "yarn":
+                args = ["add", ...(dev ? ["--dev"] : []), ...packages];
+                break;
+            case "pnpm":
+                args = ["add", ...(dev ? ["-D"] : []), ...packages];
+                break;
+            case "bun":
+                args = ["add", ...(dev ? ["-d"] : []), ...packages];
+                break;
         }
-        else if (pm === "yarn") {
-            args.push("add", dev ? "--dev" : "", ...packages);
-        }
-        else if (pm === "pnpm") {
-            args.push("add", dev ? "-D" : "", ...packages);
-        }
-        else if (pm === "bun") {
-            // bun uses `bun add` and `-d` for dev dependencies
-            args.push("add", ...(dev ? ["-d"] : []), ...packages);
-        }
-        await (0, execa_1.default)(pm, args.filter(Boolean), { cwd, stdio: "pipe" });
+        await (0, execa_1.default)(pm, args, { cwd, stdio });
         spinner.succeed(`Dependencies added successfully`);
     }
     catch (error) {
@@ -63,7 +54,43 @@ async function addDependencies(cwd, pm, packages, dev = false) {
     }
 }
 async function initGit(cwd) {
-    await (0, execa_1.default)("git", ["init"], { cwd });
-    await (0, execa_1.default)("git", ["add", "."], { cwd });
-    await (0, execa_1.default)("git", ["commit", "-m", "Initial commit from StackKit"], { cwd });
+    const spinner = logger_1.logger.startSpinner("Initializing git repository...");
+    const run = async (stdio) => {
+        await (0, execa_1.default)("git", ["init"], { cwd, stdio });
+        await (0, execa_1.default)("git", ["add", "."], { cwd, stdio });
+        await (0, execa_1.default)("git", ["commit", "-m", "Initial commit from StackKit"], { cwd, stdio });
+    };
+    try {
+        await run("pipe");
+        spinner.succeed("Git repository initialized");
+        return;
+    }
+    catch (error) {
+        const err = error;
+        spinner.fail(`Git init failed: ${err.message}`);
+        const isENOBUFS = (e) => {
+            if (!e || typeof e !== "object")
+                return false;
+            const obj = e;
+            return (obj.code === "ENOBUFS" ||
+                obj.errno === "ENOBUFS" ||
+                String(obj.message ?? "").includes("ENOBUFS"));
+        };
+        if (isENOBUFS(err)) {
+            logger_1.logger.warn("ENOBUFS detected; skipping git initialization.");
+            logger_1.logger.info("Skipped git initialization due to system resource limits.");
+            return;
+        }
+        try {
+            await run("inherit");
+            spinner.succeed("Git repository initialized (fallback)");
+            return;
+        }
+        catch (fallbackErr) {
+            const fe = fallbackErr;
+            logger_1.logger.warn(`Git init fallback failed: ${fe.message}`);
+            spinner.fail("Git initialization skipped");
+            return;
+        }
+    }
 }

package/modules/auth/authjs/generator.json

@@ -16,7 +16,7 @@
     {
       "type": "create-file",
       "destination": "proxy.ts",
-      "content": "export { auth as middleware } from \"@/lib/auth\""
+      "content": "export { auth as proxy } from \"@/lib/auth\""
     },
     {
       "type": "patch-file",

package/modules/auth/better-auth/files/lib/auth.ts

@@ -30,7 +30,9 @@ return betterAuth({
   database: mongodbAdapter(db, { client }),
 {{/case}}
 {{/switch}}
-  secret: env.BETTER_AUTH_SECRET,
+  baseURL: process.env.BETTER_AUTH_URL,
+  secret: process.env.BETTER_AUTH_SECRET,
+  trustedOrigins: [process.env.APP_URL],
   user: {
     additionalFields: {
       role: {
@@ -84,9 +86,11 @@ return betterAuth({
   session: {
     cookieCache: {
       enabled: true,
+      maxAge: 60 * 60 * 24 * 7,
     },
     expiresIn: 60 * 60 * 24 * 7,
     updateAge: 60 * 60 * 24,
+    cookieName: "better-auth.session_token",
   }
  })
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackkit",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Production-ready CLI to create and extend JavaScript or TypeScript apps with modular stacks.",
   "main": "dist/index.js",
   "bin": {

package/templates/express/README.md

@@ -0,0 +1,43 @@
+# Express Template
+
+Production-ready Express (TypeScript) starter for building REST APIs and backend services.
+
+## Requirements
+
+- Node.js 18+ (LTS recommended)
+- pnpm or npm
+
+## Quick Start
+
+Install dependencies and start the development server:
+
+```bash
+# using pnpm (recommended)
+pnpm install
+pnpm dev
+
+# or using npm
+npm install
+npm run dev
+```
+
+## Scripts
+
+- `npm run dev` - Start development server
+- `npm run build` - Build TypeScript
+- `npm start` - Start production server
+
+## Environment
+
+Use a `.env` file or environment variables for configuration. See `.env.example` for available keys.
+
+---
+
+## Generated with StackKit
+
+This project was scaffolded using **StackKit** — a CLI toolkit for building production-ready applications.
+
+- Generated via: `npx stackkit@latest create`
+
+Learn more about StackKit:
+https://github.com/tariqul420/stackkit

package/templates/express/template.json

@@ -7,7 +7,15 @@
     "databases": ["prisma", "mongoose"],
     "auth": ["better-auth"]
   },
-  "files": ["src/", ".gitignore", "package.json", "tsconfig.json", ".env.example"],
+  "files": [
+    "src/",
+    ".env.example",
+    ".gitignore",
+    "eslint.config.cjs",
+    "package.json",
+    "README.md",
+    "tsconfig.json"
+  ],
   "scripts": {
     "dev": "tsx watch src/server.ts",
     "build": "tsc",

package/templates/nextjs/.env.example

@@ -0,0 +1 @@
+NEXT_PUBLIC_APP_URL=http://localhost:3000