@hapiboo/module-auth 1.0.0

package/dist/models/user.js

@@ -0,0 +1,97 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Profile = exports.User = void 0;
+const date_1 = require("@hapiboo/date");
+const flux_1 = require("@hapiboo/flux");
+const naming_1 = require("./naming");
+let User = class User {
+    constructor() {
+        this.id = '';
+        this.account_id = '';
+        this.type = 'standard';
+        this.status = 'created';
+        this.profile = new Profile();
+        this.createdAt = date_1.DateObject.now().toUtc();
+        this.updatedAt = date_1.DateObject.now().toUtc();
+        this.lastLoginAt = '';
+    }
+    clone(model) {
+        this.id = model.id;
+        this.account_id = model.account_id;
+        this.type = model.type;
+        this.status = model.status;
+        this.profile = new Profile().clone(model.profile);
+        this.createdAt = model.createdAt;
+        this.updatedAt = model.updatedAt;
+        this.lastLoginAt = model.lastLoginAt;
+        return this;
+    }
+    create(id, account_id, type, status, display, email) {
+        this.id = id;
+        this.account_id = account_id ?? '';
+        this.type = type;
+        this.status = status;
+        this.profile = new Profile().create(display, email);
+        this.createdAt = date_1.DateObject.now().toUtc();
+        this.updatedAt = date_1.DateObject.now().toUtc();
+        this.lastLoginAt = '';
+        return this;
+    }
+    updateName(name) {
+        this.profile.display = name;
+        this.updatedAt = date_1.DateObject.now().toUtc();
+        return this;
+    }
+    confirm() {
+        this.status = 'active';
+        this.updatedAt = date_1.DateObject.now().toUtc();
+        return this;
+    }
+};
+exports.User = User;
+__decorate([
+    (0, flux_1.FluxIdentifier)()
+], User.prototype, "id", void 0);
+__decorate([
+    (0, flux_1.FluxColumn)(naming_1.naming.users.columns.account_id)
+], User.prototype, "account_id", void 0);
+__decorate([
+    (0, flux_1.FluxColumn)(naming_1.naming.users.columns.type)
+], User.prototype, "type", void 0);
+__decorate([
+    (0, flux_1.FluxColumn)(naming_1.naming.users.columns.status)
+], User.prototype, "status", void 0);
+exports.User = User = __decorate([
+    (0, flux_1.FluxTable)(naming_1.naming.users.table),
+    (0, flux_1.FluxIndex)(naming_1.naming.users.indexes.by_account, naming_1.naming.users.columns.account_id, naming_1.naming.users.columns.status),
+    (0, flux_1.FluxIndex)(naming_1.naming.users.indexes.by_type, naming_1.naming.users.columns.type, naming_1.naming.users.columns.status)
+], User);
+class Profile {
+    constructor() {
+        this.display = '';
+        this.email = '';
+        this.phone = '';
+        this.locale = '';
+        this.avatarUrl = '';
+    }
+    clone(model) {
+        this.display = model.display;
+        this.email = model.email;
+        this.phone = model.phone;
+        this.locale = model.locale;
+        this.avatarUrl = model.avatarUrl;
+        return this;
+    }
+    create(display, email) {
+        this.display = display;
+        this.email = email;
+        return this;
+    }
+}
+exports.Profile = Profile;

package/dist/router/access.d.ts

@@ -0,0 +1 @@
+export declare const access: import("@hapiboo/server").IRoutingItem;

package/dist/router/access.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.access = void 0;
+const express_1 = require("express");
+const server_1 = require("@hapiboo/server");
+const security_1 = require("../service/security");
+const controller_1 = require("./controller");
+const router = (0, express_1.Router)();
+//app roles definition
+router.get('/roles', security_1.securityService.middleware.simple, async (_request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.access.getRoles());
+});
+//app permission definieion
+router.get('/permissions', security_1.securityService.middleware.simple, async (_request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.access.getPermissions());
+});
+exports.access = server_1.routingProvider.createRoutingItem('/access', router);

package/dist/router/controller.d.ts

@@ -0,0 +1,58 @@
+import { Request } from 'express';
+import { IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+import { IFluxRequest, IFluxTokenRequest } from '../service/security';
+import { Permission, Role } from '../models';
+export declare namespace authController {
+    namespace init {
+        function start(): IResponsePromise<{
+            id: string;
+        }>;
+    }
+    namespace user {
+        function register(request: Request): IResponsePromise<{
+            user: string;
+            account: string;
+        }>;
+        function registrationConfirm(request: Request): IResponsePromise<{
+            token: string;
+            refreshToken: string;
+        }>;
+        function invitationConfirm(request: Request): IResponsePromise<{
+            token: string;
+            refreshToken: string;
+        }>;
+    }
+    namespace password {
+        function login(request: Request): IResponsePromise<{
+            token: string;
+            refreshToken: string;
+        }>;
+        function forgot(request: Request): IResponsePromiseVoid;
+        function recover(request: Request): IResponsePromise<{
+            token: string;
+            refreshToken: string;
+        }>;
+        function change(request: IFluxRequest): IResponsePromise<{
+            token: string;
+            refreshToken: string;
+        }>;
+        function refresh(request: IFluxTokenRequest): IResponsePromise<{
+            token: string;
+            refreshToken: string;
+        }>;
+    }
+    namespace profile {
+        function get(request: IFluxRequest): IResponsePromise<{
+            email: string;
+            name: string;
+            account_id: string | undefined;
+            admin: boolean;
+            permissions: string[];
+        }>;
+        function update(request: IFluxRequest): IResponsePromiseVoid;
+    }
+    namespace access {
+        function getRoles(): IResponsePromise<Role[]>;
+        function getPermissions(): IResponsePromise<Permission[]>;
+    }
+}

package/dist/router/controller.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authController = void 0;
+const server_1 = require("@hapiboo/server");
+const authentication_1 = require("../service/authentication");
+const authorization_1 = require("../service/authorization");
+var authController;
+(function (authController) {
+    let init;
+    (function (init) {
+        function start() {
+            return authentication_1.authenticationService.general.initData(process.env.FRONTEND_URL);
+        }
+        init.start = start;
+    })(init = authController.init || (authController.init = {}));
+    let user;
+    (function (user) {
+        function register(request) {
+            return server_1.server.createValidatedPromise(request, (req) => {
+                return server_1.validator.validateString(req.body.name) &&
+                    server_1.validator.validateString(req.body.login) &&
+                    server_1.validator.validateString(req.body.password);
+            }, authentication_1.authenticationService.user.registerPassword(request.body.login, request.body.name, request.body.login, request.body.password, request.body.name, request.body.login, process.env.FRONTEND_URL));
+        }
+        user.register = register;
+        function registrationConfirm(request) {
+            return server_1.server.createValidatedPromise(request, (req) => {
+                return server_1.validator.validateString(req.body.code) &&
+                    server_1.validator.validateString(req.body.password);
+            }, authentication_1.authenticationService.actions.confirmRegistration(request.body.code, request.body.password));
+        }
+        user.registrationConfirm = registrationConfirm;
+        function invitationConfirm(request) {
+            return server_1.server.createValidatedPromise(request, (req) => {
+                return server_1.validator.validateString(req.body.code) &&
+                    server_1.validator.validateString(req.body.password);
+            }, authentication_1.authenticationService.actions.confirmInvitation(request.body.code, request.body.password));
+        }
+        user.invitationConfirm = invitationConfirm;
+    })(user = authController.user || (authController.user = {}));
+    let password;
+    (function (password) {
+        function login(request) {
+            return server_1.server.createValidatedPromise(request, (req) => {
+                return server_1.validator.validateString(req.body.login) &&
+                    server_1.validator.validateString(req.body.password);
+            }, authentication_1.authenticationService.me.passwordLogin(request.body.login, request.body.password));
+        }
+        password.login = login;
+        function forgot(request) {
+            return server_1.server.createValidatedVoidPromise(request, (req) => {
+                return server_1.validator.validateString(req.body.email);
+            }, authentication_1.authenticationService.actions.forgotPassword(request.body.email, process.env.FRONTEND_URL));
+        }
+        password.forgot = forgot;
+        function recover(request) {
+            return server_1.server.createValidatedPromise(request, (req) => {
+                return server_1.validator.validateString(req.body.recovery) &&
+                    server_1.validator.validateString(req.body.password);
+            }, authentication_1.authenticationService.actions.recoverPassword(request.body.recovery, request.body.password));
+        }
+        password.recover = recover;
+        function change(request) {
+            return server_1.validator.createValidatedPromise(() => {
+                return request.payload !== undefined &&
+                    server_1.validator.validateString(request.payload.user_id) &&
+                    server_1.validator.validateString(request.body.email) &&
+                    server_1.validator.validateString(request.body.oldPassword) &&
+                    server_1.validator.validateString(request.body.newPassword);
+            }, authentication_1.authenticationService.me.changePassword(request.payload.user_id, request.body.email, request.body.oldPassword, request.body.newPassword));
+        }
+        password.change = change;
+        function refresh(request) {
+            return server_1.validator.createValidatedPromise(() => {
+                return request.payload !== undefined &&
+                    server_1.validator.validateString(request.payload.user_id) &&
+                    server_1.validator.validateString(request.payload.code);
+            }, authentication_1.authenticationService.me.refreshTokenLogin(request.payload.user_id, request.payload.code));
+        }
+        password.refresh = refresh;
+    })(password = authController.password || (authController.password = {}));
+    let profile;
+    (function (profile) {
+        function get(request) {
+            return server_1.validator.createValidatedPromise(() => {
+                return request.payload !== undefined &&
+                    server_1.validator.validateString(request.payload.user_id);
+            }, authentication_1.authenticationService.me.get(request.payload.user_id));
+        }
+        profile.get = get;
+        function update(request) {
+            return server_1.validator.createValidatedVoidPromise(() => {
+                return request.payload !== undefined &&
+                    server_1.validator.validateString(request.payload.user_id) &&
+                    server_1.validator.validateString(request.body.name);
+            }, authentication_1.authenticationService.me.update(request.payload.user_id, request.body.name));
+        }
+        profile.update = update;
+    })(profile = authController.profile || (authController.profile = {}));
+    let access;
+    (function (access) {
+        function getRoles() {
+            return authorization_1.authorizationService.role.all();
+        }
+        access.getRoles = getRoles;
+        function getPermissions() {
+            return authorization_1.authorizationService.permission.all();
+        }
+        access.getPermissions = getPermissions;
+    })(access = authController.access || (authController.access = {}));
+})(authController || (exports.authController = authController = {}));

package/dist/router/index.d.ts

@@ -0,0 +1 @@
+export declare const router: import("@hapiboo/server").IRoutingItem;

package/dist/router/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.router = void 0;
+const server_1 = require("@hapiboo/server");
+const init_1 = require("./init");
+const access_1 = require("./access");
+const profile_1 = require("./profile");
+const password_1 = require("./password");
+const user_1 = require("./user");
+exports.router = server_1.routingProvider.createRouter('/auth', [init_1.init, user_1.user, password_1.password, profile_1.profile, access_1.access]);

package/dist/router/init.d.ts

@@ -0,0 +1 @@
+export declare const init: import("@hapiboo/server").IRoutingItem;

package/dist/router/init.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const express_1 = require("express");
+const server_1 = require("@hapiboo/server");
+const controller_1 = require("./controller");
+const router = (0, express_1.Router)();
+router.put('', async (_request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.init.start());
+});
+exports.init = server_1.routingProvider.createRoutingItem('/init', router);

package/dist/router/password.d.ts

@@ -0,0 +1 @@
+export declare const password: import("@hapiboo/server").IRoutingItem;

package/dist/router/password.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.password = void 0;
+const express_1 = require("express");
+const server_1 = require("@hapiboo/server");
+const controller_1 = require("./controller");
+const security_1 = require("../service/security");
+const router = (0, express_1.Router)();
+router.post('/login', async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.password.login(request));
+});
+router.post('/forgot', async (request, response) => {
+    server_1.server.prepareEmptyPromiseResponse(response, controller_1.authController.password.forgot(request));
+});
+router.post('/recover', async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.password.recover(request));
+});
+router.post('/refresh', security_1.securityService.middleware.refresh, async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.password.refresh(request));
+});
+router.post('/password', security_1.securityService.middleware.simple, async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.password.change(request));
+});
+exports.password = server_1.routingProvider.createRoutingItem('/password', router);

package/dist/router/profile.d.ts

@@ -0,0 +1 @@
+export declare const profile: import("@hapiboo/server").IRoutingItem;

package/dist/router/profile.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profile = void 0;
+const express_1 = require("express");
+const server_1 = require("@hapiboo/server");
+const controller_1 = require("./controller");
+const security_1 = require("../service/security");
+const router = (0, express_1.Router)();
+router.get('', security_1.securityService.middleware.simple, async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.profile.get(request));
+});
+router.post('', security_1.securityService.middleware.simple, async (request, response) => {
+    server_1.server.prepareEmptyPromiseResponse(response, controller_1.authController.profile.update(request));
+});
+exports.profile = server_1.routingProvider.createRoutingItem('/profile', router);

package/dist/router/user.d.ts

@@ -0,0 +1 @@
+export declare const user: import("@hapiboo/server").IRoutingItem;

package/dist/router/user.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.user = void 0;
+const express_1 = require("express");
+const server_1 = require("@hapiboo/server");
+const controller_1 = require("./controller");
+const router = (0, express_1.Router)();
+router.post('/register', async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.user.register(request));
+});
+router.post('/confirm', async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.user.registrationConfirm(request));
+});
+router.post('/invite', async (request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.user.invitationConfirm(request));
+});
+exports.user = server_1.routingProvider.createRoutingItem('/user', router);

package/dist/service/authentication.d.ts

@@ -0,0 +1,51 @@
+import { IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+import { IFluxJwt } from './security';
+import { User } from '../models';
+export declare namespace authenticationService {
+    namespace general {
+        function initData(baseURL: string): IResponsePromise<{
+            id: string;
+        }>;
+        function get(user_id: string): IResponsePromise<User>;
+    }
+    namespace me {
+        function get(user_id: string): IResponsePromise<{
+            id: string;
+            email: string;
+            name: string;
+            account_id: string | undefined;
+            admin: boolean;
+            permissions: string[];
+        }>;
+        function update(user_id: string, name: string): IResponsePromise<User>;
+        function passwordLogin(name: string, password: string): IResponsePromise<IFluxJwt>;
+        function changePassword(user_id: string, credentialName: string, oldPassword: string, newPassword: string): IResponsePromise<IFluxJwt>;
+        function refreshTokenLogin(user_id: string, refreshCode: string): IResponsePromise<IFluxJwt>;
+    }
+    namespace admin {
+        function invite(name: string, emailAddress: string, displayName: string, baseURL: string): IResponsePromise<{
+            id: string;
+        }>;
+        function remove(id: string, currentUserId: string): IResponsePromiseVoid;
+        function getAll(): IResponsePromise<User[]>;
+    }
+    namespace user {
+        function registerPassword(credentialName: string, userDisplayName: string, userEmailAddress: string, password: string, account_name: string, account_email: string, baseUrl: string): IResponsePromise<{
+            user: string;
+            account: string;
+        }>;
+        function invite(account_id: string, credentialName: string, displayName: string, emailAddress: string, baseUrl: string): IResponsePromise<{
+            id: string;
+        }>;
+        function updatePayload<T>(user_id: string, account_id: string, payload: T): string;
+        function remove(user_id: string, currentUserId: string, account_id: string): IResponsePromiseVoid;
+        function getForAccount(account_id: string): IResponsePromise<User[]>;
+    }
+    namespace actions {
+        function resendConfirmation(user_id: string, baseUrl: string): IResponsePromiseVoid;
+        function confirmRegistration(code: string, password: string): IResponsePromise<IFluxJwt>;
+        function confirmInvitation(code: string, password: string): IResponsePromise<IFluxJwt>;
+        function recoverPassword(recovery: string, password: string): IResponsePromise<IFluxJwt>;
+        function forgotPassword(credentialName: string, baseUrl: string): IResponsePromiseVoid;
+    }
+}