stackkit 0.2.8 → 0.3.0

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

@@ -12,20 +12,24 @@ 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
- */
+async function readJsonSafe(filePath) {
+    try {
+        return (await fs_extra_1.default.readJson(filePath));
+    }
+    catch {
+        return null;
+    }
+}
 async function discoverModules(modulesDir) {
     const discovered = {
         frameworks: [],
         databases: [],
         auth: [],
     };
-    // If modulesDir isn't provided or doesn't exist, try common locations
     const candidates = [];
     if (modulesDir)
         candidates.push(modulesDir);
-    candidates.push(path_1.default.join((0, package_root_1.getPackageRoot)(), "modules")); // package root
+    candidates.push(path_1.default.join((0, package_root_1.getPackageRoot)(), "modules"));
     let resolvedModulesDir;
     for (const c of candidates) {
         if (await fs_extra_1.default.pathExists(c)) {
@@ -36,32 +40,26 @@ async function discoverModules(modulesDir) {
     if (!resolvedModulesDir)
         return discovered;
     modulesDir = resolvedModulesDir;
-    // Discover frameworks from templates directory
     const templatesDir = path_1.default.join(modulesDir, "..", "templates");
     if (await fs_extra_1.default.pathExists(templatesDir)) {
         const frameworkDirs = await fs_extra_1.default.readdir(templatesDir);
         for (const frameworkName of frameworkDirs) {
             const templateJsonPath = path_1.default.join(templatesDir, frameworkName, "template.json");
             if (await fs_extra_1.default.pathExists(templateJsonPath)) {
-                try {
-                    const templateConfig = (await fs_extra_1.default.readJson(templateJsonPath));
+                const templateConfig = await readJsonSafe(templateJsonPath);
+                if (templateConfig) {
                     discovered.frameworks.push({
                         ...templateConfig,
                         name: frameworkName,
                         category: "framework",
                     });
                 }
-                catch {
-                    // ignore invalid template
-                }
             }
         }
     }
-    // Discover database modules
     const databaseDir = path_1.default.join(modulesDir, "database");
     if (await fs_extra_1.default.pathExists(databaseDir)) {
         const dbModules = await fs_extra_1.default.readdir(databaseDir);
-        // Sort to ensure consistent order: prisma first, then others
         dbModules.sort((a, b) => {
             if (a === "prisma")
                 return -1;
@@ -73,22 +71,17 @@ async function discoverModules(modulesDir) {
             const modulePath = path_1.default.join(databaseDir, moduleName);
             const moduleJsonPath = path_1.default.join(modulePath, "module.json");
             if (await fs_extra_1.default.pathExists(moduleJsonPath)) {
-                try {
-                    const metadata = (await fs_extra_1.default.readJson(moduleJsonPath));
-                    // Ensure name/displayName fallbacks
+                const metadata = await readJsonSafe(moduleJsonPath);
+                if (metadata) {
                     if (!metadata.name)
                         metadata.name = moduleName;
                     if (!metadata.displayName)
                         metadata.displayName = moduleName;
                     discovered.databases.push(metadata);
                 }
-                catch {
-                    // ignore invalid module
-                }
             }
         }
     }
-    // Discover auth modules
     const authDir = path_1.default.join(modulesDir, "auth");
     if (await fs_extra_1.default.pathExists(authDir)) {
         const authModules = await fs_extra_1.default.readdir(authDir);
@@ -96,25 +89,19 @@ async function discoverModules(modulesDir) {
             const modulePath = path_1.default.join(authDir, moduleName);
             const moduleJsonPath = path_1.default.join(modulePath, "module.json");
             if (await fs_extra_1.default.pathExists(moduleJsonPath)) {
-                try {
-                    const metadata = (await fs_extra_1.default.readJson(moduleJsonPath));
+                const metadata = await readJsonSafe(moduleJsonPath);
+                if (metadata) {
                     if (!metadata.name)
                         metadata.name = moduleName;
                     if (!metadata.displayName)
                         metadata.displayName = moduleName;
                     discovered.auth.push(metadata);
                 }
-                catch {
-                    // ignore invalid module
-                }
             }
         }
     }
     return discovered;
 }
-/**
- * Get valid database options for CLI
- */
 function getValidDatabaseOptions(databases) {
     const options = ["none"];
     for (const db of databases) {
@@ -129,15 +116,11 @@ function getValidDatabaseOptions(databases) {
             }
         }
         else {
-            // For other databases, add the module name directly (generic handling)
             options.push(db.name);
         }
     }
     return options;
 }
-/**
- * Get valid auth options for CLI
- */
 function getValidAuthOptions(authModules) {
     const options = ["none"];
     for (const auth of authModules) {
@@ -145,28 +128,17 @@ function getValidAuthOptions(authModules) {
     }
     return options;
 }
-// parseDatabaseOption moved to shared helpers
-/**
- * Get compatible auth options for given framework and database
- */
 function getCompatibleAuthOptions(authModules, framework, database, frameworksMeta) {
     const compatible = [];
     for (const auth of authModules) {
-        // Check if auth supports the framework
         if (auth.supportedFrameworks && !auth.supportedFrameworks.includes(framework)) {
             continue;
         }
-        // Normalize database option (handle prisma-<provider> values)
         const parsedDb = (0, shared_1.parseDatabaseOption)(database || "").database;
-        // If module provides explicit compatibility matrix, use it
         let dbCompatible = true;
         if (auth.compatibility && auth.compatibility.databases) {
             dbCompatible = auth.compatibility.databases.includes(parsedDb);
         }
-        // If the framework template explicitly lists this auth as compatible,
-        // allow it even if the auth module's database compatibility would normally
-        // exclude the current database selection (covers cases like React where
-        // the framework can support auth without a DB).
         let explicitlyAllowedByFramework = false;
         if (frameworksMeta && Array.isArray(frameworksMeta)) {
             const fw = frameworksMeta.find((f) => f.name === framework);
@@ -184,17 +156,12 @@ function getCompatibleAuthOptions(authModules, framework, database, frameworksMe
             value: auth.name,
         });
     }
-    // Add "None" at the end
     compatible.push({ name: "None", value: "none" });
     return compatible;
 }
-/**
- * Get database choices for inquirer prompts
- */
 function getDatabaseChoices(databases, framework) {
     const choices = [];
     for (const db of databases) {
-        // Check framework compatibility
         if (db.supportedFrameworks && !db.supportedFrameworks.includes(framework)) {
             continue;
         }
@@ -212,11 +179,9 @@ function getDatabaseChoices(databases, framework) {
             }
         }
         else {
-            // Generic handling for other database modules
             choices.push({ name: db.displayName || db.name, value: db.name });
         }
     }
-    // Add "None" at the end
     choices.push({ name: "None", value: "none" });
     return choices;
 }

package/dist/lib/framework/framework-utils.d.ts

@@ -15,8 +15,7 @@ export interface ModuleConfig {
         databases?: string[];
     };
 }
-export declare class FrameworkUtils {
-    private static frameworkConfigs;
-    static loadFrameworkConfig(frameworkName: string, templatesDir: string): Promise<FrameworkConfig>;
-    static isCompatible(framework: string, database?: string, auth?: string): boolean;
-}
+export declare const FrameworkUtils: {
+    loadFrameworkConfig(frameworkName: string, templatesDir: string): Promise<FrameworkConfig>;
+    isCompatible(framework: string, database?: string, auth?: string): boolean;
+};

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

@@ -36,16 +36,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FrameworkUtils = void 0;
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-class FrameworkUtils {
-    static async loadFrameworkConfig(frameworkName, templatesDir) {
+const frameworkConfigs = new Map();
+async function collectModuleNames(baseDir) {
+    if (!(await fs.pathExists(baseDir))) {
+        return [];
+    }
+    const names = [];
+    const entries = await fs.readdir(baseDir);
+    for (const entry of entries) {
+        const moduleJson = path.join(baseDir, entry, "module.json");
+        if (!(await fs.pathExists(moduleJson))) {
+            continue;
+        }
+        try {
+            const moduleConfig = (await fs.readJson(moduleJson));
+            if (moduleConfig.name) {
+                names.push(moduleConfig.name);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return names;
+}
+exports.FrameworkUtils = {
+    async loadFrameworkConfig(frameworkName, templatesDir) {
         const configPath = path.join(templatesDir, frameworkName, "template.json");
         if (await fs.pathExists(configPath)) {
             const config = await fs.readJson(configPath);
-            this.frameworkConfigs.set(frameworkName, config);
+            frameworkConfigs.set(frameworkName, config);
             return config;
         }
-        // Derive compatibility dynamically from available modules if possible
         const defaultConfig = {
             name: frameworkName,
             displayName: frameworkName.charAt(0).toUpperCase() + frameworkName.slice(1),
@@ -56,51 +78,20 @@ class FrameworkUtils {
         };
         try {
             const modulesDir = path.join(templatesDir, "..", "modules");
-            const dbDir = path.join(modulesDir, "database");
-            const authDir = path.join(modulesDir, "auth");
-            if (await fs.pathExists(dbDir)) {
-                const dbs = await fs.readdir(dbDir);
-                for (const d of dbs) {
-                    const moduleJson = path.join(dbDir, d, "module.json");
-                    if (await fs.pathExists(moduleJson)) {
-                        try {
-                            const m = await fs.readJson(moduleJson);
-                            if (m && m.name)
-                                defaultConfig.compatibility.databases.push(m.name);
-                        }
-                        catch {
-                            // ignore malformed
-                        }
-                    }
-                }
-            }
-            if (await fs.pathExists(authDir)) {
-                const auths = await fs.readdir(authDir);
-                for (const a of auths) {
-                    const moduleJson = path.join(authDir, a, "module.json");
-                    if (await fs.pathExists(moduleJson)) {
-                        try {
-                            const m = await fs.readJson(moduleJson);
-                            if (m && m.name)
-                                defaultConfig.compatibility.auth.push(m.name);
-                        }
-                        catch {
-                            // ignore malformed
-                        }
-                    }
-                }
-            }
+            defaultConfig.compatibility.databases = await collectModuleNames(path.join(modulesDir, "database"));
+            defaultConfig.compatibility.auth = await collectModuleNames(path.join(modulesDir, "auth"));
         }
         catch {
-            // ignore discovery errors and leave empty lists
+            defaultConfig.compatibility.databases = [];
+            defaultConfig.compatibility.auth = [];
         }
-        this.frameworkConfigs.set(frameworkName, defaultConfig);
+        frameworkConfigs.set(frameworkName, defaultConfig);
         return defaultConfig;
-    }
-    static isCompatible(framework, database, auth) {
-        const config = this.frameworkConfigs.get(framework);
+    },
+    isCompatible(framework, database, auth) {
+        const config = frameworkConfigs.get(framework);
         if (!config)
-            return true; // Assume compatible if no config
+            return true;
         if (database && !config.compatibility.databases.includes(database)) {
             return false;
         }
@@ -108,7 +99,5 @@ class FrameworkUtils {
             return false;
         }
         return true;
-    }
-}
-exports.FrameworkUtils = FrameworkUtils;
-FrameworkUtils.frameworkConfigs = new Map();
+    },
+};

package/dist/lib/fs/files.js

@@ -19,7 +19,7 @@ async function copyBaseFramework(templatesDir, targetDir, framework) {
         throw new Error(`Base template not found for framework: ${framework}\n` + `Expected at: ${baseDir}`);
     }
     await fs_extra_1.default.copy(baseDir, targetDir, {
-        filter: (src) => !constants_1.EXCLUDE_FROM_COPY.includes(path_1.default.basename(src)),
+        filter: (src) => !constants_1.EXCLUDE_FROM_COPY.some((entry) => entry === path_1.default.basename(src)),
     });
 }
 async function mergePackageJson(targetDir, config) {

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

@@ -14,6 +14,12 @@ export interface TemplateCondition {
     auth?: string | string[];
     features?: string[];
 }
+type SelectedModules = {
+    framework: string;
+    database?: string;
+    auth?: string;
+    prismaProvider?: string;
+};
 export interface Operation {
     type: "create-file" | "patch-file" | "add-dependency" | "add-script" | "add-env" | "run-command";
     description?: string;
@@ -57,46 +63,34 @@ export declare class AdvancedCodeGenerator {
     private postInstallCommands;
     private createdFiles;
     constructor(frameworkConfig: FrameworkConfig);
+    private initializeContext;
+    private isGeneratorSelected;
     loadGenerators(modulesPath: string): Promise<void>;
     private evaluateCondition;
     private processTemplate;
     private renderHeadingFromExpr;
     private processVariableDefinitions;
     private processTemplateRecursive;
-    generate(selectedModules: {
-        framework: string;
-        database?: string;
-        auth?: string;
-        prismaProvider?: string;
-    }, features: string[], outputPath: string): Promise<string[]>;
+    generate(selectedModules: SelectedModules, features: string[], outputPath: string): Promise<string[]>;
     getCreatedFiles(): string[];
     private executeOperation;
     private copyTemplate;
     private processOperationTemplates;
     private executeCreateFile;
+    private parsePathPattern;
+    private collectFilesRecursively;
     private executePatchFile;
     private executeAddDependency;
     private executeAddScript;
     private executeAddEnv;
     private executeRunCommand;
     private generatePackageJson;
-    /**
-     * Apply generators to an existing project directory instead of creating a new template.
-     * This executes applicable operations and updates package.json in-place.
-     */
-    applyToProject(selectedModules: {
-        framework: string;
-        database?: string;
-        auth?: string;
-        prismaProvider?: string;
-    }, features: string[], projectPath: string): Promise<string[]>;
+    applyToProject(selectedModules: SelectedModules, features: string[], projectPath: string): Promise<string[]>;
     getAvailableGenerators(): {
         frameworks: string[];
         databases: string[];
         auths: string[];
     };
-    /**
-     * Register a generator config dynamically (used for modules that only provide module.json patches).
-     */
     registerGenerator(type: "framework" | "database" | "auth", name: string, config: GeneratorConfig): void;
 }
+export {};