identity-admin 1.0.0

package/src/helpers/SchemaHelper.ts

@@ -0,0 +1,27 @@
+import { Schema } from 'mongoose';
+
+export default class SchemaHelper {
+
+    public static belongsTo(schema: Schema, modelName: string): void {
+
+        const fieldName = this.lowerFirstLetter(modelName);
+        const localFieldName = fieldName + 'Id';
+
+        schema.virtual(fieldName, {
+            ref: modelName,
+            localField: localFieldName,
+            foreignField: '_id',
+            justOne: true
+        });
+    }
+
+    private static lowerFirstLetter(value: string): string {
+
+        if(value.length == 0) {
+            return '';
+        }
+
+        return value.charAt(0).toLowerCase() + value.slice(1);
+    }
+    
+}

package/src/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/src/middlewares/isAuth.ts

@@ -0,0 +1,46 @@
+import ResponseUtils from "../utils/ResponseUtils";
+import { NextFunction, Router, 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 const defaultHeaders = function(req: IRequest, res: Response, next: NextFunction) {
+
+  req.language = req.headers['accept-language'] ? req.headers['accept-language'] as string : 'en';
+  req.timezone = req.headers.timezone ? req.headers.timezone as string : 'UTC';
+
+  next();
+};
+
+export const authenticate = async (req: IRequest, res: Response, next: NextFunction, authenticate: AuthenticateMiddleWare) => {
+  const adminCredentials = {
+    email: req.body.user.email,
+    password: req.body.user.password
+  }
+  const user = await authenticate(adminCredentials);
+  if(!user) {
+    return ResponseUtils.unauthorized(res);
+  }
+  req.user = user as Document;
+  next();
+}
+
+const isAuth = function(req: IRequest, res: Response, next: NextFunction)  {
+  const session: any = req.session;
+  if(!session.userName) {
+    return ResponseUtils.unauthorized(res);
+  }
+  next();
+}
+
+
+
+export default isAuth

package/src/models/ModelNames.ts

@@ -0,0 +1,6 @@
+export default class ModelNames {
+
+  public static User = 'IdentityUser';
+  public static RequestLog = 'RequestLog';
+
+}

package/src/models/request-log/IRequestLog.ts

@@ -0,0 +1,25 @@
+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/src/models/request-log/RequestLog.ts

@@ -0,0 +1,52 @@
+import SchemaHelper from '../../helpers/SchemaHelper';
+import { model, Schema } from 'mongoose';
+import ModelNames from '../ModelNames';
+
+import IRequestLogModel, { IRequestLogDocument } from './IRequestLog';
+
+// belongs_to User
+const RequestLogSchema: Schema = new Schema({
+    method: {
+        type: String
+    },
+    endpoint: {
+        type: String
+    },
+    url: {
+        type: String
+    },
+    startTime: {
+        type: Date
+    },
+    durationInMilliseconds: {
+        type: Number
+    },
+    userId: {
+        type: 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.belongsTo(RequestLogSchema, ModelNames.User);
+
+const RequestLog: IRequestLogModel = model<IRequestLogDocument, IRequestLogModel>(ModelNames.RequestLog, RequestLogSchema);
+
+export default RequestLog;

package/src/repositories/DashboardRepository.ts

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

package/src/repositories/Repository.ts

@@ -0,0 +1,269 @@
+import { injectable, unmanaged } from 'inversify';
+import { Aggregate, Document, Error, HydratedDocument, Model, Query } from 'mongoose';
+
+import SaveResult, { ISaveError } from './SaveResult';
+
+export interface PaginateParams {
+    page: number;
+    perPage: number;
+}
+
+interface IQueryOptions {
+    filter?: any;
+    sort?: any;
+    select?: any;
+    limit?: number;
+    skip?: number;
+    paginateParams?: PaginateParams;
+    populate?: any;
+}
+
+interface PageInfo {
+    currentPage: number;
+    pagesCount: number;
+    nextPage: number;
+    recordsCount: number;
+    perPage: number;
+}
+
+interface Page<T> {
+    records: T [];
+    pageInfo: PageInfo;
+}
+
+export interface IDashboardRepository{}
+
+export interface IRepository<T extends Document> {
+    findById(id: any): Promise<T | null>;
+
+    findOne(queryOptions?: IQueryOptions): Promise<T | null>;
+
+    findMany(queryOptions?: IQueryOptions): Promise<T[]>;
+
+    count(filterOptions: any): Promise<number>;
+
+    save(props: any): Promise<SaveResult<T>>;
+
+    saveAll(props: any []): Promise<any>
+
+    findByIdAndUpdate(id: any, props: any): Promise<T | null>;
+
+    findOneAndUpdate(filter: any, props: any, options?: any): Promise<T | null>;
+
+    remove(filterOptions: any): Promise<T | null>;
+
+    distinct(field: string, filterOptions: any): Promise<T[] | null>;
+
+    paginate(queryOptions: IQueryOptions): Promise<Page<T>>;
+
+    update(instance: T, props: any): Promise<SaveResult<T>>;
+
+    saveInstance(instance: T): Promise<SaveResult<T>>;
+}
+
+@injectable()
+export default class Repository<T extends Document> implements IRepository<T>,IDashboardRepository {
+
+    private static NO_NEXT_PAGE = -1;
+
+    public constructor(@unmanaged() protected model: Model<T>) {}
+
+    public async findById(id: any): Promise<T | null> {
+        return await this.model.findById(id);
+    }
+
+    public async findOne(queryOptions?: IQueryOptions): Promise<T | null> {
+        
+        const filter = queryOptions?.filter ? queryOptions.filter : {};
+        const populate = queryOptions?.populate;
+        return this.model.findOne(filter).populate(populate).exec() as Promise<T | null>;
+    }
+
+    public async findMany(queryOptions: IQueryOptions): Promise<T []> {
+
+        const filter = queryOptions.filter ? queryOptions.filter : {};
+        const sort = queryOptions.sort;
+        const select = queryOptions.select;
+        const limit = this.getLimit(queryOptions);
+        const skip = this.getSkip(queryOptions);
+        const populate = queryOptions.populate;
+
+        var query = this.model.find(filter);
+
+        if (select) {
+            query = query.select(select);
+        }
+        if (sort) {
+            query = query.sort(sort);
+        }
+        if (skip) {
+            query = query.skip(skip);
+        }
+        if (limit) {
+            query = query.limit(limit);
+        }
+        if (populate) {
+            query = query.populate(populate) as Query<HydratedDocument<T, {}, {}>[], HydratedDocument<T, {}, {}>, {}, T>;
+        }
+
+        return await query;
+    }
+
+    public async paginate(queryOptions: IQueryOptions): Promise<Page<T>> {
+
+        const filter = queryOptions.filter ? queryOptions.filter : {};
+
+        const limit = this.getLimit(queryOptions)!;
+        const skip = this.getSkip(queryOptions)!;
+
+        const pageInfoPromise = await this.createPageInfo(filter, skip, limit);
+        const recordsPromise = await this.findMany(queryOptions);
+
+        const [records, pageInfo] = await Promise.all([recordsPromise, pageInfoPromise]);
+
+        return {
+            records: records,
+            pageInfo
+        };
+    }
+
+    private getLimit(queryOptions: IQueryOptions): number | undefined {
+
+        if (queryOptions.paginateParams) {
+            return queryOptions.paginateParams.perPage;
+        }
+        return queryOptions.limit;
+    }
+
+    private getSkip(queryOptions: IQueryOptions): number | undefined {
+
+        if (queryOptions.paginateParams) {
+            return queryOptions.paginateParams.perPage * (queryOptions.paginateParams.page - 1);
+        }
+
+        return queryOptions.skip;
+    }
+
+    public toLimitSkip(paginateParams: PaginateParams): [number, number]{
+
+        return [paginateParams.perPage, paginateParams.perPage * (paginateParams.page - 1)];
+    }
+
+    protected async createPageInfo(filter: any, skip: number, limit: number): Promise<PageInfo> {
+
+        const count = await this.count(filter);
+
+        const currentPage = (skip / limit) + 1;
+        const pagesCount = Math.ceil(count / limit);
+        const nextPage = currentPage < pagesCount ? (currentPage + 1) : Repository.NO_NEXT_PAGE;
+
+        return {
+            currentPage,
+            pagesCount,
+            nextPage,
+            perPage: limit,
+            recordsCount: count
+        }
+    }
+
+    protected async createPageInfoFromAggregate(aggregate: Aggregate<any []>, skip: number, limit: number): Promise<PageInfo> {
+
+        const count = await this.countAggregate(aggregate);
+
+        const currentPage = (skip / limit) + 1;
+        const pagesCount = Math.ceil(count / limit);
+        const nextPage = currentPage < pagesCount ? (currentPage + 1) : Repository.NO_NEXT_PAGE;
+
+        return {
+            currentPage,
+            pagesCount,
+            nextPage,
+            perPage: limit,
+            recordsCount: count
+        }
+    }
+
+    public async count(filter: any): Promise<number> {
+        return this.model.countDocuments(filter);
+    }
+
+    public async countAggregate(aggregate: Aggregate<any []>): Promise<number> {
+
+        const queryResult = await aggregate.count('count');
+        if (queryResult.length == 0) {
+            return 0;
+        }
+
+        return queryResult[0].count;
+    }
+
+    public async update(instance: T, props: any): Promise<SaveResult<T>> {
+
+        const allProps = {
+            ...instance.toObject(),
+            ...props
+        };
+
+        return this.save(allProps);
+    }
+
+    public async save(props: any): Promise<SaveResult<T>> {
+
+        const instance = new this.model(props);
+        const hasId = !!props._id;
+        instance.isNew = !hasId;
+
+        return this.saveInstance(instance);
+    }
+
+    public async saveInstance(instance: T): Promise<SaveResult<T>> {
+        
+        var document: T | undefined;
+        var errors: ISaveError[] = [];
+
+        try {
+            
+            document = await instance.save();
+            return new SaveResult(document, errors);
+        } catch(e) {
+            
+            if (e instanceof Error.ValidationError) {
+
+                errors = Object.keys(e.errors).map((key) => {
+                    
+                    const saveError: any = (e as Error.ValidationError).errors[key];
+
+                    return {
+                        path: saveError.path,
+                        type: saveError.kind,
+                        message: saveError.message
+                    } as ISaveError
+                });
+            }
+        }
+
+        return new SaveResult(document, errors);
+    }
+
+    public async saveAll(props: any []): Promise<any> {
+        return this.model.insertMany(props);
+    }
+
+    public async findByIdAndUpdate(id: any, props: any): Promise<T | null> {
+        return await this.model.findByIdAndUpdate(id, props, {new: true, returnOriginal: false, returnDocument: 'after' });
+    }
+
+    public async findOneAndUpdate(filter: any, props: any): Promise<T | null> {
+        return await this.model.findOneAndUpdate(filter, props, {new: true, returnOriginal: false, returnDocument: 'after', setDefaultsOnInsert: true, upsert: true });
+    }
+
+    public async remove(filter: any): Promise<T | null> {
+        return await this.model.findOneAndRemove(filter);
+    }
+
+
+    public async distinct(field: string, filter: any): Promise<T[] | null> {
+        return await this.model.distinct(field, filter);
+    }
+
+}

package/src/repositories/RequestLogRepository.ts

@@ -0,0 +1,40 @@
+import { injectable } from 'inversify';
+import { IRequestLogDocument } from '../models/request-log/IRequestLog';
+import RequestLog from '../models/request-log/RequestLog';
+import Repository, { IRepository } from './Repository';
+
+
+export interface IRequestLogRepository extends IRepository<IRequestLogDocument> { 
+    deleteTillLastDays(days: number): Promise<void>;
+}
+
+@injectable()
+export default class RequestLogRepository extends Repository<IRequestLogDocument> {
+
+    constructor() {
+        super(RequestLog);
+    }
+
+    public async deleteTillLastDays(days: number): Promise<void> {
+        const day = 1000 * 60 * 60 * 24;
+        const currentTime = Date.now();
+        const time = new Date(currentTime - days * day)
+        await RequestLog.deleteMany({ createdAt: {$lt: time } });
+    }
+
+    public async getRequestLogsStats() {
+        
+        const stats = await RequestLog
+        .aggregate()
+        .match({})
+        .group({
+            _id: { endpoint: '$endpoint' },
+            count: { $sum: 1 },
+            average: {$avg: '$durationInMilliseconds'}
+        })
+        .sort({ count: -1 })
+
+        return stats;
+    }
+
+}

package/src/repositories/SaveResult.ts

@@ -0,0 +1,31 @@
+import { Document } from "mongoose";
+
+export default class SaveResult <T extends Document> {
+
+    private document: T | undefined;
+    private errors: ISaveError [];
+
+    constructor(document: T | undefined, errors: ISaveError []) {
+        this.document = document;
+        this.errors = errors;
+    }
+
+    public getDocument(): T | undefined {
+        return this.document;
+    }
+
+    public getErrors(): ISaveError [] {
+        return this.errors;
+    }
+
+    public isValid(): boolean {
+        return this.errors.length === 0;
+    }
+}
+
+export interface ISaveError {
+
+    type: string;
+    path: string;
+    message: string;
+}

package/src/router/index.ts

@@ -0,0 +1,91 @@
+import express, { NextFunction, Router, Request, Response } from "express";
+import DashboardController from "../controllers/DashboardController";
+import ResourceController from "../controllers/ResourceController";
+import path from "path";
+import i18n from "i18n";
+import ResponseUtils from "../utils/ResponseUtils";
+import { AuthenticateMiddleWare } from "../types/DashbordConfig";
+import isAuth, { authenticate, defaultHeaders, IRequest } from "../middlewares/isAuth";
+import ActionController from "../controllers/ActionController";
+
+const createMainRouter = (router: Router, controller: DashboardController) => {
+  router.use((req, res, next) => defaultHeaders(req as IRequest, res, next));
+
+  router
+    .route(`/api/:resource`)
+    .get((req: Request, res: Response) => controller.index(req as IRequest, res))
+    .post((req: Request, res: Response) => controller.create(req as IRequest, res));
+
+  router
+    .route("/api/:resource/:id")
+    .get((req: Request, res: Response) => controller.show(req as IRequest, res))
+    .patch((req: Request, res: Response) => controller.update(req as IRequest, res))
+    .delete((req: Request, res: Response) => controller.delete(req as IRequest, res));
+};
+
+const createResourceRouter = (
+  router: Router,
+  controller: ResourceController
+) => {
+  router
+  .route("/api/resources")
+  .get((req: Request, res: Response) => controller.index(req as IRequest, res));
+};
+
+const createActionsRouter = (router: Router, controller: ActionController) => {
+  router
+  .route("actions/:actionKey")
+  .post((req: Request, res: Response) => controller.execute(req as IRequest, res));
+};
+
+const createLoginRoute = (router: Router, verify: AuthenticateMiddleWare) => {
+  router
+    .route("/api/auth/login")
+    .all((req: Request, res, next) => authenticate(req as IRequest, res, next, verify))
+    .post(async (req, res) => {
+      const session: any = req.session;
+      session.userName = (req.user as any).email;
+
+      return ResponseUtils.ok(res, {
+        user: req.user,
+      });
+    });
+};
+
+const createRouter = (
+  dashboardController: DashboardController,
+  resourceController: ResourceController,
+  ActionController: ActionController,
+  authenticate?: AuthenticateMiddleWare
+): Router => {
+  const router = Router();
+
+
+
+  if (authenticate) {
+    createLoginRoute(router, authenticate);
+    router.route(`/api/:resource`).all((req: Request, res, next) => isAuth(req as IRequest, res, next));
+  }
+
+  createResourceRouter(router, resourceController);
+  createMainRouter(router, dashboardController);
+  createActionsRouter(router, ActionController);
+  
+  router.use(i18n.init);
+
+
+  return router;
+};
+
+export const createViewRoute = (router: Router, appPath: string) => {
+  router
+  .get(`(/*)?`,
+    async (req: Request, res: Response, next: NextFunction) => {
+      console.log(req.path);
+      console.log(appPath);
+      return res.sendFile(path.join(appPath, "index.html"));
+    }
+  );
+}
+
+export default createRouter;

package/src/types/DashbordConfig.ts

@@ -0,0 +1,24 @@
+import { Document } from "mongoose";
+import { IResourceFile } from "./IResourceFile";
+import i18n from "i18n";
+
+export type AuthenticateMiddleWare = (adminCredentials: AdminCredentials) => Promise<boolean| Document>;
+
+export interface AdminCredentials {
+  email: string;
+  password: string;
+}
+
+export interface CookieConfiguration {
+  cookiesSecret: string;
+  cookieName: string;
+}
+
+
+export default interface DashboardConfig {
+  resources: IResourceFile[];
+  rootPath?: string;
+  localesOptions?: i18n.ConfigurationOptions;
+  cookiesConfiguration?: CookieConfiguration;
+  authenticate?: AuthenticateMiddleWare;
+}