node-ts-app-starter 1.0.0

package/README.md

@@ -0,0 +1,97 @@
+# node-starter-project
+
+A high-performance, production-ready Node.js + TypeScript boilerplate generator. This CLI scaffolds a complete backend architecture featuring Supabase, Redis, BullMQ, and Express with best-practice security and validation middleware.
+
+## Quick Start
+
+You don't need to install this package globally. Simply run the following command to scaffold a new project:
+
+```
+npx node-ts-starter <your-project-name>
+```
+
+Next Steps:
+
+1. ```cd <your-project-name>```
+
+2. Configure your .env file (see .env.example).
+
+3. Run the command ```npm run dev``` to start the server
+
+## Supabase Type Generation
+
+To get full IntelliSense for your database tables, you can generate types directly from your Supabase project.
+
+1. Find your Project ID in your Supabase Dashboard (Settings > General).
+
+2. Open your ```package.json```.
+
+3. Update the ```gen-types``` script by replacing the placeholder ```YOUR_PROJECT_ID``` with your own:
+```"gen-types": "npx supabase gen types typescript --project-id YOUR_PROJECT_ID --schema public > src/types/database.types.ts"```
+
+4. Run the script ```npm run gen-types``` to generate your supabase typescript definitions directly from your supabase schema.
+
+## Logging with Pino
+
+The starter uses Pino for logging. In development, logs are pretty-printed for readability. In production, they are emitted as high-speed JSON for compatibility with log aggregators (like Datadog or ELK).
+
+* **Development**: Logs are readable and color-coded.
+
+* **Production**: Logs are optimized for minimal CPU overhead.
+
+## Features
+
+The generated project comes pre-configured with a modular architecture:
+
+* Framework: Express.js (v5+) with TypeScript.
+
+* Database & Auth: Integrated Supabase client.
+
+* Caching & Queues: Redis integration with BullMQ for universal background job processing.
+
+* Security: Helmet, CORS, Express Rate Limit, and XSS Sanitizer.
+
+* Validation: Ajv for high-speed JSON Schema validation.
+
+* Email: SendGrid service wrapper with support for background sending via BullMQ.
+
+* Middleware: Custom Global Error Handler, apiError utility classes and pino middleware to add request ID to every request for traceability.
+
+* Logging: Every request is logged using pino with the respective request Id attached for logging and monitoring purposes
+
+* Code Quality: ESLint and Prettier pre-configured for TypeScript.
+
+## Folder Structure
+
+src/
+├── config/         # Service configurations (Supabase, Redis, Mail, Queues, Logger)
+├── middleware/     # Global error handling, validation, logging
+├── utils/          # reusable helper functions
+├── routes/         # Express route definitions
+├── mail/           # Sendgrid mailer service logic
+├── types/          # TypeScript interfaces and enums
+└── app.ts          # Application entry point
+
+## Available Scripts
+
+Once the project is generated, you can use the following commands:
+
+* ```npm run dev```: Start the development server with ```nodemon``` and ```ts-node```.
+
+* ```npm run build```: Compile TypeScript to JavaScript in the ```dist/``` folder.
+
+* ```npm run gen-types```: Pull TypeScript types from Supabase.
+
+* ```npm start```: Run the compiled production build.
+
+* ```npm run lint```: Check for code style and logic issues.
+
+* ```npm run format```: Automatically fix code formatting with Prettier.
+
+## Author
+
+**George Kwabena Asiedu**
+
+* GitHub: george-asiedu
+
+* Email: <asiedug41@gmail.com>

package/bin/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const shell = require('shelljs');
+
+// Capture the project name from the argument (default to 'my-node-app')
+const projectName = process.argv[2] || 'my-node-app';
+const destination = path.join(process.cwd(), projectName);
+const templatePath = path.join(__dirname, '../template');
+
+// Prevent overwriting existing folders
+if (fs.existsSync(destination)) {
+  console.error(`Error: Folder "${projectName}" already exists.`);
+  process.exit(1);
+}
+
+console.log(`Creating a new project in: ${destination}...`);
+
+try {
+  fs.mkdirSync(destination, { recursive: true });
+  fs.cpSync(templatePath, destination, { recursive: true });
+} catch (err) {
+  console.error('Error copying template files:', err);
+  process.exit(1);
+}
+
+const filesToRename = {
+  'gitignore.txt': '.gitignore',
+  'prettierrc.txt': '.prettierrc',
+  'eslint.config.txt': 'eslint.config.mjs'
+};
+
+Object.entries(filesToRename).forEach(([oldName, newName]) => {
+  const oldPath = path.join(destination, oldName);
+  const newPath = path.join(destination, newName);
+
+  if (fs.existsSync(oldPath)) {
+    fs.renameSync(oldPath, newPath);
+  }
+});
+
+// Update the package.json inside the NEW folder with the project name
+const pkgPath = path.join(destination, 'package.json');
+if (fs.existsSync(pkgPath)) {
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  pkg.name = projectName; // Change "starter-project" to whatever the user typed
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+}
+
+console.log('Installing dependencies, this may take a moment...');
+
+shell.cd(destination);
+if (shell.exec('npm install').code !== 0) {
+  console.error('Error installing dependencies');
+  process.exit(1);
+}
+console.log(`
+Success! Created ${projectName} at ${destination}
+To get started:
+cd ${projectName}
+npm run dev
+`);

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "node-ts-app-starter",
+  "version": "1.0.0",
+  "description": "CLI tool to scaffold a Node.js + TypeScript project with Supabase, Redis, and Express",
+  "main": "bin/cli.js",
+  "bin": {
+    "create-node-app": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "template"
+  ],
+  "scripts": {
+    "test-local": "npm link",
+    "publish-project": "npm publish --access public"
+  },
+  "author": "george-asiedu <asiedug41@gmail.com>",
+  "license": "ISC",
+  "dependencies": {
+    "shelljs": "^0.10.0"
+  }
+}

package/template/.env.example

@@ -0,0 +1,12 @@
+PORT=your-port
+ENV=development
+SUPABASE_URL=your-supabase-url
+SUPABASE_KEY=your-supabase-key
+SUPABASE_SERVICE_ROLE_KEY=your-supabase-service-role-key
+REDIS_HOST=your-redis-host
+REDIS_PORT=your-redis-port
+REDIS_USERNAME=default
+REDIS_PASSWORD=your-redis-password
+SENDGRID_API_KEY=your-sendgrid-api-key
+SENDER_EMAIL=your-sender-email
+CLIENT_URL=your-client-url

package/template/eslint.config.txt

@@ -0,0 +1,14 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+import prettierPlugin from "eslint-plugin-prettier";
+
+export default defineConfig([
+  { files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], plugins: { js, "@typescript-eslint": tseslint, prettier: prettierPlugin }, extends: ["js/recommended", "eslint:recommended",
+      "plugin:@typescript-eslint/recommended",
+      "plugin:prettier/recommended",], languageOptions: { globals: globals.node },  rules: {
+      "prettier/prettier": "error",
+    }, },
+  tseslint.configs.recommended,
+]);

package/template/gitignore.txt

@@ -0,0 +1,141 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.*
+!.env.example
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Sveltekit cache directory
+.svelte-kit/
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Firebase cache directory
+.firebase/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v3
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Vite logs files
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+.vscode/
+.idea/

package/template/package.json

@@ -0,0 +1,71 @@
+{
+	"name": "starter-project",
+	"version": "1.0.0",
+	"description": "A high-performance, production-ready Node.js + TypeScript boilerplate generator. This CLI scaffolds a complete backend architecture featuring Supabase, Redis, BullMQ, and Express with best-practice security and validation middleware.",
+	"main": "app.ts",
+	"scripts": {
+		"build:deploy": "npm install && npm build",
+		"build": "tsc",
+		"gen-types": "npx supabase gen types typescript --project-id YOUR_PROJECT_ID --schema public > src/types/database.types.ts",
+		"dev": "tsx watch src/app.ts",
+		"start": "node dist/app.js",
+		"lint": "eslint . --ext .ts",
+		"lint:fix": "eslint . --ext .ts --fix",
+		"format": "prettier --write ."
+	},
+	"keywords": [
+		"node",
+		"typescript",
+		"starter",
+		"utils",
+		"template"
+	],
+	"author": "george-asiedu <asiedug41@gmail.com>",
+	"type": "module",
+	"license": "ISC",
+	"dependencies": {
+		"@sendgrid/mail": "^8.1.6",
+		"@supabase/supabase-js": "^2.97.0",
+		"@types/multer": "^2.0.0",
+		"ajv": "^8.18.0",
+		"ajv-errors": "^3.0.0",
+		"ajv-formats": "^3.0.1",
+		"bullmq": "^5.69.3",
+		"compression": "^1.8.1",
+		"cookie-parser": "^1.4.7",
+		"cors": "^2.8.6",
+		"dotenv": "^17.3.1",
+		"express": "^5.2.1",
+		"express-rate-limit": "^8.2.1",
+		"express-xss-sanitizer": "^2.0.1",
+		"helmet": "^8.1.0",
+		"morgan": "^1.10.1",
+		"multer": "^2.0.2",
+		"pino": "^10.3.1",
+		"pino-http": "^11.0.0",
+		"redis": "^5.11.0",
+		"uuid": "^13.0.0"
+	},
+	"devDependencies": {
+		"@eslint/js": "^10.0.1",
+		"@types/compression": "^1.8.1",
+		"@types/cookie-parser": "^1.4.10",
+		"@types/cors": "^2.8.19",
+		"@types/express": "^5.0.6",
+		"@types/morgan": "^1.9.10",
+		"@types/node": "^25.3.0",
+		"@types/sendgrid": "^2.0.31",
+		"@types/uuid": "^10.0.0",
+		"eslint": "^10.0.0",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-prettier": "^5.5.5",
+		"globals": "^17.3.0",
+		"jiti": "^2.6.1",
+		"nodemon": "^3.1.11",
+		"prettier": "^3.8.1",
+		"ts-node": "^10.9.2",
+		"tsx": "^4.21.0",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.56.0"
+	}
+}

package/template/prettierrc.txt

@@ -0,0 +1,5 @@
+{
+  "singleQuote": true,
+  "semi": true,
+  "trailingComma": "all"
+}

package/template/src/app.ts

@@ -0,0 +1,85 @@
+import express, { NextFunction, Request, Response } from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import morgan from 'morgan';
+import compression from 'compression';
+import rateLimit from 'express-rate-limit';
+import cookieParser from 'cookie-parser';
+import { pinoMiddleware } from './middleware/pino.js';
+import { env } from './config/env.config.js';
+import { redisClient } from './config/redis.config.js';
+import { supabase } from './config/supabase.config.js';
+import { globalErrorHandler } from './middleware/globalErrorHandler.js';
+import routes from './routes/index.js';
+import logger from './config/logger.config.js';
+
+const app = express();
+app.use(pinoMiddleware);
+
+app.use(morgan('dev'));
+app.use(
+  helmet({
+    contentSecurityPolicy: false,
+  }),
+);
+app.use(cors());
+
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  limit: 100,
+  message: "Too many requests from this IP, please try again later.",
+});
+app.use("/api", limiter);
+
+app.use(compression());
+app.use(cookieParser());
+app.use(express.json({ limit: "10mb" }));
+app.use(express.urlencoded({ extended: true }));
+
+app.get('/', (_req: Request, res: Response) => {
+  res.send('Server is running!');
+});
+
+app.get("/health", async (_req: Request, res: Response) => {
+  const healthStatus: any = {
+    status: "ok",
+    uptime: process.uptime(),
+    timestamp: new Date().toISOString(),
+    services: {
+      server: "healthy",
+      redis: "unknown",
+      supabase: "unknown",
+    }
+  };
+
+  try {
+    const redisPing = await redisClient.ping();
+    healthStatus.services.redis = redisPing === 'PONG' ? 'healthy' : 'unhealthy';
+
+    const { error } = await supabase.from("profiles").select("id").limit(1);
+    healthStatus.services.supabase = error ? 'unhealthy' : 'healthy';
+
+  } catch (error) {
+    healthStatus.status = "error";
+     logger.error({ err: error as Error }, 'Health check failed');
+  }
+
+  const isHealthy = healthStatus.services.redis === 'healthy' && 
+                    healthStatus.services.supabase === 'healthy';
+
+  res.status(isHealthy ? 200 : 503).json(healthStatus);
+});
+
+app.use("/api", routes);
+
+app.use((err: Error, req: Request, res: Response, next: NextFunction) =>
+  globalErrorHandler(err, req, res, next),
+);
+
+const port = env.port;
+if (!port)
+  throw new Error("Port number is not defined in environment variables");
+
+app.listen(port, () => {
+  logger.log(`Server is running on port ${port}`);
+});

package/template/src/config/env.config.ts

@@ -0,0 +1,42 @@
+import dotenv from 'dotenv';
+import path from 'path';
+
+const envFilePath = path.resolve(process.cwd(), `.env`);
+
+dotenv.config({ path: envFilePath });
+const requiredVars = [
+	'PORT',
+	'ENV',
+	'SUPABASE_URL',
+	'SUPABASE_KEY',
+	'SUPABASE_SERVICE_ROLE_KEY',
+	'SENDGRID_API_KEY',
+	'SENDER_EMAIL',
+	'REDIS_HOST',
+	'REDIS_PORT',
+	'REDIS_USERNAME',
+	'REDIS_PASSWORD',
+	'CLIENT_URL',
+];
+const missing = requiredVars.filter(v => !process.env[v]);
+
+if (missing.length > 0) {
+	throw new Error(
+		`Missing required environment variables in ${envFilePath}: ${missing.join(', ')}`,
+	);
+}
+
+export const env = {
+	port: Number(process.env.PORT),
+	supabaseUrl: process.env.SUPABASE_URL as string,
+	supabaseKey: process.env.SUPABASE_KEY as string,
+	supabaseServiceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY as string,
+	nodeEnv: process.env.NODE_ENV as string,
+	redisHost: process.env.REDIS_HOST as string,
+	redisPort: Number(process.env.REDIS_PORT),
+	redisUsername: process.env.REDIS_USERNAME as string,
+	redisPassword: process.env.REDIS_PASSWORD as string,
+	sendGridApiKey: process.env.SENDGRID_API_KEY as string,
+	senderEmail: process.env.SENDER_EMAIL as string,
+	clientUrl: process.env.CLIENT_URL as string,
+};

package/template/src/config/logger.config.ts

@@ -0,0 +1,14 @@
+import { env } from './env.config.js';
+import pino from 'pino';
+
+const loggerOptions = {
+  level: env.nodeEnv === 'production' ? 'info' : 'debug',
+  redact: ['req.headers.authorization', 'body.password'],
+  ...(env.nodeEnv !== 'production' && {
+    transport: { target: 'pino-pretty', options: { colorize: true } },
+  }),
+};
+
+const logger = pino(loggerOptions);
+
+export default logger;

package/template/src/config/queue.config.ts

@@ -0,0 +1,18 @@
+import { Queue } from "bullmq";
+import { bullConnection } from "./redis.config.js";
+
+export const mainQueue = new Queue("main-app-queue", {
+  connection: bullConnection,
+  defaultJobOptions: {
+    attempts: 3,
+    backoff: { type: "exponential", delay: 1000 },
+    removeOnComplete: true,
+  },
+});
+
+/**
+ * Universal helper to add jobs
+ */
+export const dispatch = (name: string, data: any) => {
+  return mainQueue.add(name, data);
+};

package/template/src/config/redis.config.ts

@@ -0,0 +1,21 @@
+import { createClient } from 'redis';
+import { env } from "./env.config.js";
+import logger from './logger.config.js';
+
+export const redisClient = createClient({
+	username: env.redisUsername,
+	password: env.redisPassword,
+	socket: {
+		host: env.redisHost,
+		port: env.redisPort,
+	},
+});
+
+export const bullConnection = {
+	url: env.redisHost + ':' + env.redisPort,
+};
+
+redisClient.on('error', (err: any) =>
+	logger.error({ err }, 'Redis Client Error'),
+);
+await redisClient.connect();

package/template/src/config/sendgrid.config.ts

@@ -0,0 +1,8 @@
+import sgMail from "@sendgrid/mail";
+import { env } from "./env.config.js";
+
+const apiKey = env.sendGridApiKey;
+
+sgMail.setApiKey(apiKey);
+
+export default sgMail;

package/template/src/config/supabase.config.ts

@@ -0,0 +1,13 @@
+import { createClient } from '@supabase/supabase-js';
+import { env } from './env.config.js';
+
+const supabaseUrl = env.supabaseUrl;
+const supabaseKey = env.supabaseKey;
+const supabaseServiceRoleKey = env.supabaseServiceRoleKey;
+
+export const supabase = createClient(supabaseUrl, supabaseKey);
+
+export const supabaseAdmin =
+	supabaseServiceRoleKey ?
+		createClient(supabaseUrl, supabaseServiceRoleKey)
+	:	null;

package/template/src/mail/mail.service.ts

@@ -0,0 +1,42 @@
+import { env } from "../config/env.config.js";
+import logger from "../config/logger.config.js";
+import sgMail from "../config/sendgrid.config.js";
+
+interface EmailOptions {
+  to: string | string[];
+  subject: string;
+  text?: string;
+  html: string;
+  isMultiple?: boolean;
+}
+
+export class MailService {
+  private static readonly SENDER_EMAIL = env.senderEmail;
+
+  static async send(options: EmailOptions) {
+    const { to, isMultiple = true } = options;
+
+    const msg = {
+      to: options.to,
+      from: this.SENDER_EMAIL,
+      subject: options.subject,
+      text: options.text || options.subject,
+      html: options.html,
+    };
+
+    try {
+      if (Array.isArray(to) && isMultiple) {
+        return await sgMail.sendMultiple(msg);
+      }
+
+      return await sgMail.send(msg);
+    } catch (error: any) {
+      logger.error(
+				{ err: error },
+				'SendGrid Error:',
+				error.response?.body || error.message,
+			);
+      throw new Error("Failed to send email");
+    }
+  }
+}

package/template/src/middleware/apiError.ts

@@ -0,0 +1,18 @@
+import { HttpCode } from "../types/types.js";
+
+export class ApiError extends Error {
+  public readonly status: string;
+  public readonly statusCode: HttpCode;
+  public readonly isOperational: boolean;
+
+  constructor(message: string, statusCode: HttpCode) {
+    super(message);
+    Object.setPrototypeOf(this, ApiError.prototype);
+
+    this.status = `${statusCode}`.startsWith("4") ? "fail" : "error";
+    this.statusCode = statusCode;
+    this.isOperational = true;
+
+    Error.captureStackTrace(this, this.constructor);
+  }
+}

package/template/src/middleware/globalErrorHandler.ts

@@ -0,0 +1,60 @@
+import { Request, Response, NextFunction } from 'express';
+import { HttpCode } from '../types/types.js';
+import { ApiError } from './apiError.js';
+import logger from '../config/logger.config.js';
+
+export const globalErrorHandler = (
+	err: Error,
+	_req: Request,
+	res: Response,
+	_next: NextFunction,
+): void => {
+	let error = err;
+
+	if (typeof err === 'object' && err !== null && 'name' in err) {
+		const name = (err as any).name;
+		if (name === 'JsonWebTokenError') {
+			error = new ApiError('Token is invalid', HttpCode.UNAUTHORIZED_ACCESS);
+		} else if (name === 'TokenExpiredError') {
+			error = new ApiError('Token expired', HttpCode.UNAUTHORIZED_ACCESS);
+		}
+	}
+
+	if (!(error instanceof ApiError)) {
+		// CAPTURE THE ORIGINAL MESSAGE AND STACK BEFORE OVERWRITING
+		const originalMessage = error.message || 'An unexpected error occurred';
+		const originalStack = error.stack;
+
+		error = new ApiError(
+			originalMessage, // Use the real error message in Dev
+			HttpCode.INTERNAL_SERVER_ERROR,
+		);
+
+		// Restore the original stack trace so you can debug
+		if (originalStack) error.stack = originalStack;
+	}
+
+	const nodeEnv = process.env.NODE_ENV || 'development';
+	const appError = error as ApiError;
+
+	if (nodeEnv === 'development') {
+		res.status(appError.statusCode).json({
+			status: appError.status,
+			message: appError.message,
+			stack: appError.stack,
+		});
+	} else {
+		if (appError.isOperational) {
+			res.status(appError.statusCode).json({
+				status: appError.status,
+				message: appError.message,
+			});
+		} else {
+			logger.error({ err: appError }, 'ERROR');
+			res.status(500).json({
+				status: 'Error',
+				message: 'Something went wrong',
+			});
+		}
+	}
+};

package/template/src/middleware/pino.ts

@@ -0,0 +1,20 @@
+/**
+ * This middleware ensures every request has a unique ID. 
+ * It checks if the API Gateway already provided one (via x-request-id); 
+ * otherwise, it generates a new one.
+*/
+
+import { Request, Response } from 'express';
+import { v4 as uuidv4 } from 'uuid';
+import pinoHttp from 'pino-http';
+import logger from '../config/logger.config.js';
+
+
+export const pinoMiddleware = pinoHttp.default({
+  logger,
+  genReqId: (req: Request) => req.headers['x-request-id'] || uuidv4(),
+  customSuccessMessage: (req: Request, _res: Response) =>
+    `Request completed: ${req.method} ${req.url}`,
+  customErrorMessage: (_req: Request, _res: Response, err: any) =>
+    `Request failed: ${err.message}`,
+});

package/template/src/routes/index.ts

@@ -0,0 +1,5 @@
+import { Router } from "express";
+
+const router: Router = Router();
+
+export default router;

package/template/src/types/types.ts

@@ -0,0 +1,9 @@
+export enum HttpCode {
+  BAD_REQUEST = 400,
+  UNAUTHORIZED_ACCESS = 401,
+  NOT_FOUND = 404,
+  INTERNAL_SERVER_ERROR = 500,
+  FORBIDDEN = 403,
+  CONFLICT = 409,
+  NO_CONTENT = 204,
+}

package/template/src/utils/helper.ts

@@ -0,0 +1,30 @@
+import { ErrorObject } from "ajv";
+
+export type ValidatorError =
+  | ErrorObject<string, Record<string, any>, unknown>
+  | { instancePath: string; message: string };
+
+// Helper function to safely extract ajv error message
+export const errorMessage = (errors: ValidatorError[] | null | undefined) => {
+  return errors
+    ?.map((e) => {
+      if (e.instancePath === "") {
+        return e.message;
+      }
+      return e.instancePath.replace("/", "") + " : " + e.message;
+    })
+    .join(", ");
+};
+
+//global type-safe request handler
+declare global {
+  namespace Express {
+    interface Request {
+      user: {
+        id: string;
+        email: string;
+        role: string;
+      };
+    }
+  }
+}

package/template/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "module": "nodenext",
+    "moduleResolution": "NodeNext", 
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}