@hapiboo/module-auth 1.0.0

package/dist/service/authorization.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorizationService = void 0;
+const uuid_1 = require("uuid");
+const core_1 = require("@hapiboo/core");
+const date_1 = require("@hapiboo/date");
+const models_1 = require("../models");
+const repository_1 = require("./repository");
+const settings_1 = require("./settings");
+var authorizationValidator;
+(function (authorizationValidator) {
+    let cache;
+    (function (cache) {
+        const cacheLoading = new Map();
+        const userPermissionCache = new Map();
+        //const userRoleCache: Map<string, Map<string, string[]>> = new Map<string, Map<string, string[]>>();
+        function checkUserPermission(user_id, permission_id) {
+            if (userPermissionCache.has(user_id)) {
+                const permissions = userPermissionCache.get(user_id);
+                if (settings_1.authSettings.overrulingPermission !== undefined) {
+                    return permissions.includes(permission_id) || permissions.includes(settings_1.authSettings.overrulingPermission);
+                }
+                else {
+                    return permissions.includes(permission_id);
+                }
+            }
+            else {
+                if (cacheLoading.has(user_id)) {
+                    const loadStart = cacheLoading.get(user_id);
+                    return date_1.DateObject.now().getMilisecondsDifference(loadStart);
+                }
+                else {
+                    cacheLoading.set(user_id, date_1.DateObject.now());
+                    authorizationService.access.getForUser(user_id)
+                        .then((userPermissions) => {
+                        fillUserPermissions(user_id, userPermissions);
+                    })
+                        .catch((error) => {
+                        console.error(`Error fetching user permissions for user ${user_id}:`, error);
+                        cacheLoading.delete(user_id);
+                    });
+                    return 0;
+                }
+            }
+        }
+        cache.checkUserPermission = checkUserPermission;
+        function fillUserPermissions(user_id, permissions) {
+            userPermissionCache.set(user_id, permissions.map((item) => { return item.permission_id; }));
+            cacheLoading.delete(user_id);
+        }
+        cache.fillUserPermissions = fillUserPermissions;
+    })(cache = authorizationValidator.cache || (authorizationValidator.cache = {}));
+})(authorizationValidator || (authorizationValidator = {}));
+var helper;
+(function (helper) {
+    let userAccess;
+    (function (userAccess) {
+        function assignPermission(account_id, user_id, role_id, permission_id) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                const model = new models_1.UserAccess().createFromRole((0, uuid_1.v4)(), account_id, user_id, role_id, permission_id);
+                core_1.promise.resolve(repository_1.repository.userAccess.create(model), resolve, reject);
+            });
+        }
+        userAccess.assignPermission = assignPermission;
+        function assignPermissions(account_id, user_id, role_id, permission_ids, created) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                if (permission_ids.length === 0) {
+                    resolve(created);
+                }
+                else {
+                    core_1.promise.check(assignPermission(account_id, user_id, role_id, permission_ids.pop()), reject)
+                        .then((data) => {
+                        created.push(data);
+                        core_1.promise.resolve(assignPermissions(account_id, user_id, role_id, permission_ids, created), resolve, reject);
+                    });
+                }
+            });
+        }
+        userAccess.assignPermissions = assignPermissions;
+    })(userAccess = helper.userAccess || (helper.userAccess = {}));
+})(helper || (helper = {}));
+var authorizationService;
+(function (authorizationService) {
+    let permission;
+    (function (permission_1) {
+        function create(name) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                const model = new models_1.Permission().create((0, uuid_1.v4)(), name);
+                core_1.promise.resolve(repository_1.repository.permission.create(model), resolve, reject);
+            });
+        }
+        permission_1.create = create;
+        function edit(id, name) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.check(repository_1.repository.permission.getById(id), reject)
+                    .then((permission) => {
+                    permission.name = name;
+                    core_1.promise.resolve(repository_1.repository.permission.update(permission), resolve, reject);
+                });
+            });
+        }
+        permission_1.edit = edit;
+        function all() {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.resolve(repository_1.repository.permission.filter(undefined), resolve, reject);
+            });
+        }
+        permission_1.all = all;
+    })(permission = authorizationService.permission || (authorizationService.permission = {}));
+    let role;
+    (function (role_1) {
+        function create(name, description, lucide_icon, permissions) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                const model = new models_1.Role().create((0, uuid_1.v4)(), name, description, lucide_icon, permissions);
+                core_1.promise.resolve(repository_1.repository.role.create(model), resolve, reject);
+            });
+        }
+        role_1.create = create;
+        function edit(id, name, description, lucide_icon, permissions) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.check(repository_1.repository.role.getById(id), reject)
+                    .then((role) => {
+                    core_1.promise.resolve(repository_1.repository.role.update(role.edit(name, description, lucide_icon, permissions)), resolve, reject);
+                });
+            });
+        }
+        role_1.edit = edit;
+        function all() {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.resolve(repository_1.repository.role.filter(undefined), resolve, reject);
+            });
+        }
+        role_1.all = all;
+    })(role = authorizationService.role || (authorizationService.role = {}));
+    let access;
+    (function (access) {
+        let byRole;
+        (function (byRole) {
+            function assign(account_id, user_id, role_id) {
+                return core_1.promise.createDelayedPromise((resolve, reject) => {
+                    core_1.promise.check(repository_1.repository.role.getById(role_id), reject)
+                        .then((data) => {
+                        core_1.promise.resolve(helper.userAccess.assignPermissions(account_id, user_id, role_id, [...data.permissions], []), resolve, reject);
+                    });
+                });
+            }
+            byRole.assign = assign;
+            function assignList(account_id, user_id, role_ids) {
+                return core_1.promise.createDelayedPromise((resolve, reject) => {
+                    core_1.promise.check(repository_1.repository.userAccess.getForUserByRoles(user_id), reject)
+                        .then((data) => {
+                        core_1.promise.checkVoid(core_1.promise.all(data.map((item) => { return repository_1.repository.userAccess.remove(item.id); })), reject)
+                            .then(() => {
+                            core_1.promise.checkVoid(core_1.promise.all(role_ids.map((role_id) => { return assign(account_id, user_id, role_id); })), reject)
+                                .then(() => {
+                                core_1.promise.resolve(getForUser(user_id), resolve, reject);
+                            });
+                        });
+                    });
+                });
+            }
+            byRole.assignList = assignList;
+            function remove(account_id, user_id) {
+                return assignList(account_id, user_id, []);
+            }
+            byRole.remove = remove;
+        })(byRole = access.byRole || (access.byRole = {}));
+        let byPermission;
+        (function (byPermission) {
+            function assign(_user_id, _permission_id) { }
+            byPermission.assign = assign;
+            function assignList(_user_id, _permission_id) { }
+            byPermission.assignList = assignList;
+            function remove(_account_id, _user_id) {
+                return core_1.promise.createDelayedVoidPromise((resolve, _reject) => {
+                    resolve();
+                });
+            }
+            byPermission.remove = remove;
+        })(byPermission = access.byPermission || (access.byPermission = {}));
+        function removeAllForUser(user_id) {
+            return core_1.promise.createDelayedVoidPromise((resolve, reject) => {
+                core_1.promise.check(repository_1.repository.userAccess.getForUser(user_id), reject)
+                    .then((data) => {
+                    core_1.promise.resolveVoid(core_1.promise.all(data.map((item) => { return repository_1.repository.userAccess.remove(item.id); })), resolve, reject);
+                });
+            });
+        }
+        access.removeAllForUser = removeAllForUser;
+        function getForAccount(account_id) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.resolve(repository_1.repository.userAccess.getForAccount(account_id), resolve, reject);
+            });
+        }
+        access.getForAccount = getForAccount;
+        function getForUser(user_id) {
+            return core_1.promise.createDelayedPromise((resolve, reject) => {
+                core_1.promise.resolve(repository_1.repository.userAccess.getForUser(user_id), resolve, reject);
+            });
+        }
+        access.getForUser = getForUser;
+        function split(user_access) {
+            const roles = user_access.filter((item) => { return item.role_id !== undefined; });
+            const unique = [...new Map(roles.map(item => [item.role_id, item])).values()];
+            const permissions = user_access.filter((item) => { return item.role_id === undefined; });
+            return { roles: unique, permissions };
+        }
+        access.split = split;
+    })(access = authorizationService.access || (authorizationService.access = {}));
+    let middleware;
+    (function (middleware) {
+        function check(user_id, permission_id, response, next) {
+            const hasPermission = authorizationValidator.cache.checkUserPermission(user_id, permission_id);
+            if (hasPermission === true) {
+                next();
+            }
+            else if (hasPermission === false) {
+                response.status(403);
+                response.json({ error: 'unauthorized' });
+            }
+            else {
+                if (typeof hasPermission === 'number' && hasPermission < 1000) {
+                    setTimeout(() => {
+                        check(user_id, permission_id, response, next);
+                    }, 100);
+                }
+                else {
+                    response.status(403);
+                    response.json({ error: 'permission data loading, try again later' });
+                }
+            }
+        }
+        function permission(permission_id) {
+            return function (request, response, next) {
+                const user_id = request.payload?.user_id;
+                if (user_id !== undefined) {
+                    check(user_id, permission_id, response, next);
+                }
+                else {
+                    response.status(403);
+                    response.json({ error: 'unauthorized' });
+                }
+            };
+        }
+        middleware.permission = permission;
+    })(middleware = authorizationService.middleware || (authorizationService.middleware = {}));
+})(authorizationService || (exports.authorizationService = authorizationService = {}));

package/dist/service/repository.d.ts

@@ -0,0 +1,44 @@
+import { IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+import { Credential, User, Permission, Role, UserAccess, CredentialType, UserType } from '../models';
+export declare namespace repository {
+    namespace permission {
+        function create(source: Permission): IResponsePromise<Permission>;
+        function update(source: Permission): IResponsePromise<Permission>;
+        function remove(id: string): IResponsePromiseVoid;
+        function getById(id: string): IResponsePromise<Permission>;
+        function filter(id: string | undefined): IResponsePromise<Permission[]>;
+    }
+    namespace role {
+        function create(source: Role): IResponsePromise<Role>;
+        function update(source: Role): IResponsePromise<Role>;
+        function remove(id: string): IResponsePromiseVoid;
+        function getById(id: string): IResponsePromise<Role>;
+        function filter(id: string | undefined): IResponsePromise<Role[]>;
+    }
+    namespace userAccess {
+        function create(source: UserAccess): IResponsePromise<UserAccess>;
+        function update(source: UserAccess): IResponsePromise<UserAccess>;
+        function remove(id: string): IResponsePromiseVoid;
+        function getById(id: string): IResponsePromise<UserAccess>;
+        function getForUser(user_id: string): IResponsePromise<UserAccess[]>;
+        function getForUserByRoles(user_id: string): IResponsePromise<UserAccess[]>;
+        function getForUserDirectly(user_id: string): IResponsePromise<UserAccess[]>;
+        function getForUserAndPermission(user_id: string, permission_id: string): IResponsePromise<UserAccess[]>;
+        function getForAccount(account_id: string): IResponsePromise<UserAccess[]>;
+    }
+    namespace user {
+        function create(source: User): IResponsePromise<User>;
+        function update(source: User): IResponsePromise<User>;
+        function remove(id: string): IResponsePromiseVoid;
+        function getById(id: string): IResponsePromise<User>;
+        function count(): IResponsePromise<number>;
+        function filter(id: string | undefined, type: UserType | undefined, account_id: string | undefined): IResponsePromise<User[]>;
+    }
+    namespace credential {
+        function create(source: Credential): IResponsePromise<Credential>;
+        function update(source: Credential): IResponsePromise<Credential>;
+        function remove(id: string): IResponsePromiseVoid;
+        function getById(id: string): IResponsePromise<Credential>;
+        function filter(name: string | undefined, user_id: string | undefined, confirmationCode: string | undefined, recoveryCode: string | undefined, inviteCode: string | undefined, credential_type: CredentialType | undefined): IResponsePromise<Credential[]>;
+    }
+}

package/dist/service/repository.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repository = void 0;
+const flux_1 = require("@hapiboo/flux");
+const models_1 = require("../models");
+const naming_1 = require("../models/naming");
+var repository;
+(function (repository) {
+    let permission;
+    (function (permission) {
+        function create(source) {
+            return flux_1.fluxApplication.repository.createModel(models_1.Permission, source);
+        }
+        permission.create = create;
+        function update(source) {
+            return flux_1.fluxApplication.repository.updateModel(models_1.Permission, source);
+        }
+        permission.update = update;
+        function remove(id) {
+            return flux_1.fluxApplication.repository.deleteModel(models_1.Permission, id);
+        }
+        permission.remove = remove;
+        function getById(id) {
+            return flux_1.fluxApplication.repository.readModel(models_1.Permission, id);
+        }
+        permission.getById = getById;
+        function filter(id) {
+            const conditions = [];
+            if (id) {
+                conditions.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition('id', '=', id));
+            }
+            if (conditions.length > 0) {
+                return flux_1.fluxApplication.repository.readArray(models_1.Permission, { condition: flux_1.conditionBuilder.createSubCondition('AND', conditions) }, undefined);
+            }
+            else {
+                return flux_1.fluxApplication.repository.readArray(models_1.Permission, undefined, undefined);
+            }
+        }
+        permission.filter = filter;
+    })(permission = repository.permission || (repository.permission = {}));
+    let role;
+    (function (role) {
+        function create(source) {
+            return flux_1.fluxApplication.repository.createModel(models_1.Role, source);
+        }
+        role.create = create;
+        function update(source) {
+            return flux_1.fluxApplication.repository.updateModel(models_1.Role, source);
+        }
+        role.update = update;
+        function remove(id) {
+            return flux_1.fluxApplication.repository.deleteModel(models_1.Role, id);
+        }
+        role.remove = remove;
+        function getById(id) {
+            return flux_1.fluxApplication.repository.readModel(models_1.Role, id);
+        }
+        role.getById = getById;
+        function filter(id) {
+            const conditions = [];
+            if (id) {
+                conditions.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition('id', '=', id));
+            }
+            if (conditions.length > 0) {
+                return flux_1.fluxApplication.repository.readArray(models_1.Role, { condition: flux_1.conditionBuilder.createSubCondition('AND', conditions) }, undefined);
+            }
+            else {
+                return flux_1.fluxApplication.repository.readArray(models_1.Role, undefined, undefined);
+            }
+        }
+        role.filter = filter;
+    })(role = repository.role || (repository.role = {}));
+    let userAccess;
+    (function (userAccess) {
+        function create(source) {
+            return flux_1.fluxApplication.repository.createModel(models_1.UserAccess, source);
+        }
+        userAccess.create = create;
+        function update(source) {
+            return flux_1.fluxApplication.repository.updateModel(models_1.UserAccess, source);
+        }
+        userAccess.update = update;
+        function remove(id) {
+            return flux_1.fluxApplication.repository.deleteModel(models_1.UserAccess, id);
+        }
+        userAccess.remove = remove;
+        function getById(id) {
+            return flux_1.fluxApplication.repository.readModel(models_1.UserAccess, id);
+        }
+        userAccess.getById = getById;
+        function getForUser(user_id) {
+            return flux_1.fluxApplication.repository.queryArray(models_1.UserAccess, naming_1.naming.user_access.indexes.user_account, { key: user_id, sort: undefined }, undefined, undefined);
+        }
+        userAccess.getForUser = getForUser;
+        function getForUserByRoles(user_id) {
+            return flux_1.fluxApplication.repository.queryArray(models_1.UserAccess, naming_1.naming.user_access.indexes.user_account, { key: user_id, sort: undefined }, { condition: flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.user_access.columns.role_id, 'EXISTS', undefined) }, undefined);
+        }
+        userAccess.getForUserByRoles = getForUserByRoles;
+        function getForUserDirectly(user_id) {
+            return flux_1.fluxApplication.repository.queryArray(models_1.UserAccess, naming_1.naming.user_access.indexes.user_account, { key: user_id, sort: undefined }, { condition: flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.user_access.columns.role_id, 'NOT EXISTS', undefined) }, undefined);
+        }
+        userAccess.getForUserDirectly = getForUserDirectly;
+        function getForUserAndPermission(user_id, permission_id) {
+            return flux_1.fluxApplication.repository.queryArray(models_1.UserAccess, naming_1.naming.user_access.indexes.user_permission, { key: user_id, sort: permission_id }, undefined, undefined);
+        }
+        userAccess.getForUserAndPermission = getForUserAndPermission;
+        function getForAccount(account_id) {
+            return flux_1.fluxApplication.repository.queryArray(models_1.UserAccess, naming_1.naming.user_access.indexes.account_user, { key: account_id, sort: undefined }, undefined, undefined);
+        }
+        userAccess.getForAccount = getForAccount;
+    })(userAccess = repository.userAccess || (repository.userAccess = {}));
+    let user;
+    (function (user) {
+        function create(source) {
+            return flux_1.fluxApplication.repository.createModel(models_1.User, source);
+        }
+        user.create = create;
+        function update(source) {
+            return flux_1.fluxApplication.repository.updateModel(models_1.User, source);
+        }
+        user.update = update;
+        function remove(id) {
+            return flux_1.fluxApplication.repository.deleteModel(models_1.User, id);
+        }
+        user.remove = remove;
+        function getById(id) {
+            return flux_1.fluxApplication.repository.readModel(models_1.User, id);
+        }
+        user.getById = getById;
+        function count() {
+            return flux_1.fluxApplication.repository.countModel(models_1.User);
+        }
+        user.count = count;
+        function filter(id, type, account_id) {
+            const conditions = [];
+            if (id) {
+                conditions.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition('id', '=', id));
+            }
+            if (type) {
+                conditions.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.users.columns.type, '=', type));
+            }
+            if (account_id) {
+                conditions.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.users.columns.account_id, '=', account_id));
+            }
+            if (conditions.length > 0) {
+                return flux_1.fluxApplication.repository.readArray(models_1.User, { condition: flux_1.conditionBuilder.createSubCondition('AND', conditions) }, undefined);
+            }
+            else {
+                return flux_1.fluxApplication.repository.readArray(models_1.User, undefined, undefined);
+            }
+        }
+        user.filter = filter;
+    })(user = repository.user || (repository.user = {}));
+    let credential;
+    (function (credential) {
+        function create(source) {
+            return flux_1.fluxApplication.repository.createModel(models_1.Credential, source);
+        }
+        credential.create = create;
+        function update(source) {
+            return flux_1.fluxApplication.repository.updateModel(models_1.Credential, source);
+        }
+        credential.update = update;
+        function remove(id) {
+            return flux_1.fluxApplication.repository.deleteModel(models_1.Credential, id);
+        }
+        credential.remove = remove;
+        function getById(id) {
+            return flux_1.fluxApplication.repository.readModel(models_1.Credential, id);
+        }
+        credential.getById = getById;
+        function filter(name, user_id, confirmationCode, recoveryCode, inviteCode, credential_type) {
+            const list = [];
+            if (name) {
+                list.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.credentials.columns.name, '=', name));
+            }
+            if (user_id) {
+                list.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.credentials.columns.user_id, '=', user_id));
+            }
+            if (confirmationCode) {
+                list.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.credentials.columns.confirmation, '=', confirmationCode));
+            }
+            if (recoveryCode) {
+                list.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.credentials.columns.recovery, '=', recoveryCode));
+            }
+            if (inviteCode) {
+                list.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.credentials.columns.invite, '=', inviteCode));
+            }
+            if (credential_type) {
+                list.push(flux_1.conditionBuilder.createSimpleStringOrNumberCondition(naming_1.naming.credentials.columns.type, '=', credential_type));
+            }
+            if (list.length > 0) {
+                return flux_1.fluxApplication.repository.readArray(models_1.Credential, { condition: flux_1.conditionBuilder.createSubCondition('AND', list) }, undefined);
+            }
+            else {
+                return flux_1.fluxApplication.repository.readArray(models_1.Credential, undefined, undefined);
+            }
+        }
+        credential.filter = filter;
+    })(credential = repository.credential || (repository.credential = {}));
+})(repository || (exports.repository = repository = {}));

package/dist/service/security.d.ts

@@ -0,0 +1,46 @@
+import { NextFunction, Request, Response } from 'express';
+interface IFluxTokenPayload {
+    user_id: string;
+    code: string;
+}
+interface IFluxPayload {
+    user_id: string;
+    account_id: string | undefined;
+    admin: boolean;
+}
+interface IFluxDataPayload<TData> extends IFluxPayload {
+    data?: TData | undefined;
+}
+export interface IFluxJwt {
+    token: string;
+    refreshToken: string;
+}
+export interface IFluxTokenRequest extends Request {
+    payload?: IFluxTokenPayload;
+}
+export interface IFluxRequest extends Request {
+    payload?: IFluxPayload;
+}
+export interface IFluxDataRequest<TData> extends IFluxRequest {
+    payload?: IFluxDataPayload<TData>;
+}
+export declare namespace securityService {
+    function initialize(jwt_secret: string): void;
+    function registerClient(client_secret: string): void;
+    namespace token {
+        function refresh(user_id: string, refreshCode: string, expirationInHours: number): string;
+        function data<TData>(user_id: string, account_id: string | undefined, admin: boolean, expirationInHours: number, data: TData | undefined): string;
+        function client(client: string): string;
+    }
+    namespace middleware {
+        function client(request: Request, response: Response, next: NextFunction): void;
+        function refresh(request: IFluxTokenRequest, response: Response, next: NextFunction): void;
+        function simple(request: IFluxRequest, response: Response, next: NextFunction): void;
+        function full<TData>(request: IFluxDataRequest<TData>, response: Response, next: NextFunction): void;
+        function admin(request: IFluxRequest, response: Response, next: NextFunction): void;
+        function data<TData>(request: IFluxDataRequest<TData>, response: Response, next: NextFunction): void;
+        function checkAdmin(request: IFluxRequest, response: Response, next: NextFunction): void;
+        function checkData<TData>(request: IFluxDataRequest<TData>, response: Response, next: NextFunction): void;
+    }
+}
+export {};