stackkit-cli 0.4.4 → 0.4.5

package/dist/utils/module-utils.js

@@ -0,0 +1,461 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDatabaseConfig = mergeDatabaseConfig;
+exports.mergeAuthConfig = mergeAuthConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importStar(require("path"));
+const config_utils_1 = require("./config-utils");
+const files_1 = require("./files");
+const logger_1 = require("./logger");
+/**
+ * Process environment variables with variable replacement
+ */
+function processEnvVars(envVarList, variables) {
+    const envVars = {};
+    for (const envVar of envVarList) {
+        let value = envVar.value;
+        for (const [key, val] of Object.entries(variables)) {
+            value = value.replace(new RegExp(`{{${key}}}`, "g"), val);
+        }
+        envVars[envVar.key] = value;
+    }
+    return envVars;
+}
+/**
+ * Get framework-specific paths for file placement
+ */
+function getFrameworkPaths(framework) {
+    switch (framework) {
+        case "nextjs":
+            return { lib: "lib", router: "app", models: "lib/models" };
+        case "express":
+            return { lib: "lib", router: "src", models: "lib/models" };
+        case "react-vite":
+            return { lib: "src/lib", router: "src", models: "src/models" };
+        default:
+            return { lib: "src/lib", router: "src", models: "src/models" };
+    }
+}
+/**
+ * Generate variables based on database, framework, and provider
+ */
+function generateVariables(database, framework, dbProvider, auth) {
+    const variables = {};
+    // Database-specific variables
+    variables.dbFile = database === "prisma" ? "prisma.ts" : "db.ts";
+    variables.dbDescription =
+        database === "prisma"
+            ? "Create Prisma client singleton"
+            : "Create MongoDB connection with Mongoose";
+    // Auth-specific variables
+    if (auth) {
+        variables.authFile = "auth.ts";
+        variables.authDescription = `Create ${auth} authentication configuration`;
+        // Dynamic dbImport for auth modules
+        const libPath = framework === "nextjs" ? "@/lib" : ".";
+        const adapterImport = 'import { prismaAdapter } from "better-auth/adapters/prisma";';
+        if (database === "prisma") {
+            variables.dbImport = `import { prisma } from "${libPath}/prisma";
+${adapterImport}`;
+        }
+        else {
+            variables.dbImport =
+                database === "prisma"
+                    ? `import { prisma } from "${libPath}/prisma";`
+                    : `import { client } from "${libPath}/db";`;
+        }
+    }
+    else {
+        // Framework-specific database import for database modules
+        const libPath = framework === "nextjs" ? "@/lib" : ".";
+        variables.dbImport = database === "prisma" ? `${libPath}/prisma` : `${libPath}/db`;
+    }
+    // Provider-specific variables
+    if (dbProvider) {
+        variables.provider = dbProvider;
+        switch (dbProvider) {
+            case "postgresql":
+                variables.connectionString = "postgresql://user:password@localhost:5432/mydb?schema=public";
+                variables.prismaClientInit = `import { PrismaPg } from "@prisma/adapter-pg";
+
+const globalForPrisma = global as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+const adapter = new PrismaPg({
+  connectionString: process.env.DATABASE_URL!,
+});
+
+const prisma = globalForPrisma.prisma ?? new PrismaClient({
+  adapter,
+});
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+`;
+                break;
+            case "mongodb":
+                variables.connectionString = "mongodb+srv://username:password@cluster.mongodb.net/mydb";
+                variables.prismaClientInit = `
+const prisma = new PrismaClient()
+`;
+                break;
+            case "mysql":
+                variables.connectionString = "mysql://user:password@localhost:3306/mydb";
+                variables.prismaClientInit = `import { PrismaMariaDb } from '@prisma/adapter-mariadb';
+
+const adapter = new PrismaMariaDb({
+  host: process.env.DATABASE_HOST,
+  user: process.env.DATABASE_USER,
+  password: process.env.DATABASE_PASSWORD,
+  database: process.env.DATABASE_NAME,
+  connectionLimit: 5
+});
+const prisma = new PrismaClient({ adapter });
+`;
+                break;
+            case "sqlite":
+                variables.connectionString = "file:./dev.db";
+                variables.prismaClientInit = `import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
+
+const adapter = new PrismaBetterSqlite3({ url: process.env.DATABASE_URL });
+const prisma = new PrismaClient({ adapter });
+`;
+                break;
+        }
+    }
+    return variables;
+}
+/**
+ * Process a single patch with variable replacement
+ */
+async function processPatch(patch, filesDir, targetDir, variables, frameworkPaths) {
+    if (patch.type === "create-file") {
+        if (!patch.source || !patch.destination)
+            return;
+        try {
+            // Replace variables in source and destination
+            const sourcePath = patch.source.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match);
+            const sourceFile = (0, path_1.join)(filesDir, sourcePath);
+            let destFile = (0, path_1.join)(targetDir, patch.destination.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match));
+            // Apply framework-specific path replacements
+            destFile = destFile
+                .replace("{{lib}}", frameworkPaths.lib)
+                .replace("{{router}}", frameworkPaths.router)
+                .replace("{{models}}", frameworkPaths.models);
+            if (!(await fs_extra_1.default.pathExists(sourceFile))) {
+                logger_1.logger.warn(`Source file not found: ${sourceFile}`);
+                return;
+            }
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(destFile));
+            const ext = path_1.default.extname(sourceFile);
+            if ([".ts", ".js", ".tsx", ".prisma", ".json"].includes(ext)) {
+                let content = await fs_extra_1.default.readFile(sourceFile, "utf-8");
+                for (const [key, value] of Object.entries(variables)) {
+                    content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
+                }
+                await fs_extra_1.default.writeFile(destFile, content);
+            }
+            else {
+                await fs_extra_1.default.copy(sourceFile, destFile, { overwrite: false });
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to process patch ${patch.description}: ${error.message}`);
+            throw error;
+        }
+    }
+    else if (patch.type === "patch-file") {
+        if (!patch.file)
+            return;
+        try {
+            const filePath = (0, path_1.join)(targetDir, patch.file);
+            if (!(await fs_extra_1.default.pathExists(filePath))) {
+                logger_1.logger.warn(`File to patch not found: ${filePath}`);
+                return;
+            }
+            let content = await fs_extra_1.default.readFile(filePath, "utf-8");
+            for (const operation of patch.operations || []) {
+                if (operation.type === "add-import" && operation.imports) {
+                    // Add imports at the top of the file, after existing imports
+                    const imports = operation.imports.join("\n");
+                    // Find the last import statement
+                    const importRegex = /^import\s+.*$/gm;
+                    const matches = [...content.matchAll(importRegex)];
+                    if (matches.length > 0) {
+                        const lastImport = matches[matches.length - 1];
+                        const insertIndex = (lastImport.index ?? 0) + lastImport[0].length;
+                        content = content.slice(0, insertIndex) + "\n" + imports + content.slice(insertIndex);
+                    }
+                    else {
+                        // No imports found, add at the beginning
+                        content = imports + "\n\n" + content;
+                    }
+                }
+                else if (operation.type === "add-code") {
+                    if (operation.after && operation.code) {
+                        const insertIndex = content.indexOf(operation.after);
+                        if (insertIndex !== -1) {
+                            const afterIndex = insertIndex + operation.after.length;
+                            content = content.slice(0, afterIndex) + operation.code + content.slice(afterIndex);
+                        }
+                    }
+                }
+            }
+            await fs_extra_1.default.writeFile(filePath, content);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to process patch-file ${patch.description}: ${error.message}`);
+            throw error;
+        }
+    }
+}
+/**
+ * Validate and extract module data
+ */
+async function loadModuleData(modulePath) {
+    const moduleJsonPath = (0, path_1.join)(modulePath, "module.json");
+    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
+        throw new Error(`Module configuration not found: ${moduleJsonPath}`);
+    }
+    const moduleData = await fs_extra_1.default.readJson(moduleJsonPath);
+    if (!moduleData) {
+        throw new Error(`Invalid module configuration: ${moduleJsonPath}`);
+    }
+    return moduleData;
+}
+async function mergeDatabaseConfig(templatesDir, targetDir, database, framework, dbProvider) {
+    try {
+        const modulesDir = (0, path_1.join)(templatesDir, "..", "modules");
+        const dbModulePath = (0, path_1.join)(modulesDir, "database", database);
+        if (!(await fs_extra_1.default.pathExists(dbModulePath))) {
+            logger_1.logger.warn(`Database module not found: ${database}`);
+            return [];
+        }
+        const moduleData = await loadModuleData(dbModulePath);
+        const variables = generateVariables(database, framework, dbProvider);
+        const frameworkPaths = getFrameworkPaths(framework);
+        const filesDir = (0, path_1.join)(dbModulePath, "files");
+        if (await fs_extra_1.default.pathExists(filesDir)) {
+            for (const patch of moduleData.patches || []) {
+                await processPatch(patch, filesDir, targetDir, variables, frameworkPaths);
+            }
+        }
+        // Merge dependencies
+        let dependencies = {};
+        let devDependencies = {};
+        if (moduleData.dependencies) {
+            if (moduleData.dependencies.common || moduleData.dependencies.providers) {
+                // Structured dependencies (common + providers)
+                dependencies = {
+                    ...moduleData.dependencies.common,
+                    ...(dbProvider ? moduleData.dependencies.providers?.[dbProvider] : {}),
+                };
+            }
+            else {
+                // Flat dependencies structure
+                dependencies = { ...moduleData.dependencies };
+            }
+        }
+        if (moduleData.devDependencies) {
+            if (moduleData.devDependencies.common || moduleData.devDependencies.providers) {
+                // Structured devDependencies
+                devDependencies = {
+                    ...moduleData.devDependencies.common,
+                    ...(dbProvider ? moduleData.devDependencies.providers?.[dbProvider] : {}),
+                };
+            }
+            else {
+                // Flat devDependencies structure
+                devDependencies = { ...moduleData.devDependencies };
+            }
+        }
+        await (0, files_1.mergePackageJson)(targetDir, { dependencies, devDependencies });
+        // Process environment variables
+        const envVars = {};
+        const commonEnvVars = Array.isArray(moduleData.envVars)
+            ? moduleData.envVars
+            : moduleData.envVars?.common || [];
+        const providerEnvVars = dbProvider && moduleData.envVars?.providers?.[dbProvider]
+            ? moduleData.envVars.providers[dbProvider]
+            : [];
+        const allEnvVars = [...commonEnvVars, ...providerEnvVars];
+        Object.assign(envVars, processEnvVars(allEnvVars, variables));
+        await (0, files_1.mergeEnvFile)(targetDir, envVars);
+        // Apply framework-specific patches
+        if (moduleData.frameworkPatches) {
+            const frameworkKey = framework === "react-vite" ? "react" : framework;
+            const patches = moduleData.frameworkPatches[frameworkKey];
+            if (patches) {
+                await (0, config_utils_1.applyFrameworkPatches)(targetDir, patches);
+            }
+        }
+        return moduleData.postInstall || [];
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to merge database config for ${database}: ${error.message}`);
+        throw error;
+    }
+}
+async function mergeAuthConfig(templatesDir, targetDir, framework, auth, database = "none", dbProvider) {
+    try {
+        const modulesDir = (0, path_1.join)(templatesDir, "..", "modules");
+        const authModulePath = (0, path_1.join)(modulesDir, "auth", auth);
+        if (!(await fs_extra_1.default.pathExists(authModulePath))) {
+            logger_1.logger.warn(`Auth module not found: ${auth}`);
+            return;
+        }
+        const moduleData = await loadModuleData(authModulePath);
+        if (moduleData.supportedFrameworks && !moduleData.supportedFrameworks.includes(framework)) {
+            logger_1.logger.warn(`Auth ${auth} does not support framework ${framework}`);
+            return;
+        }
+        let frameworkConfig = null;
+        if (moduleData.frameworkConfigs) {
+            frameworkConfig = moduleData.frameworkConfigs[framework];
+            if (!frameworkConfig) {
+                logger_1.logger.warn(`No config for framework ${framework} in ${auth}`);
+                return;
+            }
+            const shared = moduleData.frameworkConfigs.shared;
+            if (shared) {
+                frameworkConfig = {
+                    ...shared,
+                    ...frameworkConfig,
+                };
+            }
+        }
+        const variables = generateVariables(database, framework, dbProvider, auth);
+        const frameworkPaths = getFrameworkPaths(framework);
+        // Handle database adapters first to set variables
+        if (database !== "none" && moduleData.databaseAdapters) {
+            let adapterKey = database;
+            if (database === "prisma" && dbProvider) {
+                adapterKey = `prisma-${dbProvider}`;
+            }
+            const adapterConfig = moduleData.databaseAdapters[adapterKey];
+            if (adapterConfig) {
+                // Generate adapter code based on database type
+                if (database === "prisma" && dbProvider) {
+                    variables.databaseAdapter = `database: prismaAdapter(prisma, {\n    provider: "${dbProvider}",\n  }),`;
+                }
+                if (adapterConfig.schema && adapterConfig.schemaDestination) {
+                    const schemaSource = (0, path_1.join)(authModulePath, adapterConfig.schema);
+                    const schemaDest = (0, path_1.join)(targetDir, adapterConfig.schemaDestination);
+                    if (await fs_extra_1.default.pathExists(schemaSource)) {
+                        await fs_extra_1.default.ensureDir(path_1.default.dirname(schemaDest));
+                        let content = await fs_extra_1.default.readFile(schemaSource, "utf-8");
+                        // Set schema variables for Prisma
+                        if (dbProvider === "postgresql") {
+                            variables.provider = "postgresql";
+                            variables.idDefault = "@default(cuid())";
+                            variables.userIdType = "";
+                        }
+                        else if (dbProvider === "mongodb") {
+                            variables.provider = "mongodb";
+                            variables.idDefault = '@default(auto()) @map("_id") @db.ObjectId';
+                            variables.userIdType = "@db.ObjectId";
+                        }
+                        else if (dbProvider === "mysql") {
+                            variables.provider = "mysql";
+                            variables.idDefault = "@default(cuid())";
+                            variables.userIdType = "";
+                        }
+                        else if (dbProvider === "sqlite") {
+                            variables.provider = "sqlite";
+                            variables.idDefault = "@default(cuid())";
+                            variables.userIdType = "";
+                        }
+                        for (const [key, value] of Object.entries(variables)) {
+                            content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
+                        }
+                        await fs_extra_1.default.writeFile(schemaDest, content, { flag: "a" }); // append
+                    }
+                }
+                if (adapterConfig.dependencies) {
+                    const commonDeps = moduleData.databaseAdapters.common?.dependencies || {};
+                    const commonDevDeps = moduleData.databaseAdapters.common?.devDependencies || {};
+                    const specificDeps = adapterConfig.dependencies;
+                    const specificDevDeps = adapterConfig.devDependencies || {};
+                    await (0, files_1.mergePackageJson)(targetDir, {
+                        dependencies: { ...commonDeps, ...specificDeps },
+                        devDependencies: { ...commonDevDeps, ...specificDevDeps },
+                    });
+                }
+            }
+        }
+        const filesDir = (0, path_1.join)(authModulePath, "files");
+        if (await fs_extra_1.default.pathExists(filesDir)) {
+            const patches = frameworkConfig?.patches || moduleData.patches || [];
+            for (const patch of patches) {
+                await processPatch(patch, filesDir, targetDir, variables, frameworkPaths);
+            }
+        }
+        // Add framework-specific patches
+        if (framework === "nextjs") {
+            const apiSource = (0, path_1.join)(filesDir, "api/auth/[...all]/route.ts");
+            const apiDest = (0, path_1.join)(targetDir, "app/api/auth/[...all]/route.ts");
+            if (await fs_extra_1.default.pathExists(apiSource)) {
+                await fs_extra_1.default.ensureDir(path_1.default.dirname(apiDest));
+                await fs_extra_1.default.copy(apiSource, apiDest, { overwrite: false });
+            }
+        }
+        // Merge package.json
+        await (0, files_1.mergePackageJson)(targetDir, {
+            dependencies: frameworkConfig?.dependencies || moduleData.dependencies,
+            devDependencies: frameworkConfig?.devDependencies || moduleData.devDependencies,
+        });
+        // Process environment variables
+        const envVars = {};
+        const envVarList = frameworkConfig?.envVars || moduleData.envVars || [];
+        Object.assign(envVars, processEnvVars(envVarList, variables));
+        await (0, files_1.mergeEnvFile)(targetDir, envVars);
+        // Apply framework-specific patches
+        if (moduleData.frameworkPatches) {
+            const frameworkKey = framework === "react-vite" ? "react" : framework;
+            const patches = moduleData.frameworkPatches[frameworkKey];
+            if (patches) {
+                await (0, config_utils_1.applyFrameworkPatches)(targetDir, patches);
+            }
+        }
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to merge auth config for ${auth}: ${error.message}`);
+        throw error;
+    }
+}

package/dist/utils/package-manager.js

@@ -20,28 +20,20 @@ async function detectPackageManager(cwd) {
     }
 }
 async function installDependencies(cwd, pm) {
-    const spinner = logger_1.logger.startSpinner(`Installing dependencies with ${pm}...`);
-    try {
-        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" });
-        spinner.succeed(`Dependencies installed successfully`);
+    const args = [];
+    if (pm === "npm") {
+        args.push("install");
     }
-    catch (error) {
-        spinner.fail(`Failed to install dependencies`);
-        throw new Error(`Failed to install dependencies: ${error}`);
+    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" });
 }
 async function addDependencies(cwd, pm, packages, dev = false) {
     if (packages.length === 0)
@@ -71,15 +63,7 @@ async function addDependencies(cwd, pm, packages, dev = false) {
     }
 }
 async function initGit(cwd) {
-    const spinner = logger_1.logger.startSpinner("Initializing git repository...");
-    try {
-        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 });
-        spinner.succeed("Git repository initialized");
-    }
-    catch {
-        spinner.fail("Failed to initialize git repository");
-        // Don't throw - git init is optional
-    }
+    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 });
 }

package/modules/auth/authjs/files/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,6 @@
+import NextAuth from "next-auth";
+import { authOptions } from "@/lib/auth";
+
+const handler = NextAuth(authOptions);
+
+export { handler as GET, handler as POST };

package/modules/auth/authjs/files/lib/auth-client.ts

@@ -0,0 +1,11 @@
+import { getServerSession } from "next-auth/next";
+import { authOptions } from "@/lib/auth";
+
+export async function getSession() {
+  return await getServerSession(authOptions);
+}
+
+export async function getCurrentUser() {
+  const session = await getSession();
+  return session?.user;
+}

package/modules/auth/authjs/files/lib/auth.ts

@@ -0,0 +1,41 @@
+import { NextAuthOptions } from "next-auth";
+import { PrismaAdapter } from "@auth/prisma-adapter";
+import { prisma } from "@/lib/prisma";
+import GoogleProvider from "next-auth/providers/google";
+import GitHubProvider from "next-auth/providers/github";
+
+export const authOptions: NextAuthOptions = {
+  adapter: PrismaAdapter(prisma),
+  providers: [
+    GoogleProvider({
+      clientId: process.env.GOOGLE_CLIENT_ID!,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+    }),
+    GitHubProvider({
+      clientId: process.env.GITHUB_ID!,
+      clientSecret: process.env.GITHUB_SECRET!,
+    }),
+  ],
+  session: {
+    strategy: "jwt",
+  },
+  callbacks: {
+    async jwt({ token, user }) {
+      if (user) {
+        token.id = user.id;
+      }
+      return token;
+    },
+    async session({ session, token }) {
+      if (token) {
+        session.user.id = token.id as string;
+      }
+      return session;
+    },
+  },
+  pages: {
+    signIn: "/auth/signin",
+    signOut: "/auth/signout",
+    error: "/auth/error",
+  },
+};

package/modules/auth/authjs/files/schemas/prisma-schema.prisma

@@ -0,0 +1,45 @@
+
+model Account {
+  id                String  @id {{idDefault}}
+  userId            String {{userIdType}}
+  type              String
+  provider          String
+  providerAccountId String
+  refresh_token     String? @db.Text
+  access_token      String? @db.Text
+  expires_at        Int?
+  token_type        String?
+  scope             String?
+  id_token          String? @db.Text
+  session_state     String?
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([provider, providerAccountId])
+}
+
+model Session {
+  id           String   @id {{idDefault}}
+  sessionToken String   @unique
+  userId       String {{userIdType}}
+  expires      DateTime
+  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+}
+
+model User {
+  id            String    @id {{idDefault}}
+  name          String?
+  email         String    @unique
+  emailVerified DateTime?
+  image         String?
+  accounts      Account[]
+  sessions      Session[]
+}
+
+model VerificationToken {
+  identifier String
+  token      String   @unique
+  expires    DateTime
+
+  @@unique([identifier, token])
+}