@vasrefil/api-toolkit 1.0.0 → 1.0.1

package/src/helpers/query.helper.ts

@@ -1,122 +0,0 @@
-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/status.interface.ts

@@ -1,13 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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 }