@ifecodes/backend-template 1.1.8 → 1.4.0

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

@@ -1,45 +1,63 @@
-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 UnprocessableEntityError extends HttpError {
+  constructor(message = "Unprocessable Entity") {
+    super(422, 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 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,11 +1,14 @@
-export {
-  HttpError,
-  BadRequestError,
-  UnauthorizedError,
-  ForbiddenError,
-  NotFoundError,
-  ConflictError,
-  InternalServerError,
-} from "./http-error";
-
-export { default as logger } from "./logger";
+export {
+  HttpError,
+  BadRequestError,
+  UnprocessableEntityError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  ConflictError,
+  TooManyRequestsError,
+  BadGatewayError,
+  InternalServerError,
+} from "./http-error";
+
+export { default as logger } from "./logger";

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

@@ -1,68 +1,58 @@
-import { ENV } from "@/config";
-
-// ANSI color codes for terminal output
-const colors = {
-  reset: "\x1b[0m",
-  blue: "\x1b[34m",
-  cyan: "\x1b[36m",
-  yellow: "\x1b[33m",
-  red: "\x1b[31m",
-  bold: "\x1b[1m",
-};
-
-function format(tag: string, color: string) {
-  return `${color}${colors.bold}[${tag}]${colors.reset}`;
-}
-
-function getEnvironment() {
-  return ENV.NODE_ENV === "development" || ENV.NODE_ENV === "staging"
-    ? "development"
-    : 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;
-    console.log(format(tag, colors.blue), ...args);
-  },
-
-  info(tag: string, ...args: unknown[]) {
-    if (getEnvironment() !== "development") return;
-    console.info(format(tag, colors.cyan), ...args);
-  },
-
-  warn(tag: string, ...args: unknown[]) {
-    if (getEnvironment() !== "development") return;
-    console.warn(format(tag, colors.yellow), ...args);
-  },
-
-  error(tag: string, ...args: unknown[]) {
-    if (getEnvironment() !== "development") return;
-    console.error(format(tag, colors.red), ...args);
-  },
-};
-
-export default logger;
+import { ENV } from "@/config";
+
+// ANSI color codes for terminal output
+const colors = {
+  reset: "\x1b[0m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  bold: "\x1b[1m",
+};
+
+function format(tag: string, color: string) {
+  return `${color}${colors.bold}[${tag}]${colors.reset}`;
+}
+
+function getEnvironment() {
+  return ENV.NODE_ENV === "development" || ENV.NODE_ENV === "staging"
+    ? "development"
+    : ENV.NODE_ENV;
+}
+
+function shouldLog(level: "log" | "info" | "warn" | "error") {
+  if (level === "log") {
+    return getEnvironment() === "development";
+  }
+
+  return true;
+}
+
+console.log(
+  format("logger", colors.blue),
+  `Logger initialized for ${getEnvironment()} environment.`,
+);
+
+const logger = {
+  log(tag: string, ...args: unknown[]) {
+    if (!shouldLog("log")) return;
+    console.log(format(tag, colors.blue), ...args);
+  },
+
+  info(tag: string, ...args: unknown[]) {
+    if (!shouldLog("info")) return;
+    console.info(format(tag, colors.cyan), ...args);
+  },
+
+  warn(tag: string, ...args: unknown[]) {
+    if (!shouldLog("warn")) return;
+    console.warn(format(tag, colors.yellow), ...args);
+  },
+
+  error(tag: string, ...args: unknown[]) {
+    if (!shouldLog("error")) return;
+    console.error(format(tag, colors.red), ...args);
+  },
+};
+
+export default logger;

package/template/base/ts/tsconfig.json

@@ -1,22 +1,21 @@
-{
-  // 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"]
-}
+{
+  // 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,
+
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

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

@@ -1,50 +1,50 @@
-export const deps = ["argon2"];
-
-export const getFiles = (language = "typescript") => {
-  const ext = language === "javascript" ? ".js" : ".ts";
-
-  const tsContent = `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);
-};
-`;
-
-  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,
-  };
-};
+export const deps = ["argon2"];
+
+export const getFiles = (language = "typescript") => {
+  const ext = language === "javascript" ? ".js" : ".ts";
+
+  const tsContent = `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);
+};
+`;
+
+  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/health-openapi.ts

@@ -0,0 +1,62 @@
+// Enhanced OpenAPI spec for health endpoint when auth is enabled
+export const healthOpenApiWithMongo = {
+  get: {
+    tags: ["Health"],
+    summary: "Health check with MongoDB status",
+    description:
+      "Returns API health, runtime metrics, and MongoDB connection status.",
+    parameters: [
+      {
+        name: "verbose",
+        in: "query",
+        required: false,
+        schema: { type: "boolean" },
+        description: "Optional verbose mode for richer diagnostics.",
+      },
+    ],
+    responses: {
+      "200": {
+        description: "Healthy response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                status: { type: "string", enum: ["healthy", "unhealthy"] },
+                uptime: { type: "number" },
+                timestamp: { type: "string" },
+                services: {
+                  type: "object",
+                  properties: {
+                    mongodb: {
+                      type: "string",
+                      enum: ["connected", "disconnected"],
+                    },
+                    memory: {
+                      type: "object",
+                      properties: {
+                        rss: { type: "number" },
+                        heapUsed: { type: "number" },
+                      },
+                    },
+                  },
+                },
+                failed: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "List of failed services",
+                },
+              },
+            },
+          },
+        },
+      },
+      "400": {
+        description: "Validation error",
+      },
+      "503": {
+        description: "Service unhealthy (when MongoDB is down)",
+      },
+    },
+  },
+};