@ifecodes/backend-template 1.1.7 → 1.1.9

package/template/base/js/src/middlewares/not-found.middleware.js

@@ -1,10 +1,10 @@
-const notFound = (req, res) => {
-  res.status(404).json({
-    status: "error",
-    message: `Route ${req.originalUrl} not found`,
-  });
-};
-
-module.exports = {
-  notFound,
-};
+const notFound = (req, res) => {
+  res.status(404).json({
+    status: "error",
+    message: `Route ${req.originalUrl} not found`,
+  });
+};
+
+module.exports = {
+  notFound,
+};

package/template/base/js/src/middlewares/root.middleware.js

@@ -1,16 +1,16 @@
-const rootHandler = (_, res) => {
-  res.json({
-    name: "/*__PROJECT_NAME__*/",
-    type: "/*__PROJECT_TYPE__*/",
-    version: "1.0.0",
-    status: "running",
-    endpoints: {
-      health: "/api/v1/health",
-      /*__AUTH_ENDPOINT__*/
-    },
-  });
-};
-
-module.exports = {
-  rootHandler,
-};
+const rootHandler = (_, res) => {
+  res.json({
+    name: "/*__PROJECT_NAME__*/",
+    type: "/*__PROJECT_TYPE__*/",
+    version: "1.0.0",
+    status: "running",
+    endpoints: {
+      health: "/api/v1/health",
+      /*__AUTH_ENDPOINT__*/
+    },
+  });
+};
+
+module.exports = {
+  rootHandler,
+};

package/template/base/js/src/modules/v1/health/health.controller.js

@@ -1,21 +1,21 @@
-const { logger } = require("../../../utils");
-
-const healthCheck = async (_, res) => {
-  logger.info("Health", "healthy");
-
-  return res.status(200).json({
-    status: "healthy",
-    uptime: process.uptime(),
-    timestamp: new Date().toISOString(),
-    services: {
-      memory: {
-        rss: process.memoryUsage().rss,
-        heapUsed: process.memoryUsage().heapUsed,
-      },
-    },
-  });
-};
-
-module.exports = {
-  healthCheck
-};
+const { logger } = require("../../../utils");
+
+const healthCheck = async (_, res) => {
+  logger.info("Health", "healthy");
+
+  return res.status(200).json({
+    status: "healthy",
+    uptime: process.uptime(),
+    timestamp: new Date().toISOString(),
+    services: {
+      memory: {
+        rss: process.memoryUsage().rss,
+        heapUsed: process.memoryUsage().heapUsed,
+      },
+    },
+  });
+};
+
+module.exports = {
+  healthCheck
+};

package/template/base/js/src/modules/v1/health/health.route.js

@@ -1,9 +1,9 @@
-const { Router } = require("express");
-const { healthCheck } = require("./health.controller");
-const { methodNotAllowedHandler } = require("../../../middlewares");
-
-const router = Router();
-router.use(methodNotAllowedHandler(["GET"]));
-router.get("/", healthCheck);
-
-module.exports = router;
+const { Router } = require("express");
+const { healthCheck } = require("./health.controller");
+const { methodNotAllowedHandler } = require("../../../middlewares");
+
+const router = Router();
+router.use(methodNotAllowedHandler(["GET"]));
+router.get("/", healthCheck);
+
+module.exports = router;

package/template/base/js/src/modules/v1/health/index.js

@@ -1,5 +1,5 @@
-const healthRoutes = require("./health.route");
-
-module.exports = {
-  healthRoutes,
-};
+const healthRoutes = require("./health.route");
+
+module.exports = {
+  healthRoutes,
+};

package/template/base/js/src/modules/v1/index.js

@@ -1,8 +1,8 @@
-const { Router } = require("express");
-const { healthRoutes } = require("./health");
-
-const router = Router();
-
-router.use("/health", healthRoutes);
-
-module.exports = router;
+const { Router } = require("express");
+const { healthRoutes } = require("./health");
+
+const router = Router();
+
+router.use("/health", healthRoutes);
+
+module.exports = router;

package/template/base/js/src/routes.js

@@ -1,16 +1,16 @@
-const { Router } = require("express");
-const modulesRouter = require("./modules");
-const { notFound, rootHandler } = require("./middlewares");
-
-const router = Router();
-
-// Root endpoint
-router.get("/", rootHandler);
-
-router.use("/api", modulesRouter);
-
-// 404 handler - must be last
-router.use(notFound);
-
-module.exports = router;
-
+const { Router } = require("express");
+const modulesRouter = require("./modules");
+const { notFound, rootHandler } = require("./middlewares");
+
+const router = Router();
+
+// Root endpoint
+router.get("/", rootHandler);
+
+router.use("/api", modulesRouter);
+
+// 404 handler - must be last
+router.use(notFound);
+
+module.exports = router;
+

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

@@ -1,53 +1,74 @@
-class HttpError extends Error {
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-
-class BadRequestError extends HttpError {
-  constructor(message = "Bad Request") {
-    super(400, message);
-  }
-}
-
-class UnauthorizedError extends HttpError {
-  constructor(message = "Unauthorized") {
-    super(401, message);
-  }
-}
-
-class ForbiddenError extends HttpError {
-  constructor(message = "Forbidden") {
-    super(403, message);
-  }
-}
-
-class NotFoundError extends HttpError {
-  constructor(message = "Not Found") {
-    super(404, message);
-  }
-}
-
-class ConflictError extends HttpError {
-  constructor(message = "Conflict") {
-    super(409, message);
-  }
-}
-
-class InternalServerError extends HttpError {
-  constructor(message = "Internal Server Error") {
-    super(500, message);
-  }
-}
-
-module.exports = {
-  HttpError,
-  BadRequestError,
-  UnauthorizedError,
-  ForbiddenError,
-  NotFoundError,
-  ConflictError,
-  InternalServerError,
-};
+class HttpError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class BadRequestError extends HttpError {
+  constructor(message = "Bad Request") {
+    super(400, message);
+  }
+}
+
+class UnprocessableEntityError extends HttpError {
+  constructor(message = "Unprocessable Entity") {
+    super(422, message);
+  }
+}
+
+class UnauthorizedError extends HttpError {
+  constructor(message = "Unauthorized") {
+    super(401, message);
+  }
+}
+
+class ForbiddenError extends HttpError {
+  constructor(message = "Forbidden") {
+    super(403, message);
+  }
+}
+
+class NotFoundError extends HttpError {
+  constructor(message = "Not Found") {
+    super(404, message);
+  }
+}
+
+class ConflictError extends HttpError {
+  constructor(message = "Conflict") {
+    super(409, message);
+  }
+}
+
+class TooManyRequestsError extends HttpError {
+  constructor(message = "Too Many Requests") {
+    super(429, message);
+  }
+}
+
+class BadGatewayError extends HttpError {
+  constructor(message = "Bad Gateway") {
+    super(502, message);
+  }
+}
+
+class InternalServerError extends HttpError {
+  constructor(message = "Internal Server Error") {
+    super(500, message);
+  }
+}
+
+module.exports = {
+  HttpError,
+  BadRequestError,
+  UnprocessableEntityError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  ConflictError,
+  TooManyRequestsError,
+  BadGatewayError,
+  InternalServerError,
+};

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

@@ -1,22 +1,28 @@
 const {
   HttpError,
   BadRequestError,
+  UnprocessableEntityError,
   UnauthorizedError,
   ForbiddenError,
   NotFoundError,
   ConflictError,
+  TooManyRequestsError,
+  BadGatewayError,
   InternalServerError,
-} = require("./http-error");
+} = require('./http-error');
 
-const logger = require("./logger");
+const logger = require('./logger');
 
 module.exports = {
   HttpError,
   BadRequestError,
+  UnprocessableEntityError,
   UnauthorizedError,
   ForbiddenError,
   NotFoundError,
   ConflictError,
+  TooManyRequestsError,
+  BadGatewayError,
   InternalServerError,
   logger,
 };

package/template/base/ts/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "scripts": {
     "dev": "ts-node-dev --respawn --transpile-only -r tsconfig-paths/register src/server.ts",
-    "start": "node dist/server.js",
+    "start": "node -r module-alias/register dist/server.js",
     "build": "tsc",
     "lint": "eslint \"src/**/*.{ts,tsx}\"",
     "format": "prettier --write \"src/**/*.{ts,json}\"",

package/template/base/ts/src/app.ts

@@ -1,5 +1,6 @@
 import express from "express";
 import router from "./routes";
+import { errorHandler } from "@/middlewares";
 /*__IMPORTS__*/
 
 const app = express();
@@ -12,4 +13,6 @@ app.use(express.json());
 // Connect routes
 app.use(router);
 
+app.use(errorHandler);
+
 export default app;

package/template/base/ts/src/middlewares/error-handler.middleware.ts

@@ -0,0 +1,23 @@
+import { NextFunction, Request, Response } from "express";
+import { HttpError } from "@/utils";
+
+// Centralized error handling middleware
+
+export const errorHandler = (
+  err: unknown,
+  _: Request,
+  res: Response,
+  __: NextFunction,
+) => {
+  if (err instanceof HttpError) {
+    return res.status(err.status).json({
+      status: "error",
+      message: err.message,
+    });
+  }
+
+  return res.status(500).json({
+    status: "error",
+    message: "Internal Server Error",
+  });
+};

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

@@ -1,3 +1,4 @@
 export { default as methodNotAllowedHandler } from "./method-not-allowed.middleware";
 export { notFound } from "./not-found.middleware";
 export { rootHandler } from "./root.middleware";
+export { errorHandler } from "./error-handler.middleware";

package/template/base/ts/src/middlewares/method-not-allowed.middleware.ts

@@ -1,5 +1,7 @@
 import { Request, Response, NextFunction } from "express";
 
+// Middleware to handle 405 Method Not Allowed for unsupported HTTP methods on defined routes
+
 const methodNotAllowed =
   (allowedMethods: string[]) => (req: Request, res: Response, next: NextFunction) => {
     if (!allowedMethods.includes(req.method)) {

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

@@ -14,6 +14,12 @@ export class BadRequestError extends HttpError {
   }
 }
 
+export class UnprocessableEntityError extends HttpError {
+  constructor(message = "Unprocessable Entity") {
+    super(422, message);
+  }
+}
+
 export class UnauthorizedError extends HttpError {
   constructor(message = "Unauthorized") {
     super(401, message);
@@ -38,6 +44,18 @@ export class ConflictError extends HttpError {
   }
 }
 
+export class TooManyRequestsError extends HttpError {
+  constructor(message = "Too Many Requests") {
+    super(429, message);
+  }
+}
+
+export class BadGatewayError extends HttpError {
+  constructor(message = "Bad Gateway") {
+    super(502, message);
+  }
+}
+
 export class InternalServerError extends HttpError {
   constructor(message = "Internal Server Error") {
     super(500, message);

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

@@ -1,10 +1,13 @@
 export {
   HttpError,
   BadRequestError,
+  UnprocessableEntityError,
   UnauthorizedError,
   ForbiddenError,
   NotFoundError,
   ConflictError,
+  TooManyRequestsError,
+  BadGatewayError,
   InternalServerError,
 } from "./http-error";
 

package/template/base/ts/tsconfig.json

@@ -11,9 +11,8 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
 
-    "baseUrl": "src",
     "paths": {
-      "@/*": ["*"]
+      "@/*": ["./src/*"]
     },
     "types": ["node"]
   },

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

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

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

@@ -1,28 +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);
+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/index.ts

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

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

@@ -1,15 +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;
+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/gateway/js/inject.js

@@ -2,20 +2,22 @@ export const gatewayDeps = ["http-proxy-middleware"];
 
 export const generateGatewayRoutes = (services, mode = "docker") => {
   const routes = services
-    .filter(s => s !== "gateway")
+    .filter((s) => s !== "gateway")
     .map((service, index) => {
+      const servicePort = `${service.toUpperCase().replace(/-/g, "_")}_PORT`;
       const port = 4001 + index; // Host port mapping: gateway=4000, services start at 4001
-      const routePath = service.replace("-service", "");
-      
+
       // Docker: use container name with internal port 4000
       // Non-docker: use localhost with mapped host port
       const host = mode === "docker" ? service : "localhost";
-      const targetPort = mode === "docker" ? 4000 : port;
-      
+      // Build a placeholder that will render as ${SERVICE_PORT} in the generated code
+      const servicePortPlaceholder = "${" + servicePort + "}";
+
       return `
 // Proxy to ${service}
+const ${servicePort} = ENV.${servicePort} || ${port}
 app.use("/api", createProxyMiddleware({
-  target: "http://${host}:${targetPort}/api",
+  target: \`http://${host}:${servicePortPlaceholder}/api\`,
   changeOrigin: true,
   on: {
     error: (err, req, res) => {