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:

1npm install express-ts-skeleton

Usage

Defining the Main Route File

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

1import { IndexRouteFormat, Routehelper } from "express-ts-skeleton";
2import { commonRoutes } from "./common.routes";
3
4//Define an array of routes
5const routes: Array<IndexRouteFormat> = [
6  {
7    path: "/common", // Path for the route
8    route: commonRoutes, // Common routes to use
9  },
10];
11
12// Create a new router instance
13export const router = Routehelper.mountRoutes(routes);

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:

1import { RequestMethod, RouteFormat, Routehelper } from "express-ts-skeleton";
2import { controllers } from "../controllers/common.cotrollers";
3
4const routes: Array<RouteFormat> = [
5  {
6    type: RequestMethod.GET, //Request method
7    path: "/", //Path
8    middlewares: [
9      // Add middleware
10    ],
11    validate: null, //Add validator
12    handler: "get", // controller class function
13  },
14];
15
16export const commonRoutes = Routehelper.assembleRouter(controllers, routes);

Example of Controllers

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

1import { FailureResponse, SuccessResponse } from "express-ts-skeleton";
2
3export class Controllers {
4  constructor() {}
5
6  async create() {
7    try {
8      return SuccessResponse.success("Success");
9    } catch (err: unknown) {
10      return FailureResponse.failure({
11        message: err instanceof Error ? err.message : (err as string),
12        error: err instanceof Error ? err.message : "Unknown error",
13      });
14    }
15  }
16}

Example of Validators

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

1import { validateObjectLiteral } from "express-ts-skeleton";
2import Joi from "joi";
3
4export const validators: validateObjectLiteral = {
5  create: {
6    query: Joi.object().keys({
7      id: Joi.string().regex(/[0-9]/),
8    }),
9    params: Joi.object().keys({
10      id: Joi.string().regex(/[0-9]/),
11    }),
12    body: Joi.object().keys({
13      id: Joi.string().regex(/[0-9]/),
14    }),
15  },
16};

• 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

1import { CommonHelper } from "express-ts-skeleton";
2
3const filterQuery = CommonHelper.filter<{ name: string }>({
4  data,
5  fields: { name: "normal" },
6});

• 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

1im.jsmeet@gmail.com