create-stackkit-app 0.4.2 → 0.4.4

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

@@ -1,28 +1,45 @@
-import mongoose from 'mongoose';
+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"],
+  },
+});

package/modules/database/prisma/module.json

@@ -0,0 +1,140 @@
+{
+  "name": "prisma",
+  "displayName": "Prisma",
+  "description": "Prisma ORM",
+  "category": "database",
+  "provider": "prisma",
+  "supportedFrameworks": ["nextjs", "express"],
+  "dependencies": {
+    "common": {
+      "@prisma/client": "^7.2.0",
+      "dotenv": "^17.2.3"
+    },
+    "providers": {
+      "postgresql": {
+        "@prisma/adapter-pg": "^7.2.0",
+        "pg": "^8.16.3"
+      },
+      "mongodb": {
+        "@prisma/client": "6.19"
+      },
+      "mysql": {
+        "@prisma/adapter-mariadb": "^7.2.0"
+      },
+      "sqlite": {
+        "@prisma/adapter-better-sqlite3": "^7.2.0"
+      }
+    }
+  },
+  "devDependencies": {
+    "common": {
+      "prisma": "^7.2.0",
+      "tsx": "^4.21.0"
+    },
+    "providers": {
+      "postgresql": {
+        "@types/pg": "^8.16.0"
+      },
+      "mongodb": {
+        "prisma": "6.19"
+      },
+      "mysql": {},
+      "sqlite": {
+        "@types/better-sqlite3": "^7.6.13"
+      }
+    }
+  },
+  "envVars": {
+    "common": [
+      {
+        "key": "DATABASE_URL",
+        "value": "{{connectionString}}",
+        "description": "Database connection URL",
+        "required": true
+      }
+    ],
+    "providers": {
+      "mysql": [
+        {
+          "key": "DATABASE_HOST",
+          "value": "localhost",
+          "description": "MySQL host",
+          "required": true
+        },
+        {
+          "key": "DATABASE_USER",
+          "value": "",
+          "description": "MySQL username",
+          "required": true
+        },
+        {
+          "key": "DATABASE_PASSWORD",
+          "value": "",
+          "description": "MySQL password",
+          "required": true
+        },
+        {
+          "key": "DATABASE_NAME",
+          "value": "mydb",
+          "description": "MySQL database name",
+          "required": true
+        },
+        {
+          "key": "DATABASE_PORT",
+          "value": "3306",
+          "description": "MySQL port",
+          "required": false
+        }
+      ]
+    }
+  },
+  "frameworkPatches": {
+    "express": {
+      "tsconfig.json": {
+        "merge": {
+          "compilerOptions": {
+            "baseUrl": ".",
+            "paths": {
+              "@/*": ["./src/*"]
+            }
+          },
+          "include": ["src/**/*"],
+          "exclude": ["node_modules", "dist", "prisma/migrations"]
+        }
+      }
+    },
+    "nextjs": {
+      "tsconfig.json": {
+        "merge": {
+          "compilerOptions": {
+            "paths": {
+              "@/*": ["./*"]
+            }
+          },
+          "exclude": ["node_modules", ".next", "out", "prisma/migrations"]
+        }
+      }
+    }
+  },
+  "patches": [
+    {
+      "type": "create-file",
+      "description": "Create Prisma schema",
+      "source": "prisma/schema.prisma",
+      "destination": "prisma/schema.prisma"
+    },
+    {
+      "type": "create-file",
+      "description": "Create Prisma config",
+      "source": "prisma.config.ts",
+      "destination": "prisma.config.ts"
+    },
+    {
+      "type": "create-file",
+      "description": "Create Prisma client singleton",
+      "source": "lib/prisma.ts",
+      "destination": "{{lib}}/prisma.ts"
+    }
+  ],
+  "postInstall": ["npx prisma generate"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-stackkit-app",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Create a new StackKit project with modular composition",
   "main": "dist/index.js",
   "bin": {
@@ -44,13 +44,22 @@
     "fs-extra": "^11.2.0",
     "inquirer": "^9.3.8",
     "ora": "^5.4.1",
-    "validate-npm-package-name": "^5.0.1"
+    "validate-npm-package-name": "^5.0.1",
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@babel/preset-react": "^7.28.5"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.11.0",
     "@types/validate-npm-package-name": "^4.0.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "recast": "^0.20.5",
+    "@babel/core": "^7.28.5",
+    "@babel/plugin-transform-typescript": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/plugin-transform-react-jsx": "^7.27.1"
   }
 }

package/templates/express/.env.example

@@ -1,11 +1,3 @@
+# APP CONFIGURATION
 PORT=3000
-NODE_ENV=development
-APP_URL=http://localhost:3000
-SITE_URL=http://localhost:5173
-
-# Proxy (set to true if running behind a proxy/load-balancer)
-TRUST_PROXY=false
-
-# Rate limit
-RATE_LIMIT_MAX=100
-RATE_LIMIT_WINDOW_MS=900000
+NODE_ENV=development

package/templates/express/package.json

@@ -1,11 +1,10 @@
 {
-  "name": "my-app",
+  "name": "my-express-app",
   "version": "1.0.0",
   "private": true,
+  "type": "module",
   "scripts": {
     "dev": "tsx watch src/server.ts",
-    "clean": "rimraf dist",
-    "prebuild": "npm run clean",
     "build": "tsc",
     "lint": "eslint src --ext .ts",
     "lint:fix": "eslint src --ext .ts --fix",
@@ -13,26 +12,22 @@
     "start:prod": "cross-env NODE_ENV=production node dist/server.js"
   },
   "dependencies": {
-    "compression": "^1.7.4",
     "cors": "^2.8.5",
-    "dotenv": "^16.4.7",
-    "express": "^4.21.2",
-    "express-rate-limit": "^6.7.0",
-    "helmet": "^7.0.0",
-    "morgan": "^1.10.0"
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "helmet": "^8.1.0",
+    "morgan": "^1.10.1"
   },
   "devDependencies": {
-    "@types/compression": "^1.8.1",
-    "@types/cors": "^2.8.17",
-    "@types/express": "^4.17.21",
-    "@types/morgan": "^1.9.4",
-    "@types/node": "^22.10.5",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^25.0.6",
     "@typescript-eslint/eslint-plugin": "^8.52.0",
     "@typescript-eslint/parser": "^8.52.0",
-    "cross-env": "^7.0.3",
+    "cross-env": "^10.1.0",
     "eslint": "^9.39.2",
-    "rimraf": "^5.0.0",
-    "tsx": "^4.19.2",
-    "typescript": "^5.7.2"
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
   }
 }

package/templates/express/src/app.ts

@@ -1,62 +1,44 @@
-import compression from 'compression';
-import cors from 'cors';
-import express, { Application, NextFunction, Request, Response } from 'express';
-import rateLimit from 'express-rate-limit';
-import helmet from 'helmet';
-import morgan from 'morgan';
-import { env } from './config/env';
-import { errorHandler } from './middlewares/error.middleware';
+import cors from "cors";
+import express, { Application, NextFunction, Request, Response } from "express";
+import helmet from "helmet";
+import morgan from "morgan";
+import { env } from "./config/env";
+import { authRoutes } from "./features/auth/auth.route";
+import { errorHandler } from "./middlewares/error.middleware";
 
 // app initialization
 const app: Application = express();
 app.use(express.json());
 
-// trust proxy when behind reverse proxy (like Heroku, Vercel, Load Balancers)
-if (env.app.trust_proxy) {
-  app.set('trust proxy', 1);
-}
-
 // security headers
 app.use(helmet());
 
-// response compression
-app.use(compression());
-
-// rate limiting
-const limiter = rateLimit({
-  windowMs: env.app.rateLimit.windowMs,
-  max: env.app.rateLimit.max,
-  standardHeaders: true,
-  legacyHeaders: false,
-});
-app.use(limiter);
-
 // logging
-if (env.node.isProduction) {
-  app.use(morgan('combined'));
+if (env.isProduction) {
+  app.use(morgan("combined"));
 } else {
-  app.use(morgan('dev'));
+  app.use(morgan("dev"));
 }
 
 // cors configuration
-app.use(
-  cors({
-    origin: [env.app.site_url],
-    credentials: true,
-  })
-);
+app.use(cors());
 
 // Home page route
-app.get('/', (req: Request, res: Response) => {
-  res.json({
-    title: 'StackKit - Production-ready project generator',
+app.get("/", (_req: Request, res: Response) => {
+  res.status(200).json({
+    title: "Welcome to your Express app",
     description:
-      'Modern CLI tool for creating production-ready web applications with modular architecture. Build with Next.js, Express, or React.',
+      "Built with StackKit - A production-ready Express template with TypeScript, security, and best practices.",
+    version: "1.0.0",
+    docs: "https://github.com/tariqul420/stackkit",
   });
 });
 
+// routes
+app.use("/api/auth", authRoutes);
+
 // unhandled routes
-app.use((req: Request, res: Response, next: NextFunction) => {
+app.use((req: Request, _res: Response, next: NextFunction) => {
   const error: any = new Error(`Can't find ${req.originalUrl} on this server!`);
   error.status = 404;
 

package/templates/express/src/config/env.ts

@@ -1,23 +1,12 @@
-import dotenv from 'dotenv';
-import path from 'path';
+import dotenv from "dotenv";
+import path from "path";
 
-dotenv.config({ path: path.join(process.cwd(), '.env') });
+dotenv.config({ path: path.join(process.cwd(), ".env") });
 
 const env = {
-  app: {
-    port: Number(process.env.PORT) || 3000,
-    url: process.env.APP_URL || 'http://localhost:3000',
-    site_url: process.env.SITE_URL || 'http://localhost:5173',
-    trust_proxy: (process.env.TRUST_PROXY || 'false') === 'true',
-    rateLimit: {
-      max: Number(process.env.RATE_LIMIT_MAX) || 100,
-      windowMs: Number(process.env.RATE_LIMIT_WINDOW_MS) || 15 * 60 * 1000,
-    },
-  },
-  node: {
-    env: process.env.NODE_ENV || 'development',
-    isProduction: (process.env.NODE_ENV || 'development') === 'production',
-  },
+  port: Number(process.env.PORT) || 3000,
+  node_env: process.env.NODE_ENV || "development",
+  isProduction: (process.env.NODE_ENV || "development") === "production",
 };
 
 export { env };

package/templates/express/src/features/auth/auth.controller.ts

@@ -0,0 +1,48 @@
+import { NextFunction, Request, Response } from "express";
+import { authServices } from "./auth.service";
+
+const signup = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = await authServices.signup(req.body);
+
+    res.status(201).json({
+      success: true,
+      message: "User registered successfully",
+      data: result,
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const signin = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email, password } = req.body;
+
+    const result = await authServices.signin(email, password);
+
+    if (!result) {
+      res.status(401).json({
+        success: false,
+        message: "Invalid email or password",
+      });
+      return;
+    }
+
+    res.status(200).json({
+      success: true,
+      message: "Login successful",
+      data: {
+        token: result.token,
+        user: result.user,
+      },
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+export const authController = {
+  signup,
+  signin,
+};

package/templates/express/src/features/auth/auth.route.ts

@@ -0,0 +1,10 @@
+import { Router } from "express";
+import { authController } from "./auth.controller";
+
+const router = Router();
+
+// routes
+router.post("/signup", authController.signup);
+router.post("/signin", authController.signin);
+
+export const authRoutes = router;

package/templates/express/src/features/auth/auth.service.ts

@@ -0,0 +1,21 @@
+// @ts-nocheck
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+const signup = async (payload: Record<string, unknown>) => {
+  // your logic here
+};
+
+const signin = async (
+  email: string,
+  password: string,
+): Promise<{ token: string; user: any } | null> => {
+  // your logic here
+  return null;
+};
+
+export const authServices = {
+  signup,
+  signin,
+};
+
+export type { User };