stackkit 0.2.1 → 0.2.3

package/dist/cli/doctor.js

@@ -7,12 +7,13 @@ exports.doctorCommand = doctorCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+const installed_detection_1 = require("../lib/discovery/installed-detection");
 const logger_1 = require("../lib/ui/logger");
 const package_root_1 = require("../lib/utils/package-root");
 // Constants for consistent messaging
 const MESSAGES = {
     NO_PACKAGE_JSON: "No package.json found in current directory or any parent directory.",
-    UNSUPPORTED_PROJECT: "Unsupported project type. Only Next.js, Express, and React projects are supported.",
+    UNSUPPORTED_PROJECT: "Unsupported project type or unable to detect framework.",
     NODE_TOO_OLD: (version) => `Node.js version ${version} is not supported. Minimum required: Node 18.`,
     NODE_WARNING: (version) => `Node.js version ${version} is supported but Node 20+ is recommended.`,
     NODE_SUCCESS: (version) => `Node.js version ${version} is supported.`,
@@ -84,8 +85,8 @@ async function runDoctorChecks() {
     }
     const nodeVersionCheck = checkNodeVersion();
     checks.push(nodeVersionCheck);
-    const authModules = detectAuthModules(packageJson);
-    const databaseModules = detectDatabaseModules(packageJson);
+    const authModules = await (0, installed_detection_1.detectAuthModules)(packageJson);
+    const databaseModules = await (0, installed_detection_1.detectDatabaseModules)(packageJson);
     const filesCheck = await checkKeyFiles(projectRoot, projectType, authModules, databaseModules);
     checks.push(...filesCheck);
     const envCheck = await checkEnvFiles(projectRoot, authModules, databaseModules);
@@ -124,7 +125,7 @@ async function runDoctorChecks() {
             prismaSchema: databaseModules.includes("prisma")
                 ? await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, "prisma", "schema.prisma"))
                 : undefined,
-            authRoutes: authModules.length > 0 ? await checkAuthRoutesExist(projectRoot, projectType) : undefined,
+            authRoutes: authModules.length > 0 ? await checkAuthRoutesExist(projectRoot) : undefined,
             tsconfig: await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, "tsconfig.json")),
             eslintConfig: await checkEslintConfigExists(projectRoot),
             git: await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".git")),
@@ -173,6 +174,29 @@ async function detectPackageManager(projectRoot) {
 }
 function detectProjectType(packageJson) {
     const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    // Try to detect using available templates
+    try {
+        const templatesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "templates");
+        if (fs_extra_1.default.existsSync(templatesDir)) {
+            const dirs = fs_extra_1.default.readdirSync(templatesDir);
+            for (const d of dirs) {
+                const tplPath = path_1.default.join(templatesDir, d, "template.json");
+                if (!fs_extra_1.default.existsSync(tplPath))
+                    continue;
+                try {
+                    const tpl = JSON.parse(fs_extra_1.default.readFileSync(tplPath, "utf-8"));
+                    if (tpl && tpl.framework && deps[tpl.framework])
+                        return tpl.framework;
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    catch {
+        // ignore template-based detection errors
+    }
     if (deps.next) {
         return "nextjs";
     }
@@ -209,129 +233,7 @@ function checkNodeVersion() {
         };
     }
 }
-function detectAuthModules(packageJson) {
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const modules = [];
-    try {
-        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "auth");
-        if (fs_extra_1.default.existsSync(modulesDir)) {
-            const authDirs = fs_extra_1.default.readdirSync(modulesDir);
-            for (const authDir of authDirs) {
-                try {
-                    const genPath = path_1.default.join(modulesDir, authDir, "generator.json");
-                    const modJson = path_1.default.join(modulesDir, authDir, "module.json");
-                    let pkgNames = [];
-                    if (fs_extra_1.default.existsSync(genPath)) {
-                        const gen = JSON.parse(fs_extra_1.default.readFileSync(genPath, "utf-8"));
-                        if (Array.isArray(gen.operations)) {
-                            for (const op of gen.operations) {
-                                if (op.dependencies && typeof op.dependencies === "object") {
-                                    pkgNames.push(...Object.keys(op.dependencies));
-                                }
-                                if (op.devDependencies && typeof op.devDependencies === "object") {
-                                    pkgNames.push(...Object.keys(op.devDependencies));
-                                }
-                            }
-                        }
-                    }
-                    // Fallback: check module.json provider/name
-                    let moduleName = authDir;
-                    if (fs_extra_1.default.existsSync(modJson)) {
-                        try {
-                            const m = JSON.parse(fs_extra_1.default.readFileSync(modJson, "utf-8"));
-                            if (m && m.name)
-                                moduleName = m.name;
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                    }
-                    for (const pkg of pkgNames) {
-                        if (deps[pkg]) {
-                            modules.push(moduleName);
-                            break;
-                        }
-                    }
-                }
-                catch {
-                    // ignore per-module errors
-                }
-            }
-        }
-    }
-    catch {
-        // ignore discovery errors
-    }
-    // Fallback to original simple checks if nothing found
-    if (modules.length === 0) {
-        if (deps["better-auth"])
-            modules.push("better-auth");
-        if (deps["next-auth"])
-            modules.push("authjs");
-    }
-    return Array.from(new Set(modules));
-}
-function detectDatabaseModules(packageJson) {
-    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-    const modules = [];
-    try {
-        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "database");
-        if (fs_extra_1.default.existsSync(modulesDir)) {
-            const dbDirs = fs_extra_1.default.readdirSync(modulesDir);
-            for (const dbDir of dbDirs) {
-                try {
-                    const genPath = path_1.default.join(modulesDir, dbDir, "generator.json");
-                    const modJson = path_1.default.join(modulesDir, dbDir, "module.json");
-                    let pkgNames = [];
-                    if (fs_extra_1.default.existsSync(genPath)) {
-                        const gen = JSON.parse(fs_extra_1.default.readFileSync(genPath, "utf-8"));
-                        if (Array.isArray(gen.operations)) {
-                            for (const op of gen.operations) {
-                                if (op.dependencies && typeof op.dependencies === "object") {
-                                    pkgNames.push(...Object.keys(op.dependencies));
-                                }
-                                if (op.devDependencies && typeof op.devDependencies === "object") {
-                                    pkgNames.push(...Object.keys(op.devDependencies));
-                                }
-                            }
-                        }
-                    }
-                    let moduleName = dbDir;
-                    if (fs_extra_1.default.existsSync(modJson)) {
-                        try {
-                            const m = JSON.parse(fs_extra_1.default.readFileSync(modJson, "utf-8"));
-                            if (m && m.name)
-                                moduleName = m.name;
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                    }
-                    for (const pkg of pkgNames) {
-                        if (deps[pkg]) {
-                            modules.push(moduleName);
-                            break;
-                        }
-                    }
-                }
-                catch {
-                    // ignore per-module errors
-                }
-            }
-        }
-    }
-    catch {
-        // ignore discovery errors
-    }
-    // Fallback to original checks if nothing found
-    if (modules.length === 0) {
-        if (deps["@prisma/client"] || deps["prisma"])
-            modules.push("prisma");
-        if (deps["mongoose"])
-            modules.push("mongoose");
-    }
-    return Array.from(new Set(modules));
-}
+// Module detection is delegated to shared utilities in `lib/discovery`.
 async function checkKeyFiles(projectRoot, projectType, authModules, databaseModules) {
     const checks = [];
     const envExampleExists = await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".env.example"));
@@ -348,8 +250,8 @@ async function checkKeyFiles(projectRoot, projectType, authModules, databaseModu
             message: schemaExists ? "Prisma schema found" : "Prisma schema missing (required for Prisma)",
         });
     }
-    if (authModules.length > 0 && projectType === "nextjs") {
-        const authRoutesExist = await checkAuthRoutesExist(projectRoot, projectType);
+    if (authModules.length > 0) {
+        const authRoutesExist = await checkAuthRoutesExist(projectRoot);
         checks.push({
             status: authRoutesExist ? "success" : "warning",
             message: authRoutesExist
@@ -359,9 +261,7 @@ async function checkKeyFiles(projectRoot, projectType, authModules, databaseModu
     }
     return checks;
 }
-async function checkAuthRoutesExist(projectRoot, projectType) {
-    if (projectType !== "nextjs")
-        return true; // Skip for non-Next.js
+async function checkAuthRoutesExist(projectRoot) {
     // Build candidate auth route paths from generator.json files in modules/auth
     const candidates = new Set();
     try {
@@ -397,22 +297,10 @@ async function checkAuthRoutesExist(projectRoot, projectType) {
         // ignore discovery errors
     }
     // Fallback to known common paths if generators don't provide any
-    const fallback = [
-        "app/api/auth/[...nextauth]/route.ts",
-        "app/api/auth/[...nextauth]/route.js",
-        "src/app/api/auth/[...nextauth]/route.ts",
-        "src/app/api/auth/[...nextauth]/route.js",
-        "pages/api/auth/[...nextauth].ts",
-        "pages/api/auth/[...nextauth].js",
-        "src/pages/api/auth/[...nextauth].ts",
-        "src/pages/api/auth/[...nextauth].js",
-        "app/api/auth/[...all]/route.ts",
-        "app/api/auth/[...all]/route.js",
-        "src/app/api/auth/[...all]/route.ts",
-        "src/app/api/auth/[...all]/route.js",
-    ];
-    for (const p of fallback)
-        candidates.add(p);
+    // If generators provided candidate routes, check them. Otherwise
+    // do not assume any hard-coded route locations.
+    if (candidates.size === 0)
+        return false;
     for (const routePath of candidates) {
         if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, routePath))) {
             return true;
@@ -468,16 +356,7 @@ async function checkEnvFiles(projectRoot, authModules, databaseModules) {
         }
     }
     catch {
-        // fallback to previous minimal checks if discovery fails
-        if (databaseModules.includes("prisma")) {
-            requiredKeys.push("DATABASE_URL");
-        }
-        if (authModules.includes("authjs")) {
-            requiredKeys.push("NEXTAUTH_SECRET", "NEXTAUTH_URL");
-        }
-        if (authModules.includes("better-auth")) {
-            requiredKeys.push("BETTER_AUTH_SECRET", "BETTER_AUTH_URL");
-        }
+        // If discovery fails, keep requiredKeys empty rather than using hard-coded defaults.
     }
     const envPaths = [".env", ".env.local"];
     let envContent = "";
@@ -603,7 +482,7 @@ function generateSuggestions(authModules, databaseModules) {
         suggestions.push("stackkit add auth     - Add authentication module");
     }
     if (databaseModules.length === 0) {
-        suggestions.push("stackkit add db       - Add database module");
+        suggestions.push("stackkit add database - Add database module");
     }
     // Always show available commands
     suggestions.push("stackkit list         - View available modules");

package/dist/cli/list.js

@@ -7,7 +7,6 @@ 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");
@@ -28,7 +27,7 @@ async function listCommand(options) {
                 frameworks.forEach((framework, index) => {
                     const isLast = index === frameworks.length - 1;
                     const prefix = isLast ? "└──" : "├──";
-                    logger_1.logger.log(`  ${chalk_1.default.gray(prefix)} ${chalk_1.default.cyan(framework.displayName)}`);
+                    logger_1.logger.log(`  ${chalk_1.default.gray(prefix)} ${chalk_1.default.cyan(framework.displayName || framework.name)}`);
                 });
                 logger_1.logger.newLine();
             }
@@ -36,22 +35,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"));
                 const grouped = modules.reduce((acc, mod) => {
-                    if (!acc[mod.category]) {
-                        acc[mod.category] = [];
-                    }
-                    acc[mod.category].push(mod);
+                    const cat = mod.category || "other";
+                    if (!acc[cat])
+                        acc[cat] = [];
+                    acc[cat].push(mod);
                     return acc;
                 }, {});
                 const categories = Object.keys(grouped);
@@ -78,32 +69,11 @@ async function listCommand(options) {
                                 : isLastMod
                                     ? "│       └──"
                                     : "│       ├──";
-                            // 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";
-                                })();
+                            // Derive provider list directly from the Prisma generator metadata
+                            const providers = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
+                            const providersText = providers.length
+                                ? providers.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join(", ")
+                                : "None";
                             logger_1.logger.log(`  ${chalk_1.default.gray(providerPrefix)} ${chalk_1.default.dim(`Providers: ${providersText}`)}`);
                         }
                     });

package/dist/index.js

@@ -99,12 +99,12 @@ function buildOptionHints() {
             }
         }
         return {
-            databaseHint: dbs.length > 0 ? dbs.join(", ") : "prisma, mongoose, none",
-            authHint: auths.length > 0 ? auths.join(", ") : "better-auth, authjs, none",
+            databaseHint: dbs.length > 0 ? dbs.join(", ") : "none",
+            authHint: auths.length > 0 ? auths.join(", ") : "none",
         };
     }
     catch {
-        return { databaseHint: "prisma, mongoose, none", authHint: "better-auth, authjs, none" };
+        return { databaseHint: "none", authHint: "none" };
     }
 }
 const hints = buildOptionHints();
@@ -134,7 +134,7 @@ program
     .command("create [project-name]")
     .description("Create a new StackKit project")
     .usage("[project-name] [options]")
-    .option("-f, --framework <framework>", "Framework: nextjs, express, react")
+    .option("-f, --framework <framework>", "Framework (discovered)")
     .option("-d, --database <database>", `Database: ${hints.databaseHint}`)
     .option("--prisma-provider <provider>", "Prisma provider")
     .option("-a, --auth <auth>", `Auth: ${hints.authHint}`)

package/dist/lib/discovery/installed-detection.d.ts

@@ -0,0 +1,7 @@
+interface PackageJsonLike {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+export declare function detectAuthModules(packageJson: PackageJsonLike): Promise<string[]>;
+export declare function detectDatabaseModules(packageJson: PackageJsonLike): Promise<string[]>;
+export {};

package/dist/lib/discovery/installed-detection.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAuthModules = detectAuthModules;
+exports.detectDatabaseModules = detectDatabaseModules;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const package_root_1 = require("../utils/package-root");
+async function collectModulePkgNames(modulePath) {
+    const pkgNames = [];
+    const genPath = path_1.default.join(modulePath, "generator.json");
+    if (await fs_extra_1.default.pathExists(genPath)) {
+        try {
+            const gen = await fs_extra_1.default.readJson(genPath);
+            if (Array.isArray(gen.operations)) {
+                for (const op of gen.operations) {
+                    if (op.dependencies && typeof op.dependencies === "object") {
+                        pkgNames.push(...Object.keys(op.dependencies));
+                    }
+                    if (op.devDependencies && typeof op.devDependencies === "object") {
+                        pkgNames.push(...Object.keys(op.devDependencies));
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore malformed generator
+        }
+    }
+    // Also check module.json for declared deps
+    const modJson = path_1.default.join(modulePath, "module.json");
+    if (await fs_extra_1.default.pathExists(modJson)) {
+        try {
+            const m = (await fs_extra_1.default.readJson(modJson));
+            if (m && typeof m === "object") {
+                const deps = m.dependencies || {};
+                if (typeof deps === "object")
+                    pkgNames.push(...Object.keys(deps));
+                const devDeps = m.devDependencies || {};
+                if (typeof devDeps === "object")
+                    pkgNames.push(...Object.keys(devDeps));
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return Array.from(new Set(pkgNames));
+}
+async function detectAuthModules(packageJson) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const modules = [];
+    try {
+        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "auth");
+        if (await fs_extra_1.default.pathExists(modulesDir)) {
+            const authDirs = await fs_extra_1.default.readdir(modulesDir);
+            for (const authDir of authDirs) {
+                try {
+                    const modulePath = path_1.default.join(modulesDir, authDir);
+                    const pkgNames = await collectModulePkgNames(modulePath);
+                    // Fallback: check module.json provider/name for display
+                    let moduleName = authDir;
+                    const modJson = path_1.default.join(modulePath, "module.json");
+                    if (await fs_extra_1.default.pathExists(modJson)) {
+                        try {
+                            const m = (await fs_extra_1.default.readJson(modJson));
+                            if (m && m.name)
+                                moduleName = m.name;
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                    for (const pkg of pkgNames) {
+                        if (deps[pkg]) {
+                            modules.push(moduleName);
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // ignore per-module errors
+                }
+            }
+        }
+    }
+    catch {
+        // ignore discovery errors
+    }
+    return Array.from(new Set(modules));
+}
+async function detectDatabaseModules(packageJson) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const modules = [];
+    try {
+        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "database");
+        if (await fs_extra_1.default.pathExists(modulesDir)) {
+            const dbDirs = await fs_extra_1.default.readdir(modulesDir);
+            for (const dbDir of dbDirs) {
+                try {
+                    const modulePath = path_1.default.join(modulesDir, dbDir);
+                    const pkgNames = await collectModulePkgNames(modulePath);
+                    let moduleName = dbDir;
+                    const modJson = path_1.default.join(modulePath, "module.json");
+                    if (await fs_extra_1.default.pathExists(modJson)) {
+                        try {
+                            const m = await fs_extra_1.default.readJson(modJson);
+                            if (m && m.name)
+                                moduleName = m.name;
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                    for (const pkg of pkgNames) {
+                        if (deps[pkg]) {
+                            modules.push(moduleName);
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // ignore per-module errors
+                }
+            }
+        }
+    }
+    catch {
+        // ignore discovery errors
+    }
+    return Array.from(new Set(modules));
+}

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

@@ -128,11 +128,8 @@ function getValidDatabaseOptions(databases) {
                 options.push("prisma");
             }
         }
-        else if (db.name === "mongoose") {
-            options.push("mongoose");
-        }
         else {
-            // For other databases, add the name directly
+            // For other databases, add the module name directly (generic handling)
             options.push(db.name);
         }
     }
@@ -161,12 +158,10 @@ function getCompatibleAuthOptions(authModules, framework, database) {
         }
         // Normalize database option (handle prisma-<provider> values)
         const parsedDb = (0, shared_1.parseDatabaseOption)(database || "").database;
-        // Special compatibility rules
-        if (auth.name === "authjs" && (parsedDb !== "prisma" || framework !== "nextjs")) {
-            continue;
-        }
-        if (auth.name === "better-auth" && parsedDb === "none" && framework !== "react") {
-            continue;
+        // If module provides explicit compatibility matrix, use it
+        if (auth.compatibility && auth.compatibility.databases) {
+            if (!auth.compatibility.databases.includes(parsedDb))
+                continue;
         }
         compatible.push({
             name: auth.displayName,
@@ -200,11 +195,9 @@ function getDatabaseChoices(databases, framework) {
                 choices.push({ name: "Prisma", value: "prisma" });
             }
         }
-        else if (db.name === "mongoose") {
-            choices.push({ name: "Mongoose", value: "mongoose" });
-        }
         else {
-            choices.push({ name: db.displayName, value: db.name });
+            // Generic handling for other database modules
+            choices.push({ name: db.displayName || db.name, value: db.name });
         }
     }
     // Add "None" at the end

package/dist/lib/discovery/shared.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDatabaseOption = parseDatabaseOption;
 exports.getPrismaProvidersFromGenerator = getPrismaProvidersFromGenerator;
 exports.isPrismaOption = isPrismaOption;
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const package_root_1 = require("../utils/package-root");
 function parseDatabaseOption(dbOption) {
@@ -19,20 +20,21 @@ function parseDatabaseOption(dbOption) {
     }
     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 gen = fs_extra_1.default.readJsonSync(genPath, { throws: false });
         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));
+        const ops = gen && typeof gen === "object" ? gen["operations"] : undefined;
+        if (Array.isArray(ops)) {
+            for (const op of ops) {
+                const cond = op && typeof op === "object" ? op["condition"] : undefined;
+                if (cond && typeof cond["prismaProvider"] === "string") {
+                    providers.add(String(cond["prismaProvider"]));
+                }
             }
         }
         return Array.from(providers);

package/dist/lib/generation/code-generator.d.ts

@@ -53,6 +53,7 @@ export declare class AdvancedCodeGenerator {
     private generators;
     private frameworkConfig;
     private postInstallCommands;
+    private createdFiles;
     constructor(frameworkConfig: FrameworkConfig);
     loadGenerators(modulesPath: string): Promise<void>;
     private evaluateCondition;
@@ -65,6 +66,7 @@ export declare class AdvancedCodeGenerator {
         auth?: string;
         prismaProvider?: string;
     }, features: string[], outputPath: string): Promise<string[]>;
+    getCreatedFiles(): string[];
     private executeOperation;
     private copyTemplate;
     private processOperationTemplates;