create-stackkit-app 0.4.3 → 0.4.4

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

@@ -0,0 +1,311 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDatabaseConfig = mergeDatabaseConfig;
+exports.mergeAuthConfig = mergeAuthConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importStar(require("path"));
+const config_utils_1 = require("./config-utils");
+const file_utils_1 = require("./file-utils");
+async function mergeDatabaseConfig(templatesDir, targetDir, database, framework, dbProvider) {
+    const modulesDir = (0, path_1.join)(templatesDir, "..", "modules");
+    const dbModulePath = (0, path_1.join)(modulesDir, "database", database);
+    if (!(await fs_extra_1.default.pathExists(dbModulePath))) {
+        // eslint-disable-next-line no-console
+        console.warn(`Database module not found: ${database}`);
+        return [];
+    }
+    // Read module.json
+    const moduleJsonPath = (0, path_1.join)(dbModulePath, "module.json");
+    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
+        return [];
+    }
+    const moduleData = await fs_extra_1.default.readJson(moduleJsonPath);
+    const variables = {};
+    if (dbProvider) {
+        variables.provider = dbProvider;
+        if (dbProvider === "postgresql") {
+            variables.connectionString = "postgresql://user:password@localhost:5432/mydb?schema=public";
+            variables.prismaClientInit = `
+import { PrismaPg } from "@prisma/adapter-pg";
+
+const globalForPrisma = global as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+const adapter = new PrismaPg({
+  connectionString: process.env.DATABASE_URL!,
+});
+
+const prisma = globalForPrisma.prisma ?? new PrismaClient({
+  adapter,
+});
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+`;
+        }
+        else if (dbProvider === "mongodb") {
+            variables.connectionString = "mongodb+srv://username:password@cluster.mongodb.net/mydb";
+            variables.prismaClientInit = `
+const prisma = new PrismaClient()
+`;
+        }
+        else if (dbProvider === "mysql") {
+            variables.connectionString = "mysql://user:password@localhost:3306/mydb";
+            variables.prismaClientInit = `
+import { PrismaMariaDb } from '@prisma/adapter-mariadb';
+
+const adapter = new PrismaMariaDb({
+  host: process.env.DATABASE_HOST,
+  user: process.env.DATABASE_USER,
+  password: process.env.DATABASE_PASSWORD,
+  database: process.env.DATABASE_NAME,
+  connectionLimit: 5
+});
+const prisma = new PrismaClient({ adapter });
+`;
+        }
+        else if (dbProvider === "sqlite") {
+            variables.connectionString = "file:./dev.db";
+            variables.prismaClientInit = `
+import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
+
+const adapter = new PrismaBetterSqlite3({ url: process.env.DATABASE_URL });
+const prisma = new PrismaClient({ adapter });
+`;
+        }
+    }
+    const filesDir = (0, path_1.join)(dbModulePath, "files");
+    if (await fs_extra_1.default.pathExists(filesDir)) {
+        const libDir = framework === "nextjs" ? "lib" : "src";
+        for (const patch of moduleData.patches || []) {
+            if (patch.type === "create-file") {
+                const sourceFile = (0, path_1.join)(filesDir, patch.source);
+                let destFile = (0, path_1.join)(targetDir, patch.destination);
+                destFile = destFile
+                    .replace("{{lib}}", libDir)
+                    .replace("{{src}}", "src")
+                    .replace("{{models}}", framework === "nextjs" ? "models" : "src/models");
+                if (await fs_extra_1.default.pathExists(sourceFile)) {
+                    await fs_extra_1.default.ensureDir((0, path_1.join)(destFile, ".."));
+                    // Check if text file
+                    const ext = path_1.default.extname(sourceFile);
+                    if ([".ts", ".js", ".prisma", ".json"].includes(ext)) {
+                        let content = await fs_extra_1.default.readFile(sourceFile, "utf-8");
+                        for (const [key, value] of Object.entries(variables)) {
+                            content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
+                        }
+                        await fs_extra_1.default.writeFile(destFile, content);
+                    }
+                    else {
+                        await fs_extra_1.default.copy(sourceFile, destFile, { overwrite: false });
+                    }
+                }
+            }
+        }
+    }
+    const dependencies = {
+        ...moduleData.dependencies.common,
+        ...(dbProvider ? moduleData.dependencies.providers[dbProvider] : {}),
+    };
+    const devDependencies = {
+        ...moduleData.devDependencies.common,
+        ...(dbProvider ? moduleData.devDependencies.providers[dbProvider] : {}),
+    };
+    await (0, file_utils_1.mergePackageJson)(targetDir, {
+        dependencies,
+        devDependencies,
+    });
+    const envVars = {};
+    const commonEnvVars = Array.isArray(moduleData.envVars) ? moduleData.envVars : moduleData.envVars?.common || [];
+    const providerEnvVars = dbProvider && moduleData.envVars?.providers?.[dbProvider] ? moduleData.envVars.providers[dbProvider] : [];
+    const allEnvVars = [...commonEnvVars, ...providerEnvVars];
+    for (const envVar of allEnvVars) {
+        let value = envVar.value;
+        for (const [key, val] of Object.entries(variables)) {
+            value = value.replace(new RegExp(`{{${key}}}`, "g"), val);
+        }
+        envVars[envVar.key] = value;
+    }
+    await (0, file_utils_1.mergeEnvFile)(targetDir, envVars);
+    if (moduleData.frameworkPatches) {
+        const frameworkKey = framework === "react-vite" ? "react" : framework;
+        const patches = moduleData.frameworkPatches[frameworkKey];
+        if (patches) {
+            await (0, config_utils_1.applyFrameworkPatches)(targetDir, patches);
+        }
+    }
+    return moduleData.postInstall || [];
+}
+async function mergeAuthConfig(templatesDir, targetDir, framework, auth, database = "none", dbProvider) {
+    const modulesDir = (0, path_1.join)(templatesDir, "..", "modules");
+    const authKey = auth;
+    const authModulePath = (0, path_1.join)(modulesDir, "auth", authKey);
+    if (!(await fs_extra_1.default.pathExists(authModulePath))) {
+        // eslint-disable-next-line no-console
+        console.warn(`Auth module not found: ${authKey}`);
+        return;
+    }
+    // Read module.json
+    const moduleJsonPath = (0, path_1.join)(authModulePath, "module.json");
+    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
+        return;
+    }
+    const moduleData = await fs_extra_1.default.readJson(moduleJsonPath);
+    if (moduleData.supportedFrameworks && !moduleData.supportedFrameworks.includes(framework)) {
+        // eslint-disable-next-line no-console
+        console.warn(`Auth ${authKey} does not support framework ${framework}`);
+        return;
+    }
+    let frameworkConfig = null;
+    if (moduleData.frameworkConfigs) {
+        frameworkConfig = moduleData.frameworkConfigs[framework];
+        if (!frameworkConfig) {
+            // eslint-disable-next-line no-console
+            console.warn(`No config for framework ${framework} in ${authKey}`);
+            return;
+        }
+    }
+    const variables = {};
+    if (framework === "nextjs") {
+        variables.dbImport = "@/lib/db";
+    }
+    else if (framework === "express") {
+        variables.dbImport = "../db";
+    }
+    else {
+        variables.dbImport = "../db";
+    }
+    const filesDir = (0, path_1.join)(authModulePath, "files");
+    if (await fs_extra_1.default.pathExists(filesDir)) {
+        const getReplacements = () => {
+            if (framework === "nextjs") {
+                return { lib: "lib", router: "app" };
+            }
+            else if (framework === "express") {
+                return { lib: "src", router: "src" };
+            }
+            else {
+                return { lib: "src", router: "src" };
+            }
+        };
+        const replacements = getReplacements();
+        const patches = frameworkConfig?.patches || moduleData.patches || [];
+        for (const patch of patches) {
+            if (patch.type === "create-file") {
+                const sourceFile = (0, path_1.join)(filesDir, patch.source);
+                let destFile = (0, path_1.join)(targetDir, patch.destination);
+                destFile = destFile
+                    .replace("{{lib}}", replacements.lib)
+                    .replace("{{router}}", replacements.router);
+                if (await fs_extra_1.default.pathExists(sourceFile)) {
+                    await fs_extra_1.default.ensureDir(path_1.default.dirname(destFile));
+                    // Check if text file
+                    const ext = path_1.default.extname(sourceFile);
+                    if ([".ts", ".js", ".json"].includes(ext)) {
+                        let content = await fs_extra_1.default.readFile(sourceFile, "utf-8");
+                        for (const [key, value] of Object.entries(variables)) {
+                            content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
+                        }
+                        await fs_extra_1.default.writeFile(destFile, content);
+                    }
+                    else {
+                        await fs_extra_1.default.copy(sourceFile, destFile, { overwrite: false });
+                    }
+                }
+            }
+        }
+    }
+    // Add framework-specific patches
+    if (framework === "nextjs") {
+        const apiSource = (0, path_1.join)(filesDir, "api/auth/[...all]/route.ts");
+        const apiDest = (0, path_1.join)(targetDir, "app/api/auth/[...all]/route.ts");
+        if (await fs_extra_1.default.pathExists(apiSource)) {
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(apiDest));
+            await fs_extra_1.default.copy(apiSource, apiDest, { overwrite: false });
+        }
+    }
+    if (database !== "none" && moduleData.databaseAdapters) {
+        let adapterKey = database;
+        if (database === "prisma" && dbProvider) {
+            adapterKey = `prisma-${dbProvider}`;
+        }
+        const adapterConfig = moduleData.databaseAdapters[adapterKey];
+        if (adapterConfig) {
+            variables.databaseAdapter = adapterConfig.adapterCode;
+            if (adapterConfig.schema && adapterConfig.schemaDestination) {
+                const schemaSource = (0, path_1.join)(authModulePath, adapterConfig.schema);
+                const schemaDest = (0, path_1.join)(targetDir, adapterConfig.schemaDestination);
+                if (await fs_extra_1.default.pathExists(schemaSource)) {
+                    await fs_extra_1.default.ensureDir(path_1.default.dirname(schemaDest));
+                    let content = await fs_extra_1.default.readFile(schemaSource, "utf-8");
+                    // Set schema variables
+                    if (dbProvider === "postgresql") {
+                        variables.provider = "postgresql";
+                        variables.idDefault = "@default(cuid())";
+                        variables.userIdType = "";
+                    }
+                    else if (dbProvider === "mongodb") {
+                        variables.provider = "mongodb";
+                        variables.idDefault = '@default(auto()) @map("_id") @db.ObjectId';
+                        variables.userIdType = "@db.ObjectId";
+                    }
+                    for (const [key, value] of Object.entries(variables)) {
+                        content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
+                    }
+                    await fs_extra_1.default.writeFile(schemaDest, content, { flag: "a" }); // append
+                }
+            }
+            if (adapterConfig.dependencies) {
+                await (0, file_utils_1.mergePackageJson)(targetDir, {
+                    dependencies: adapterConfig.dependencies,
+                });
+            }
+        }
+    }
+    await (0, file_utils_1.mergePackageJson)(targetDir, {
+        dependencies: frameworkConfig?.dependencies || moduleData.dependencies,
+        devDependencies: frameworkConfig?.devDependencies || moduleData.devDependencies,
+    });
+    const envVars = {};
+    const envVarList = frameworkConfig?.envVars || moduleData.envVars || [];
+    for (const envVar of envVarList) {
+        envVars[envVar.key] = envVar.value;
+    }
+    await (0, file_utils_1.mergeEnvFile)(targetDir, envVars);
+}

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

@@ -0,0 +1 @@
+export declare function installDependencies(cwd: string, packageManager: string): Promise<void>;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDependencies = installDependencies;
+const child_process_1 = require("child_process");
+async function installDependencies(cwd, packageManager) {
+    const commands = {
+        npm: "npm install",
+        yarn: "yarn install",
+        pnpm: "pnpm install",
+        bun: "bun install",
+    };
+    const isAvailable = (cmd) => {
+        try {
+            (0, child_process_1.execSync)(`command -v ${cmd}`, { stdio: "ignore" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    let chosen = packageManager;
+    if (!isAvailable(chosen)) {
+        const fallbacks = ["pnpm", "npm", "yarn", "bun"];
+        const found = fallbacks.find((p) => isAvailable(p));
+        if (found) {
+            // eslint-disable-next-line no-console
+            console.warn(`Selected package manager '${chosen}' was not found. Falling back to '${found}'.`);
+            chosen = found;
+        }
+        else {
+            throw new Error(`Selected package manager '${packageManager}' was not found and no fallback package manager is available. Please install '${packageManager}' or use a different package manager.`);
+        }
+    }
+    const command = commands[chosen];
+    (0, child_process_1.execSync)(command, {
+        cwd,
+        stdio: "pipe",
+    });
+}

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;