@ifecodes/backend-template 1.0.0

package/template/base/src/server.ts

@@ -0,0 +1,11 @@
+import app from "./app";
+import { ENV } from "./config";
+/*__DB_IMPORT__*/
+
+const PORT = ENV.PORT || 3000;
+
+/*__DB_CONNECT__*/
+
+app.listen(PORT, () => {
+  console.log(`Server is running on port ${PORT}`);
+});

package/template/base/src/utils/http-error.ts

@@ -0,0 +1,47 @@
+export class HttpError extends Error {
+  public status: number;
+
+  constructor(status: number, message: string) {
+    super(message);
+    this.status = status;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class BadRequestError extends HttpError {
+  constructor(message = "Bad Request") {
+    super(400, message);
+  }
+}
+
+export class UnauthorizedError extends HttpError {
+  constructor(message = "Unauthorized") {
+    super(401, message);
+  }
+}
+
+export class ForbiddenError extends HttpError {
+  constructor(message = "Forbidden") {
+    super(403, message);
+  }
+}
+
+export class NotFoundError extends HttpError {
+  constructor(message = "Not Found") {
+    super(404, message);
+  }
+}
+
+export class ConflictError extends HttpError {
+  constructor(message = "Conflict") {
+    super(409, message);
+  }
+}
+
+export class InternalServerError extends HttpError {
+  constructor(message = "Internal Server Error") {
+    super(500, message);
+  }
+}
+
+export default HttpError;

package/template/base/src/utils/index.ts

@@ -0,0 +1,11 @@
+export {
+  HttpError,
+  BadRequestError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  ConflictError,
+  InternalServerError,
+} from "./http-error";
+
+export { default as logger } from "./logger";

package/template/base/src/utils/logger.ts

@@ -0,0 +1,34 @@
+import { ENV } from "@/config";
+
+function format(tag: string, args: unknown[]) {
+  return [`%c[${tag}]`, "color:#6366f1;font-weight:600", ...args];
+}
+
+const environment =
+  ENV.NODE_ENV === "development" || ENV.NODE_ENV === "staging"
+    ? "development"
+    : ENV.NODE_ENV;
+
+const logger = {
+  log(tag: string, ...args: unknown[]) {
+    if (environment !== "development") return;
+    console.log(...format(tag, args));
+  },
+
+  info(tag: string, ...args: unknown[]) {
+    if (environment !== "development") return;
+    console.info(...format(tag, args));
+  },
+
+  warn(tag: string, ...args: unknown[]) {
+    if (environment !== "development") return;
+    console.warn(...format(tag, args));
+  },
+
+  error(tag: string, ...args: unknown[]) {
+    if (environment !== "development") return;
+    console.error(...format(tag, args));
+  },
+};
+
+export default logger;

package/template/base/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "rootDir": "src",
+    "outDir": "dist",
+
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+
+    "baseUrl": "src",
+    "paths": {
+      "@/*": ["*"]
+    },
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/template/features/auth/argon2/inject.js

@@ -0,0 +1,25 @@
+export const deps = ["argon2"];
+
+export const files = {
+  "src/utils/hash.ts": `
+import argon2 from "argon2";
+
+const HASH_OPTIONS = {
+  type: argon2.argon2id,
+  memoryCost: 2 ** 16,
+  timeCost: 3,
+  parallelism: 1,
+};
+
+export const hashPassword = async (password: string): Promise<string> => {
+  return argon2.hash(password, HASH_OPTIONS);
+};
+
+export const verifyPassword = async (
+  hash: string,
+  password: string,
+): Promise<boolean> => {
+  return argon2.verify(hash, password);
+};
+`
+};

package/template/features/auth/base/inject.js

@@ -0,0 +1,89 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Read all module files
+const modulesDir = path.join(__dirname, "../modules");
+const modelsDir = path.join(__dirname, "../models");
+const utilsDir = path.join(__dirname, "../utils");
+
+const readDirFiles = (dir, prefix = "") => {
+  const files = {};
+  const items = fs.readdirSync(dir);
+  
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+    const relativePath = path.join(prefix, item);
+    
+    if (fs.statSync(fullPath).isDirectory()) {
+      Object.assign(files, readDirFiles(fullPath, relativePath));
+    } else {
+      files[relativePath] = fs.readFileSync(fullPath, "utf8");
+    }
+  }
+  
+  return files;
+};
+
+const moduleFiles = readDirFiles(modulesDir, "src/modules/v1/auth");
+const modelFiles = readDirFiles(modelsDir, "src/models");
+const utilFiles = readDirFiles(utilsDir, "src/utils");
+
+// Add MongoDB-enabled db.ts
+const dbContent = `import mongoose from "mongoose";
+import { ENV } from "./env";
+import { logger } from "@/utils";
+
+export const connectDB = async () => {
+  await mongoose.connect(ENV.MONGO_URI);
+  logger.log("db", "MongoDB connected");
+};
+`;
+
+// Add MongoDB health check
+const healthControllerContent = `import { Request, Response } from "express";
+import mongoose from "mongoose";
+import { logger } from "@/utils";
+
+export const healthCheck = async (_: Request, res: Response) => {
+  const mongoState = mongoose.connection.readyState;
+  const healthy = mongoState === 1;
+
+  const failed: string[] = [];
+  if (mongoState !== 1) failed.push("mongodb");
+
+  logger.info("Health", healthy ? "healthy" : "unhealthy");
+
+  return res.status(healthy ? 200 : 503).json({
+    status: healthy ? "healthy" : "unhealthy",
+    uptime: process.uptime(),
+    timestamp: new Date().toISOString(),
+    services: {
+      mongodb: mongoState === 1 ? "connected" : "disconnected",
+      memory: {
+        rss: process.memoryUsage().rss,
+        heapUsed: process.memoryUsage().heapUsed,
+      },
+    },
+    failed,
+  });
+};
+`;
+
+export const files = {
+  ...moduleFiles,
+  ...modelFiles,
+  ...utilFiles,
+  "src/config/db.ts": dbContent,
+  "src/modules/v1/health/health.controller.ts": healthControllerContent,
+};
+
+export const imports = `import { authRoutes } from "./auth";`;
+
+export const middleware = `router.use("/auth", authRoutes);`;
+
+export const deps = ["jsonwebtoken", "@types/jsonwebtoken", "mongoose"];
+
+export const targetFile = "src/modules/v1/index.ts";

package/template/features/auth/bcrypt/inject.js

@@ -0,0 +1,18 @@
+export const deps = ["bcrypt"];
+
+export const files = {
+  "src/utils/hash.ts": `
+import bcrypt from "bcrypt";
+
+export const hashPassword = async (password: string): Promise<string> => {
+  return bcrypt.hash(password, 12);
+};
+
+export const verifyPassword = async (
+  hash: string,
+  password: string,
+): Promise<boolean> => {
+  return bcrypt.compare(password, hash);
+};
+`
+};

package/template/features/auth/models/index.ts

@@ -0,0 +1 @@
+export { UserModel, IUser } from "./user.model";

package/template/features/auth/models/user.model.ts

@@ -0,0 +1,28 @@
+import { Schema, model, Document } from "mongoose";
+
+export interface IUser extends Document {
+  email: string;
+  password: string;
+  fullName: string;
+}
+
+const userSchema = new Schema<IUser>(
+  {
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    password: {
+      type: String,
+      required: true,
+    },
+    fullName: {
+      type: String,
+      required: true,
+    },
+  },
+  { timestamps: true },
+);
+
+export const UserModel = model<IUser>("User", userSchema);

package/template/features/auth/modules/auth.controller.ts

@@ -0,0 +1,20 @@
+import { Request, Response, NextFunction } from "express";
+import { loginService, registerService } from "./auth.service";
+
+export const login = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const token = await loginService(req.body);
+    return res.status(200).json({ token });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+export const register = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const token = await registerService(req.body);
+    return res.status(201).json({ token });
+  } catch (err) {
+    return next(err);
+  }
+};

package/template/features/auth/modules/auth.routes.ts

@@ -0,0 +1,11 @@
+import { Router } from "express";
+import { register, login } from "./auth.controller";
+import { methodNotAllowedHandler } from "@/middlewares";
+
+const router = Router();
+router.use(methodNotAllowedHandler(["POST"]));
+router.post("/login", login);
+router.post("/register", register);
+
+export default router;
+

package/template/features/auth/modules/auth.service.ts

@@ -0,0 +1,38 @@
+import { generateToken } from "@/utils";
+import { UserModel } from "@/models/user.model";
+import { hashPassword, verifyPassword } from "@/utils";
+import { UnauthorizedError, ConflictError } from "@/utils";
+
+export const loginService = async ({
+  email,
+  password,
+}: {
+  email: string;
+  password: string;
+}) => {
+  const user = await UserModel.findOne({ email }).exec();
+  if (!user) throw new UnauthorizedError("User not found");
+
+  const match = await verifyPassword(user.password, password);
+  if (!match) throw new UnauthorizedError("Invalid credentials");
+
+  return generateToken({ email: user.email });
+};
+
+export const registerService = async ({
+  email,
+  password,
+  fullName,
+}: {
+  email: string;
+  password: string;
+  fullName: string;
+}) => {
+  const exists = await UserModel.findOne({ email }).exec();
+  if (exists) throw new ConflictError("Email already registered");
+
+  const hashed = await hashPassword(password);
+  const user = await UserModel.create({ email, password: hashed, fullName });
+
+  return generateToken({ email: user.email });
+};

package/template/features/auth/modules/index.ts

@@ -0,0 +1 @@
+export { default as authRoutes } from "./auth.routes";

package/template/features/auth/utils/hash.ts

@@ -0,0 +1,20 @@
+/**
+ * This base hash utility defines generic hashing function signatures.
+ * The actual implementation will be replaced by bcrypt or argon2 depending
+ * on user selection during template generation.
+ */
+
+export async function hashPassword(_password: string): Promise<string> {
+  throw new Error(
+    "hashPassword() not implemented — hashing method not selected (bcrypt or argon2)"
+  );
+}
+
+export async function verifyPassword(
+  _hashed: string,
+  _password: string
+): Promise<boolean> {
+  throw new Error(
+    "verifyPassword() not implemented — hashing method not selected (bcrypt or argon2)"
+  );
+}

package/template/features/auth/utils/jwt.ts

@@ -0,0 +1,15 @@
+import jwt from "jsonwebtoken";
+import { ENV } from "@/config";
+
+// JwtPayload mirrors the global JwtPayload declared in `src/types/express.d.ts`.
+export type JwtPayload = {
+  email?: string;
+  iat?: number;
+  exp?: number;
+};
+
+export const generateToken = (payload: JwtPayload) =>
+  jwt.sign(payload, ENV.JWT_SECRET, { expiresIn: "7d" });
+
+export const verifyToken = (token: string): JwtPayload =>
+  jwt.verify(token, ENV.JWT_SECRET) as JwtPayload;

package/template/features/cors/inject.js

@@ -0,0 +1,9 @@
+export const deps = ["cors", "@types/cors"];
+export const imports = `import cors from "cors";`;
+export const middleware = `
+const corsOptions = {
+  origin: ENV.ALLOWED_ORIGIN,
+  credentials: true,
+};
+
+app.use(cors(corsOptions));`;

package/template/features/helmet/inject.js

@@ -0,0 +1,3 @@
+export const deps = ["helmet"];
+export const imports = `import helmet from "helmet";`;
+export const middleware = `app.use(helmet());`;

package/template/features/morgan/inject.js

@@ -0,0 +1,3 @@
+export const deps = ["morgan", "@types/morgan"];
+export const imports = `import morgan from "morgan";`;
+export const middleware = `app.use(morgan("dev"));`;

package/template/features/rate-limit/inject.js

@@ -0,0 +1,3 @@
+export const deps = ["express-rate-limit"];
+export const imports = `import rateLimit from "express-rate-limit";`;
+export const middleware = `app.use(rateLimit({ windowMs: 15*60*1000, max: 100 }));`;

package/template/gateway/app.ts

@@ -0,0 +1,26 @@
+import express, { Request, Response, NextFunction } from "express";
+import { createProxyMiddleware } from "http-proxy-middleware";
+import { logger } from "@/utils";
+
+const app = express();
+
+// Health check for the gateway itself
+app.get("/health", (_req: Request, res: Response) => {
+  res.json({ status: "ok", service: "gateway" });
+});
+
+// Service routes - will be dynamically configured
+/*__ROUTES__*/
+
+// 404 handler
+app.use((req: Request, res: Response) => {
+  res.status(404).json({ error: "Route not found" });
+});
+
+// Error handler
+app.use((err: any, req: Request, res: Response, next: NextFunction) => {
+  logger.error("Gateway error:", err);
+  res.status(500).json({ error: "Internal gateway error" });
+});
+
+export default app;

package/template/gateway/inject.js

@@ -0,0 +1,27 @@
+export const gatewayDeps = ["http-proxy-middleware"];
+
+export const generateGatewayRoutes = (services) => {
+  const routes = services
+    .filter(s => s !== "gateway")
+    .map((service, index) => {
+      const port = 4001 + index; // Gateway is 4000, services start at 4001
+      const routePath = service.replace("-service", "");
+      
+      return `
+// Route ${service} to port ${port}
+app.use("/${routePath}", createProxyMiddleware({
+  target: "http://localhost:${port}",
+  changeOrigin: true,
+  pathRewrite: {
+    "^/${routePath}": "",
+  },
+  onError: (err, req, res) => {
+    logger.error(\`Proxy error for ${service}:\`, err);
+    res.status(503).json({ error: "Service unavailable" });
+  },
+}));`;
+    })
+    .join("\n");
+
+  return routes;
+};

package/template/gateway/server.ts

@@ -0,0 +1,19 @@
+import http from "http";
+import app from "./app";
+import { logger } from "@/utils";
+import { ENV } from "@/config";
+
+const PORT = ENV.PORT || 4000;
+
+const server = http.createServer(app);
+
+server.listen(PORT, () => {
+  logger.info(`🚀 API Gateway running on port ${PORT}`);
+});
+
+process.on("SIGTERM", () => {
+  logger.info("SIGTERM signal received: closing HTTP server");
+  server.close(() => {
+    logger.info("HTTP server closed");
+  });
+});

package/template/microservice/docker/Dockerfile

@@ -0,0 +1,5 @@
+FROM node:20
+WORKDIR /app
+COPY . .
+RUN npm install
+CMD ["npm","run","dev"]

package/template/microservice/docker/docker-compose.yml

@@ -0,0 +1,6 @@
+version: "3"
+services:
+  api:
+    build: .
+    ports:
+      - "4000:4000"

package/template/microservice/nodocker/pm2.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  apps: [{ name: "api", script: "src/server.ts" }]
+};