create-stackkit-app 0.4.4 → 0.4.5

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

@@ -42,27 +42,77 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importStar(require("path"));
 const config_utils_1 = require("./config-utils");
 const file_utils_1 = require("./file-utils");
-async function mergeDatabaseConfig(templatesDir, targetDir, database, framework, dbProvider) {
-    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))) {
-        // eslint-disable-next-line no-console
-        console.warn(`Database module not found: ${database}`);
-        return [];
+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;
     }
-    // Read module.json
-    const moduleJsonPath = (0, path_1.join)(dbModulePath, "module.json");
-    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
-        return [];
+    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" };
     }
-    const moduleData = await fs_extra_1.default.readJson(moduleJsonPath);
+}
+/**
+ * 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;
-        if (dbProvider === "postgresql") {
-            variables.connectionString = "postgresql://user:password@localhost:5432/mydb?schema=public";
-            variables.prismaClientInit = `
-import { PrismaPg } from "@prisma/adapter-pg";
+        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;
@@ -78,17 +128,16 @@ const prisma = globalForPrisma.prisma ?? new PrismaClient({
 
 if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
 `;
-        }
-        else if (dbProvider === "mongodb") {
-            variables.connectionString = "mongodb+srv://username:password@cluster.mongodb.net/mydb";
-            variables.prismaClientInit = `
+                break;
+            case "mongodb":
+                variables.connectionString = "mongodb+srv://username:password@cluster.mongodb.net/mydb";
+                variables.prismaClientInit = `
 const prisma = new PrismaClient()
 `;
-        }
-        else if (dbProvider === "mysql") {
-            variables.connectionString = "mysql://user:password@localhost:3306/mydb";
-            variables.prismaClientInit = `
-import { PrismaMariaDb } from '@prisma/adapter-mariadb';
+                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,
@@ -99,213 +148,314 @@ const adapter = new PrismaMariaDb({
 });
 const prisma = new PrismaClient({ adapter });
 `;
-        }
-        else if (dbProvider === "sqlite") {
-            variables.connectionString = "file:./dev.db";
-            variables.prismaClientInit = `
-import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
+                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;
         }
     }
-    const filesDir = (0, path_1.join)(dbModulePath, "files");
-    if (await fs_extra_1.default.pathExists(filesDir)) {
-        const libDir = framework === "nextjs" ? "lib" : "src";
-        for (const patch of moduleData.patches || []) {
-            if (patch.type === "create-file") {
-                const sourceFile = (0, path_1.join)(filesDir, patch.source);
-                let destFile = (0, path_1.join)(targetDir, patch.destination);
-                destFile = destFile
-                    .replace("{{lib}}", libDir)
-                    .replace("{{src}}", "src")
-                    .replace("{{models}}", framework === "nextjs" ? "models" : "src/models");
-                if (await fs_extra_1.default.pathExists(sourceFile)) {
-                    await fs_extra_1.default.ensureDir((0, path_1.join)(destFile, ".."));
-                    // Check if text file
-                    const ext = path_1.default.extname(sourceFile);
-                    if ([".ts", ".js", ".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);
+    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 {
-                        await fs_extra_1.default.copy(sourceFile, destFile, { overwrite: false });
+                        // 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);
         }
-    }
-    const dependencies = {
-        ...moduleData.dependencies.common,
-        ...(dbProvider ? moduleData.dependencies.providers[dbProvider] : {}),
-    };
-    const devDependencies = {
-        ...moduleData.devDependencies.common,
-        ...(dbProvider ? moduleData.devDependencies.providers[dbProvider] : {}),
-    };
-    await (0, file_utils_1.mergePackageJson)(targetDir, {
-        dependencies,
-        devDependencies,
-    });
-    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];
-    for (const envVar of allEnvVars) {
-        let value = envVar.value;
-        for (const [key, val] of Object.entries(variables)) {
-            value = value.replace(new RegExp(`{{${key}}}`, "g"), val);
-        }
-        envVars[envVar.key] = value;
-    }
-    await (0, file_utils_1.mergeEnvFile)(targetDir, envVars);
-    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 process patch-file ${patch.description}: ${error.message}`);
+            throw error;
         }
     }
-    return moduleData.postInstall || [];
 }
-async function mergeAuthConfig(templatesDir, targetDir, framework, auth, database = "none", dbProvider) {
-    const modulesDir = (0, path_1.join)(templatesDir, "..", "modules");
-    const authKey = auth;
-    const authModulePath = (0, path_1.join)(modulesDir, "auth", authKey);
-    if (!(await fs_extra_1.default.pathExists(authModulePath))) {
-        // eslint-disable-next-line no-console
-        console.warn(`Auth module not found: ${authKey}`);
-        return;
-    }
-    // Read module.json
-    const moduleJsonPath = (0, path_1.join)(authModulePath, "module.json");
+/**
+ * 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))) {
-        return;
+        throw new Error(`Module configuration not found: ${moduleJsonPath}`);
     }
     const moduleData = await fs_extra_1.default.readJson(moduleJsonPath);
-    if (moduleData.supportedFrameworks && !moduleData.supportedFrameworks.includes(framework)) {
-        // eslint-disable-next-line no-console
-        console.warn(`Auth ${authKey} does not support framework ${framework}`);
-        return;
+    if (!moduleData) {
+        throw new Error(`Invalid module configuration: ${moduleJsonPath}`);
     }
-    let frameworkConfig = null;
-    if (moduleData.frameworkConfigs) {
-        frameworkConfig = moduleData.frameworkConfigs[framework];
-        if (!frameworkConfig) {
-            // eslint-disable-next-line no-console
-            console.warn(`No config for framework ${framework} in ${authKey}`);
-            return;
+    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, file_utils_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, file_utils_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 || [];
     }
-    const variables = {};
-    if (framework === "nextjs") {
-        variables.dbImport = "@/lib/db";
-    }
-    else if (framework === "express") {
-        variables.dbImport = "../db";
-    }
-    else {
-        variables.dbImport = "../db";
+    catch (error) {
+        logger_1.logger.error(`Failed to merge database config for ${database}: ${error.message}`);
+        throw error;
     }
-    const filesDir = (0, path_1.join)(authModulePath, "files");
-    if (await fs_extra_1.default.pathExists(filesDir)) {
-        const getReplacements = () => {
-            if (framework === "nextjs") {
-                return { lib: "lib", router: "app" };
+}
+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;
             }
-            else if (framework === "express") {
-                return { lib: "src", router: "src" };
+            const shared = moduleData.frameworkConfigs.shared;
+            if (shared) {
+                frameworkConfig = {
+                    ...shared,
+                    ...frameworkConfig,
+                };
             }
-            else {
-                return { lib: "src", router: "src" };
+        }
+        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 replacements = getReplacements();
-        const patches = frameworkConfig?.patches || moduleData.patches || [];
-        for (const patch of patches) {
-            if (patch.type === "create-file") {
-                const sourceFile = (0, path_1.join)(filesDir, patch.source);
-                let destFile = (0, path_1.join)(targetDir, patch.destination);
-                destFile = destFile
-                    .replace("{{lib}}", replacements.lib)
-                    .replace("{{router}}", replacements.router);
-                if (await fs_extra_1.default.pathExists(sourceFile)) {
-                    await fs_extra_1.default.ensureDir(path_1.default.dirname(destFile));
-                    // Check if text file
-                    const ext = path_1.default.extname(sourceFile);
-                    if ([".ts", ".js", ".json"].includes(ext)) {
-                        let content = await fs_extra_1.default.readFile(sourceFile, "utf-8");
+            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(destFile, content);
-                    }
-                    else {
-                        await fs_extra_1.default.copy(sourceFile, destFile, { overwrite: false });
+                        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, file_utils_1.mergePackageJson)(targetDir, {
+                        dependencies: { ...commonDeps, ...specificDeps },
+                        devDependencies: { ...commonDevDeps, ...specificDevDeps },
+                    });
+                }
             }
         }
-    }
-    // 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 });
-        }
-    }
-    if (database !== "none" && moduleData.databaseAdapters) {
-        let adapterKey = database;
-        if (database === "prisma" && dbProvider) {
-            adapterKey = `prisma-${dbProvider}`;
+        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);
+            }
         }
-        const adapterConfig = moduleData.databaseAdapters[adapterKey];
-        if (adapterConfig) {
-            variables.databaseAdapter = adapterConfig.adapterCode;
-            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
-                    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";
-                    }
-                    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
-                }
+        // 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 });
             }
-            if (adapterConfig.dependencies) {
-                await (0, file_utils_1.mergePackageJson)(targetDir, {
-                    dependencies: adapterConfig.dependencies,
-                });
+        }
+        // Merge package.json
+        await (0, file_utils_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, file_utils_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);
             }
         }
     }
-    await (0, file_utils_1.mergePackageJson)(targetDir, {
-        dependencies: frameworkConfig?.dependencies || moduleData.dependencies,
-        devDependencies: frameworkConfig?.devDependencies || moduleData.devDependencies,
-    });
-    const envVars = {};
-    const envVarList = frameworkConfig?.envVars || moduleData.envVars || [];
-    for (const envVar of envVarList) {
-        envVars[envVar.key] = envVar.value;
+    catch (error) {
+        logger_1.logger.error(`Failed to merge auth config for ${auth}: ${error.message}`);
+        throw error;
     }
-    await (0, file_utils_1.mergeEnvFile)(targetDir, envVars);
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installDependencies = installDependencies;
 const child_process_1 = require("child_process");
+const logger_1 = require("./logger");
 async function installDependencies(cwd, packageManager) {
     const commands = {
         npm: "npm install",
@@ -23,8 +24,7 @@ async function installDependencies(cwd, packageManager) {
         const fallbacks = ["pnpm", "npm", "yarn", "bun"];
         const found = fallbacks.find((p) => isAvailable(p));
         if (found) {
-            // eslint-disable-next-line no-console
-            console.warn(`Selected package manager '${chosen}' was not found. Falling back to '${found}'.`);
+            logger_1.logger.warn(`Selected package manager '${chosen}' was not found. Falling back to '${found}'.`);
             chosen = found;
         }
         else {

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;
+}