stackkit-cli 0.4.3 → 0.4.4

package/bin/stackkit.js

@@ -1,2 +1,11 @@
 #!/usr/bin/env node
-require("../dist/index.js");
+
+try {
+  // eslint-disable-next-line
+  require("ts-node/register");
+  // eslint-disable-next-line
+  require("../src/index.ts");
+} catch {
+  // eslint-disable-next-line
+  require("../dist/index.js");
+}

package/dist/commands/add.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addCommand = addCommand;
 const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const path_1 = __importDefault(require("path"));
@@ -27,6 +28,81 @@ async function addCommand(module, options) {
             logger_1.logger.error(`Module "${module}" not found`);
             process.exit(1);
         }
+        // For database modules, ensure provider is selected
+        let selectedProvider = options.provider;
+        if (moduleMetadata.category === "database" && !selectedProvider) {
+            if (typeof moduleMetadata.dependencies === "object" &&
+                "providers" in moduleMetadata.dependencies) {
+                const providers = Object.keys(moduleMetadata.dependencies.providers || {});
+                if (providers.length > 0) {
+                    const { provider } = await inquirer_1.default.prompt([
+                        {
+                            type: "list",
+                            name: "provider",
+                            message: "Select database provider:",
+                            choices: providers.map((p) => ({ name: p, value: p })),
+                        },
+                    ]);
+                    selectedProvider = provider;
+                }
+            }
+        }
+        // Merge dependencies based on provider
+        const mergedDeps = {};
+        const mergedDevDeps = {};
+        if (typeof moduleMetadata.dependencies === "object" &&
+            !("common" in moduleMetadata.dependencies)) {
+            // Already flat
+            Object.assign(mergedDeps, moduleMetadata.dependencies);
+        }
+        else if (typeof moduleMetadata.dependencies === "object" &&
+            "common" in moduleMetadata.dependencies) {
+            Object.assign(mergedDeps, moduleMetadata.dependencies.common);
+            if (selectedProvider &&
+                typeof moduleMetadata.dependencies === "object" &&
+                "providers" in moduleMetadata.dependencies &&
+                typeof moduleMetadata.dependencies.providers === "object" &&
+                selectedProvider in moduleMetadata.dependencies.providers) {
+                Object.assign(mergedDeps, moduleMetadata.dependencies.providers[selectedProvider]);
+            }
+        }
+        if (moduleMetadata.devDependencies) {
+            if (typeof moduleMetadata.devDependencies === "object" &&
+                !("common" in moduleMetadata.devDependencies)) {
+                Object.assign(mergedDevDeps, moduleMetadata.devDependencies);
+            }
+            else if (typeof moduleMetadata.devDependencies === "object" &&
+                "common" in moduleMetadata.devDependencies) {
+                Object.assign(mergedDevDeps, moduleMetadata.devDependencies.common);
+                if (selectedProvider &&
+                    typeof moduleMetadata.devDependencies === "object" &&
+                    "providers" in moduleMetadata.devDependencies &&
+                    typeof moduleMetadata.devDependencies.providers === "object" &&
+                    selectedProvider in moduleMetadata.devDependencies.providers) {
+                    Object.assign(mergedDevDeps, moduleMetadata.devDependencies.providers[selectedProvider]);
+                }
+            }
+        }
+        // Update metadata with merged deps
+        moduleMetadata.dependencies = mergedDeps;
+        moduleMetadata.devDependencies = mergedDevDeps;
+        // Set variables for replacements
+        const variables = {};
+        if (selectedProvider) {
+            variables.provider = selectedProvider;
+            if (selectedProvider === "postgresql") {
+                variables.connectionString = "postgresql://user:password@localhost:5432/mydb?schema=public";
+            }
+            else if (selectedProvider === "mongodb") {
+                variables.connectionString = "mongodb://localhost:27017/mydb";
+            }
+            else if (selectedProvider === "mysql") {
+                variables.connectionString = "mysql://user:password@localhost:3306/mydb";
+            }
+            else if (selectedProvider === "sqlite") {
+                variables.connectionString = "file:./dev.db";
+            }
+        }
         // Check if framework is supported
         if (!moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
             logger_1.logger.error(`Module "${module}" does not support ${projectInfo.framework}. Supported: ${moduleMetadata.supportedFrameworks.join(", ")}`);
@@ -54,6 +130,24 @@ async function addCommand(module, options) {
         }
         // Apply module patches
         await applyModulePatches(projectRoot, projectInfo, moduleMetadata, modulesDir, module, options);
+        // Apply framework patches
+        if (moduleMetadata.frameworkPatches && !options.dryRun) {
+            await applyFrameworkPatches(projectRoot, moduleMetadata.frameworkPatches, projectInfo.framework);
+        }
+        // Run post-install commands
+        if (moduleMetadata.postInstall && moduleMetadata.postInstall.length > 0 && !options.dryRun) {
+            const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
+            try {
+                for (const command of moduleMetadata.postInstall) {
+                    (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: "pipe" });
+                }
+                postInstallSpinner.succeed("Post-install commands completed");
+            }
+            catch (error) {
+                postInstallSpinner.fail("Failed to run post-install commands");
+                throw error;
+            }
+        }
         // Add dependencies
         if (Object.keys(moduleMetadata.dependencies).length > 0 && options.install !== false) {
             const deps = Object.entries(moduleMetadata.dependencies).map(([name, version]) => `${name}@${version}`);
@@ -78,8 +172,13 @@ async function addCommand(module, options) {
         }
         // Add environment variables
         if (moduleMetadata.envVars.length > 0) {
+            // Replace variables in envVars
+            const processedEnvVars = moduleMetadata.envVars.map((envVar) => ({
+                ...envVar,
+                value: envVar.value?.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match),
+            }));
             if (!options.dryRun) {
-                await (0, env_editor_1.addEnvVariables)(projectRoot, moduleMetadata.envVars, { force: options.force });
+                await (0, env_editor_1.addEnvVariables)(projectRoot, processedEnvVars, { force: options.force });
             }
             else {
                 logger_1.logger.log(`  ${chalk_1.default.dim("~")} .env.example`);
@@ -208,3 +307,41 @@ async function findModulePath(modulesDir, moduleName, provider) {
     }
     return null;
 }
+async function applyFrameworkPatches(projectRoot, patches, framework) {
+    const frameworkKey = framework;
+    const frameworkPatches = patches[frameworkKey];
+    if (!frameworkPatches)
+        return;
+    for (const [filename, patchConfig] of Object.entries(frameworkPatches)) {
+        const filePath = path_1.default.join(projectRoot, filename);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            const fileContent = await fs_extra_1.default.readJson(filePath);
+            if (patchConfig.merge) {
+                const merged = deepMerge(fileContent, patchConfig.merge);
+                await fs_extra_1.default.writeJson(filePath, merged, { spaces: 2 });
+                const relativePath = path_1.default.relative(projectRoot, filePath);
+                logger_1.logger.log(`  ${chalk_1.default.blue("~")} ${relativePath}`);
+            }
+        }
+    }
+}
+function deepMerge(target, source) {
+    const output = { ...target };
+    for (const key in source) {
+        if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+            if (target[key]) {
+                output[key] = deepMerge(target[key], source[key]);
+            }
+            else {
+                output[key] = source[key];
+            }
+        }
+        else if (Array.isArray(source[key])) {
+            output[key] = Array.from(new Set([...(target[key] || []), ...source[key]]));
+        }
+        else {
+            output[key] = source[key];
+        }
+    }
+    return output;
+}

package/dist/types/index.d.ts

@@ -12,10 +12,22 @@ export interface ModuleMetadata {
     description: string;
     category: "auth" | "database" | "ui" | "other";
     supportedFrameworks: string[];
-    dependencies: Record<string, string>;
-    devDependencies?: Record<string, string>;
+    dependencies: {
+        common?: Record<string, string>;
+        providers?: Record<string, Record<string, string>>;
+    } | Record<string, string>;
+    devDependencies?: {
+        common?: Record<string, string>;
+        providers?: Record<string, Record<string, string>>;
+    } | Record<string, string>;
     envVars: EnvVar[];
     patches: ModulePatch[];
+    frameworkPatches?: Record<string, {
+        [file: string]: {
+            merge?: Record<string, unknown>;
+        };
+    }>;
+    postInstall?: string[];
 }
 export interface EnvVar {
     key: string;

package/modules/auth/better-auth/files/lib/auth.ts

@@ -0,0 +1,13 @@
+import { betterAuth } from "better-auth";
+
+{{databaseAdapter}}
+  emailAndPassword: {
+    enabled: true,
+  },
+  socialProviders: {
+    google: {
+      clientId: process.env.GOOGLE_CLIENT_ID!,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+    },
+  },
+});

package/modules/auth/better-auth/files/schemas/prisma-schema.prisma

@@ -0,0 +1,63 @@
+// Better Auth models
+model User {
+    id            String    @id {{idDefault}}
+    name          String
+    email         String
+    emailVerified Boolean   @default(false)
+    image         String?
+    createdAt     DateTime  @default(now())
+    updatedAt     DateTime  @updatedAt
+    sessions      Session[]
+    accounts      Account[]
+    role          String    @default("USER")
+
+    @@unique([email])
+    @@map("user")
+}
+
+model Session {
+    id        String   @id {{idDefault}}
+    expiresAt DateTime
+    token     String   @unique
+    createdAt DateTime @default(now())
+    updatedAt DateTime @updatedAt
+    ipAddress String?
+    userAgent String?
+    userId    String {{userIdType}}
+    user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+    @@index([userId])
+    @@map("session")
+}
+
+model Account {
+    id                    String    @id {{idDefault}}
+    accountId             String
+    providerId            String
+    userId                String {{userIdType}}
+    user                  User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+    accessToken           String?
+    refreshToken          String?
+    idToken               String?
+    accessTokenExpiresAt  DateTime?
+    refreshTokenExpiresAt DateTime?
+    scope                 String?
+    password              String?
+    createdAt             DateTime  @default(now())
+    updatedAt             DateTime  @updatedAt
+
+    @@index([userId])
+    @@map("account")
+}
+
+model Verification {
+    id         String   @id {{idDefault}}
+    identifier String
+    value      String
+    expiresAt  DateTime
+    createdAt  DateTime @default(now())
+    updatedAt  DateTime @updatedAt
+
+    @@index([identifier])
+    @@map("verification")
+}

package/modules/auth/better-auth/module.json

@@ -0,0 +1,54 @@
+{
+  "name": "better-auth",
+  "displayName": "Better Auth",
+  "description": "Modern authentication with Better Auth",
+  "category": "auth",
+  "provider": "better-auth",
+  "supportedFrameworks": ["nextjs", "express", "react-vite"],
+  "databaseAdapters": {
+    "prisma-postgresql": {
+      "adapterCode": "import { prisma } from \"{{dbImport}}\";\nimport { prismaAdapter } from \"@better-auth/prisma\";\n\nexport const auth = betterAuth({\n  database: prismaAdapter(prisma, {\n    provider: \"postgresql\",\n  }),",
+      "schema": "files/schemas/prisma-schema.prisma",
+      "schemaDestination": "prisma/schema.prisma",
+      "dependencies": {
+        "better-auth": "^1.1.4"
+      }
+    },
+    "prisma-mongodb": {
+      "adapterCode": "import { prisma } from \"{{dbImport}}\";\nimport { prismaAdapter } from \"@better-auth/prisma\";\n\nexport const auth = betterAuth({\n  database: prismaAdapter(prisma, {\n    provider: \"mongodb\",\n  }),",
+      "schema": "files/schemas/prisma-schema.prisma",
+      "schemaDestination": "prisma/schema.prisma",
+      "dependencies": {
+        "better-auth": "^1.1.4"
+      }
+    },
+    "mongoose-mongodb": {
+      "adapterCode": "import { client } from \"{{dbImport}}\";\nimport { mongodbAdapter } from \"better-auth/adapters/mongodb\";\n\nexport const auth = betterAuth({\n  database: mongodbAdapter(client),",
+      "dependencies": {
+        "better-auth": "^1.1.4"
+      }
+    }
+  },
+  "envVars": [
+    {
+      "key": "BETTER_AUTH_SECRET",
+      "value": "",
+      "description": "Secret key for Better Auth. Generate with: openssl rand -base64 32",
+      "required": true
+    },
+    {
+      "key": "BETTER_AUTH_URL",
+      "value": "http://localhost:3000",
+      "description": "Base URL of your application (change in production)",
+      "required": true
+    }
+  ],
+  "patches": [
+    {
+      "type": "create-file",
+      "description": "Create Better Auth configuration",
+      "source": "files/lib/auth.ts",
+      "destination": "{{lib}}/auth.ts"
+    }
+  ]
+}

package/modules/auth/clerk/module.json

@@ -0,0 +1,115 @@
+{
+  "name": "clerk",
+  "displayName": "Clerk",
+  "description": "Clerk Authentication",
+  "category": "auth",
+  "provider": "clerk",
+  "supportedFrameworks": ["nextjs", "express", "react-vite"],
+  "frameworkConfigs": {
+    "nextjs": {
+      "dependencies": {
+        "@clerk/nextjs": "^6.10.2"
+      },
+      "envVars": [
+        {
+          "key": "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY",
+          "value": "",
+          "description": "Clerk publishable key (from Clerk dashboard)",
+          "required": true
+        },
+        {
+          "key": "CLERK_SECRET_KEY",
+          "value": "",
+          "description": "Clerk secret key (from Clerk dashboard)",
+          "required": true
+        },
+        {
+          "key": "NEXT_PUBLIC_CLERK_SIGN_IN_URL",
+          "value": "/sign-in",
+          "description": "Sign in page URL",
+          "required": true
+        },
+        {
+          "key": "NEXT_PUBLIC_CLERK_SIGN_UP_URL",
+          "value": "/sign-up",
+          "description": "Sign up page URL",
+          "required": true
+        },
+        {
+          "key": "NEXT_PUBLIC_CLERK_AFTER_SIGN_IN_URL",
+          "value": "/",
+          "description": "Redirect URL after sign in",
+          "required": true
+        },
+        {
+          "key": "NEXT_PUBLIC_CLERK_AFTER_SIGN_UP_URL",
+          "value": "/",
+          "description": "Redirect URL after sign up",
+          "required": true
+        }
+      ],
+      "patches": [
+        {
+          "type": "create-file",
+          "description": "Create Clerk auth provider",
+          "source": "nextjs/auth-provider.tsx",
+          "destination": "{{lib}}/auth-provider.tsx"
+        },
+        {
+          "type": "create-file",
+          "description": "Create Clerk middleware",
+          "source": "nextjs/middleware.ts",
+          "destination": "middleware.ts"
+        }
+      ]
+    },
+    "express": {
+      "dependencies": {
+        "@clerk/express": "^1.3.0"
+      },
+      "envVars": [
+        {
+          "key": "CLERK_PUBLISHABLE_KEY",
+          "value": "",
+          "description": "Clerk publishable key (from Clerk dashboard)",
+          "required": true
+        },
+        {
+          "key": "CLERK_SECRET_KEY",
+          "value": "",
+          "description": "Clerk secret key (from Clerk dashboard)",
+          "required": true
+        }
+      ],
+      "patches": [
+        {
+          "type": "create-file",
+          "description": "Create Clerk auth utilities",
+          "source": "express/auth.ts",
+          "destination": "{{lib}}/auth.ts"
+        }
+      ]
+    },
+    "react-vite": {
+      "dependencies": {
+        "@clerk/clerk-react": "^5.15.0"
+      },
+      "envVars": [
+        {
+          "key": "VITE_CLERK_PUBLISHABLE_KEY",
+          "value": "",
+          "description": "Clerk publishable key (from Clerk dashboard)",
+          "required": true
+        }
+      ],
+      "patches": [
+        {
+          "type": "create-file",
+          "description": "Create Clerk auth provider",
+          "source": "react/auth-provider.tsx",
+          "destination": "{{lib}}/auth-provider.tsx"
+        }
+      ]
+    }
+  }
+}

package/modules/database/mongoose-mongodb/files/lib/db.ts

@@ -1,28 +1,45 @@
+import "dotenv/config";
 import mongoose from "mongoose";
 
-const MONGODB_URI = process.env.MONGODB_URI || "mongodb://localhost:27017/myapp";
+const MONGODB_URI = process.env.DATABASE_URL || "mongodb://localhost:27017/myapp";
 
 if (!MONGODB_URI) {
-  throw new Error("Please define the MONGODB_URI environment variable");
+  throw new Error("Please define the DATABASE_URL environment variable");
 }
 
-let cached = global.mongoose;
+interface MongooseCache {
+  conn: typeof mongoose | null;
+  promise: Promise<typeof mongoose> | null;
+}
+
+declare global {
+  var mongoose: MongooseCache | undefined;
+}
+
+const cached: MongooseCache = global.mongoose || { conn: null, promise: null };
 
-if (!cached) {
-  cached = global.mongoose = { conn: null, promise: null };
+if (!global.mongoose) {
+  global.mongoose = cached;
 }
 
-async function connectDB() {
+async function connectDB(): Promise<typeof mongoose> {
   if (cached.conn) {
+    console.log("Using existing MongoDB connection");
     return cached.conn;
   }
 
   if (!cached.promise) {
     const opts = {
       bufferCommands: false,
+      maxPoolSize: 10, // Maintain up to 10 socket connections
+      serverSelectionTimeoutMS: 5000, // Keep trying to send operations for 5 seconds
+      socketTimeoutMS: 45000, // Close sockets after 45 seconds of inactivity
+      family: 4, // Use IPv4, skip trying IPv6
     };
 
+    console.log("Creating new MongoDB connection");
     cached.promise = mongoose.connect(MONGODB_URI, opts).then((mongoose) => {
+      console.log("MongoDB connected successfully");
       return mongoose;
     });
   }
@@ -31,10 +48,31 @@ async function connectDB() {
     cached.conn = await cached.promise;
   } catch (e) {
     cached.promise = null;
+    console.error("MongoDB connection error:", e);
     throw e;
   }
 
   return cached.conn;
 }
 
+// Handle connection events
+mongoose.connection.on("connected", () => {
+  console.log("Mongoose connected to MongoDB");
+});
+
+mongoose.connection.on("error", (err) => {
+  console.error("Mongoose connection error:", err);
+});
+
+mongoose.connection.on("disconnected", () => {
+  console.log("Mongoose disconnected");
+});
+
+// Close connection on app termination
+process.on("SIGINT", async () => {
+  await mongoose.connection.close();
+  console.log("MongoDB connection closed due to app termination");
+  process.exit(0);
+});
+
 export default connectDB;

package/modules/database/mongoose-mongodb/files/models/User.ts

@@ -0,0 +1,39 @@
+import mongoose, { Document, Schema } from "mongoose";
+
+export interface IUser extends Document {
+  name: string;
+  email: string;
+  password: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const UserSchema: Schema = new Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+    password: {
+      type: String,
+      required: true,
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Add indexes for better performance
+UserSchema.index({ email: 1 });
+UserSchema.index({ createdAt: -1 });
+
+export default mongoose.models.User || mongoose.model<IUser>("User", UserSchema);

package/modules/database/mongoose-mongodb/module.json

@@ -7,28 +7,35 @@
   "database": "mongodb",
   "supportedFrameworks": ["nextjs", "express"],
   "dependencies": {
-    "mongoose": "^8.8.4"
+    "mongoose": "^8.8.4",
+    "dotenv": "^17.2.3"
+  },
+  "devDependencies": {
+    "@types/mongoose": "^5.11.97"
+  },
+  "envVars": {
+    "common": [
+      {
+        "key": "DATABASE_URL",
+        "value": "mongodb://localhost:27017/myapp",
+        "description": "MongoDB connection string",
+        "required": true
+      }
+    ]
   },
-  "devDependencies": {},
-  "envVars": [
-    {
-      "key": "MONGODB_URI",
-      "value": "mongodb://localhost:27017/myapp",
-      "description": "MongoDB connection string",
-      "required": true
-    }
-  ],
   "frameworkPatches": {
     "express": {
       "tsconfig.json": {
         "merge": {
           "compilerOptions": {
+            "baseUrl": ".",
             "paths": {
               "@/*": ["./src/*"],
               "@/models/*": ["./src/models/*"]
             }
           },
-          "include": ["src/**/*", "src/models/**/*"]
+          "include": ["src/**/*", "src/models/**/*"],
+          "exclude": ["node_modules", "dist"]
         }
       }
     },
@@ -36,10 +43,12 @@
       "tsconfig.json": {
         "merge": {
           "compilerOptions": {
+            "baseUrl": ".",
             "paths": {
               "@/models/*": ["./models/*"]
             }
-          }
+          },
+          "exclude": ["node_modules", ".next", "out"]
         }
       }
     }
@@ -50,6 +59,12 @@
       "description": "Create MongoDB connection with Mongoose",
       "source": "lib/db.ts",
       "destination": "{{lib}}/db.ts"
+    },
+    {
+      "type": "create-file",
+      "description": "Create sample User model",
+      "source": "models/User.ts",
+      "destination": "{{models}}/User.ts"
     }
   ]
 }

package/modules/database/prisma/files/lib/prisma.ts

@@ -0,0 +1,6 @@
+import "dotenv/config";
+import { PrismaClient } from "@/generated/prisma/client";
+
+{{prismaClientInit}}
+
+export { prisma };

package/modules/database/prisma/files/prisma/schema.prisma

@@ -0,0 +1,8 @@
+generator client {
+    provider = "prisma-client"
+    output   = "../generated/prisma"
+}
+
+datasource db {
+    provider = "{{provider}}"
+}

package/modules/database/prisma/files/prisma.config.ts

@@ -0,0 +1,12 @@
+import "dotenv/config";
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    path: "prisma/migrations",
+  },
+  datasource: {
+    url: process.env["DATABASE_URL"],
+  },
+});