entkapp 5.5.0 → 5.6.1

package/src/plugins/BasePlugin.mjs

@@ -0,0 +1,240 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Base class for all entkapp plugins.
+ * Defines the contract for ecosystem detection, entry point mapping,
+ * and missing dependency / devDependency detection.
+ * Version 5.0.0: Added getMissingDependencies(), getOrphanedConfigs(), runDependencyDiagnostics().
+ */
+export class BasePlugin {
+    constructor(context) {
+        this.context = context;
+        this.customGetters = new Map();
+    }
+
+    /**
+     * Unique identifier for the plugin (e.g., 'nextjs').
+     */
+    get name() {
+        throw new Error('Plugin must implement name getter');
+    }
+
+    /**
+     * Returns a list of configuration files that indicate this ecosystem is active.
+     */
+    getConfigFiles() {
+        return [];
+    }
+
+    /**
+     * Returns regex patterns for files that should be treated as entry points.
+     */
+    getRoutePatterns() {
+        return [];
+    }
+
+    /**
+     * Returns symbols that are implicitly required/exported by the framework.
+     */
+    getRequiredSystemContracts() {
+        return ['default'];
+    }
+
+    /**
+     * Returns the npm package names required for this plugin to work.
+     * Each entry is either a string or an object:
+     *   { name: string, dev?: boolean, optional?: boolean }
+     *   - dev: true  => expected in devDependencies
+     *   - dev: false => expected in dependencies
+     *   - optional   => only warn, not error
+     *
+     * Override in subclasses to enable automatic dependency checking.
+     * @returns {Array<string | {name: string, dev?: boolean, optional?: boolean}>}
+     */
+    getRequiredPackages() {
+        return [];
+    }
+
+    /**
+     * Version 5.0.0: Checks whether all required packages are present in package.json.
+     * Returns an array of diagnostic objects describing missing or misplaced dependencies.
+     *
+     * @param {string} baseDir - The project root directory
+     * @returns {Promise<Array>}
+     */
+    async getMissingDependencies(baseDir) {
+        const diagnostics = [];
+        const requiredPackages = this.getRequiredPackages();
+        if (requiredPackages.length === 0) return diagnostics;
+
+        let pkg = null;
+        try {
+            const raw = await fs.readFile(path.join(baseDir, 'package.json'), 'utf8');
+            pkg = JSON.parse(raw);
+        } catch {
+            return diagnostics;
+        }
+
+        const deps = pkg.dependencies || {};
+        const devDeps = pkg.devDependencies || {};
+
+        for (const entry of requiredPackages) {
+            const pkgName = typeof entry === 'string' ? entry : entry.name;
+            const isDev = typeof entry === 'object' ? entry.dev : undefined;
+            const isOptional = typeof entry === 'object' ? (entry.optional ?? false) : false;
+
+            const inDeps = pkgName in deps;
+            const inDevDeps = pkgName in devDeps;
+            const found = inDeps ? 'dependencies' : inDevDeps ? 'devDependencies' : null;
+
+            if (!found) {
+                let triggerFile = null;
+                for (const cfgFile of this.getConfigFiles()) {
+                    try {
+                        await fs.access(path.join(baseDir, cfgFile));
+                        triggerFile = cfgFile;
+                        break;
+                    } catch { /* not found */ }
+                }
+
+                const expectedIn = isDev === true ? 'devDependencies' : isDev === false ? 'dependencies' : 'either';
+                const severity = isOptional ? 'warning' : 'error';
+
+                let message = `Plugin "${this.name}": package "${pkgName}" is not installed`;
+                if (triggerFile) {
+                    message += ` (config file "${triggerFile}" was found)`;
+                }
+                if (isDev === true) {
+                    message += ` — expected in devDependencies`;
+                } else if (isDev === false) {
+                    message += ` — expected in dependencies`;
+                }
+
+                diagnostics.push({
+                    plugin: this.name,
+                    package: pkgName,
+                    expectedIn,
+                    foundIn: null,
+                    configFile: triggerFile,
+                    severity,
+                    message,
+                });
+            } else if (isDev === true && found === 'dependencies') {
+                diagnostics.push({
+                    plugin: this.name,
+                    package: pkgName,
+                    expectedIn: 'devDependencies',
+                    foundIn: 'dependencies',
+                    configFile: null,
+                    severity: 'warning',
+                    message: `Plugin "${this.name}": package "${pkgName}" is in "dependencies" but should be in "devDependencies"`,
+                });
+            } else if (isDev === false && found === 'devDependencies') {
+                diagnostics.push({
+                    plugin: this.name,
+                    package: pkgName,
+                    expectedIn: 'dependencies',
+                    foundIn: 'devDependencies',
+                    configFile: null,
+                    severity: 'warning',
+                    message: `Plugin "${this.name}": package "${pkgName}" is in "devDependencies" but should be in "dependencies"`,
+                });
+            }
+        }
+
+        return diagnostics;
+    }
+
+    /**
+     * Version 5.0.0: Checks for config files that exist without the corresponding package.
+     * Detects "orphaned" configs – e.g. .prettierrc exists but prettier is not installed.
+     *
+     * @param {string} baseDir
+     * @returns {Promise<Array>}
+     */
+    async getOrphanedConfigs(baseDir) {
+        const diagnostics = [];
+        const requiredPackages = this.getRequiredPackages();
+        if (requiredPackages.length === 0) return diagnostics;
+
+        let pkg = null;
+        try {
+            const raw = await fs.readFile(path.join(baseDir, 'package.json'), 'utf8');
+            pkg = JSON.parse(raw);
+        } catch {
+            return diagnostics;
+        }
+
+        const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+
+        const anyPackagePresent = requiredPackages.some(entry => {
+            const pkgName = typeof entry === 'string' ? entry : entry.name;
+            return pkgName in allDeps;
+        });
+
+        if (!anyPackagePresent) {
+            for (const cfgFile of this.getConfigFiles()) {
+                try {
+                    await fs.access(path.join(baseDir, cfgFile));
+                    const missingPkgs = requiredPackages
+                        .map(e => typeof e === 'string' ? e : e.name)
+                        .filter(n => !(n in allDeps));
+
+                    diagnostics.push({
+                        plugin: this.name,
+                        configFile: cfgFile,
+                        severity: 'error',
+                        message: `Plugin "${this.name}": config file "${cfgFile}" exists but required package(s) [${missingPkgs.join(', ')}] are not installed`,
+                    });
+                } catch { /* file not found */ }
+            }
+        }
+
+        return diagnostics;
+    }
+
+    /**
+     * Version 5.0.0: Run all dependency diagnostics (missing + orphaned).
+     * Convenience method combining getMissingDependencies and getOrphanedConfigs.
+     *
+     * @param {string} baseDir
+     * @returns {Promise<Array>}
+     */
+    async runDependencyDiagnostics(baseDir) {
+        const [missing, orphaned] = await Promise.all([
+            this.getMissingDependencies(baseDir),
+            this.getOrphanedConfigs(baseDir),
+        ]);
+        return [...missing, ...orphaned];
+    }
+
+    /**
+     * Version 3.2.0: Dynamic getter for custom plugin properties.
+     * @param {string} key - The property key to retrieve
+     * @returns {any} The value of the custom property
+     */
+    get(key) {
+        const methodName = `get${key.charAt(0).toUpperCase() + key.slice(1)}`;
+        if (typeof this[methodName] === 'function') {
+            return this[methodName]();
+        }
+        return this.customGetters.get(key);
+    }
+
+    /**
+     * Optional: Logic to detect if the plugin should be active in the given directory.
+     */
+    async isActive(baseDir) {
+        const configFiles = this.getConfigFiles();
+        for (const file of configFiles) {
+            try {
+                await fs.access(path.join(baseDir, file));
+                return true;
+            } catch {
+                continue;
+            }
+        }
+        return false;
+    }
+}

package/src/plugins/PluginRegistry.mjs

@@ -0,0 +1,203 @@
+import { loadAdditionalPlugins } from "./ecosystems/PluginLoader.mjs";
+import path from 'path';
+import fs from 'fs/promises';
+import { pathToFileURL } from 'url';
+import { AllPluginClasses } from './ecosystems/UltimateBundle.mjs';
+/**
+ * ============================================================================
+ * Plugin Registry for entkapp v5.0.0
+ * ============================================================================
+ * Advanced Plugin Registry supporting Builtin and Custom plugins.
+ * v5.0.0: Added runAllDependencyDiagnostics() for project-wide dependency checks.
+ */
+export class PluginRegistry {
+    constructor(context) {
+        this.context = context;
+        this.plugins = new Map();
+        this.config = null;
+    }
+
+    async init(projectRoot) {
+        const configPath = path.join(projectRoot, 'entkapp', 'config.json');
+        try {
+            const configRaw = await fs.readFile(configPath, 'utf8');
+            this.config = JSON.parse(configRaw);
+        } catch (e) {
+            this.config = {
+                useBuiltinPlugins: true,
+                useCustomPlugins: true,
+            };
+        }
+        if (this.config.useBuiltinPlugins !== false) {
+            await this.loadBuiltinPlugins();
+        }
+        if (this.config.useCustomPlugins !== false) {
+            await this.loadCustomPlugins(projectRoot);
+        }
+    }
+
+    async loadBuiltinPlugins() {
+        // Delegate to PluginLoader which registers all built-in plugins
+        loadAdditionalPlugins(this);
+
+        // Also load TypeScript and Next.js plugins (primary framework plugins)
+        
+
+        AllPluginClasses.forEach(PluginClass => {
+            this.register(new PluginClass(this.context));
+        });
+    }
+    async loadCustomPlugins(projectRoot) {
+        const pluginsDir = path.join(projectRoot, 'entkapp', 'plugins');
+        try {
+            const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                let pluginPath = path.join(pluginsDir, entry.name);
+                // Folder-based plugin support
+                if (entry.isDirectory()) {
+                    const files = await fs.readdir(pluginPath);
+                    if (files.includes('index.ts')) {
+                        pluginPath = path.join(pluginPath, 'index.ts');
+                    } else if (files.includes('index.mjs')) {
+                        pluginPath = path.join(pluginPath, 'index.mjs');
+                    } else {
+                        continue;
+                    }
+                }
+                if (pluginPath.endsWith('.ts')) {
+                    await this.loadTypeScriptPlugin(pluginPath);
+                } else if (pluginPath.endsWith('.mjs') || pluginPath.endsWith('.mjs')) {
+                    await this.loadJavaScriptPlugin(pluginPath);
+                }
+            }
+        } catch (e) {
+            // No custom plugins or dir missing
+        }
+    }
+
+    async loadJavaScriptPlugin(pluginPath) {
+        try {
+            const pluginModule = await import(pathToFileURL(pluginPath).href);
+            const PluginClass = pluginModule.default || pluginModule;
+            const pluginInstance = new PluginClass(this.context);
+            this.register(pluginInstance);
+        } catch (e) {
+            console.error(`[PluginRegistry] Failed to load JS plugin ${pluginPath}:`, e);
+        }
+    }
+
+    async loadTypeScriptPlugin(pluginPath) {
+        try {
+            if (this.context?.verbose) {
+                console.log(`[PluginRegistry] Transpiling TS plugin: ${pluginPath}`);
+            }
+            await this.loadJavaScriptPlugin(pluginPath);
+        } catch (e) {
+            console.error(`[PluginRegistry] Failed to load TS plugin ${pluginPath}:`, e);
+        }
+    }
+
+    register(plugin) {
+        if (plugin && plugin.name) {
+            this.plugins.set(plugin.name, plugin);
+        }
+    }
+
+    getPlugins() {
+        return Array.from(this.plugins.values());
+    }
+
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+
+    async getActivePlugins(baseDir) {
+        const active = [];
+        for (const plugin of this.plugins.values()) {
+            if (await plugin.isActive(baseDir)) {
+                active.push(plugin);
+            }
+        }
+        return active;
+    }
+
+    /**
+     * Version 5.0.0: Run dependency diagnostics across all registered plugins.
+     * Returns a consolidated list of missing/misplaced dependencies and orphaned configs.
+     *
+     * @param {string} baseDir - The project root directory to check
+     * @returns {Promise<Array<{
+     *   plugin: string,
+     *   severity: 'error' | 'warning',
+     *   message: string,
+     *   package?: string,
+     *   configFile?: string,
+     *   expectedIn?: string,
+     *   foundIn?: string | null
+     * }>>}
+     */
+    async runAllDependencyDiagnostics(baseDir) {
+        const allDiagnostics = [];
+        const seenMessages = new Set();
+
+        for (const plugin of this.plugins.values()) {
+            if (typeof plugin.runDependencyDiagnostics === 'function') {
+                try {
+                    const diagnostics = await plugin.runDependencyDiagnostics(baseDir);
+                    for (const d of diagnostics) {
+                        // Deduplicate by message to avoid noise from overlapping plugins
+                        if (!seenMessages.has(d.message)) {
+                            seenMessages.add(d.message);
+                            allDiagnostics.push(d);
+                        }
+                    }
+                } catch (e) {
+                    if (this.context?.verbose) {
+                        console.warn(`[PluginRegistry] Dependency diagnostic failed for plugin "${plugin.name}":`, e.message);
+                    }
+                }
+            }
+        }
+
+        // Sort: errors first, then warnings; then alphabetically by plugin name
+        return allDiagnostics.sort((a, b) => {
+            if (a.severity !== b.severity) return a.severity === 'error' ? -1 : 1;
+            return a.plugin.localeCompare(b.plugin);
+        });
+    }
+
+    /**
+     * Version 5.0.0: Format dependency diagnostics for console output.
+     * @param {Array} diagnostics - Result of runAllDependencyDiagnostics()
+     * @returns {string} Formatted string ready for console output
+     */
+    formatDependencyDiagnostics(diagnostics) {
+        if (diagnostics.length === 0) {
+            return '[entkapp] No missing dependencies detected.';
+        }
+
+        const errors = diagnostics.filter(d => d.severity === 'error');
+        const warnings = diagnostics.filter(d => d.severity === 'warning');
+
+        const lines = [];
+        lines.push(`[entkapp] Dependency Diagnostics: ${errors.length} error(s), ${warnings.length} warning(s)`);
+        lines.push('');
+
+        if (errors.length > 0) {
+            lines.push('  Errors:');
+            for (const d of errors) {
+                lines.push(`    [ERROR]  ${d.message}`);
+            }
+            lines.push('');
+        }
+
+        if (warnings.length > 0) {
+            lines.push('  Warnings:');
+            for (const d of warnings) {
+                lines.push(`    [WARN]   ${d.message}`);
+            }
+        }
+
+        return lines.join('\n');
+    }
+}

package/src/plugins/ecosystems/BackendServices.mjs

@@ -0,0 +1,197 @@
+/**
+ * ============================================================================
+ * Backend Services Plugins for entkapp v5.0.0
+ * ============================================================================
+ * Built-in support for GraphQL, REST APIs, Databases, and BaaS providers.
+ * v5.0.0: All plugins implement getRequiredPackages() for dependency detection.
+ */
+import { BasePlugin } from '../BasePlugin.mjs';
+import fs from 'fs/promises';
+import path from 'path';
+
+export class GraphQLPlugin extends BasePlugin {
+  get name() { return 'graphql'; }
+  getConfigFiles() { return ['package.json', 'graphql.config.mjs', 'graphql.config.ts', '.graphqlconfig', 'graphql.config.yml']; }
+  getRequiredPackages() {
+    return [{ name: 'graphql', dev: false }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.graphql || pkgJson.devDependencies?.graphql || pkgJson.dependencies?.['@apollo/client']);
+    } catch { return false; }
+  }
+  async analyze(node, filePath) {
+    const gqlPattern = /gql\s*`([\s\S]*?)`/g;
+    const matches = node.rawCode?.match(gqlPattern) || [];
+    if (matches.length > 0) node.graphqlQueries = matches;
+  }
+}
+
+export class ApolloPlugin extends BasePlugin {
+  get name() { return 'apollo'; }
+  getConfigFiles() { return ['package.json', 'apollo.config.mjs', 'apollo.config.ts']; }
+  getRequiredPackages() {
+    return [
+      { name: '@apollo/client', dev: false },
+      { name: '@apollo/server', dev: false, optional: true },
+    ];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@apollo/client'] || pkgJson.dependencies?.['@apollo/server'] ||
+               pkgJson.devDependencies?.['@apollo/client'] || pkgJson.devDependencies?.['@apollo/server']);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('ApolloClient') || node.rawCode?.includes('ApolloServer')) node.isEntry = true;
+  }
+}
+
+export class DatabasePlugin extends BasePlugin {
+  get name() { return 'database'; }
+  getConfigFiles() { return ['package.json', 'prisma/schema.prisma', 'drizzle.config.ts', 'drizzle.config.mjs', 'ormconfig.json']; }
+  getRequiredPackages() {
+    return [
+      { name: '@prisma/client', dev: false, optional: true },
+      { name: 'drizzle-orm', dev: false, optional: true },
+      { name: 'typeorm', dev: false, optional: true },
+    ];
+  }
+  async analyze(node, filePath) {
+    if (node.explicitImports?.has('@prisma/client') || node.explicitImports?.has('drizzle-orm'))
+      node.usesDatabase = true;
+  }
+}
+
+export class PrismaPlugin extends BasePlugin {
+  get name() { return 'prisma'; }
+  getConfigFiles() { return ['prisma/schema.prisma', 'schema.prisma']; }
+  getRequiredPackages() {
+    return [
+      { name: '@prisma/client', dev: false },
+      { name: 'prisma', dev: true },
+    ];
+  }
+  async isActive(baseDir) {
+    for (const f of this.getConfigFiles()) {
+      try { await fs.access(path.join(baseDir, f)); return true; } catch {}
+    }
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@prisma/client'] || pkgJson.devDependencies?.prisma);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('new PrismaClient()')) node.isEntry = true;
+  }
+}
+
+export class DrizzlePlugin extends BasePlugin {
+  get name() { return 'drizzle'; }
+  getConfigFiles() { return ['drizzle.config.ts', 'drizzle.config.mjs', 'drizzle.config.mjs']; }
+  getRequiredPackages() {
+    return [
+      { name: 'drizzle-orm', dev: false },
+      { name: 'drizzle-kit', dev: true },
+    ];
+  }
+  async isActive(baseDir) {
+    for (const f of this.getConfigFiles()) {
+      try { await fs.access(path.join(baseDir, f)); return true; } catch {}
+    }
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['drizzle-orm'] || pkgJson.devDependencies?.['drizzle-orm']);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('drizzle(')) node.isEntry = true;
+  }
+}
+
+export class MongoosePlugin extends BasePlugin {
+  get name() { return 'mongoose'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() {
+    return [{ name: 'mongoose', dev: false }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.mongoose || pkgJson.devDependencies?.mongoose);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('mongoose.model(')) node.isEntry = true;
+  }
+}
+
+export class SupabasePlugin extends BasePlugin {
+  get name() { return 'supabase'; }
+  getConfigFiles() { return ['supabase/config.toml', '.env', '.env.local', 'package.json']; }
+  getRequiredPackages() {
+    return [{ name: '@supabase/supabase-js', dev: false }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.['@supabase/supabase-js'] || pkgJson.devDependencies?.['@supabase/supabase-js']);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('createClient') && node.rawCode?.includes('supabase')) node.isEntry = true;
+  }
+}
+
+export class FirebasePlugin extends BasePlugin {
+  get name() { return 'firebase'; }
+  getConfigFiles() { return ['firebase.json', '.firebaserc', 'package.json']; }
+  getRequiredPackages() {
+    return [{ name: 'firebase', dev: false }];
+  }
+  async isActive(baseDir) {
+    for (const f of ['firebase.json', '.firebaserc']) {
+      try { await fs.access(path.join(baseDir, f)); return true; } catch {}
+    }
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      return !!(pkgJson.dependencies?.firebase || pkgJson.devDependencies?.firebase);
+    } catch { return false; }
+  }
+  async analyze(node) {
+    if (node.rawCode?.includes('initializeApp') && node.rawCode?.includes('firebase')) node.isEntry = true;
+  }
+}
+
+export class ClerkPlugin extends BasePlugin {
+  get name() { return 'clerk'; }
+  getConfigFiles() { return ['package.json', '.env', '.env.local']; }
+  getRequiredPackages() {
+    return [{ name: '@clerk/nextjs', dev: false, optional: true }, { name: '@clerk/clerk-react', dev: false, optional: true }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      const allDeps = { ...(pkgJson.dependencies || {}), ...(pkgJson.devDependencies || {}) };
+      return Object.keys(allDeps).some(k => k.startsWith('@clerk/'));
+    } catch { return false; }
+  }
+}
+
+export class TRPCPlugin extends BasePlugin {
+  get name() { return 'trpc'; }
+  getConfigFiles() { return ['package.json']; }
+  getRequiredPackages() {
+    return [{ name: '@trpc/server', dev: false }, { name: '@trpc/client', dev: false }];
+  }
+  async isActive(baseDir) {
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      const allDeps = { ...(pkgJson.dependencies || {}), ...(pkgJson.devDependencies || {}) };
+      return Object.keys(allDeps).some(k => k.startsWith('@trpc/'));
+    } catch { return false; }
+  }
+  getRequiredSystemContracts() { return ['router', 'procedure', 'createTRPCRouter']; }
+}