stackkit 0.2.0 → 0.2.2

package/dist/cli/doctor.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 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.",
@@ -211,24 +212,125 @@ function checkNodeVersion() {
 function detectAuthModules(packageJson) {
     const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
     const modules = [];
-    if (deps["better-auth"]) {
-        modules.push("better-auth");
+    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
+                }
+            }
+        }
     }
-    if (deps["next-auth"]) {
-        modules.push("authjs");
+    catch {
+        // ignore discovery errors
     }
-    return modules;
+    // 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 = [];
-    if (deps["@prisma/client"] || deps["prisma"]) {
-        modules.push("prisma");
+    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
     }
-    if (deps["mongoose"]) {
-        modules.push("mongoose");
+    // 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 modules;
+    return Array.from(new Set(modules));
 }
 async function checkKeyFiles(projectRoot, projectType, authModules, databaseModules) {
     const checks = [];
@@ -260,8 +362,42 @@ async function checkKeyFiles(projectRoot, projectType, authModules, databaseModu
 async function checkAuthRoutesExist(projectRoot, projectType) {
     if (projectType !== "nextjs")
         return true; // Skip for non-Next.js
-    const possiblePaths = [
-        // NextAuth routes
+    // Build candidate auth route paths from generator.json files in modules/auth
+    const candidates = new Set();
+    try {
+        const authModulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "auth");
+        if (await fs_extra_1.default.pathExists(authModulesDir)) {
+            const authDirs = await fs_extra_1.default.readdir(authModulesDir);
+            for (const dir of authDirs) {
+                const genPath = path_1.default.join(authModulesDir, dir, "generator.json");
+                if (!(await fs_extra_1.default.pathExists(genPath)))
+                    continue;
+                try {
+                    const gen = await fs_extra_1.default.readJson(genPath);
+                    if (Array.isArray(gen.operations)) {
+                        for (const op of gen.operations) {
+                            if (typeof op.destination === "string")
+                                candidates.add(op.destination);
+                            if (Array.isArray(op.operations)) {
+                                for (const sub of op.operations) {
+                                    if (typeof sub.destination === "string")
+                                        candidates.add(sub.destination);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // ignore malformed generator
+                }
+            }
+        }
+    }
+    catch {
+        // 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",
@@ -270,13 +406,14 @@ async function checkAuthRoutesExist(projectRoot, projectType) {
         "pages/api/auth/[...nextauth].js",
         "src/pages/api/auth/[...nextauth].ts",
         "src/pages/api/auth/[...nextauth].js",
-        // Better Auth routes
         "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 routePath of possiblePaths) {
+    for (const p of fallback)
+        candidates.add(p);
+    for (const routePath of candidates) {
         if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, routePath))) {
             return true;
         }
@@ -288,14 +425,59 @@ async function checkEnvFiles(projectRoot, authModules, databaseModules) {
     const requiredKeys = [];
     const missing = [];
     const present = [];
-    if (databaseModules.includes("prisma")) {
-        requiredKeys.push("DATABASE_URL");
-    }
-    if (authModules.includes("authjs")) {
-        requiredKeys.push("NEXTAUTH_SECRET", "NEXTAUTH_URL");
+    // Dynamically collect required env keys from generator.json for detected modules
+    try {
+        const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules");
+        async function collectEnvKeys(category, name) {
+            const genPath = path_1.default.join(modulesDir, category, name, "generator.json");
+            if (!(await fs_extra_1.default.pathExists(genPath)))
+                return;
+            try {
+                const gen = await fs_extra_1.default.readJson(genPath);
+                if (Array.isArray(gen.operations)) {
+                    for (const op of gen.operations) {
+                        if (op.type === "add-env" && op.envVars && typeof op.envVars === "object") {
+                            for (const k of Object.keys(op.envVars)) {
+                                if (!requiredKeys.includes(k))
+                                    requiredKeys.push(k);
+                            }
+                        }
+                        // Also check nested operations (e.g., patch-file -> operations)
+                        if (Array.isArray(op.operations)) {
+                            for (const sub of op.operations) {
+                                if (sub.type === "add-env" && sub.envVars && typeof sub.envVars === "object") {
+                                    for (const k of Object.keys(sub.envVars)) {
+                                        if (!requiredKeys.includes(k))
+                                            requiredKeys.push(k);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // ignore malformed generator
+            }
+        }
+        for (const db of databaseModules) {
+            await collectEnvKeys("database", db);
+        }
+        for (const auth of authModules) {
+            await collectEnvKeys("auth", auth);
+        }
     }
-    if (authModules.includes("better-auth")) {
-        requiredKeys.push("BETTER_AUTH_SECRET", "BETTER_AUTH_URL");
+    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");
+        }
     }
     const envPaths = [".env", ".env.local"];
     let envContent = "";

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