identity-admin 1.0.0

package/lib/helpers/ResourceGenerator.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const StringUtils_1 = __importDefault(require("../utils/StringUtils"));
+const SchemaGenerator_1 = __importDefault(require("./SchemaGenerator"));
+const ResourceHelper_1 = __importDefault(require("./ResourceHelper"));
+const ActionsGenerator_1 = __importDefault(require("./ActionsGenerator"));
+const SetupParent = {
+    name: 'Setup',
+    icon: 'PermDataSetting'
+};
+class ResourceGenerator {
+    static generate(resource) {
+        const modelName = resource.properties.modelName;
+        const modifiedResource = JSON.parse(JSON.stringify(resource));
+        const schema = resource.properties.resource.schema.paths;
+        const title = ResourceHelper_1.default.getSchemaTitle(schema, resource);
+        const recordFields = ResourceHelper_1.default.manageFields(schema, title, resource.properties.hiddenProperties);
+        const modelCheck = resource.properties.model ? JSON.parse(JSON.stringify(resource.properties.model)) : undefined;
+        const actionsCheck = resource.properties.actions;
+        const modelAndPopulatedString = SchemaGenerator_1.default.generateSchema(schema, modelCheck, modelName, resource);
+        modifiedResource.properties.model = modelAndPopulatedString[0];
+        modifiedResource.properties.populatedString = modelAndPopulatedString[1];
+        const modifiedProperties = ResourceHelper_1.default.addVirtualFields(JSON.parse(JSON.stringify(recordFields)), modelCheck);
+        modifiedResource.properties.path = ResourceHelper_1.default.getModelPath(modelName);
+        const modifiedListProperties = modifiedProperties[0];
+        const modifiedShowProperties = modifiedProperties[1];
+        const modifiedFormProperties = modifiedProperties[2];
+        if (!resource.properties.parent) {
+            modifiedResource.properties.parent = SetupParent;
+        }
+        if (!resource.properties.name) {
+            modifiedResource.properties.name = StringUtils_1.default.convertCamelCaseToWord(modelName);
+        }
+        if (!resource.showProperties) {
+            modifiedResource.showProperties = modifiedShowProperties;
+        }
+        if (!resource.listProperties) {
+            modifiedResource.listProperties = ResourceHelper_1.default.exchangeFirstFieldWithTitle(JSON.parse(JSON.stringify(modifiedListProperties)), title);
+        }
+        if (!resource.formProperties) {
+            modifiedResource.formProperties = ResourceHelper_1.default.removeUnWantedFieldsFromCreateOrUpdate(JSON.parse(JSON.stringify(modifiedFormProperties)));
+        }
+        modifiedResource.properties.title = title;
+        if (!resource.properties.defaultOrderBy) {
+            modifiedResource.properties.defaultOrderBy = title;
+        }
+        if (!resource.properties.defaultOrder) {
+            modifiedResource.properties.defaultOrder = 'asc';
+        }
+        if (!resource.properties.defaultrowsPerPage) {
+            modifiedResource.properties.defaultrowsPerPage = 10;
+        }
+        modifiedResource.listProperties = ResourceHelper_1.default.prepareProperties(resource.listProperties ? resource.listProperties : modifiedResource.listProperties, modelName, modifiedResource.properties.model, resource);
+        modifiedResource.showProperties = ResourceHelper_1.default.prepareProperties(resource.showProperties ? resource.showProperties : modifiedResource.showProperties, modelName, modifiedResource.properties.model, resource);
+        modifiedResource.properties.filters = ResourceHelper_1.default.getFilters(resource.properties.filters ? JSON.parse(JSON.stringify(resource.properties.filters)) : undefined);
+        if (modifiedResource.properties.filters && modifiedResource.properties.filters.scopes && modifiedResource.properties.filters.scopes.isAccessible) {
+            const options = resource.properties.filters.scopes.options;
+            modifiedResource.properties.filters.scopes.options = ResourceHelper_1.default.setScopeFilterOptions(modelName, options);
+        }
+        const actions = ActionsGenerator_1.default.generateActions(actionsCheck, resource);
+        modifiedResource.properties.actions = actions;
+        return modifiedResource;
+    }
+}
+exports.default = ResourceGenerator;

package/lib/helpers/ResourceHelper.d.ts

@@ -0,0 +1,23 @@
+import { IResourceFile } from "../types/IResourceFile";
+import { IDashboardRepository } from "../repositories/Repository";
+export default class ResourcesHelper {
+    static getSchemaTitle(schema: any, resource: any): any;
+    static prepareProperties(properties: string[], modelName: string, model: any, resource: IResourceFile): {}[];
+    static getFieldType(schemaField: any): any;
+    static checkResourceTranslation(resource: IResourceFile, key: string): string | undefined;
+    static checkActionTranslation(resource: IResourceFile, action: string): string | undefined;
+    static setScopeFilterOptions(modelName: string, options: string[]): any;
+    static getFilters(filters: any): {
+        scopes: {};
+        searchBar: {};
+    };
+    static addExtraFields(showProperties: any, model: any, record: any, filterBy: string, repo: IDashboardRepository): Promise<any>;
+    static getTitle(schema: any): "title" | "name" | "_id" | "email";
+    static exchangeFirstFieldWithTitle(arrayOfFields: any, title: string): any;
+    static addVirtualFields(arrayOfFields: string[], model: any): any[];
+    static manageFields(schema: any, title: string, hiddenProperties: any): any[];
+    static checkUnwantedFields(fieldKey: string, title: string): boolean;
+    static getModelPath(modelName: string): any;
+    static removeUnWantedFieldsFromCreateOrUpdate(arrayOfFields: string[]): string[];
+    static checkCreateBeforeHandler(resource: any): boolean;
+}

package/lib/helpers/ResourceHelper.js

@@ -0,0 +1,274 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("../types/helpers");
+const StringUtils_1 = __importDefault(require("../utils/StringUtils"));
+const i18n_1 = require("i18n");
+var pluralize = require('pluralize');
+class ResourcesHelper {
+    static getSchemaTitle(schema, resource) {
+        if (resource.properties.title) {
+            return resource.properties.title;
+        }
+        return this.getTitle(schema);
+    }
+    static prepareProperties(properties, modelName, model, resource) {
+        var preparedProperties = [];
+        properties.forEach(key => {
+            if (model[key]) {
+                const refCheck = model[key].type === 'ref';
+                var path = undefined;
+                if (refCheck) {
+                    path = model[key].path;
+                }
+                const translation = this.checkResourceTranslation(resource, key);
+                const propertyObject = {
+                    key,
+                    value: translation ? translation : StringUtils_1.default.checkRefId(key) ? StringUtils_1.default.convertCamelCaseToWord(key.slice(0, -2)) : StringUtils_1.default.convertCamelCaseToWord(key),
+                    path: path
+                };
+                preparedProperties.push(propertyObject);
+            }
+        });
+        return preparedProperties;
+    }
+    static getFieldType(schemaField) {
+        if (schemaField.instance === 'password') {
+            return 'password';
+        }
+        if (schemaField.instance === 'Embedded') {
+            return 'nestedSchema';
+        }
+        if (schemaField.options.ref) {
+            return 'ref';
+        }
+        else if (schemaField.enumValues && schemaField.enumValues.length !== 0) {
+            return 'enum';
+        }
+        else {
+            return schemaField.instance;
+        }
+    }
+    static checkResourceTranslation(resource, key) {
+        var translation = undefined;
+        if (!resource.properties.keysTranslations || !resource.properties.keysTranslations[key]) {
+            return translation;
+        }
+        translation = (0, i18n_1.__)(resource.properties.keysTranslations[key]);
+        return translation;
+    }
+    static checkActionTranslation(resource, action) {
+        var translation = undefined;
+        if (!resource.properties.actionsTranslations || !resource.properties.actionsTranslations[action]) {
+            return translation;
+        }
+        translation = (0, i18n_1.__)(resource.properties.actionsTranslations[action]);
+        return translation;
+    }
+    static setScopeFilterOptions(modelName, options) {
+        var arrayOfOptions = [];
+        options.forEach((key) => {
+            const valueOfOption = StringUtils_1.default.lowerCaseFirstLetter(modelName) + '_filter_scope_' + key;
+            const optionObject = {
+                key,
+                value: (0, i18n_1.__)(valueOfOption)
+            };
+            arrayOfOptions.push(optionObject);
+        });
+        return arrayOfOptions;
+    }
+    static getFilters(filters) {
+        var filterObject = {
+            scopes: {},
+            searchBar: {}
+        };
+        if (!filters || Object.keys(filters).length === 0) {
+            filterObject = {
+                scopes: {
+                    isAccessible: false
+                },
+                searchBar: {
+                    isAccessible: true
+                }
+            };
+            return filterObject;
+        }
+        if (!filters.searchBar || !filters.searchBar.hasOwnProperty('isAccessible')) {
+            filterObject.searchBar = {
+                isAccessible: true
+            };
+        }
+        else {
+            filterObject.searchBar = filters.searchBar;
+        }
+        if (!filters.scopes || !filters.scopes.hasOwnProperty('isAccessible')) {
+            filterObject.scopes = {
+                isAccessible: false
+            };
+        }
+        else {
+            filterObject.scopes = filters.scopes;
+        }
+        return filterObject;
+    }
+    static addExtraFields(showProperties, model, record, filterBy, repo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (var i = 0; i < showProperties.length; i++) {
+                // if (!model.hasOwnProperty(showProperties[i].key)) {
+                //     const modelName = pluralize.singular(showProperties[i].key)
+                //     const repository: any = this.getResourceSymbol(modelName)
+                //     filterBy = filterBy + "Id"
+                //     const filterQuery:  {[key:string]: any} = {}
+                //     filterQuery[filterBy] = record._id
+                //     const extraRecords = await repository.findMany({
+                //         filter: filterQuery
+                //     });
+                //     record[showProperties[i].key] = extraRecords
+                // }
+                const key = showProperties[i].key;
+                if ((model[key].type === 'ref' && model.virtuals && model.virtuals[key]) || (model[key].type === 'Array' && model.virtuals && model.virtuals[key] && model[key].arrayType === 'ref')) {
+                    const modelName = pluralize.singular(showProperties[i].key);
+                    const repository = repo;
+                    filterBy = filterBy + "Id";
+                    const filterQuery = {};
+                    filterQuery[filterBy] = record._id;
+                    const extraRecords = yield repository.findMany({
+                        filter: filterQuery
+                    });
+                    record[showProperties[i].key] = extraRecords;
+                }
+            }
+            ;
+            return record;
+        });
+    }
+    // public static getResourceRepository(resourceName: string) {
+    //     const resource = StringUtils.upperCaseFirstLetter(resourceName);
+    //     const repositorySymbol = Symbol.for(`I${resource}Repository`)
+    //     const repository = container.get(repositorySymbol)
+    //     return repository;
+    // }
+    static getTitle(schema) {
+        if (schema['title']) {
+            return 'title';
+        }
+        if (schema['name']) {
+            return 'name';
+        }
+        if (schema['email']) {
+            return 'email';
+        }
+        return '_id';
+    }
+    static exchangeFirstFieldWithTitle(arrayOfFields, title) {
+        if (arrayOfFields[0] !== title) {
+            for (var i = 1; i < arrayOfFields.length; i++) {
+                const field = arrayOfFields[i];
+                if (field === title) {
+                    const temp = arrayOfFields[0];
+                    arrayOfFields[0] = title;
+                    arrayOfFields[i] = temp;
+                    break;
+                }
+            }
+        }
+        return arrayOfFields;
+    }
+    static addVirtualFields(arrayOfFields, model) {
+        var showProperties = JSON.parse(JSON.stringify(arrayOfFields));
+        var listProperties = JSON.parse(JSON.stringify(arrayOfFields));
+        var formProperties = JSON.parse(JSON.stringify(arrayOfFields));
+        if (!model || !model.virtuals || !(Object.keys(model.virtuals))) {
+            return [listProperties, showProperties, formProperties];
+        }
+        const virtualFields = model.virtuals;
+        for (const extraField in virtualFields) {
+            if (virtualFields[extraField].showIn) {
+                switch (virtualFields[extraField].showIn) {
+                    case helpers_1.Virtuals.SHOW:
+                        showProperties.push(extraField);
+                        break;
+                    case helpers_1.Virtuals.LIST:
+                        listProperties.push(extraField);
+                        break;
+                    case helpers_1.Virtuals.FORM:
+                        formProperties.push(extraField);
+                        break;
+                }
+            }
+            else {
+                showProperties.push(extraField);
+                listProperties.push(extraField);
+                formProperties.push(extraField);
+            }
+        }
+        return [listProperties, showProperties, formProperties];
+    }
+    static manageFields(schema, title, hiddenProperties) {
+        var arrayOfFields = [];
+        if (!hiddenProperties || !hiddenProperties.includes('_id')) {
+            arrayOfFields.push('_id');
+        }
+        if (title !== '_id' && (!hiddenProperties || !hiddenProperties.includes(title))) {
+            arrayOfFields.push(title);
+        }
+        const fields = Object.keys(schema);
+        for (var i = 0; i < fields.length; i++) {
+            const fieldKey = fields[i];
+            if (hiddenProperties && hiddenProperties.includes(fieldKey)) {
+                continue;
+            }
+            const unwantedField = this.checkUnwantedFields(fieldKey, title);
+            if (unwantedField) {
+                continue;
+            }
+            arrayOfFields.push(fieldKey);
+        }
+        return arrayOfFields;
+    }
+    static checkUnwantedFields(fieldKey, title) {
+        if (fieldKey === '__v' || fieldKey === '_id' || fieldKey === title || fieldKey === 'salt' || fieldKey === 'hash' || fieldKey === 'forgotPasswordToken') {
+            return true;
+        }
+        return false;
+    }
+    static getModelPath(modelName) {
+        const modelPath = pluralize(StringUtils_1.default.lowerCaseFirstLetter(modelName));
+        return modelPath;
+    }
+    static removeUnWantedFieldsFromCreateOrUpdate(arrayOfFields) {
+        var modifiedArrayOfFields = [];
+        arrayOfFields.forEach(field => {
+            if (field !== '_id' && field !== 'createdAt' && field !== 'updatedAt') {
+                modifiedArrayOfFields.push(field);
+            }
+        });
+        return modifiedArrayOfFields;
+    }
+    // public static checkIndexBeforeHandler(resource: any) {
+    //     const crudOperations = resource.properties.crudOperations
+    //     if (crudOperations && crudOperations.index && crudOperations.index.before) {
+    //         return true
+    //     }
+    //     return false
+    // }
+    static checkCreateBeforeHandler(resource) {
+        const crudOperations = resource.properties.crudOperations;
+        if (crudOperations && crudOperations.create && crudOperations.create.before) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.default = ResourcesHelper;

package/lib/helpers/SchemaGenerator.d.ts

@@ -0,0 +1,5 @@
+import { IResourceFile } from "../types/IResourceFile";
+export default class SchemaGenerator {
+    static generateSchema(schema: any, model: any, modelName: string, resource: IResourceFile): any[];
+    private static setNestedSchema;
+}

package/lib/helpers/SchemaGenerator.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const StringUtils_1 = __importDefault(require("../utils/StringUtils"));
+const ResourceHelper_1 = __importDefault(require("./ResourceHelper"));
+var pluralize = require('pluralize');
+class SchemaGenerator {
+    static generateSchema(schema, model, modelName, resource) {
+        const schemaFields = Object.keys(schema);
+        var populatedString = '';
+        if (!model) {
+            model = {};
+        }
+        schemaFields.forEach(field => {
+            const schemaField = schema[field];
+            const refCheck = schemaField.options.ref;
+            const translation = ResourceHelper_1.default.checkResourceTranslation(resource, field);
+            const fieldType = ResourceHelper_1.default.getFieldType(schemaField);
+            model[field] = model[field] ? model[field] : {};
+            if (fieldType === 'ref') {
+                populatedString = StringUtils_1.default.getPopulatedString(populatedString, field);
+                model[field].path = StringUtils_1.default.lowerCaseFirstLetter(refCheck);
+            }
+            if (fieldType === 'nestedSchema') {
+                const modelAndPopulatedString = this.setNestedSchema(schema[field].schema.paths, modelName, model, field, populatedString, resource);
+                model = modelAndPopulatedString[0];
+                populatedString = modelAndPopulatedString[1];
+            }
+            else if (fieldType === 'Array') {
+                model[field].required = schema[field].caster.isRequired;
+                if (schema[field].schema) {
+                    const modelAndPopulatedString = this.setNestedSchema(schema[field].schema.paths, modelName, model, field, populatedString, resource);
+                    model = modelAndPopulatedString[0];
+                    populatedString = modelAndPopulatedString[1];
+                    model[field].arrayType = 'nestedSchema';
+                }
+                else if (schema[field].caster.options.ref) {
+                    populatedString = StringUtils_1.default.getPopulatedString(populatedString, field);
+                    model[field].path = StringUtils_1.default.lowerCaseFirstLetter(schema[field].caster.options.ref);
+                    model[field].apiRoute = 'admin/' + StringUtils_1.default.lowerCaseFirstLetter(pluralize(schema[field].caster.options.ref));
+                    model[field].arrayType = 'ref';
+                }
+                else {
+                    model[field].arrayType = schema[field].caster.instance;
+                }
+            }
+            model[field].type = model[field].type ? model[field].type : fieldType;
+            model[field].defaultValue = schema[field].defaultValue ? schema[field].defaultValue : undefined;
+            model[field].required = model[field].required ? model[field].required : schemaField.isRequired ? schemaField.isRequired : false;
+            model[field].apiRoute = model[field].apiRoute ? model[field].apiRoute : schemaField.options.ref ? 'admin/' + StringUtils_1.default.lowerCaseFirstLetter(pluralize(schemaField.options.ref)) : undefined;
+            model[field].enumValues = model[field].type === 'enum' ? schemaField.enumValues : undefined;
+            model[field].value = model[field].value ? model[field].value : translation ? translation : refCheck ? StringUtils_1.default.checkRefId(field) ? StringUtils_1.default.convertCamelCaseToWord(field.slice(0, -2)) : StringUtils_1.default.convertCamelCaseToWord(field) : StringUtils_1.default.convertCamelCaseToWord(field);
+        });
+        if (model.virtuals) {
+            for (const extraField in model.virtuals) {
+                model[extraField] = model[extraField] ? model[extraField] : {};
+                model[extraField].type = model.virtuals[extraField].type;
+                model[extraField].arrayType = model.virtuals[extraField].arrayType ? model.virtuals[extraField].arrayType : undefined;
+                model[extraField].required = model.virtuals[extraField].required;
+                model[extraField].value = ResourceHelper_1.default.checkResourceTranslation(resource, extraField) ? ResourceHelper_1.default.checkResourceTranslation(resource, extraField) : StringUtils_1.default.convertCamelCaseToWord(extraField);
+                model[extraField].path = StringUtils_1.default.getRefPath(extraField);
+            }
+        }
+        return [model, populatedString];
+    }
+    static setNestedSchema(paths, modelName, model, field, populatedString, resource) {
+        var nestedSchema = {};
+        var nestedSchemaKeys = [];
+        const nestedModelodelAndPopulatedString = this.generateSchema(paths, nestedSchema, modelName, resource);
+        model[field].schema = nestedModelodelAndPopulatedString[0];
+        model[field].populatedString = nestedModelodelAndPopulatedString[1];
+        const populatedStringArray = nestedModelodelAndPopulatedString[1].split(' ');
+        populatedStringArray.forEach((nestedSchemaPopulatedString) => {
+            if (nestedSchemaPopulatedString) {
+                populatedString = StringUtils_1.default.getPopulatedString(populatedString, field + '.' + nestedSchemaPopulatedString);
+            }
+        });
+        for (const key in model[field].schema) {
+            nestedSchemaKeys.push(key);
+        }
+        model[field].keys = nestedSchemaKeys;
+        return [model, populatedString];
+    }
+}
+exports.default = SchemaGenerator;

package/lib/helpers/SchemaHelper.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from 'mongoose';
+export default class SchemaHelper {
+    static belongsTo(schema: Schema, modelName: string): void;
+    private static lowerFirstLetter;
+}

package/lib/helpers/SchemaHelper.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SchemaHelper {
+    static belongsTo(schema, modelName) {
+        const fieldName = this.lowerFirstLetter(modelName);
+        const localFieldName = fieldName + 'Id';
+        schema.virtual(fieldName, {
+            ref: modelName,
+            localField: localFieldName,
+            foreignField: '_id',
+            justOne: true
+        });
+    }
+    static lowerFirstLetter(value) {
+        if (value.length == 0) {
+            return '';
+        }
+        return value.charAt(0).toLowerCase() + value.slice(1);
+    }
+}
+exports.default = SchemaHelper;

package/lib/locales/en.json

@@ -0,0 +1,11 @@
+{
+	"actions_new": "Create New",
+	"actions_edit": "Edit",
+	"actions_delete": "Delete",
+	"actions_delete_confirmMessage_title": "Do you really want to delete this record?",
+	"actions_delete_confirmMessage_body": "If you clicked yes, this record will be permanently deleted.",
+	"actions_bulkDelete_confirmMessage_title": "Do you really want to delete these records?",
+	"actions_bulkDelete_confirmMessage_body": "If you clicked yes, these records will be permanently deleted.",
+	"actions_delete_options_yes": "Delete",
+	"actions_delete_options_no": "No"
+}

package/lib/middlewares/isAuth.d.ts

@@ -0,0 +1,13 @@
+import { NextFunction, Request, Response } from "express";
+import { AuthenticateMiddleWare } from "../types/DashbordConfig";
+import { Document } from "mongoose";
+export interface IRequest extends Request {
+    user: Document;
+    language: string;
+    timezone: string;
+    startTime: Date;
+}
+export declare const defaultHeaders: (req: IRequest, res: Response, next: NextFunction) => void;
+export declare const authenticate: (req: IRequest, res: Response, next: NextFunction, authenticate: AuthenticateMiddleWare) => Promise<void>;
+declare const isAuth: (req: IRequest, res: Response, next: NextFunction) => void;
+export default isAuth;

package/lib/middlewares/isAuth.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticate = exports.defaultHeaders = void 0;
+const ResponseUtils_1 = __importDefault(require("../utils/ResponseUtils"));
+const defaultHeaders = function (req, res, next) {
+    req.language = req.headers['accept-language'] ? req.headers['accept-language'] : 'en';
+    req.timezone = req.headers.timezone ? req.headers.timezone : 'UTC';
+    next();
+};
+exports.defaultHeaders = defaultHeaders;
+const authenticate = (req, res, next, authenticate) => __awaiter(void 0, void 0, void 0, function* () {
+    const adminCredentials = {
+        email: req.body.user.email,
+        password: req.body.user.password
+    };
+    const user = yield authenticate(adminCredentials);
+    if (!user) {
+        return ResponseUtils_1.default.unauthorized(res);
+    }
+    req.user = user;
+    next();
+});
+exports.authenticate = authenticate;
+const isAuth = function (req, res, next) {
+    const session = req.session;
+    if (!session.userName) {
+        return ResponseUtils_1.default.unauthorized(res);
+    }
+    next();
+};
+exports.default = isAuth;

package/lib/models/ModelNames.d.ts

@@ -0,0 +1,4 @@
+export default class ModelNames {
+    static User: string;
+    static RequestLog: string;
+}

package/lib/models/ModelNames.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ModelNames {
+}
+exports.default = ModelNames;
+ModelNames.User = 'IdentityUser';
+ModelNames.RequestLog = 'RequestLog';

package/lib/models/request-log/IRequestLog.d.ts

@@ -0,0 +1,22 @@
+import { Document, Model, Types } from 'mongoose';
+export interface IRequestLogProps {
+    _id?: Types.ObjectId;
+    method: string;
+    endpoint: string;
+    url: string;
+    startTime: Date;
+    durationInMilliseconds: number;
+    query: string;
+    body: string;
+    userAgent?: string;
+    headers?: string;
+    status?: number;
+    message?: string;
+}
+export interface IRequestLogDocument extends IRequestLogProps, Document {
+    _id: Types.ObjectId;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export default interface IRequestLogModel extends Model<IRequestLogDocument> {
+}

package/lib/models/request-log/IRequestLog.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/request-log/RequestLog.d.ts

@@ -0,0 +1,3 @@
+import IRequestLogModel from './IRequestLog';
+declare const RequestLog: IRequestLogModel;
+export default RequestLog;

package/lib/models/request-log/RequestLog.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SchemaHelper_1 = __importDefault(require("../../helpers/SchemaHelper"));
+const mongoose_1 = require("mongoose");
+const ModelNames_1 = __importDefault(require("../ModelNames"));
+// belongs_to User
+const RequestLogSchema = new mongoose_1.Schema({
+    method: {
+        type: String
+    },
+    endpoint: {
+        type: String
+    },
+    url: {
+        type: String
+    },
+    startTime: {
+        type: Date
+    },
+    durationInMilliseconds: {
+        type: Number
+    },
+    userId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        default: null
+    },
+    query: {
+        type: String
+    },
+    body: {
+        type: String
+    },
+    userAgent: {
+        type: String
+    },
+    headers: {
+        type: String
+    },
+    message: {
+        type: String
+    },
+    status: {
+        type: Number
+    }
+}, { timestamps: true });
+SchemaHelper_1.default.belongsTo(RequestLogSchema, ModelNames_1.default.User);
+const RequestLog = (0, mongoose_1.model)(ModelNames_1.default.RequestLog, RequestLogSchema);
+exports.default = RequestLog;

package/lib/repositories/DashboardRepository.d.ts

@@ -0,0 +1,5 @@
+import Repository from "./Repository";
+import { Document, Model } from "mongoose";
+export default class DashboardRepository extends Repository<Document> {
+    constructor(model: Model<Document, Model<Document>>);
+}