@vasrefil/api-toolkit 1.0.3 → 1.0.6

package/dist/index.d.ts

@@ -1 +1 @@
-export {};
+export declare const customMiddleware: (req: Request, res: Response, next: any) => void;

package/dist/index.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.customMiddleware = void 0;
 const express_1 = __importDefault(require("express"));
 const path_1 = __importDefault(require("path"));
 const cors_1 = __importDefault(require("cors"));
@@ -39,3 +40,8 @@ app.use(errorHandler());
 app.listen(port, () => {
     console.log(`Server is running on port ${port}`);
 });
+const customMiddleware = (req, res, next) => {
+    // Your middleware logic here
+    next();
+};
+exports.customMiddleware = customMiddleware;

package/dist/out-tsc/api-response/user.response.d.ts

@@ -0,0 +1,48 @@
+import { Status } from '../interfaces/status.interface';
+export declare const UserApiResp: {
+    NO_AUTHORIZATION_HEADER: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    NOT_AUTHORIZED: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    USER_NOT_FOUND: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    USER_DEACTIVATED: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    UNVERIFIED_EMAIL: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    UNCOMPELETE_ACCOUNT_SETUP: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    UNCOMPELETE_PIN_SETUP: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    NO_PIN_TOKEN_HEADER: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+    EXPIRED_PIN_TOKEN: {
+        code: string;
+        status: Status;
+        message: string;
+    };
+};

package/dist/out-tsc/api-response/user.response.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserApiResp = void 0;
+const status_interface_1 = require("../interfaces/status.interface");
+exports.UserApiResp = {
+    NO_AUTHORIZATION_HEADER: {
+        code: 'NAH0401', status: status_interface_1.Status.UN_AUTHORIZED, message: 'Please specify authorization header'
+    },
+    NOT_AUTHORIZED: {
+        code: 'NA00401', status: status_interface_1.Status.UN_AUTHORIZED, message: 'You are not authorized'
+    },
+    USER_NOT_FOUND: {
+        code: 'UNF0401', status: status_interface_1.Status.UN_AUTHORIZED, message: 'User not found'
+    },
+    USER_DEACTIVATED: {
+        code: 'UD00401', status: status_interface_1.Status.UN_AUTHORIZED, message: 'Your account has been deactivated'
+    },
+    UNVERIFIED_EMAIL: {
+        code: 'UE00403', status: status_interface_1.Status.FORBIDDEN, message: 'Your email address is not verified'
+    },
+    UNCOMPELETE_ACCOUNT_SETUP: {
+        code: 'UAS0403', status: status_interface_1.Status.FORBIDDEN, message: 'Account setup is not completed'
+    },
+    UNCOMPELETE_PIN_SETUP: {
+        code: 'UPS0403', status: status_interface_1.Status.FORBIDDEN, message: 'Pin setup is not completed'
+    },
+    NO_PIN_TOKEN_HEADER: {
+        code: 'NPTH401', status: status_interface_1.Status.UN_AUTHORIZED, message: 'Please specify pin_token header'
+    },
+    EXPIRED_PIN_TOKEN: {
+        code: 'EPT0401', status: status_interface_1.Status.UN_AUTHORIZED, message: 'Your session has expired, Please login with your pin'
+    },
+};

package/dist/out-tsc/app-middlewares/airbrake.d.ts

@@ -0,0 +1,10 @@
+import { ServiceRespI } from '../interfaces/interface';
+declare class AirbrakeLogger {
+    private airbrake;
+    constructor(projectId: string, projectKey: string);
+    logRequestError(serviceResponse: ServiceRespI): void;
+    logError(error: any, params: any, route: any): void;
+    getAirbrakeInstance(): any;
+    getAirbrakeExpress(): any;
+}
+export { AirbrakeLogger };

package/dist/out-tsc/app-middlewares/airbrake.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AirbrakeLogger = void 0;
+const env_1 = __importDefault(require("../env"));
+const Airbrake = require('@airbrake/node');
+const airbrakeExpress = require('@airbrake/node/dist/instrumentation/express');
+const json_stringify_safe = require('json-stringify-safe');
+class AirbrakeLogger {
+    constructor(projectId, projectKey) {
+        this.airbrake = new Airbrake.Notifier({
+            projectId: projectId,
+            projectKey: projectKey,
+            environment: `${env_1.default.NODE_ENV}`
+        });
+    }
+    logRequestError(serviceResponse) {
+        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, params, route) {
+        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;
+    }
+}
+exports.AirbrakeLogger = AirbrakeLogger;

package/dist/out-tsc/controllers/_root.control.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Model } from 'mongoose';
+import { FetchAllQuery, FetchWithPaginationDataI, ModelPopulateI, NestedRecordQueryOptionsI } from '../interfaces/root-controller.interface';
+export declare class RootController {
+    private model;
+    private modelName;
+    constructor(model: Model<any>, modelName?: string);
+    unique: (conditions: {
+        key: string;
+        value: string;
+    }) => Promise<boolean>;
+    getDocumentCount: (conditon?: {}, query?: object) => Promise<number>;
+    create: (payload: any) => Promise<any>;
+    fetchAll(condition?: object, query?: FetchAllQuery, select?: string | object, populate?: any): import("mongoose").Query<Omit<any, never>[], any, {}, any>;
+    fetchAllWithPagination: (conditon: object, query?: FetchAllQuery, select?: string | object, populate?: ModelPopulateI[]) => Promise<FetchWithPaginationDataI>;
+    getOneP: (condition: object, select?: any) => Promise<any>;
+    getOne(condition: object, select?: string | object, populate?: any): any;
+    getById: (id: string, select?: string | object) => Promise<any>;
+    updateOne(condition: object, updateValues: object): any;
+    updateMany(condition: object, updateValues: object): import("mongoose").Query<import("mongodb").UpdateResult, any, {}, any>;
+    updateById(id: string, updateValues: object): any;
+    deleteOne(condition: object): import("mongoose").Query<import("mongodb").DeleteResult, any, {}, any>;
+    deleteMany(condition: object): import("mongoose").Query<import("mongodb").DeleteResult, any, {}, any>;
+    deleteById(id: string): import("mongoose").Query<any, any, {}, any>;
+    search: (payload: {
+        key: any;
+        value: any;
+    }, select?: string) => Promise<never>;
+    getNestedRecord: (options: NestedRecordQueryOptionsI, errorMessage?: string) => Promise<any>;
+}

package/dist/out-tsc/controllers/_root.control.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootController = void 0;
+const query_helper_1 = require("../helpers/query.helper");
+class RootController {
+    constructor(model, modelName = 'Document') {
+        this.unique = async (conditions) => {
+            const { key, value } = conditions;
+            const res = await this.model.findOne({ [key]: value });
+            if (res) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        };
+        this.getDocumentCount = async (conditon = {}, query) => {
+            const { filter } = query_helper_1.QueryHelper.build_query(query);
+            return await this.model.countDocuments({ ...filter, ...conditon });
+        };
+        this.create = async (payload) => {
+            try {
+                const document = await (this.model.create({ ...payload }));
+                return document.toJSON();
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+        this.fetchAllWithPagination = async (conditon, query, select = '', populate) => {
+            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;
+            }
+        };
+        this.getOneP = async (condition, select) => {
+            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;
+            }
+        };
+        this.getById = async (id, select = '') => {
+            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;
+            }
+        };
+        this.search = async (payload, 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;
+            }
+        };
+        this.getNestedRecord = async (options, errorMessage) => {
+            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];
+        };
+        this.model = model;
+        this.modelName = modelName;
+    }
+    fetchAll(condition = {}, query, select = '', populate) {
+        const { filter, skip, limit, sort } = query_helper_1.QueryHelper.build_query(query);
+        return this.model.find({ ...filter, ...condition }).select(select).skip(skip).limit(limit).sort(sort).populate(populate);
+    }
+    getOne(condition, select = '', populate) {
+        return this.model.findOne(condition).select(select).populate(populate).lean();
+    }
+    updateOne(condition, updateValues) {
+        return this.model.updateOne({ ...condition }, { ...updateValues }, { new: true });
+    }
+    updateMany(condition, updateValues) {
+        return this.model.updateMany({ ...condition }, { ...updateValues }).lean();
+    }
+    updateById(id, updateValues) {
+        return this.model.findByIdAndUpdate(id, { ...updateValues }, { new: true }).lean();
+    }
+    deleteOne(condition) {
+        return this.model.deleteOne({ ...condition });
+    }
+    deleteMany(condition) {
+        return this.model.deleteMany({ ...condition });
+    }
+    deleteById(id) {
+        return this.model.findByIdAndDelete(id);
+    }
+}
+exports.RootController = RootController;

package/dist/out-tsc/controllers/index.d.ts

@@ -0,0 +1 @@
+export * from "./_root.control";

package/dist/out-tsc/controllers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./_root.control"), exports);

package/dist/out-tsc/controllers/sample.control.d.ts

@@ -0,0 +1,6 @@
+import { RootController } from './_root.control';
+declare class SampleController extends RootController {
+    constructor();
+}
+declare const _default: SampleController;
+export default _default;

package/dist/out-tsc/controllers/sample.control.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _root_control_1 = require("./_root.control");
+const sample_model_1 = __importDefault(require("../models/sample.model"));
+class SampleController extends _root_control_1.RootController {
+    constructor() {
+        super(sample_model_1.default);
+    }
+}
+exports.default = new SampleController;

package/dist/out-tsc/env.d.ts

@@ -0,0 +1,12 @@
+declare const env: {
+    MONGODB_URI: string | undefined;
+    ADMIN_JWT_KEY: string;
+    NODE_ENV: string | undefined;
+    RATE_LIMIT_REDIS_URL: string | undefined;
+    API_KEY: string | undefined;
+    AIRBRAKE: {
+        PROJECT_ID: string | undefined;
+        PROJECT_KEY: string | undefined;
+    };
+};
+export default env;

package/dist/out-tsc/env.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv = require('dotenv');
+dotenv.config();
+const env = {
+    MONGODB_URI: process.env.MONGODB_URI,
+    ADMIN_JWT_KEY: process.env.ADMIN_JWT_KEY,
+    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
+    },
+};
+exports.default = env;

package/dist/out-tsc/helpers/currency-formatter.helper.d.ts

@@ -0,0 +1 @@
+export declare const currency_fmt: (value: any) => string;

package/dist/out-tsc/helpers/currency-formatter.helper.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currency_fmt = void 0;
+const currency_fmt = (value) => {
+    const result = new Intl.NumberFormat('en-NG', {
+        style: 'currency',
+        currency: 'NGN',
+    }).format(value);
+    return result;
+};
+exports.currency_fmt = currency_fmt;

package/dist/out-tsc/helpers/query.helper.d.ts

@@ -0,0 +1,22 @@
+declare class QueryHelper_ {
+    build_query(query: any): {
+        sort: any;
+        limit: number;
+        skip: number;
+        filter: any;
+        page: number;
+    };
+    get_date_range(payload: {
+        date_type: string;
+        date_range: {
+            start_date: Date;
+            end_date: Date;
+        };
+    }): {};
+    get_filters(filter: any): any;
+    process_filters: (query: any) => {} | undefined;
+    private get_sort;
+    private str_to_obj;
+}
+declare const QueryHelper: QueryHelper_;
+export { QueryHelper };

package/dist/out-tsc/helpers/query.helper.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryHelper = void 0;
+const date_util_1 = require("../utilities/date.util");
+class QueryHelper_ {
+    constructor() {
+        this.process_filters = (query) => {
+            try {
+                const { filters } = query;
+                let result = [];
+                let filter_query = {};
+                const filters_ = filters ? this.str_to_obj(filters) : {};
+                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);
+            }
+        };
+    }
+    build_query(query) {
+        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) : {};
+        let searchx = search ? this.str_to_obj(search) : {};
+        const date_rangex = date_range ? this.str_to_obj(date_range) : {};
+        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) {
+        let date_filter_range = null;
+        let filter = {};
+        const { date_type, date_range } = payload;
+        if (date_type === 'today') {
+            date_filter_range = date_util_1.DateUtil.get_today_date_range();
+        }
+        else if (date_type === 'this_week') {
+            date_filter_range = date_util_1.DateUtil.this_week_date_range();
+        }
+        else if (date_type === 'this_month') {
+            date_filter_range = date_util_1.DateUtil.this_month_date_range();
+        }
+        else if (date_type === 'this_year') {
+            date_filter_range = date_util_1.DateUtil.this_year_date_range();
+        }
+        else if (date_type === 'custom' && date_range && (date_range.start_date && date_range.end_date)) {
+            date_filter_range = date_util_1.DateUtil.get_custom_date_range(date_range);
+        }
+        else if (date_type === 'last_30_days') {
+            const d = date_util_1.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) {
+        const filters = {};
+        if (!filter)
+            return filters;
+        for (const [key, value] of Object.entries(filter)) {
+            const value_ = value;
+            if (key === 'createdAt') {
+                filters.startDate = value_['$gte'];
+                filters.endDate = value_['$lt'];
+            }
+            else if (key === '$or' || key === '$and') {
+                const values = value;
+                if (values && values.length) {
+                    values.forEach(item => {
+                        const arrKey = Object.keys(item)[0];
+                        const arrValue = Object.values(item)[0];
+                        filters[arrKey] = arrValue ? arrValue['$eq'] : null;
+                    });
+                }
+            }
+            else {
+                filters[key] = value;
+            }
+        }
+        return filters;
+    }
+    get_sort(query) {
+        try {
+            const { key, value } = query.sort ? this.str_to_obj(query.sort) : {};
+            const single_sort = { [key || 'createdAt']: value || '-1' };
+            const sorts = query.sorts ? this.str_to_obj(query.sorts) : {};
+            const sort = Object.values(sorts).length ? sorts : single_sort;
+            return sort;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    str_to_obj(string) {
+        return JSON.parse(string);
+    }
+}
+const QueryHelper = new QueryHelper_;
+exports.QueryHelper = QueryHelper;

package/dist/out-tsc/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/out-tsc/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const cors_1 = __importDefault(require("cors"));
+const helmet_1 = __importDefault(require("helmet"));
+const errorHandler = require("errorhandler");
+const _config_1 = require("./models/_config");
+const index_route_1 = require("./routes/index.route");
+const logger_util_1 = require("./utilities/logger.util");
+// import { airbrake, airbrakeExpress } from './app-middlewares/airbrake';
+const port = process.env.PORT || 8082;
+const app = (0, express_1.default)();
+//configure application
+app.use(express_1.default.static(path_1.default.join(__dirname, "public")));
+//mount json form parser
+app.use(express_1.default.json());
+//mount query string parser
+app.use(express_1.default.urlencoded({ extended: true }));
+app.use((0, helmet_1.default)());
+app.use(logger_util_1.morgan);
+//cors error allow
+app.options("*", (0, cors_1.default)());
+app.use((0, cors_1.default)());
+// catch 404 and forward to error handler
+app.use(function (err, req, res, next) {
+    err.status = 404;
+    next(err);
+});
+//error handling
+app.use(errorHandler());
+(0, _config_1.dbConfig)();
+// app.use(airbrakeExpress.makeMiddleware(airbrake));
+(0, index_route_1.routes)(app);
+// app.use(airbrakeExpress.makeErrorHandler(airbrake));
+app.listen(port, () => {
+    console.log(`Server is running on port ${port}`);
+});