express-ts-skeleton

express-ts-skeleton is a boilerplate for building Express applications using TypeScript. It simplifies the process of defining routes and handling responses in your Express applications.

Features

• A skeleton for your ts project
• Easily define routes with a structured approach.
• Return standardized success and failure responses.
• Supports middleware and validation for route handling.

Installation

You can install the package via npm:

npm install express-ts-skeleton

Usage

Defining the Main Route File

To define your main route file, you can use the following example:

import { Router } from "express";
import { IndexRouteFormat } from "express-ts-skeleton";
import { Routes } from "./path/to/routes";

// Define an array of routes
const routes: Array<IndexRouteFormat> = [
  {
    path: "/route", // Path for the route
    route: Routes, // Common routes to use
  },
];

// Create a new router instance
export const router = Router();

// Configure the router with the defined routes
routes.forEach(async (route) => {
  router.use(route.path, route.route); // Use the common routes for the specified path
});

Defining Routes

To define specific routes for your application, create an array of RouteFormat objects. Below is an example of how to set up common routes using the routeMaker function:

import { RequestMethod, RouteFormat, routeMaker } from "express-ts-skeleton";
import { controllers } from "../controllers/common.cotrollers";
import { validators } from "../validators/common.validators";

const routes: Array<RouteFormat> = [
  {
    type: RequestMethod.POST, //Request method
    path: "/", //Path
    middlewares: [
      // Add middleware
    ],
    validate: validators.create, //Add validator
    handler: "create", // controller class function
  },
];

export const commonRoutes = routeMaker(controllers, routes);

Example of Controllers

Create controllers to handle business logic. Below is an example of a controller class:

import { FailureResponse, SuccessResponse } from "express-ts-skeleton";

export class Controllers {
  constructor() {}

  async create() {
    try {
      return SuccessResponse.success("Success");
    } catch (err: unknown) {
      return FailureResponse.failure({
        message: err instanceof Error ? err.message : (err as string),
        error: err instanceof Error ? err.message : "Unknown error",
      });
    }
  }
}

Example of Validators

You can use the commonValidators object to validate different aspects of incoming requests (query, params, and body) in your Express routes.

import { validateObjectLiteral } from "express-ts-skeleton";
import Joi from "joi";

export const validators: validateObjectLiteral = {
  create: {
    query: Joi.object().keys({
      id: Joi.string().regex(/[0-9]/),
    }),
    params: Joi.object().keys({
      id: Joi.string().regex(/[0-9]/),
    }),
    body: Joi.object().keys({
      id: Joi.string().regex(/[0-9]/),
    }),
  },
};

• These keys (query, parmas, body) are optional.
• query - to validate query of request.
• params - to validate params of request.
• body - to validate body of request.

CommonHelper

filter - To create a filter

import { CommonHelper } from "express-ts-skeleton";

const filterQuery = CommonHelper.filter<{ name: string }>({
  data,
  fields: { name: "normal" },
});

• use normal to apply normal filter on feild.
• use regex to apple regex on field.
• use greaterThan to apply greater than on feild
• use lessThan to apply less than on feild

License

This project is licensed under the MIT License.

Report bugs

[email protected]