identity-admin 1.0.0 → 1.1.0

package/src/helpers/SchemaHelper.ts

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

@@ -1,11 +0,0 @@
-{
-  "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

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

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

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

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

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

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

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

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

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

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

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