@ifecodes/backend-template 1.1.3 → 1.1.6

package/template/base/{src → ts/src}/modules/v1/health/health.controller.ts

@@ -1,18 +1,18 @@
-import { Request, Response } from "express";
-import { logger } from "@/utils";
-
-export const healthCheck = async (_: Request, res: Response) => {
-  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,
-      },
-    },
-  });
-};
+import { Request, Response } from "express";
+import { logger } from "@/utils";
+
+export const healthCheck = async (_: Request, res: Response) => {
+  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,
+      },
+    },
+  });
+};

package/template/base/{src → ts/src}/modules/v1/health/health.route.ts

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

package/template/base/{src → ts/src}/modules/v1/health/index.ts

@@ -1 +1 @@
-export { default as healthRoutes } from "./health.route";
+export { default as healthRoutes } from "./health.route";

package/template/base/{src → ts/src}/modules/v1/index.ts

@@ -1,8 +1,8 @@
-import { Router } from "express";
-import { healthRoutes } from "./health";
-
-const router = Router();
-
-router.use("/health", healthRoutes);
-
-export default router;
+import { Router } from "express";
+import { healthRoutes } from "./health";
+
+const router = Router();
+
+router.use("/health", healthRoutes);
+
+export default router;

package/template/base/{src → ts/src}/routes.ts

@@ -1,15 +1,15 @@
-import { Router } from "express";
-import modulesRouter from "./modules";
-import { notFound, rootHandler } from "./middlewares";
-
-const router = Router();
-
-// Root endpoint
-router.get("/", rootHandler);
-
-router.use("/", modulesRouter);
-
-// 404 handler - must be last
-router.use(notFound);
-
-export default router;
+import { Router } from "express";
+import modulesRouter from "./modules";
+import { notFound, rootHandler } from "./middlewares";
+
+const router = Router();
+
+// Root endpoint
+router.get("/", rootHandler);
+
+router.use("/api", modulesRouter);
+
+// 404 handler - must be last
+router.use(notFound);
+
+export default router;

package/template/base/{src → ts/src}/utils/http-error.ts

@@ -1,45 +1,45 @@
-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 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);
+  }
+}

package/template/base/{src → ts/src}/utils/logger.ts

@@ -20,6 +20,29 @@ function getEnvironment() {
     : ENV.NODE_ENV;
 }
 
+console.log(
+  format("logger", colors.blue),
+  `Logger initialized for ${getEnvironment()} environment.`,
+);
+
+const requiredKeys = ENV && Object.keys(ENV).length ? Object.keys(ENV) : [];
+
+const missing = requiredKeys.filter(
+  (k) => ENV == null || (ENV as Record<string, string | undefined>)[k] === undefined || (ENV as Record<string, string | undefined>)[k] === "",
+);
+
+if (missing.length === requiredKeys.length) {
+  console.warn(
+    format("logger", colors.yellow),
+    "ENV values missing — make sure to set up your environment variables correctly.",
+  );
+} else if (missing.length > 0) {
+  console.warn(
+    format("logger", colors.yellow),
+    `Missing ENV keys: ${missing.join(", ")}`,
+  );
+}
+
 const logger = {
   log(tag: string, ...args: unknown[]) {
     if (getEnvironment() !== "development") return;

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

@@ -1,8 +1,9 @@
 export const deps = ["argon2"];
 
-export const files = {
-  "src/utils/hash.ts": `
-import argon2 from "argon2";
+export const getFiles = (language = "typescript") => {
+  const ext = language === "javascript" ? ".js" : ".ts";
+
+  const tsContent = `import argon2 from "argon2";
 
 const HASH_OPTIONS = {
   type: argon2.argon2id,
@@ -21,5 +22,29 @@ export const verifyPassword = async (
 ): Promise<boolean> => {
   return argon2.verify(hash, password);
 };
-`
+`;
+
+  const jsContent = `const argon2 = require("argon2");
+
+const HASH_OPTIONS = {
+  type: argon2.argon2id,
+  memoryCost: 2 ** 16,
+  timeCost: 3,
+  parallelism: 1,
+};
+
+async function hashPassword(password) {
+  return argon2.hash(password, HASH_OPTIONS);
+}
+
+async function verifyPassword(hash, password) {
+  return argon2.verify(hash, password);
+}
+
+module.exports = { hashPassword, verifyPassword };
+`;
+
+  return {
+    [`src/utils/hash${ext}`]: language === "javascript" ? jsContent : tsContent,
+  };
 };

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

@@ -9,45 +9,78 @@ const modulesDir = path.join(__dirname, "../modules");
 const modelsDir = path.join(__dirname, "../models");
 const utilsDir = path.join(__dirname, "../utils");
 
-const readDirFiles = (dir, prefix = "") => {
+const readDirFiles = (dir, prefix = "", language = "typescript") => {
   const files = {};
   const items = fs.readdirSync(dir);
-  
+  const ext = language === "javascript" ? ".js" : ".ts";
+
   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));
+    const isDir = fs.statSync(fullPath).isDirectory();
+    const desiredName = item.replace(/\.ts$|\.js$/, ext);
+    const chosenPath = isDir
+      ? fullPath
+      : fs.existsSync(path.join(dir, desiredName))
+      ? path.join(dir, desiredName)
+      : fullPath;
+
+    const relativePath = path.join(prefix, path.basename(desiredName));
+
+    if (isDir) {
+      Object.assign(files, readDirFiles(chosenPath, relativePath, language));
     } else {
-      files[relativePath] = fs.readFileSync(fullPath, "utf8");
+      const content = fs.readFileSync(chosenPath, "utf8");
+      files[relativePath] = content;
     }
   }
-  
+
   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";
+const getDbContent = (language) => {
+  const tsContent = `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");
+  try {
+    await mongoose.connect(ENV.MONGO_URI);
+    logger.log("db", "MongoDB connected");
+  } catch (error) {
+    logger.error("db", "MongoDB connection failed", error);
+    process.exit(1);
+  }
 };
 `;
 
-// Add MongoDB health check
-const healthControllerContent = `import { Request, Response } from "express";
+  if (language === "javascript") {
+    return `const mongoose = require("mongoose");
+const { ENV } = require("./env");
+const { logger } = require("../utils");
+
+async function connectDB() {
+  try {
+    await mongoose.connect(ENV.MONGO_URI);
+    logger.log("db", "MongoDB connected");
+  } catch (error) {
+    logger.error("db", "MongoDB connection failed", error);
+    process.exit(1);
+  }
+}
+
+module.exports = { connectDB };
+`;
+  }
+
+  return tsContent;
+};
+
+const getHealthControllerContent = (language) => {
+  const tsContent = `import { Request, Response } from "express";
 import mongoose from "mongoose";
-import { logger } from "@/utils";
+const { logger } = require("../../../utils");
 
-export const healthCheck = async (_: Request, res: Response) => {
+export const healthCheck = async (_req: Request, res: Response) => {
   const mongoState = mongoose.connection.readyState;
   const healthy = mongoState === 1;
 
@@ -72,16 +105,65 @@ export const healthCheck = async (_: Request, res: Response) => {
 };
 `;
 
-export const files = {
-  ...moduleFiles,
-  ...modelFiles,
-  ...utilFiles,
-  "src/config/db.ts": dbContent,
-  "src/modules/v1/health/health.controller.ts": healthControllerContent,
+  if (language === "javascript") {
+    return `const mongoose = require("mongoose");
+const { logger } = require("../../../utils");
+
+async function healthCheck(_req, res) {
+  const mongoState = mongoose.connection.readyState;
+  const healthy = mongoState === 1;
+
+  const failed = [];
+  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,
+  });
+}
+
+module.exports = { healthCheck };
+`;
+  }
+
+  return tsContent;
+};
+
+export const getFiles = (language = "typescript") => {
+  const ext = language === "javascript" ? ".js" : ".ts";
+  const moduleFiles = readDirFiles(modulesDir, "src/modules/v1/auth", language);
+  const modelFiles = readDirFiles(modelsDir, "src/models", language);
+  const utilFiles = readDirFiles(utilsDir, "src/utils", language);
+
+  return {
+    ...moduleFiles,
+    ...modelFiles,
+    ...utilFiles,
+    [`src/config/db${ext}`]: getDbContent(language),
+    [`src/modules/v1/health/health.controller${ext}`]: getHealthControllerContent(language),
+  };
 };
 
+// For backward compatibility
+export const files = getFiles("typescript");
+
 export const imports = `import { authRoutes } from "./auth";`;
 
+export const getImports = (language) => language === "javascript"
+  ? `const { authRoutes } = require("./auth");`
+  : `import { authRoutes } from "./auth";`;
+
 export const middleware = `router.use("/auth", authRoutes);`;
 
 export const deps = ["jsonwebtoken", "mongoose"];

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

@@ -2,12 +2,14 @@ export const deps = ["bcrypt"];
 
 export const devDeps = ["@types/bcrypt"];
 
-export const files = {
-  "src/utils/hash.ts": `
-import bcrypt from "bcrypt";
+export const getFiles = (language = "typescript") => {
+  const ext = language === "javascript" ? ".js" : ".ts";
+
+  const tsContent = `import bcrypt from "bcrypt";
 
 export const hashPassword = async (password: string): Promise<string> => {
-  return bcrypt.hash(password, 12);
+  const salt = await bcrypt.genSalt(10);
+  return bcrypt.hash(password, salt);
 };
 
 export const verifyPassword = async (
@@ -16,5 +18,23 @@ export const verifyPassword = async (
 ): Promise<boolean> => {
   return bcrypt.compare(password, hash);
 };
-`
+`;
+
+  const jsContent = `const bcrypt = require("bcrypt");
+
+async function hashPassword(password) {
+  const salt = await bcrypt.genSalt(10);
+  return bcrypt.hash(password, salt);
+}
+
+async function verifyPassword(hash, password) {
+  return bcrypt.compare(password, hash);
+}
+
+module.exports = { hashPassword, verifyPassword };
+`;
+
+  return {
+    [`src/utils/hash${ext}`]: language === "javascript" ? jsContent : tsContent,
+  };
 };

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

@@ -0,0 +1,24 @@
+const mongoose = require("mongoose");
+
+const userSchema = new mongoose.Schema(
+  {
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    password: {
+      type: String,
+      required: true,
+    },
+    fullName: {
+      type: String,
+      required: true,
+    },
+  },
+  { timestamps: true },
+);
+
+const UserModel = mongoose.model("User", userSchema);
+
+module.exports = { UserModel };

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

@@ -0,0 +1,21 @@
+const { loginService, registerService } = require("./auth.service");
+
+async function login(req, res, next) {
+  try {
+    const token = await loginService(req.body);
+    return res.status(200).json({ token });
+  } catch (err) {
+    return next(err);
+  }
+}
+
+async function register(req, res, next) {
+  try {
+    const token = await registerService(req.body);
+    return res.status(201).json({ token });
+  } catch (err) {
+    return next(err);
+  }
+}
+
+module.exports = { login, register };

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

@@ -0,0 +1,10 @@
+const { Router } = require("express");
+const { register, login } = require("./auth.controller");
+const { methodNotAllowedHandler } = require("../../../middlewares");
+
+const router = Router();
+router.use(methodNotAllowedHandler(["POST"]));
+router.post("/login", login);
+router.post("/register", register);
+
+module.exports = router;

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

@@ -0,0 +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 };

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

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

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

@@ -0,0 +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 };

package/template/features/cors/inject.js

@@ -1,6 +1,9 @@
 export const deps = ["cors"];
 export const devDeps = ["@types/cors"];
-export const imports = `import cors from "cors";\nimport { ENV } from "@/config";`;
+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,

package/template/features/helmet/inject.js

@@ -1,3 +1,6 @@
 export const deps = ["helmet"];
-export const imports = `import helmet from "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,4 +1,7 @@
 export const deps = ["morgan"];
 export const devDeps = ["@types/morgan"];
-export const imports = `import morgan from "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,3 +1,6 @@
 export const deps = ["express-rate-limit"];
-export const imports = `import rateLimit from "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 }));`;