identity-admin 1.0.0

package/README.md

@@ -0,0 +1,127 @@
+# Identity Admin Dashboard
+[![Build Status](https://travis-ci.org/joemccann/dillinger.svg?branch=master)](https://travis-ci.org/joemccann/dillinger)
+
+## How to install
+```bash
+npm i identity-admin
+```
+## Features
+- Creating Dashboard with minimal Ui for mongoose models.
+- Provide DashboardController for custom routing and middlewares.
+- Provide multiple dashboard instances with diffrent routes.
+
+
+
+## Create new ```unAuthenticated``` Dashboard:
+- Create new instance from Dashboard.
+- Provide Resources array of 
+resources file.
+- Build the instance after mongoose setup by passing app instance to the build function.  
+```Typescript
+const dashboard: Dashboard = new Dashboard({ resources:[ <Resource: IResourceFile> ]);
+```
+```Typescript
+dashboard.build(app);
+```
+## To create new ```Authenticated``` Dashboard:
+- Create new instance from Dashboard.
+- Provide Resources array of 
+resources file.
+- Provide authenticate function which take AdminCredentials as parameter and return a promise of boolean or user data.
+- Provide cookiesConfiguration (cookie name and cookie secret).
+- Build the instance after mongoose setup by passing app instance to the build function.  
+
+```Typescript
+const dashboard = new Dashboard({
+        resources: [ UserResource ],
+        cookiesConfiguration: {
+            cookiesSecret: "cokieieSecret",
+            cookieName: "connect.sid"
+        },
+        authenticate: async (credentials: AdminCredentials) => {
+            const user = await Admin.findOne({ email: credentials.email });
+            if (user) {
+                const matched = await bcrypt.compare(credentials.password, user.encryptedPassword);
+                if (matched) {
+                    return user;
+                }
+            }
+            return false;
+        }
+    })
+```
+```Typescript
+dashboard.build(app);
+```
+## To create new ```CustomRoutes``` Dashboard:
+``` This method require to implement your own view and new react app ```
+- Create new controller class with invirsify-express-utils notaitions and extend ActionController.
+- Create new controller class with invirsify-express-utils notaitions and extend ResourceController.
+- Create new controller class with invirsify-express-utils notaitions and extend DashboardController.
+- Provide resource file and repository in super constructor.
+- ``` Following class will create new route /v1/contries ***Now you can pass any auth middlewares you want```
+
+```TypeScript
+@controller('/v1/actions', defaultHeaders)
+export default class ActionsController extends ActionController{
+  
+  constructor(
+      @inject(TYPES.IResources) private resources: IResourceFile[]) {
+      super(resources);
+  }
+}
+```
+
+```TypeScript
+@controller('/v1/resources', defaultHeaders)
+export default class ResourcesController extends ResourceController{
+  
+  constructor(
+      @inject(TYPES.IResources) private resources: IResourceFile[]) {
+      super(resources);
+  }
+}
+```
+
+```TypeScript
+@controller('/v1/contries', defaultHeaders)
+export default class CountryController extends DashboardController{
+  
+  constructor(
+      @inject(TYPES.ICountryRepository) private countryRepository: CountryRepository,
+      @inject(TYPES.ICountryResource) private countryResource: IResourceFile  ) {
+
+      super(CountryResource, countryRepository);
+  }
+}
+```
+
+## Documentaion:
+```Typescript
+    Dashboard(dashBoardConfig: DashboardConfig);
+    build(app: Application): void;
+```
+
+#### Dashboard:
+Dashboard constructor to create new instance from idntity-admin.
+  - dashBoardConfig:
+  ```js
+  {
+    resources: IResourceFile[]; // Array of resources files.
+    rootPath?: string; // optional root path default to  /dashboard
+    localesOptions?: i18n.ConfigurationOptions; // locales options for custom dashboard
+    cookiesConfiguration: CookieConfiguration; // cookies configuration in case of authenticated dashboard
+    authenticate?: AuthenticateMiddleWare; // authenticate function used to login the admin.
+  }
+  ```
+- IResourceFile 
+``` For resource file example check```
+[IResourceFile](src/types/IResourceFile.ts)
+
+- CookieConfiguration
+```js
+{
+  cookiesSecret: string; // cookie secret to handle sessions
+  cookieName: string; // cookie name as appeared in browser
+}
+```

package/lib/Dashboard.d.ts

@@ -0,0 +1,14 @@
+import { Application } from "express";
+import i18n from "i18n";
+import DashboardConfig from "./types/DashbordConfig";
+export default class Dashboard {
+    private dashBoardConfig;
+    private DEFAULT_ROOT_PATH;
+    constructor(dashBoardConfig: DashboardConfig);
+    build(app: Application): void;
+    private configureLocalization;
+    private buildRouter;
+    private configureAuthentication;
+    private configureSession;
+    static configurBaseLocalization(options: i18n.ConfigurationOptions): void;
+}

package/lib/Dashboard.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const DashboardController_1 = __importDefault(require("./controllers/DashboardController"));
+const router_1 = __importStar(require("./router"));
+const i18n_1 = __importDefault(require("i18n"));
+const ResourceController_1 = __importDefault(require("./controllers/ResourceController"));
+const path_1 = __importDefault(require("path"));
+const ActionController_1 = __importDefault(require("./controllers/ActionController"));
+var session = require('express-session');
+var cookieParser = require('cookie-parser');
+class Dashboard {
+    constructor(dashBoardConfig) {
+        this.dashBoardConfig = dashBoardConfig;
+        this.DEFAULT_ROOT_PATH = "/dashboard";
+    }
+    build(app) {
+        this.configureLocalization();
+        this.configureAuthentication(app);
+        this.buildRouter(app);
+    }
+    configureLocalization() {
+        var _a;
+        i18n_1.default.configure((_a = this.dashBoardConfig.localesOptions) !== null && _a !== void 0 ? _a : {
+            locales: ["en"],
+            directory: __dirname + '/locales',
+        });
+    }
+    buildRouter(app) {
+        var _a;
+        const dashboardController = new DashboardController_1.default(undefined, undefined, this.dashBoardConfig.resources);
+        const resourceController = new ResourceController_1.default(this.dashBoardConfig.resources);
+        const actionController = new ActionController_1.default(this.dashBoardConfig.resources);
+        const appPath = path_1.default.normalize(path_1.default.join(__dirname, '/view'));
+        const router = (0, router_1.default)(dashboardController, resourceController, actionController, this.dashBoardConfig.authenticate);
+        app.use(express_1.default.static(appPath));
+        (0, router_1.createViewRoute)(router, appPath);
+        app.use((_a = this.dashBoardConfig.rootPath) !== null && _a !== void 0 ? _a : this.DEFAULT_ROOT_PATH, router);
+    }
+    configureAuthentication(app) {
+        if (!this.dashBoardConfig.authenticate || !this.dashBoardConfig.cookiesConfiguration) {
+            return;
+        }
+        app.use(cookieParser());
+        this.configureSession(app, this.dashBoardConfig.cookiesConfiguration);
+    }
+    configureSession(app, cookiesConfiguration) {
+        var _a;
+        const rootPath = (_a = this.dashBoardConfig.rootPath) !== null && _a !== void 0 ? _a : this.DEFAULT_ROOT_PATH;
+        app.use(`${rootPath}`, session({
+            secret: cookiesConfiguration.cookiesSecret,
+            resave: false,
+            saveUninitialized: false,
+            name: cookiesConfiguration.cookieName,
+            cookie: { path: `${rootPath}`, httpOnly: true }
+        }));
+    }
+    static configurBaseLocalization(options) {
+        i18n_1.default.configure(options);
+    }
+}
+exports.default = Dashboard;

package/lib/container/helpers/HelperInversify.d.ts

@@ -0,0 +1,6 @@
+import { Container } from 'inversify';
+import { IResourceFile } from '../../types/IResourceFile';
+export default class HelperInversify {
+    static register(container: Container): void;
+    static registerResources(container: Container, resources: IResourceFile[]): void;
+}

package/lib/container/helpers/HelperInversify.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class HelperInversify {
+    static register(container) {
+        // container.bind<IResourceFile[]>(TYPES.Resources).toConstantValue([]);
+    }
+    static registerResources(container, resources) {
+    }
+}
+exports.default = HelperInversify;

package/lib/container/helpers/HelperTypes.d.ts

@@ -0,0 +1,5 @@
+declare const HelperTypes: {
+    Resources: symbol;
+    RootPath: symbol;
+};
+export default HelperTypes;

package/lib/container/helpers/HelperTypes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HelperTypes = {
+    Resources: Symbol.for("Resources"),
+    RootPath: Symbol.for("rootPath")
+};
+exports.default = HelperTypes;

package/lib/container/index.d.ts

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

package/lib/container/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// let weapons = new ContainerModule(
+//   (
+//       bind: interfaces.Bind,
+//       unbind: interfaces.Unbind,
+//       isBound: interfaces.IsBound,
+//       rebind: interfaces.Rebind
+//   ) => {
+//       bind<Katana>("Katana").to(Katana);
+//       bind<Shuriken>("Shuriken").to(Shuriken);
+//   }
+// );
+// export default container;

package/lib/container/repositories/RepositoryInversify.d.ts

@@ -0,0 +1,4 @@
+import { Container } from 'inversify';
+export default class RepositoryInversify {
+    static register(container: Container): void;
+}

package/lib/container/repositories/RepositoryInversify.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RequestLogRepository_1 = __importDefault(require("../../repositories/RequestLogRepository"));
+const types_1 = __importDefault(require("../types"));
+class RepositoryInversify {
+    static register(container) {
+        container.bind(types_1.default.IRequestLogRepository).to(RequestLogRepository_1.default);
+    }
+}
+exports.default = RepositoryInversify;

package/lib/container/repositories/RepositoryTypes.d.ts

@@ -0,0 +1,4 @@
+declare const RepositoryTypes: {
+    IRequestLogRepository: symbol;
+};
+export default RepositoryTypes;

package/lib/container/repositories/RepositoryTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RepositoryTypes = {
+    IRequestLogRepository: Symbol.for('IRequestLogRepository')
+};
+exports.default = RepositoryTypes;

package/lib/container/types.d.ts

@@ -0,0 +1,8 @@
+declare const TYPES: {
+    DashboardController: symbol;
+    ResourceController: symbol;
+    IRequestLogRepository: symbol;
+    Resources: symbol;
+    RootPath: symbol;
+};
+export default TYPES;

package/lib/container/types.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HelperTypes_1 = __importDefault(require("./helpers/HelperTypes"));
+const RepositoryTypes_1 = __importDefault(require("./repositories/RepositoryTypes"));
+const TYPES = Object.assign(Object.assign(Object.assign({}, HelperTypes_1.default), RepositoryTypes_1.default), { DashboardController: Symbol.for('dashboardController'), ResourceController: Symbol.for('resourceController') });
+exports.default = TYPES;

package/lib/controllers/ActionController.d.ts

@@ -0,0 +1,8 @@
+import { Response } from 'express';
+import { IRequest } from '../middlewares/isAuth';
+import { IResourceFile } from '../types/IResourceFile';
+export default class ActionController {
+    private resources;
+    constructor(resources: IResourceFile[]);
+    execute(req: IRequest, res: Response): Promise<void | Response<any, Record<string, any>>>;
+}

package/lib/controllers/ActionController.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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 inversify_express_utils_1 = require("inversify-express-utils");
+const ResponseUtils_1 = __importDefault(require("../utils/ResponseUtils"));
+const StringUtils_1 = __importDefault(require("../utils/StringUtils"));
+const Repository_1 = __importDefault(require("../repositories/Repository"));
+const ResourceUtils_1 = require("../utils/ResourceUtils");
+class ActionController {
+    constructor(resources) {
+        this.resources = resources;
+    }
+    execute(req, res) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = req.body.record;
+            const modelName = req.body.modelName;
+            const resource = (0, ResourceUtils_1.getResource)(modelName, this.resources);
+            if (!resource) {
+                return ResponseUtils_1.default.notFound(res, 'Resource not found', []);
+            }
+            const repository = new Repository_1.default(resource.properties.resource);
+            const actionKey = req.params.actionKey;
+            const currentUser = req.user;
+            var response = {};
+            const data = {
+                record,
+                currentUser,
+                resource: {
+                    name: modelName,
+                    path: StringUtils_1.default.lowerCaseFirstLetter(modelName),
+                    repository
+                }
+            };
+            const extraActions = (_b = (_a = resource.properties.actions) === null || _a === void 0 ? void 0 : _a.extras) !== null && _b !== void 0 ? _b : [];
+            for (var i = 0; i < extraActions.length; i++) {
+                const extraAction = extraActions[i];
+                if (extraAction.key === actionKey) {
+                    response = yield extraAction.handler(req, res, data);
+                    break;
+                }
+            }
+            return ResponseUtils_1.default.send(res, 200, 'Ok', {
+                response
+            });
+        });
+    }
+}
+__decorate([
+    (0, inversify_express_utils_1.httpPost)('/execute/:actionKey'),
+    __param(0, (0, inversify_express_utils_1.request)()),
+    __param(1, (0, inversify_express_utils_1.response)())
+], ActionController.prototype, "execute", null);
+exports.default = ActionController;

package/lib/controllers/DashboardController.d.ts

@@ -0,0 +1,36 @@
+import { Response } from 'express';
+import { Document } from 'mongoose';
+import { IResourceFile } from '../types/IResourceFile';
+import { IDashboardRepository } from '../repositories/Repository';
+import { IRequest } from '../middlewares/isAuth';
+export interface PaginateParams {
+    page: number;
+    perPage: number;
+}
+export default class DashboardController {
+    private resource?;
+    private repository?;
+    private resources?;
+    protected static DEFAULT_PAGE: number;
+    protected static DEFAULT_PER_PAGE: number;
+    constructor(resource?: IResourceFile, repository?: IDashboardRepository);
+    constructor(resource?: IResourceFile, repository?: IDashboardRepository, resources?: IResourceFile[]);
+    protected validateRequest(req: IRequest, res: Response): boolean;
+    protected paginateParams(request: IRequest): PaginateParams;
+    protected getSearchableSubStringFilter(resource: IResourceFile, filter: {
+        [key: string]: any;
+    }, subString: RegExp): {
+        [key: string]: any;
+    };
+    protected getScopeFilter(filter: {
+        [key: string]: any;
+    }, scope: string): {
+        [key: string]: any;
+    };
+    protected getVisibileExtrsActions(currentUser: Document, record: any, resource: any, repository: any, modelName: string): Promise<any[] | undefined>;
+    index(req: IRequest, res: Response): Promise<void | Response<any, Record<string, any>>>;
+    create(req: IRequest, res: Response): Promise<void>;
+    update(req: IRequest, res: Response): Promise<void | Response<any, Record<string, any>>>;
+    show(req: IRequest, res: Response): Promise<void | Response<any, Record<string, any>>>;
+    delete(req: IRequest, res: Response): Promise<void | Response<any, Record<string, any>>>;
+}