express-ts-skeleton/README.md

This is a skeleton(boiler plate) for nodejs, express and typescript.

# 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 Version][npm-version-image]][npm-url]
[![NPM Install Size][npm-install-size-image]][npm-install-size-url]
[![NPM Downloads][npm-downloads-image]][npm-downloads-url]

```bash
npm install express-ts-skeleton
```

## Usage

### Defining the Main Route File

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

```typescript
import { IndexRouteFormat, Routehelper } from "express-ts-skeleton";
import { commonRoutes } from "./common.routes";

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

// Create a new router instance
export 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:**

```typescript
import { RequestMethod, RouteFormat, Routehelper } from "express-ts-skeleton";
import { controllers } from "../controllers/common.cotrollers";

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

export const commonRoutes = Routehelper.assembleRouter(controllers, routes);
```

### Example of Controllers

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

```typescript
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.**

```typescript
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

```typescript
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

```Javascript
im.jsmeet@gmail.com
```

[npm-version-image]: https://badgen.net/npm/v/express-ts-skeleton
[npm-install-size-image]: https://packagephobia.com/badge?p=express-ts-skeleton
[npm-downloads-image]: https://badgen.net/npm/dm/express-ts-skeleton
[npm-url]: https://www.npmjs.com/package/express-ts-skeleton
[npm-install-size-url]: https://packagephobia.com/result?p=express-ts-skeleton
[npm-downloads-url]: https://npmcharts.com/compare/express-ts-skeleton?minimal=true