@vasrefil/api-toolkit 1.0.0

package/.nvmrc

@@ -0,0 +1 @@
+20.11.0

package/README.md

@@ -0,0 +1,5 @@
+# Vasrefil API Toolkit
+
+## This is Vasrefil API Toolkit
+
+### Author: Sodiq Alabi

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vasrefil/api-toolkit",
+  "description": "This is Vasrefil API toolkit",
+  "version": "1.0.0",
+  "author": "Sodiq Alabi",
+  "main": "server.js",
+  "scripts": {
+    "start": "ts-node-dev src/server.ts",
+    "build": "tsc",
+    "serve": "node dist/server.js",
+    "dev": "nodemon --exec ts-node src/server.ts",
+    "run-ts-node": "ts-node-dev"
+  },
+  "engines": {
+    "node": "20.11.0",
+    "npm": "10.2.4"
+  },
+  "dependencies": {
+    "@airbrake/node": "^2.1.8",
+    "@types/jsonwebtoken": "^8.5.0",
+    "bcrypt": "^5.0.1",
+    "bcrypt-nodejs": "0.0.3",
+    "chalk": "^4.1.0",
+    "cors": "^2.8.5",
+    "date-fns": "^2.29.3",
+    "dotenv": "^8.2.0",
+    "errorhandler": "^1.5.1",
+    "express": "^4.18.3",
+    "helmet": "^4.2.0",
+    "ioredis": "^5.3.2",
+    "joi": "^17.3.0",
+    "json-stringify-safe": "^5.0.1",
+    "jsonwebtoken": "^8.5.1",
+    "mongoose": "^6.0.14",
+    "morgan": "^1.10.0",
+    "rate-limiter-flexible": "^2.4.2",
+    "swagger-ui-express": "^4.1.4",
+    "winston": "^3.3.3"
+  },
+  "devDependencies": {
+    "@types/body-parser": "1.19.0",
+    "@types/cors": "^2.8.17",
+    "@types/errorhandler": "1.5.0",
+    "@types/morgan": "^1.9.3",
+    "@types/node": "^14.14.7",
+    "cross-env": "^7.0.2",
+    "nodemon": "^3.1.0",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.3"
+  }
+}

package/src/.baseDir.ts

@@ -0,0 +1 @@
+// grunt-ts creates this file to help TypeScript find the compilation root of your project.  If you wish to get to stop creating it, specify a `rootDir` setting in the Gruntfile ts `options`.  See https://github.com/TypeStrong/grunt-ts#rootdir for details.  Note that `rootDir` goes under `options`, and is case-sensitive.  This message was revised in grunt-ts v6.  Note that `rootDir` requires TypeScript 1.5  or higher.

package/src/api-response/user.response.ts

@@ -0,0 +1,30 @@
+import { Status } from '../interfaces/status.interface';
+export  const UserApiResp = {
+    NO_AUTHORIZATION_HEADER: {
+        code: 'NAH0401', status: Status.UN_AUTHORIZED, message: 'Please specify authorization header'
+    },
+    NOT_AUTHORIZED: {
+        code: 'NA00401', status: Status.UN_AUTHORIZED, message: 'You are not authorized'
+    },
+    USER_NOT_FOUND: {
+        code: 'UNF0401', status: Status.UN_AUTHORIZED, message: 'User not found'
+    },
+    USER_DEACTIVATED: {
+        code: 'UD00401', status: Status.UN_AUTHORIZED, message: 'Your account has been deactivated'
+    },
+    UNVERIFIED_EMAIL: {
+        code: 'UE00403', status: Status.FORBIDDEN, message: 'Your email address is not verified'
+    },
+    UNCOMPELETE_ACCOUNT_SETUP: {
+        code: 'UAS0403', status: Status.FORBIDDEN, message: 'Account setup is not completed'
+    },
+    UNCOMPELETE_PIN_SETUP: {
+        code: 'UPS0403', status: Status.FORBIDDEN, message: 'Pin setup is not completed'
+    },
+    NO_PIN_TOKEN_HEADER: {
+        code: 'NPTH401', status: Status.UN_AUTHORIZED, message: 'Please specify pin_token header'
+    },
+    EXPIRED_PIN_TOKEN: {
+        code: 'EPT0401', status: Status.UN_AUTHORIZED, message: 'Your session has expired, Please login with your pin'
+    },
+}

package/src/app-middlewares/airbrake.ts

@@ -0,0 +1,84 @@
+import env from '../env';
+import { ServiceRespI } from '../interfaces/interface';
+const Airbrake = require('@airbrake/node');
+const airbrakeExpress = require('@airbrake/node/dist/instrumentation/express');
+const json_stringify_safe = require('json-stringify-safe');
+
+class AirbrakeLogger {
+    private airbrake: any;
+
+    constructor(projectId: string, projectKey: string) {
+        this.airbrake = new Airbrake.Notifier({
+            projectId: projectId,
+            projectKey: projectKey,
+            environment: `${env.NODE_ENV}`
+        });
+    }
+
+
+    logRequestError(serviceResponse: ServiceRespI) {
+        try {
+            const { request, error, data, message, actionType } = serviceResponse;
+            const dataErr = data ? json_stringify_safe(data) : null;
+            const errorErr = error ? json_stringify_safe(error, null) : null;
+            const messageErr = message ? json_stringify_safe(message) : null;
+            const error_ = messageErr || errorErr || dataErr;
+            const actionType_ = actionType || 'App Error';
+            const body = request && request.body ? request.body : 'no body';
+            const url = request && request.url ? request.url : 'no url';
+            this.airbrake.notify({
+                error: error_,
+                params: { url, body, actionType: actionType_ },
+                route: url
+            });
+        } catch (error) {
+            this.airbrake.notify(error);
+        }
+    }
+
+
+    logError(error: any, params: any, route: any) {
+        try {
+            this.airbrake.notify({
+                error: json_stringify_safe(error, null),
+                params,
+                route
+            });
+        } catch (error) {
+            this.airbrake.notify(error);
+        }
+    }
+
+
+    getAirbrakeInstance() {
+        return this.airbrake;
+    }
+
+    getAirbrakeExpress() {
+      return airbrakeExpress;
+    }
+}
+
+
+// Example usage with environment variables (as before):
+// const airbrakeLogger = new AirbrakeLogger(env.AIRBRAKE.PROJECT_ID, env.AIRBRAKE.PROJECT_KEY);
+
+
+// Or, instantiate directly:
+// const airbrakeLogger = new AirbrakeLogger('yourProjectId', 'yourProjectKey');
+
+// Access the underlying Airbrake instance if needed:
+// const airbrake = airbrakeLogger.getAirbrakeInstance();
+
+
+// Then use the methods:
+// airbrakeLogger.logRequestError({ /* ... your serviceResponse object */ });
+// airbrakeLogger.logError(err, {/* ...params */}, route);
+//  Access airbrake instance directly
+// airbrake.notify()
+// Access airbrake express middleware directly
+// airbrakeExpress
+
+
+export { AirbrakeLogger };
+

package/src/controllers/_root.control.ts

@@ -0,0 +1,138 @@
+import { Model, Document, } from 'mongoose';
+import { QueryHelper } from '../helpers/query.helper';
+import { FetchAllQuery, FetchWithPaginationDataI, ModelPopulateI, NestedRecordQueryOptionsI } from '../interfaces/root-controller.interface';
+
+export class RootController {
+    private model: Model<any>;
+    private modelName: string;
+    constructor(model: Model<any>, modelName: string = 'Document') {
+        this.model = model;
+        this.modelName = modelName;
+    }
+    unique = async (conditions: {key: string, value: string}) => {
+        const {key, value} = conditions;
+        const res =  await this.model.findOne({[key]: value});        
+        if(res) {
+            return false
+        } else {
+            return true;
+        }
+    }
+    getDocumentCount = async (conditon = {}, query?: object) => {
+        const { filter } = QueryHelper.build_query(query);
+        return await this.model.countDocuments({...filter, ...conditon})
+    }
+    create = async (payload: any) => {
+        try {
+            const document = await(this.model.create({...payload}))
+            return document.toJSON()
+        } catch (error) {
+            throw error;
+        }
+    }
+    fetchAll(condition: object = {}, query?: FetchAllQuery, select: string|object = '', populate?: any) {
+        const { filter, skip, limit, sort } = QueryHelper.build_query(query);
+        return this.model.find({...filter, ...condition}).select(select).skip(skip).limit(limit).sort(sort).populate(populate);
+    }
+    fetchAllWithPagination = async (
+        conditon: object, 
+        query?: FetchAllQuery, 
+        select: string|object = '', 
+        populate?: ModelPopulateI[]): Promise<FetchWithPaginationDataI> =>   {
+            try {
+                const records = await this.fetchAll(conditon, query, select, populate);
+                const total_records = await this.getDocumentCount(conditon, query);
+                return {records, total_records}
+            } catch (error) {
+               throw error
+            }
+    }
+    getOneP = async (condition: object, select?: any) => {
+        try {
+            select = select ? select : '';
+            const document =  await this.model.findOne(condition).select(select).lean()
+            if(!document) throw {message: `${this.modelName} not found`};
+            return document
+        } catch (error) {
+            throw error;
+        }
+    }
+    getOne(condition: object, select: string|object = '', populate?: any) {
+        return (this.model.findOne(condition).select(select).populate(populate).lean() as any)
+    }
+
+
+    getById = async (id: string, select: string|object = '') => {
+        try {
+            const document =  await this.model.findById(id).select(select).lean()
+            if(!document) throw {message: `${this.modelName} not found`};
+            return document;
+        } catch (error) {
+            throw error
+        }
+    }
+    updateOne(condition: object, updateValues: object) {
+        return (this.model.updateOne({...condition}, {...updateValues}, {new: true}) as any)
+    }
+    updateMany(condition: object, updateValues: object) {
+        return this.model.updateMany({...condition}, {...updateValues}).lean()
+    }
+    updateById(id: string, updateValues: object): any {
+        return this.model.findByIdAndUpdate(id, {...updateValues}, {new: true}).lean()
+    }
+    deleteOne(condition: object) {
+        return this.model.deleteOne({...condition})
+    }
+    deleteMany(condition: object) {
+        return this.model.deleteMany({...condition})
+    }
+    deleteById(id: string) {
+        return this.model.findByIdAndDelete(id)
+    }
+    search = async (payload:{key: any, value: any}, select = '') => {
+        try {
+            const regrex = new RegExp(`${payload.value}`, 'i');
+            const records = await this.model.find({[payload.key]: {$regex: regrex}}).select(select);
+            if(!records) throw {message: `${this.modelName} not found`}
+            throw records;
+        } catch (error) { 
+            throw error;
+        }
+    }
+    getNestedRecord =  async (
+        options: NestedRecordQueryOptionsI,
+        errorMessage?: string
+    ) => {
+        const {
+            parentField,
+            childIdField = '_id',
+            parentId,
+            childId
+        } = options;
+    
+        // Build the query
+        const query = {
+            _id: parentId,
+            [`${parentField}.${childIdField}`]: { $eq: childId }
+        };
+    
+        // Build the projection
+        const projection = {
+            [parentField]: {
+                $elemMatch: {
+                    [childIdField]: childId
+                }
+            }
+        };
+    
+        // Execute the query
+        const result = await this.model.findOne(query,  projection);
+    
+        if (!result) {
+            throw new Error(errorMessage || `Nested record not found in ${parentField}`);
+        }
+    
+        // Return the first element of the matched array
+        return result[parentField][0];
+    }
+}

package/src/controllers/sample.control.ts

@@ -0,0 +1,8 @@
+import { RootController } from './_root.control';
+import SampleModel from '../models/sample.model'
+class SampleController extends RootController {
+    constructor() {
+        super(SampleModel) 
+    }
+}
+export default new SampleController

package/src/env.ts

@@ -0,0 +1,15 @@
+const dotenv = require('dotenv');
+dotenv.config()
+
+const env = {
+    MONGODB_URI : process.env.MONGODB_URI,
+    ADMIN_JWT_KEY: process.env.ADMIN_JWT_KEY as string,
+    NODE_ENV: process.env.NODE_ENV,
+    RATE_LIMIT_REDIS_URL: process.env.RATE_LIMIT_REDIS_URL,
+    API_KEY: process.env.API_KEY,
+    AIRBRAKE: {
+        PROJECT_ID: process.env.AIRBRAKE_PROJECT_ID,
+        PROJECT_KEY: process.env.AIRBRAKE_PROJECT_KEY
+    },
+}
+export default env;

package/src/helpers/currency-formatter.helper.ts

@@ -0,0 +1,7 @@
+export const currency_fmt = (value: any): string => {
+    const result = new Intl.NumberFormat('en-NG', {
+        style: 'currency',
+        currency: 'NGN',
+    }).format(value)
+    return result
+}

package/src/helpers/query.helper.ts

@@ -0,0 +1,122 @@
+import { FiltersQueryI } from '../interfaces/interface';
+import { DateUtil } from '../utilities/date.util';
+
+class QueryHelper_ {
+    build_query(query: any): {sort: any, limit: number, skip: number, filter: any, page: number} {
+        if(!query) query = {};
+        const { filter, limit, page, filterRange, date_range, date_type, search } = query;        
+        let range = filterRange ?  this.str_to_obj(filterRange) : null;
+        const filterx = filter ? this.str_to_obj(filter) : ({} as any);
+        let searchx = search ? this.str_to_obj(search) :  ({} as any);
+        const date_rangex = date_range ? this.str_to_obj(date_range) : ({} as any);        
+
+        const pagex = page ? Number(page) : 1
+        const skipx = page ? ((Number(page) - 1) * limit) : 0; 
+        const limitx = Number(limit) || 20;        
+        if(range) {
+            const {field, ranges:{from, to} } = range;
+            range = {[field]: {$gte: from, $lt: to }}
+        }
+        searchx = searchx.key && searchx.value ? searchx : null;
+        const filterResult =  range || filterx || {};
+        const  date_range_ = this.get_date_range({date_type, date_range: date_rangex});
+        const search_ =  searchx ? {[searchx.key]: {$regex: new RegExp(`${searchx.value}`, 'i')}} : {};      
+          
+        const filters = this.process_filters(query)
+        const sort = this.get_sort(query);
+        const filter_result = {...filterResult, ...date_range_, ...search_, ...filters};
+        return { sort, limit: limitx, filter: filter_result, skip: skipx, page: pagex};
+    }
+    get_date_range(
+        payload: {date_type: string, date_range: {start_date: Date, end_date: Date}}
+    ) {
+        let date_filter_range = null as unknown as {start_date: any, end_date: any};
+        let filter = {};
+        const { date_type , date_range } = payload;
+        if(date_type === 'today') {
+            date_filter_range = DateUtil.get_today_date_range();
+        } else if(date_type === 'this_week') {
+            date_filter_range = DateUtil.this_week_date_range();
+        } else if(date_type === 'this_month') {
+            date_filter_range = DateUtil.this_month_date_range();
+        } else if(date_type === 'this_year') {
+            date_filter_range = DateUtil.this_year_date_range();
+        } else if(date_type === 'custom' && date_range && (date_range.start_date && date_range.end_date)) {   
+            date_filter_range = DateUtil.get_custom_date_range(date_range)
+        } else  if(date_type === 'last_30_days') {
+            const d = DateUtil.get_date_range({date: new Date(), number_of_days: 30})
+            filter = {createdAt: {$gte: d.start_date}}
+        }
+        if(date_filter_range) {
+            filter = {createdAt: {$gte: date_filter_range.start_date, $lt: date_filter_range.end_date}}
+        }
+        return filter;
+    }
+    get_filters(filter: any){        
+        const filters: any = {};
+        if(!filter) return filters;        
+        for (const [ key, value ] of Object.entries(filter)) {
+            const value_ = value as any;
+            if(key === 'createdAt'){
+                filters.startDate = value_['$gte']
+                filters.endDate = value_['$lt']
+            } else if(key === '$or' || key === '$and') {
+                const values = (value as any[])
+                if(values && values.length) {
+                    values.forEach(item => {
+                        const arrKey = Object.keys(item)[0]
+                        const arrValue = Object.values(item)[0] as any;
+                        filters[arrKey] = arrValue ? arrValue['$eq'] : null
+                    })
+                }
+            } else {
+                filters[key] = value;
+            }
+        }
+        return filters;
+    }
+
+    process_filters = (query: any) => {
+        try {
+            const { filters } = query;
+            let result: any = [];
+            let filter_query = {};
+            const filters_: FiltersQueryI = filters ? this.str_to_obj(filters) : ({} as any);
+            if(filters_ && filters_.filterSet && filters_.filterSet.length && filters_.conjunction) {
+                const logical_operator = filters_.conjunction == 'and' ? '$and' : '$or';
+                filters_.filterSet.forEach(fit => {
+                    if(fit.operator === 'contains') {
+                        result.push({[fit.field]: {$regex: fit.value, $options: 'i'} })
+                    } else if(fit.operator === 'does_not_contain') {
+                        result.push({[fit.field]: {$not: { $regex: fit.value, $options: 'i' }} })
+                    } else if(fit.operator === 'is') {
+                        result.push({[fit.field]: { $eq: fit.value} })
+                    } else if(fit.operator === 'is_not') {
+                        result.push({[fit.field]: { $ne: fit.value} })
+                    }
+                })
+                filter_query = {[logical_operator]: result}
+            }
+            return filter_query;
+        } catch (error) {
+            console.log(error);
+        }
+    }
+
+    private get_sort(query: any) {
+        try {
+            const { key, value } = query.sort ? this.str_to_obj(query.sort) : ({} as any);
+            const single_sort = {[key || 'createdAt']: value || '-1'}
+            const sorts = query.sorts ? this.str_to_obj(query.sorts) : ({} as any);
+            const sort = Object.values(sorts).length ? sorts : single_sort
+            return sort;
+        } catch (error) {
+            throw error
+        }
+    }
+    private str_to_obj(string: string) {
+        return JSON.parse(string);
+    }
+}
+const QueryHelper = new QueryHelper_;
+export { QueryHelper };

package/src/interfaces/interface.ts

@@ -0,0 +1,28 @@
+import { Status } from "./status.interface";
+import { Request, Response } from 'express';
+export interface SampleI {
+    _id: string;
+    name: string;
+    description?: string;
+    createdAt: number;
+}
+export interface ServiceRespI {
+    req: Request;
+    res: Response;
+    status: Status;
+    request?: Request;
+    actionType: string; 
+    data?: any;
+    message?: string;
+    error?: any;
+    admin_message?: string;
+}
+
+export interface FiltersQueryI {
+    filterSet: {
+        field: string;
+        operator: 'contains' | 'does_not_contain' | 'is' | 'is_not';
+        value: string;
+    }[];
+    conjunction: 'or' | 'and'
+}

package/src/interfaces/root-controller.interface.ts

@@ -0,0 +1,21 @@
+export interface FetchAllQuery {
+    filter?: any;
+    limit?: number 
+    skip?: number 
+    sort?: any;
+}
+export interface ModelPopulateI {
+    path: any, 
+    select?: any, 
+    model?: string
+}
+export interface FetchWithPaginationDataI {
+    records?: any[]
+    total_records?: number
+}
+export interface NestedRecordQueryOptionsI {
+    parentField: string;
+    parentId: string;
+    childIdField?: string;
+    childId: string;
+}

package/src/interfaces/status.interface.ts

@@ -0,0 +1,13 @@
+export enum Status {
+    SUCCESS = 'SUCCESS',
+    CREATED = 'CREATED',
+    FAILED_VALIDATION = 'FAILED_VALIDATION',
+    UN_AUTHORIZED = 'UN_AUTHORIZED', 
+    ERROR = 'ERROR',
+    PROCESSING = 'PROCESSING',
+    NOT_FOUND = 'NOT_FOUND',
+    PRECONDITION_FAILED = 'PRECONDITION_FAILED',
+    SUCCESS_NO_CONTENT = 'SUCCESS_NO_CONTENT', 
+    FORBIDDEN = 'FORBIDDEN',
+    UNPROCESSABLE_ENTRY = 'UNPROCESSABLE_ENTRY'
+}

package/src/middlewares/auth.midware.ts

@@ -0,0 +1,41 @@
+import TokenUtil from '../utilities/token.util';
+import { RootService } from '../services/_root.service';
+import { Status } from '../interfaces/status.interface';
+import { UserApiResp } from '../api-response/user.response';
+import { Request, Response, NextFunction } from 'express';
+import env from '../env';
+class AuthMidWare extends RootService {
+
+    private _is_authenticated = async (req: Request) => {
+        try {       
+            const apiKey = req.headers['api-key'];
+            if(apiKey) {
+                if(apiKey !== env.API_KEY) throw UserApiResp.NOT_AUTHORIZED;
+            } else {
+                const authHeader = req.headers.authorization;                
+                if(!authHeader) throw UserApiResp.NO_AUTHORIZATION_HEADER;
+                const token = authHeader.split(' ')[1];
+                const tokenData = await TokenUtil.verify_admin_user(token);
+                if(!tokenData) throw UserApiResp.NOT_AUTHORIZED;
+                (req as any).user = tokenData;
+            }
+            return req;                
+        } catch (error: any) {                                
+            const status = error.status || Status.UN_AUTHORIZED;
+            const message = error.message || 'You are not authorized';
+            throw {status, message, error, req}
+        }
+    }
+    auth = async (req: Request, res: Response, next: NextFunction) => {
+        const actionType = 'USER_AUTH_MIDWARE';
+        try {
+            await this._is_authenticated(req)
+            next();           
+             
+        } catch (error) {
+            const { status, message, data } = this.get_error(error);
+            return this.sendResponse({req, res, status, actionType, message, data, error})
+        }
+    }
+}
+export default new AuthMidWare;

package/src/middlewares/validator.midware.ts

@@ -0,0 +1,29 @@
+import * as joi from 'joi'
+import { RootService } from '../services/_root.service';
+import { Status } from "../interfaces/status.interface";
+const { FAILED_VALIDATION } = Status;
+import { Request, Response, NextFunction } from 'express';
+/**
+ * Validation middleware that uses joi to validate the request body.
+ * @param schema Joi schema to use to validate the request body
+ */
+export class Joi extends RootService {
+  vdtor(schema: joi.Schema, field: 'body' | 'query' = 'body') {
+    return async (req: Request, res: Response, next: NextFunction) => {
+      const actionType = 'SCHEMA_VALIDATION';
+      try {                        
+            await schema.validateAsync(req[field], {abortEarly: false})
+            next();
+          } catch (err: any) {                                      
+            const errorDetails = err.details.map((e: any) => e.message);
+            const response = {
+              message: 'Some validation errors occured',
+              errors: errorDetails,
+            }   
+           return this.sendResponse({req, res, status: FAILED_VALIDATION, actionType, data: response})
+          }
+        }; 
+  }
+}
+const newJoi = new Joi()
+export default newJoi;

package/src/models/_config.ts

@@ -0,0 +1,23 @@
+import mongoose = require("mongoose"); 
+import env from '../env';
+import chalk = require('chalk');
+
+mongoose.set('strictQuery', false)
+
+export const dbConfig = () => {
+    // Connect to MongoDB
+    if(env.MONGODB_URI) {
+      mongoose.connect(env.MONGODB_URI)
+      .then(() => {
+        console.log('✌🏾 Successfully connected to MongoDB');
+      })
+      .catch(err => {
+        console.log(err);
+        console.log(chalk.red.bgBlack.bold('An error occured while conencting to MongoDB'));
+      });
+    } else {
+      console.log('MONGODB_URI environment varaiable is required.');
+      
+    }
+}
+ 

package/src/models/sample.model.ts

@@ -0,0 +1,21 @@
+import { Document, Schema, model, Model } from "mongoose";
+
+export interface ISample extends Document {
+    name: string;
+    description?: string;
+}
+
+const schema: Schema<ISample> = new Schema({
+    name: {
+        type: String,
+    },
+    description: {
+        type: String
+    }, 
+}, {timestamps: true});
+schema.index({})
+
+export interface ISampleModel extends Model<ISample> {}
+
+const SampleModel:ISampleModel = model<ISample, ISampleModel>('sample', schema)
+export default SampleModel

package/src/routes/index.route.ts

@@ -0,0 +1,30 @@
+import * as express from "express";
+import chalk = require('chalk');
+import env from '../env';
+
+
+import SampleRoute from './sample.route';
+/**
+ * Create and return Router.
+ *
+ * @class Server
+ * @method config
+ * @return void
+ */
+export const routes = (app: express.Application) => {
+    let router: express.Router;
+    router = express.Router();
+
+    console.log(chalk.yellow.bgBlack.bold("Loading sample routes"));
+    SampleRoute.loadRoutes('/samples', router);  
+
+    router.get('/', (req, res) => res.send(`Welcome to Node-Template-TS-2 - ${env.NODE_ENV}`))
+
+    //use router middleware
+    app.use(router);
+
+    app.all('*', (req, res)=> {
+      console.log(req.url);
+      return res.status(404).json({ status: 404, error: 'not found' });
+    });
+}

package/src/routes/sample.route.ts

@@ -0,0 +1,51 @@
+import { Router } from "express";
+import SampleService from '../services/sample.service';
+import Joi from '../middlewares/validator.midware';
+import SampleValidator from '../validations/sample.validator';
+
+class SampleRoute {
+    public loadRoutes(prefix: string, router: Router) {
+        this.create(prefix, router);
+        this.getAll(prefix, router);
+        this.getOne(prefix, router);
+        this.getById(prefix, router);
+        this.updateOne(prefix, router);
+        this.updateMany(prefix, router);
+        this.updateById(prefix, router);
+        this.deleteOne(prefix, router);
+        this.deleteMany(prefix, router);
+        this.deleteById(prefix, router);
+    }       
+    private create(prefix: string, router: Router) {
+        router.post(`${prefix}`, Joi.vdtor(SampleValidator.create), SampleService.create)
+    }
+    private getAll(prefix: string, router: Router) {
+        router.get(`${prefix}`, SampleService.getAll)
+    }
+    private getOne(prefix: string, router: Router) {
+        router.get(`${prefix}/one`, SampleService.getOne)
+    }
+    private getById(prefix: string, router: Router) {
+        router.get(`${prefix}/:id`, SampleService.getById)
+    }
+    private updateOne(prefix: string, router: Router) {
+        router.put(`${prefix}/one`, SampleService.updateOne) 
+    }
+    private updateMany(prefix: string, router: Router) {
+        router.put(`${prefix}/many`, SampleService.updateMany)
+    } 
+    private updateById(prefix: string, router: Router) {
+        router.put(`${prefix}/:id`, SampleService.updateById)
+    }
+    private deleteOne(prefix: string, router: Router) { 
+        router.delete(`${prefix}/one`, SampleService.deleteOne) 
+    }
+    private deleteMany(prefix: string, router: Router) { 
+        router.delete(`${prefix}/many`, SampleService.deleteMany) 
+    }
+    private deleteById(prefix: string, router: Router) { 
+        router.delete(`${prefix}/:id`, SampleService.deleteById) 
+    }
+    
+} 
+export default new SampleRoute;

package/src/server.ts

@@ -0,0 +1,49 @@
+import express from "express";
+import path from "path";
+import cors from "cors";
+import helmet from 'helmet'
+import errorHandler = require("errorhandler");
+import { dbConfig } from './models/_config';
+import { routes } from './routes/index.route';
+import { morgan } from './utilities/logger.util';
+// import { airbrake, airbrakeExpress } from './app-middlewares/airbrake';
+const port = process.env.PORT || 8082;
+
+const app = express();
+
+//configure application
+app.use(express.static(path.join(__dirname, "public")));
+
+//mount json form parser
+app.use(express.json());
+
+//mount query string parser
+app.use(express.urlencoded({extended: true }));
+
+app.use(helmet())
+app.use(morgan)
+
+//cors error allow
+app.options("*", cors());
+app.use(cors());
+
+// catch 404 and forward to error handler
+app.use(function(err: any, req: express.Request, res: express.Response, next: express.NextFunction) {
+    err.status = 404;
+    next(err);
+});
+
+//error handling
+app.use(errorHandler());
+
+dbConfig();
+
+// app.use(airbrakeExpress.makeMiddleware(airbrake));
+
+routes(app);
+
+// app.use(airbrakeExpress.makeErrorHandler(airbrake));
+
+app.listen(port, () => {  
+  console.log(`Server is running on port ${port}`);
+});

package/src/services/_root.service.ts

@@ -0,0 +1,70 @@
+import { winston } from '../utilities/logger.util'
+import { Status } from '../interfaces/status.interface';
+import { ServiceRespI } from "../interfaces/interface";
+
+export class RootService {
+    sendResponse = (serviceResponse: ServiceRespI): any => {            
+        let { res, status, data, message, actionType, error } = serviceResponse; 
+        try {
+            status = status || Status.ERROR;
+            const code = error && error.code ? error.code : null;
+            const response: any = { status, data, message, code }
+            if(error) {
+                response.error = this.get_error_(error)
+            }
+            
+            const status_code = this.getHttpStatus(status); 
+            res.status(status_code).json(response);
+            if(status_code >= 400) {
+                const dataErr = data ? JSON.stringify(data) : data;
+                const error = `[${actionType||'App Error'}] ${response.message} ${dataErr}`
+                winston.error(error)
+            }
+        } catch (error: any) {
+            res.status(500).json({status: 'ERROR', data: error, message: error.message});
+        }
+    }
+    get_error(error: any): {status: Status, message: string, data: any} {
+        let response = {status: Status.ERROR, message: 'Request failed', data: null};
+        const { status, message, data } = error; 
+        response.status = status ? status : response.status;
+        response.message = message ? message : response.message;
+        response.data = data ? data : response.data;
+        return response;
+    }
+    private getHttpStatus(status: any): number {
+        switch (status) {
+            case 'SUCCESS': case 'PROCESSING':
+                return 200;
+            case 'CREATED':
+                return 201;
+            case 'SUCCESS_NO_CONTENT':
+                return 204;
+            case 'FAILED_VALIDATION':
+                return 400;
+            case 'UN_AUTHORIZED':
+                return 401;
+            case 'FORBIDDEN':
+                return 403;
+            case 'NOT_FOUND':
+                return 404;
+            case 'CONFLICT':
+                return 409;
+            case 'UNPROCESSABLE_ENTRY':
+                return 422;
+            case 'UNATHORIZED':
+                return 401;
+            case 'PRECONDITION_FAILED':
+                return 412;
+            case 'ERROR':
+                return 500
+            default:
+                return 400;
+        }
+    }
+    private get_error_ = (err: any) => {        
+        const error = err && err.error ? err.error : err;
+        const { req, message, status, code, ...err_rest } = error;
+        return err_rest;
+    }
+}

package/src/services/sample.service.ts

@@ -0,0 +1,105 @@
+import { Response, Request } from 'express';
+import SampleController from '../controllers/sample.control';
+import { RootService } from './_root.service';
+import { Status } from '../interfaces/status.interface';
+const { SUCCESS, ERROR, UNPROCESSABLE_ENTRY, PRECONDITION_FAILED, SUCCESS_NO_CONTENT } = Status;
+class SampleService extends RootService {
+    create = async (req: Request, res: Response) => {
+        const actionType = 'CREATE_SAMPLE';
+        try {
+            const sample = await SampleController.create(req.body);
+            this.sendResponse({req, res, status: SUCCESS, data: sample, actionType});
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    getAll = async (req: Request, res: Response) => {
+        const actionType = 'GET_ALL_SAMPLES';
+        try {
+            const samples = await SampleController.fetchAll({},req.query)
+            this.sendResponse({req, res, status: SUCCESS, actionType, data: samples});
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR,  actionType, data: error})
+        } 
+    }
+    getOne = async (req: Request, res: Response) => {
+        const actionType = 'GET_ONE_SAMPLE';
+        try {
+            const sample = await SampleController.getOne(req.query)
+            this.sendResponse({req, res, status: SUCCESS, actionType, data: sample});
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    getById = async (req: Request, res: Response) => {
+        const actionType = 'GET_SAMPLE_BY_ID'
+        try {            
+            const sample = await SampleController.getById(req.params.id);
+            this.sendResponse({req, res, status: SUCCESS, actionType, data: sample});
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    updateOne = async (req: Request, res: Response) => {
+        const actionType = 'UPDATE_ONE_SAMPLE';
+        try {            
+            const sample = await SampleController.updateOne(req.query, req.body)
+            if(sample.acknowledged) return this.sendResponse({req, res, status: SUCCESS, actionType, data: sample});
+            this.sendResponse({req, res, status: UNPROCESSABLE_ENTRY, actionType, data: 'data not updated'})
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    updateMany = async (req: Request, res: Response) => {
+        const actionType = 'UPDATE_MANY_SAMPLE';
+        try {                        
+            const sample: any = await SampleController.updateMany(req.query, req.body)
+            if(sample.acknowledged) return this.sendResponse({req, res, status: SUCCESS, actionType, data: sample});
+            this.sendResponse({req, res, status: UNPROCESSABLE_ENTRY, actionType, data: 'data not updated'})
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    updateById = async (req: Request, res: Response) => {
+        const actionType = 'UPDATE_SAMPLE_BY_ID'
+        try {            
+            const sample: any = await SampleController.updateById(req.params.id, req.body);
+            if(sample) return this.sendResponse({req, res, status: SUCCESS, actionType, data: sample});
+            this.sendResponse({req, res, status: PRECONDITION_FAILED, actionType, data: 'data not updated'})
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    deleteOne = async (req: Request, res: Response) => {
+        const actionType = 'DELETE_ONE_SAMPLE'
+        try {            
+            const sample: any = await SampleController.deleteOne(req.query)
+            if(sample.acknowledged) return this.sendResponse({req, res, status: SUCCESS_NO_CONTENT, actionType, data: sample});
+            this.sendResponse({req, res, status: UNPROCESSABLE_ENTRY, actionType, data: 'data not deleted'})
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    deleteMany = async (req: Request, res: Response) => {
+        const actionType = 'DELETE_MANY_SAMPLES';
+        try {            
+            const sample: any = await SampleController.deleteMany(req.query)
+            if(sample.acknowledged) return this.sendResponse({req, res, status: SUCCESS_NO_CONTENT, actionType, data: sample});
+            this.sendResponse({req, res, status: UNPROCESSABLE_ENTRY, actionType, data: 'data not deleted'})
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    deleteById = async (req: Request, res: Response) => {
+        const actionType = 'DELETE_SAMPLE_BY_ID';
+        try {            
+            const sample = await SampleController.deleteById(req.params.id);
+            if(sample) return this.sendResponse({req, res, status: SUCCESS_NO_CONTENT, actionType, data: sample});
+            this.sendResponse({req, res, status: PRECONDITION_FAILED, actionType, data: 'data not deleted'})
+        } catch (error) {
+            this.sendResponse({req, res, status: ERROR, actionType, data: error})
+        } 
+    }
+    
+}
+export default new SampleService;

package/src/utilities/date.util.ts

@@ -0,0 +1,68 @@
+import * as dateFns from 'date-fns';
+
+
+class DateUtil_ {
+
+    get_local_date = (date = new Date()) => {
+        const currentDate = new Date(date);
+        // const localOffset = currentDate.getTimezoneOffset() * 60000;
+        // const localDate = new Date(currentDate.getTime() - localOffset);
+        return currentDate
+    }
+    get_start_date(date: any) {
+        const d = this.get_local_date(date);
+        d.setHours(0, 0, 0, 0);
+        return d.getTime();
+    }
+    get_end_date(date: any) {
+        const d = this.get_local_date(date);
+        d.setHours(23, 0, 0, 0);
+        return d.getTime();
+    }
+    get_date_format(date: Date, format: string) {
+        return this.get_local_date(date);
+    }
+    get_today_date_range(payload?: {format?: string, date: Date}): {start_date: any, end_date: any} {       
+        const main_date = payload && payload.date ? this.get_local_date(payload.date) : this.get_local_date();
+        return {
+            start_date: dateFns.startOfDay(main_date),
+            end_date: dateFns.endOfDay(main_date)
+        }
+    }
+    get_date_range(payload?: {format?: string, date: Date, number_of_days?: number}): {start_date: any, end_date: any} {
+        const main_date = payload && payload.date ? this.get_local_date(payload.date) : this.get_local_date();
+        const number_of_days = payload?.number_of_days ? payload.number_of_days : 0;
+        const start_date = dateFns.subDays(main_date, number_of_days)
+        const end_date = dateFns.addDays(main_date, number_of_days)
+        return {
+            start_date: dateFns.startOfDay(start_date),
+            end_date: dateFns.endOfDay(end_date)
+        }
+    }
+    get_custom_date_range({start_date, end_date}: {start_date: Date; end_date: Date}) {
+        return {
+            start_date: dateFns.startOfDay(this.get_local_date(start_date)),
+            end_date: dateFns.endOfDay(this.get_local_date(end_date))
+        } 
+    }
+    this_week_date_range(): {start_date: Date, end_date: Date} {
+        return {
+            start_date: dateFns.startOfWeek(this.get_local_date()),
+            end_date: dateFns.endOfWeek(this.get_local_date())
+        }
+    }
+    this_month_date_range(): {start_date: Date, end_date: Date} {
+        return {
+            start_date: dateFns.startOfMonth(this.get_local_date()),
+            end_date: dateFns.endOfMonth(this.get_local_date())
+        }
+    }
+    this_year_date_range(): {start_date: Date, end_date: Date} {
+        return {
+            start_date: dateFns.startOfYear(this.get_local_date()),
+            end_date: dateFns.endOfYear(this.get_local_date())
+        }
+    }
+}
+const DateUtil = new DateUtil_;
+export { DateUtil }

package/src/utilities/logger.util.ts

@@ -0,0 +1,52 @@
+import env from '../env';
+import { createWriteStream } from 'fs';
+import { resolve } from 'path';
+import morgan_ from 'morgan';
+import { createLogger, format, transports } from 'winston';
+
+class LoggerUtil {
+    morgan() {
+        let dev_format = '[:date[web] :remote-addr :remote-user ] :method :url HTTP/:http-version | :status :response-time ms'
+        let prod_format = '[:date[web] :remote-addr :remote-user ] :method :url HTTP/:http-version :referrer - :user-agent | :status :response-time ms'
+        let morgan_format = env.NODE_ENV === 'prod' ? prod_format : dev_format;
+        let request_log_stream = createWriteStream(resolve(__dirname, `../../logs/request.log`), { flags: 'a' });
+        return morgan_(morgan_format, { stream: request_log_stream });
+    }
+    winston() {
+        let { colorize, combine, printf, timestamp } = format
+        let log_transports = {
+            console: new transports.Console({ level: 'warn' }),
+            combined_log: new transports.File({ level: 'info', filename: `logs/combined.log` }),
+            error_log: new transports.File({ level: 'error', filename: `logs/error.log` }),
+            exception_log: new transports.File({ filename: 'logs/exception.log' }),
+        };
+        let log_format = printf(({ level, message, timestamp }) => `[${timestamp} : ${level}] - ${message}`);
+        let logger = createLogger({
+            transports: [
+                log_transports.console,
+                log_transports.combined_log,
+                log_transports.error_log,
+            ],
+            exceptionHandlers: [
+                log_transports.exception_log,
+            ],
+            exitOnError: false,
+            format: combine(
+                colorize(),
+                timestamp(),
+                log_format
+            )
+        });
+        return logger;
+    }
+}
+
+
+const loggerUtil = new LoggerUtil()
+const morgan = loggerUtil.morgan()
+const winston = loggerUtil.winston()
+
+export {
+    morgan,
+    winston
+}

package/src/utilities/token.util.ts

@@ -0,0 +1,20 @@
+import * as jwt from 'jsonwebtoken';
+import env from '../env';
+import { UserApiResp } from '../api-response/user.response';
+
+class TokenUtil {
+    sign_admin_user(payload: any, expiresIn: string | number) {
+       return jwt.sign(payload, env?.ADMIN_JWT_KEY, {expiresIn: expiresIn ? expiresIn : '1d'});
+    }
+    verify_admin_user(token: string): any {
+        return new Promise((resolve, reject) => {
+            try {
+                const resp =  jwt.verify(token, env.ADMIN_JWT_KEY);                
+                resolve(resp)
+            } catch (error) {
+                reject({error, ...UserApiResp.NOT_AUTHORIZED})
+            }
+        }) 
+    }
+}
+export default new TokenUtil;

package/src/validations/sample.validator.ts

@@ -0,0 +1,8 @@
+import * as joi from 'joi';
+class SampleValidator {
+    public create = joi.object({
+        name: joi.string().required(),
+        description: joi.string().required()
+    })
+}
+export default new SampleValidator;

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true  // Generates TypeScript declaration files
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}