create-stackkit-app 0.4.5 → 0.4.6

package/dist/lib/create-project.js

@@ -10,12 +10,13 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const path_1 = __importDefault(require("path"));
 const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
-const file_utils_1 = require("./utils/file-utils");
 const git_utils_1 = require("./utils/git-utils");
 const js_conversion_1 = require("./utils/js-conversion");
 const logger_1 = require("./utils/logger");
-const module_utils_1 = require("./utils/module-utils");
+const code_generator_1 = require("./code-generator");
+const framework_utils_1 = require("./framework-utils");
 const package_utils_1 = require("./utils/package-utils");
+const module_discovery_1 = require("./utils/module-discovery");
 async function createProject(projectName, options) {
     logger_1.logger.newLine();
     logger_1.logger.log(chalk_1.default.bold.cyan("Create StackKit App"));
@@ -31,30 +32,36 @@ async function createProject(projectName, options) {
     showNextSteps(config);
 }
 async function getProjectConfig(projectName, options) {
+    // Discover available modules
+    const modulesDir = path_1.default.join(__dirname, "..", "..", "modules");
+    const discoveredModules = await (0, module_discovery_1.discoverModules)(modulesDir);
     if (options && Object.keys(options).length > 0) {
         if (options.yes || options.y) {
             return {
                 projectName: projectName || "my-app",
                 framework: "nextjs",
                 database: "prisma",
-                dbProvider: "postgresql",
+                prismaProvider: "postgresql",
                 auth: "better-auth",
                 language: "typescript",
                 packageManager: "pnpm",
             };
         }
-        // Validate options
-        const validFrameworks = ['nextjs', 'express', 'react-vite'];
+        // Validate options using discovered modules
+        const validFrameworks = discoveredModules.frameworks.map(f => f.name);
         const framework = options.framework || options.f;
         if (framework && !validFrameworks.includes(framework)) {
             throw new Error(`Invalid framework: ${framework}. Valid options: ${validFrameworks.join(', ')}`);
         }
-        const validDatabases = ['prisma-postgresql', 'prisma-mongodb', 'prisma-mysql', 'prisma-sqlite', 'mongoose-mongodb', 'none'];
+        const validDatabases = (0, module_discovery_1.getValidDatabaseOptions)(discoveredModules.databases);
+        // Also allow base database names like 'prisma', 'mongoose'
+        const validBaseDatabases = discoveredModules.databases.map(db => db.name);
+        const allValidDatabases = [...validDatabases, ...validBaseDatabases];
         const db = options.database || options.d;
-        if (db && !validDatabases.includes(db)) {
-            throw new Error(`Invalid database: ${db}. Valid options: ${validDatabases.join(', ')}`);
+        if (db && !allValidDatabases.includes(db)) {
+            throw new Error(`Invalid database: ${db}. Valid options: ${allValidDatabases.filter((v, i, arr) => arr.indexOf(v) === i).join(', ')}`);
         }
-        const validAuth = ['better-auth', 'authjs', 'none'];
+        const validAuth = (0, module_discovery_1.getValidAuthOptions)(discoveredModules.auth);
         const authOpt = options.auth || options.a;
         if (authOpt && !validAuth.includes(authOpt)) {
             throw new Error(`Invalid auth: ${authOpt}. Valid options: ${validAuth.join(', ')}`);
@@ -70,22 +77,11 @@ async function getProjectConfig(projectName, options) {
             throw new Error(`Invalid package manager: ${pm}. Valid options: ${validPackageManagers.join(', ')}`);
         }
         let database = "none";
-        let dbProvider;
+        let prismaProvider;
         if (db && db !== "none") {
-            if (db.startsWith("prisma-")) {
-                database = "prisma";
-                const provider = db.split("-")[1];
-                if (!["postgresql", "mongodb", "mysql", "sqlite"].includes(provider)) {
-                    throw new Error(`Invalid Prisma provider: ${provider}`);
-                }
-                dbProvider = provider;
-            }
-            else if (db === "mongoose-mongodb") {
-                database = "mongoose";
-            }
-            else {
-                throw new Error(`Unsupported database: ${db}`);
-            }
+            const parsed = (0, module_discovery_1.parseDatabaseOption)(db);
+            database = parsed.database;
+            prismaProvider = parsed.provider;
         }
         let auth = "none";
         if (authOpt && authOpt !== "none") {
@@ -94,7 +90,7 @@ async function getProjectConfig(projectName, options) {
         const finalFramework = (framework || "nextjs");
         if (finalFramework === "react-vite") {
             database = "none";
-            dbProvider = undefined;
+            prismaProvider = undefined;
         }
         // Validate auth compatibility
         if (auth === "authjs" && (database !== "prisma" || finalFramework !== "nextjs")) {
@@ -107,12 +103,13 @@ async function getProjectConfig(projectName, options) {
             projectName: projectName || "my-app",
             framework: finalFramework,
             database,
-            dbProvider,
+            prismaProvider,
             auth,
             language: (language || "typescript"),
             packageManager: (pm || "pnpm"),
         };
     }
+    // Use discovered modules for interactive prompts
     const answers = (await inquirer_1.default.prompt([
         {
             type: "input",
@@ -135,26 +132,21 @@ async function getProjectConfig(projectName, options) {
             type: "list",
             name: "framework",
             message: "Select framework:",
-            choices: [
-                { name: "Next.js", value: "nextjs" },
-                { name: "Express.js", value: "express" },
-                { name: "React (Vite)", value: "react-vite" },
-            ],
+            choices: discoveredModules.frameworks.map(f => ({
+                name: f.displayName,
+                value: f.name
+            })),
         },
         {
             type: "list",
             name: "database",
             message: "Select database/ORM:",
             when: (answers) => answers.framework !== "react-vite",
-            choices: [
-                { name: "Prisma", value: "prisma" },
-                { name: "Mongoose (MongoDB)", value: "mongoose" },
-                { name: "None", value: "none" },
-            ],
+            choices: (answers) => (0, module_discovery_1.getDatabaseChoices)(discoveredModules.databases, answers.framework),
         },
         {
             type: "list",
-            name: "dbProvider",
+            name: "prismaProvider",
             message: "Select database provider for Prisma:",
             when: (answers) => answers.database === "prisma",
             choices: [
@@ -168,35 +160,8 @@ async function getProjectConfig(projectName, options) {
             type: "list",
             name: "auth",
             message: "Select authentication:",
-            when: (answers) => (answers.database !== "none" || answers.framework === "react-vite") && answers.database !== "mongoose",
-            choices: (answers) => {
-                if (answers.framework === "react-vite") {
-                    return [
-                        { name: "Better Auth", value: "better-auth" },
-                        { name: "None", value: "none" },
-                    ];
-                }
-                if (answers.database === "mongoose") {
-                    return [
-                        { name: "Better Auth", value: "better-auth" },
-                        { name: "None", value: "none" },
-                    ];
-                }
-                if (answers.framework === "nextjs" && answers.database === "prisma") {
-                    return [
-                        { name: "Better Auth", value: "better-auth" },
-                        { name: "Auth.js", value: "authjs" },
-                        { name: "None", value: "none" },
-                    ];
-                }
-                if (answers.framework === "express" && answers.database === "prisma") {
-                    return [
-                        { name: "Better Auth", value: "better-auth" },
-                        { name: "None", value: "none" },
-                    ];
-                }
-                return [{ name: "None", value: "none" }];
-            },
+            when: (answers) => (answers.database !== "none" || answers.framework === "react-vite"),
+            choices: (answers) => (0, module_discovery_1.getCompatibleAuthOptions)(discoveredModules.auth, answers.framework, answers.database || "none"),
         },
         {
             type: "list",
@@ -221,14 +186,15 @@ async function getProjectConfig(projectName, options) {
             default: "pnpm",
         },
     ]));
+    const parsedDb = answers.database ? (0, module_discovery_1.parseDatabaseOption)(answers.database) : { database: 'none' };
     return {
         projectName: (projectName || answers.projectName),
         framework: answers.framework,
         database: (answers.framework === "react-vite"
             ? "none"
-            : answers.database),
-        dbProvider: answers.dbProvider,
-        auth: answers.database === "mongoose" ? "better-auth" : (answers.auth || "none"),
+            : parsedDb.database),
+        prismaProvider: answers.prismaProvider || parsedDb.provider,
+        auth: (answers.auth || "none"),
         language: answers.language,
         packageManager: answers.packageManager,
     };
@@ -284,8 +250,28 @@ async function generateProject(config, targetDir, options) {
 }
 async function composeTemplate(config, targetDir) {
     const templatesDir = path_1.default.join(__dirname, "..", "..", "templates");
+    const modulesDir = path_1.default.join(__dirname, "..", "..", "modules");
     await fs_extra_1.default.ensureDir(targetDir);
-    await (0, file_utils_1.copyBaseFramework)(templatesDir, targetDir, config.framework);
+    // Load framework configuration
+    const frameworkConfig = await framework_utils_1.FrameworkUtils.loadFrameworkConfig(config.framework, templatesDir);
+    // Initialize advanced code generator
+    const generator = new code_generator_1.AdvancedCodeGenerator(frameworkConfig);
+    await generator.loadGenerators(modulesDir);
+    // Generate project using advanced code generator
+    const features = [];
+    const postInstallCommands = await generator.generate({
+        framework: config.framework,
+        database: config.database === 'none' ? undefined : config.database,
+        auth: config.auth === 'none' ? undefined : config.auth,
+        prismaProvider: config.prismaProvider,
+    }, features, targetDir);
+    // Update project name in package.json
+    const packageJsonPath = path_1.default.join(targetDir, "package.json");
+    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+        packageJson.name = config.projectName;
+        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
     // Ensure .env exists: if .env.example was copied from the template, create .env from it
     try {
         const envExamplePath = path_1.default.join(targetDir, ".env.example");
@@ -298,23 +284,10 @@ async function composeTemplate(config, targetDir) {
     catch {
         // non-fatal
     }
-    const postInstallCommands = [];
-    if (config.database !== "none") {
-        const dbPostInstall = await (0, module_utils_1.mergeDatabaseConfig)(templatesDir, targetDir, config.database, config.framework, config.dbProvider);
-        postInstallCommands.push(...dbPostInstall);
-    }
-    if (config.auth !== "none") {
-        await (0, module_utils_1.mergeAuthConfig)(templatesDir, targetDir, config.framework, config.auth, config.database, config.dbProvider);
-    }
-    const packageJsonPath = path_1.default.join(targetDir, "package.json");
-    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
-        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
-        packageJson.name = config.projectName;
-        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-    }
     if (config.language === "javascript") {
         await (0, js_conversion_1.convertToJavaScript)(targetDir, config.framework);
     }
+    // For now, return empty array as post-install commands are handled by the generator
     return postInstallCommands;
 }
 function showNextSteps(config) {

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

@@ -0,0 +1,22 @@
+export interface FrameworkConfig {
+    name: string;
+    displayName: string;
+    compatibility: {
+        databases: string[];
+        auth: string[];
+    };
+}
+export interface ModuleConfig {
+    name: string;
+    displayName: string;
+    type: 'database' | 'auth';
+    compatibility?: {
+        frameworks?: string[];
+        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;
+}

package/dist/lib/framework-utils.js

@@ -0,0 +1,74 @@
+"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 });
+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 configPath = path.join(templatesDir, frameworkName, 'template.json');
+        if (await fs.pathExists(configPath)) {
+            const config = await fs.readJson(configPath);
+            this.frameworkConfigs.set(frameworkName, config);
+            return config;
+        }
+        // Default config if no template.json exists
+        const defaultConfig = {
+            name: frameworkName,
+            displayName: frameworkName.charAt(0).toUpperCase() + frameworkName.slice(1),
+            compatibility: {
+                databases: ['prisma', 'mongoose'],
+                auth: ['better-auth', 'authjs'],
+            },
+        };
+        this.frameworkConfigs.set(frameworkName, defaultConfig);
+        return defaultConfig;
+    }
+    static isCompatible(framework, database, auth) {
+        const config = this.frameworkConfigs.get(framework);
+        if (!config)
+            return true; // Assume compatible if no config
+        if (database && !config.compatibility.databases.includes(database)) {
+            return false;
+        }
+        if (auth && !config.compatibility.auth.includes(auth)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.FrameworkUtils = FrameworkUtils;
+FrameworkUtils.frameworkConfigs = new Map();

package/dist/lib/utils/module-discovery.d.ts

@@ -0,0 +1,62 @@
+export interface ModuleMetadata {
+    name: string;
+    displayName: string;
+    description: string;
+    category: string;
+    provider?: string;
+    supportedFrameworks?: string[];
+    databaseAdapters?: Record<string, unknown>;
+    frameworkConfigs?: Record<string, unknown>;
+    dependencies?: Record<string, unknown>;
+    devDependencies?: Record<string, unknown>;
+    envVars?: Record<string, unknown>;
+    patches?: unknown[];
+    postInstall?: string[];
+    compatibility?: {
+        databases?: string[];
+        auth?: string[];
+        languages?: string[];
+    };
+    framework?: string;
+    files?: string[];
+    scripts?: Record<string, string>;
+    jsScripts?: Record<string, string>;
+}
+export interface DiscoveredModules {
+    frameworks: ModuleMetadata[];
+    databases: ModuleMetadata[];
+    auth: ModuleMetadata[];
+}
+/**
+ * Discover all available modules from the modules directory
+ */
+export declare function discoverModules(modulesDir: string): Promise<DiscoveredModules>;
+/**
+ * Get valid database options for CLI
+ */
+export declare function getValidDatabaseOptions(databases: ModuleMetadata[]): string[];
+/**
+ * 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
+ */
+export declare function getCompatibleAuthOptions(authModules: ModuleMetadata[], framework: string, database: string): Array<{
+    name: string;
+    value: string;
+}>;
+/**
+ * Get database choices for inquirer prompts
+ */
+export declare function getDatabaseChoices(databases: ModuleMetadata[], framework: string): Array<{
+    name: string;
+    value: string;
+}>;

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

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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"));
+/**
+ * Discover all available modules from the modules directory
+ */
+async function discoverModules(modulesDir) {
+    const discovered = {
+        frameworks: [],
+        databases: [],
+        auth: [],
+    };
+    if (!(await fs_extra_1.default.pathExists(modulesDir))) {
+        return discovered;
+    }
+    // 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);
+                    discovered.frameworks.push({
+                        ...templateConfig,
+                        name: frameworkName,
+                        category: 'framework',
+                    });
+                }
+                catch {
+                    // Silently skip invalid templates
+                }
+            }
+        }
+    }
+    // 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);
+        for (const moduleName of dbModules) {
+            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);
+                    discovered.databases.push(metadata);
+                }
+                catch {
+                    // Silently skip invalid modules
+                }
+            }
+        }
+    }
+    // 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);
+        for (const moduleName of authModules) {
+            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);
+                    discovered.auth.push(metadata);
+                }
+                catch {
+                    // Silently skip invalid modules
+                }
+            }
+        }
+    }
+    return discovered;
+}
+/**
+ * Get valid database options for CLI
+ */
+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');
+        }
+        else if (db.name === 'mongoose') {
+            options.push('mongoose-mongodb');
+        }
+        else {
+            // For other databases, add the name directly
+            options.push(db.name);
+        }
+    }
+    return options;
+}
+/**
+ * Get valid auth options for CLI
+ */
+function getValidAuthOptions(authModules) {
+    const options = ['none'];
+    for (const auth of authModules) {
+        options.push(auth.name);
+    }
+    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-mongodb') {
+        return { database: 'mongoose' };
+    }
+    return { database: dbOption };
+}
+/**
+ * Get compatible auth options for given framework and database
+ */
+function getCompatibleAuthOptions(authModules, framework, database) {
+    const compatible = [];
+    for (const auth of authModules) {
+        // Check if auth supports the framework
+        if (auth.supportedFrameworks && !auth.supportedFrameworks.includes(framework)) {
+            continue;
+        }
+        // Special compatibility rules
+        if (auth.name === 'authjs' && (database !== 'prisma' || framework !== 'nextjs')) {
+            continue;
+        }
+        if (auth.name === 'better-auth' && database === 'none' && framework !== 'react-vite') {
+            continue;
+        }
+        compatible.push({
+            name: auth.displayName,
+            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;
+        }
+        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' });
+        }
+        else if (db.name === 'mongoose') {
+            choices.push({ name: 'Mongoose (MongoDB)', value: 'mongoose-mongodb' });
+        }
+        else {
+            choices.push({ name: db.displayName, value: db.name });
+        }
+    }
+    // Add "None" at the end
+    choices.push({ name: 'None', value: 'none' });
+    return choices;
+}

package/modules/auth/authjs/files/lib/auth.ts

@@ -2,7 +2,6 @@ import { NextAuthOptions } from "next-auth";
 import { PrismaAdapter } from "@auth/prisma-adapter";
 import { prisma } from "@/lib/prisma";
 import GoogleProvider from "next-auth/providers/google";
-import GitHubProvider from "next-auth/providers/github";
 
 export const authOptions: NextAuthOptions = {
   adapter: PrismaAdapter(prisma),
@@ -11,10 +10,6 @@ export const authOptions: NextAuthOptions = {
       clientId: process.env.GOOGLE_CLIENT_ID!,
       clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
     }),
-    GitHubProvider({
-      clientId: process.env.GITHUB_ID!,
-      clientSecret: process.env.GITHUB_SECRET!,
-    }),
   ],
   session: {
     strategy: "jwt",