@ifecodes/backend-template 1.1.8 → 1.4.0

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

@@ -1,11 +1,86 @@
-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;
-
+import { Router } from "express";
+import { register, login } from "./auth.controller";
+import { methodNotAllowedHandler, validateRequest } from "@/middlewares";
+import { z } from "zod";
+import { routeRegistry } from "@/docs";
+
+const router = Router();
+
+// Define request schemas for validation
+const registerSchema = z
+  .object({
+    username: z.string().min(3, "Username must be at least 3 characters"),
+    password: z.string().min(6, "Password must be at least 6 characters"),
+  })
+  .strict();
+
+const loginSchema = z
+  .object({
+    username: z.string().min(1, "Username is required"),
+    password: z.string().min(1, "Password is required"),
+  })
+  .strict();
+
+router.use(methodNotAllowedHandler(["POST"]));
+// Register route docs for auto OpenAPI generation
+routeRegistry.register({
+  method: "POST",
+  path: "/api/v1/auth/login",
+  handler: login,
+  docs: {
+    tags: ["Auth"],
+    summary: "User login",
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              username: { type: "string" },
+              password: { type: "string" },
+            },
+          },
+        },
+      },
+    },
+    responses: {
+      200: { description: "Successful login" },
+      400: { description: "Invalid request" },
+      401: { description: "Unauthorized" },
+    },
+  },
+});
+
+routeRegistry.register({
+  method: "POST",
+  path: "/api/v1/auth/register",
+  handler: register,
+  docs: {
+    tags: ["Auth"],
+    summary: "Register new user",
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              username: { type: "string" },
+              password: { type: "string" },
+            },
+          },
+        },
+      },
+    },
+    responses: {
+      201: { description: "User created" },
+      400: { description: "Invalid request" },
+    },
+  },
+});
+
+router.post("/login", validateRequest({ body: loginSchema }), login);
+router.post("/register", validateRequest({ body: registerSchema }), register);
+
+export default router;

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

@@ -1,29 +1,29 @@
-const { generateToken } = require("../../../utils/jwt");
-const { UserModel } = require("../../../models/user.model");
-const { hashPassword, verifyPassword } = require("../../../utils/hash");
-const {
-  UnauthorizedError,
-  ConflictError,
-} = require("../../../utils/http-error");
-
-async function loginService({ email, password }) {
-  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 });
-}
-
-async function registerService({ email, password, fullName }) {
-  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 });
-}
-
-module.exports = { loginService, registerService };
+const { generateToken } = require("../../../utils/jwt");
+const { UserModel } = require("../../../models/user.model");
+const { hashPassword, verifyPassword } = require("../../../utils/hash");
+const {
+  UnauthorizedError,
+  ConflictError,
+} = require("../../../utils/http-error");
+
+async function loginService({ email, password }) {
+  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 });
+}
+
+async function registerService({ email, password, fullName }) {
+  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 });
+}
+
+module.exports = { loginService, registerService };

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

@@ -1,38 +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 });
-};
+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.js

@@ -1 +1 @@
-module.exports = { authRoutes: require("./auth.routes") };
+module.exports = { authRoutes: require("./auth.routes") };

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

@@ -1,20 +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)"
-  );
-}
+/**
+ * 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.js

@@ -1,12 +1,12 @@
-const jwt = require("jsonwebtoken");
-const { ENV } = require("../config");
-
-async function generateToken(payload) {
-  return jwt.sign(payload, ENV.JWT_SECRET, { expiresIn: "7d" });
-}
-
-function verifyToken(token) {
-  return jwt.verify(token, ENV.JWT_SECRET);
-}
-
-module.exports = { generateToken, verifyToken };
+const jwt = require("jsonwebtoken");
+const { ENV } = require("../config");
+
+async function generateToken(payload) {
+  return jwt.sign(payload, ENV.JWT_SECRET, { expiresIn: "7d" });
+}
+
+function verifyToken(token) {
+  return jwt.verify(token, ENV.JWT_SECRET);
+}
+
+module.exports = { generateToken, verifyToken };

package/template/features/cors/inject.js

@@ -1,13 +1,14 @@
-export const deps = ["cors"];
-export const devDeps = ["@types/cors"];
-export const getImports = (language) => language === "javascript" 
-  ? `const cors = require("cors");\nconst { ENV } = require("./config");`
-  : `import cors from "cors";\nimport { ENV } from "@/config";`;
-export const imports = getImports("typescript");
-export const middleware = `
-const corsOptions = {
-  origin: ENV.ALLOWED_ORIGIN,
-  credentials: true,
-};
-
-app.use(cors(corsOptions));`;
+export const deps = ["cors"];
+export const devDeps = ["@types/cors"];
+export const getImports = (language) =>
+  language === "javascript"
+    ? `const cors = require("cors");\nconst { ENV } = require("./config");`
+    : `import cors from "cors";\nimport { ENV } from "@/config";`;
+export const imports = getImports("typescript");
+export const middleware = `
+const corsOptions = {
+  origin: ENV.ALLOWED_ORIGIN,
+  credentials: true,
+};
+
+app.use(cors(corsOptions));`;

package/template/features/helmet/inject.js

@@ -1,6 +1,7 @@
-export const deps = ["helmet"];
-export const getImports = (language) => language === "javascript"
-  ? `const helmet = require("helmet");`
-  : `import helmet from "helmet";`;
-export const imports = getImports("typescript");
-export const middleware = `app.use(helmet());`;
+export const deps = ["helmet"];
+export const getImports = (language) =>
+  language === "javascript"
+    ? `const helmet = require("helmet");`
+    : `import helmet from "helmet";`;
+export const imports = getImports("typescript");
+export const middleware = `app.use(helmet());`;

package/template/features/morgan/inject.js

@@ -1,7 +1,8 @@
-export const deps = ["morgan"];
-export const devDeps = ["@types/morgan"];
-export const getImports = (language) => language === "javascript"
-  ? `const morgan = require("morgan");`
-  : `import morgan from "morgan";`;
-export const imports = getImports("typescript");
-export const middleware = `app.use(morgan("dev"));`;
+export const deps = ["morgan"];
+export const devDeps = ["@types/morgan"];
+export const getImports = (language) =>
+  language === "javascript"
+    ? `const morgan = require("morgan");`
+    : `import morgan from "morgan";`;
+export const imports = getImports("typescript");
+export const middleware = `app.use(morgan("dev"));`;

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

@@ -1,6 +1,7 @@
-export const deps = ["express-rate-limit"];
-export const getImports = (language) => language === "javascript"
-  ? `const rateLimit = require("express-rate-limit");`
-  : `import rateLimit from "express-rate-limit";`;
-export const imports = getImports("typescript");
-export const middleware = `app.use(rateLimit({ windowMs: 15*60*1000, max: 100 }));`;
+export const deps = ["express-rate-limit"];
+export const getImports = (language) =>
+  language === "javascript"
+    ? `const rateLimit = require("express-rate-limit");`
+    : `import rateLimit from "express-rate-limit";`;
+export const imports = getImports("typescript");
+export const middleware = `app.use(rateLimit({ windowMs: 15*60*1000, max: 100 }));`;

package/template/gateway/js/app.js

@@ -1,42 +1,42 @@
-const express = require("express");
-const { createProxyMiddleware } = require("http-proxy-middleware");
-const { logger } = require("@/shared/utils");
-
-const app = express();
-
-// Root endpoint
-app.get("/", (_req, res) => {
-  logger.info("Gateway", "Root endpoint accessed");
-
-  res.json({
-    status: "ok",
-    service: "API Gateway",
-    version: "1.0.0",
-    endpoints: {
-      health: "/health",
-      healthService: "/api/v1/health",
-    },
-  });
-});
-
-// Health check for the gateway itself
-app.get("/health", (_req, res) => {
-  logger.info("Gateway", "Health check accessed");
-  res.json({ status: "ok", service: "gateway" });
-});
-
-// Service routes - will be dynamically configured
-/*__ROUTES__*/
-
-// 404 handler
-app.use((_req, res) => {
-  res.status(404).json({ error: "Route not found" });
-});
-
-// Error handler
-app.use((err, _req, res, next) => {
-  logger.error("Gateway error:", err);
-  res.status(500).json({ error: "Internal gateway error" });
-});
-
-module.exports = app;
+const express = require("express");
+const { createProxyMiddleware } = require("http-proxy-middleware");
+const { logger } = require("@/shared/utils");
+
+const app = express();
+
+// Root endpoint
+app.get("/", (_req, res) => {
+  logger.info("Gateway", "Root endpoint accessed");
+
+  res.json({
+    status: "ok",
+    service: "API Gateway",
+    version: "1.0.0",
+    endpoints: {
+      health: "/health",
+      healthService: "/api/v1/health",
+    },
+  });
+});
+
+// Health check for the gateway itself
+app.get("/health", (_req, res) => {
+  logger.info("Gateway", "Health check accessed");
+  res.json({ status: "ok", service: "gateway" });
+});
+
+// Service routes - will be dynamically configured
+/*__ROUTES__*/
+
+// 404 handler
+app.use((_req, res) => {
+  res.status(404).json({ error: "Route not found" });
+});
+
+// Error handler
+app.use((err, _req, res, next) => {
+  logger.error("Gateway error:", err);
+  res.status(500).json({ error: "Internal gateway error" });
+});
+
+module.exports = app;

package/template/gateway/js/inject.js

@@ -1,31 +1,33 @@
-export const gatewayDeps = ["http-proxy-middleware"];
-
-export const generateGatewayRoutes = (services, mode = "docker") => {
-  const routes = services
-    .filter(s => s !== "gateway")
-    .map((service, index) => {
-      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;
-      
-      return `
-// Proxy to ${service}
-app.use("/api", createProxyMiddleware({
-  target: "http://${host}:${targetPort}/api",
-  changeOrigin: true,
-  on: {
-    error: (err, req, res) => {
-      logger.error(\`Proxy error for ${service}:\`, err);
-      res.status(503).json({ error: "Service unavailable" });
-    },
-  },
-}));`;
-    })
-    .join("\n");
-
-  return routes;
-};
+export const gatewayDeps = ["http-proxy-middleware"];
+
+export const generateGatewayRoutes = (services, mode = "docker") => {
+  const routes = services
+    .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
+
+      // Docker: use container name with internal port 4000
+      // Non-docker: use localhost with mapped host port
+      const host = mode === "docker" ? service : "localhost";
+      // 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}:${servicePortPlaceholder}/api\`,
+  changeOrigin: true,
+  on: {
+    error: (err, req, res) => {
+      logger.error(\`Proxy error for ${service}:\`, err);
+      res.status(503).json({ error: "Service unavailable" });
+    },
+  },
+}));`;
+    })
+    .join("\n");
+
+  return routes;
+};

package/template/gateway/js/server.js

@@ -1,19 +1,19 @@
-const http = require('http');
-const app = require('./app');
-const { logger } = require('@/shared/utils');
-const { ENV } = require('@/shared/config');
-
-const PORT = ENV.GATEWAY_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');
-  });
-});
+const http = require("http");
+const app = require("./app");
+const { logger } = require("@/shared/utils");
+const { ENV } = require("@/shared/config");
+
+const PORT = ENV.GATEWAY_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");
+  });
+});