@hapiboo/module-auth 1.3.0 → 1.4.1

package/dist/router/controller.d.ts

@@ -7,6 +7,9 @@ export declare namespace authController {
         function start(): IResponsePromise<{
             id: string;
         }>;
+        function testMode(): IResponsePromise<{
+            testMode: boolean;
+        }>;
     }
     namespace user {
         function register(request: Request): IResponsePromise<{

package/dist/router/controller.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.authController = void 0;
+const core_1 = require("@hapiboo/core");
 const server_1 = require("@hapiboo/server");
 const authentication_1 = require("../service/authentication");
 const authorization_1 = require("../service/authorization");
@@ -12,29 +13,36 @@ var authController;
             return authentication_1.authenticationService.general.initData(process.env.FRONTEND_URL);
         }
         init.start = start;
+        function testMode() {
+            return authentication_1.authenticationService.general.testMode();
+        }
+        init.testMode = testMode;
     })(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) &&
+                return server_1.validator.validateBody(request) &&
+                    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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => 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).then(resolve).catch(reject)));
         }
         user.register = register;
         function registrationConfirm(request) {
             return server_1.server.createValidatedPromise(request, (req) => {
-                return server_1.validator.validateString(req.body.code) &&
+                return server_1.validator.validateBody(request) &&
+                    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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.actions.confirmRegistration(request.body.code, request.body.password).then(resolve).catch(reject)));
         }
         user.registrationConfirm = registrationConfirm;
         function invitationConfirm(request) {
             return server_1.server.createValidatedPromise(request, (req) => {
-                return server_1.validator.validateString(req.body.code) &&
+                return server_1.validator.validateBody(request) &&
+                    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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.actions.confirmInvitation(request.body.code, request.body.password).then(resolve).catch(reject)));
         }
         user.invitationConfirm = invitationConfirm;
     })(user = authController.user || (authController.user = {}));
@@ -42,32 +50,36 @@ var authController;
     (function (password) {
         function login(request) {
             return server_1.server.createValidatedPromise(request, (req) => {
-                return server_1.validator.validateString(req.body.login) &&
+                return server_1.validator.validateBody(request) &&
+                    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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.me.passwordLogin(request.body.login, request.body.password).then(resolve).catch(reject)));
         }
         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));
+                return server_1.validator.validateBody(request) &&
+                    server_1.validator.validateString(req.body.email);
+            }, core_1.promise.createDelayedVoidPromise((resolve, reject) => authentication_1.authenticationService.actions.forgotPassword(request.body.email, process.env.FRONTEND_URL).then(resolve).catch(reject)));
         }
         password.forgot = forgot;
         function recover(request) {
             return server_1.server.createValidatedPromise(request, (req) => {
-                return server_1.validator.validateString(req.body.recovery) &&
+                return server_1.validator.validateBody(request) &&
+                    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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.actions.recoverPassword(request.body.recovery, request.body.password).then(resolve).catch(reject)));
         }
         password.recover = recover;
         function change(request) {
             return server_1.validator.createValidatedPromise(() => {
-                return request.payload !== undefined &&
+                return server_1.validator.validateBody(request) &&
+                    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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.me.changePassword(request.payload.user_id, request.body.email, request.body.oldPassword, request.body.newPassword).then(resolve).catch(reject)));
         }
         password.change = change;
         function refresh(request) {
@@ -75,7 +87,7 @@ var authController;
                 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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.me.refreshTokenLogin(request.payload.user_id, request.payload.code).then(resolve).catch(reject)));
         }
         password.refresh = refresh;
     })(password = authController.password || (authController.password = {}));
@@ -85,15 +97,16 @@ var authController;
             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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.me.get(request.payload.user_id).then(resolve).catch(reject)));
         }
         profile.get = get;
         function update(request) {
             return server_1.validator.createValidatedVoidPromise(() => {
-                return request.payload !== undefined &&
+                return server_1.validator.validateBody(request) &&
+                    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));
+            }, core_1.promise.createDelayedPromise((resolve, reject) => authentication_1.authenticationService.me.update(request.payload.user_id, request.body.name).then(resolve).catch(reject)));
         }
         profile.update = update;
     })(profile = authController.profile || (authController.profile = {}));

package/dist/router/init.js

@@ -8,4 +8,7 @@ const router = (0, express_1.Router)();
 router.put('', async (_request, response) => {
     server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.init.start());
 });
+router.post('/test', async (_request, response) => {
+    server_1.server.prepareJsonPromiseResponse(response, controller_1.authController.init.testMode());
+});
 exports.init = server_1.routingProvider.createRoutingItem('/init', router);

package/dist/service/authentication.d.ts

@@ -6,6 +6,9 @@ export declare namespace authenticationService {
         function initData(baseURL: string): IResponsePromise<{
             id: string;
         }>;
+        function testMode(): IResponsePromise<{
+            testMode: boolean;
+        }>;
         function get(user_id: string): IResponsePromise<User>;
     }
     namespace me {

package/dist/service/authentication.js

@@ -78,64 +78,73 @@ var helper;
     (function (users) {
         function registerPassword(display, email, credentialName, password, admin, isInvited, account_id, baseUrl) {
             return core_1.promise.createPromise((resolve, reject) => {
-                //we need to find out if credentialName is not used
-                core_1.promise.check(searchPassword(credentialName, true), reject)
-                    .then((value) => {
-                    if (value.found) {
-                        reject(core_1.ResponseError.getMessageResponse(409, 'credential name already registered'));
-                    }
-                    else {
-                        if (display && email && credentialName) {
-                            //let's create actual user data
-                            const user_id = (0, uuid_1.v4)();
-                            let confirm = (0, uuid_1.v4)().substring(0, 6).toUpperCase();
-                            let invite = undefined;
-                            if (isInvited) {
-                                confirm = undefined;
-                                invite = (0, uuid_1.v4)().substring(0, 6).toUpperCase();
-                                password = '';
-                            }
-                            core_1.promise.check(repository_1.repository.credential.create(new models_1.Credential().createPassword((0, uuid_1.v4)(), credentialName, user_id, 'pending', password, confirm, invite)), reject)
-                                .then((cred) => {
-                                //now, create user
-                                core_1.promise.check(repository_1.repository.user.create(new models_1.User().create(user_id, account_id, admin ? 'admin' : 'standard', 'created', display, email)), reject)
-                                    .then((dataItem) => {
-                                    //and send the code to confirm
-                                    emails.confirm(email, display, isInvited, isInvited ? cred.invite : cred.confirmation, baseUrl)
-                                        .then(() => {
-                                        resolve({ user: dataItem, credentials: cred });
-                                    }).catch((reason) => {
-                                        console.error(reason.message);
-                                        //in case of error, we need to remove all created data
-                                        repository_1.repository.user.remove(dataItem.id)
+                //let's check if we could move forward with current settings
+                if (!isInvited && !settings_1.authSettings.allowSelfRegistration()) {
+                    reject(core_1.ResponseError.getMessageResponse(403, 'Self registration is not allowed.'));
+                }
+                else {
+                    //we need to find out if credentialName is not used
+                    core_1.promise.check(searchPassword(credentialName, true), reject)
+                        .then((value) => {
+                        if (value.found) {
+                            reject(core_1.ResponseError.getMessageResponse(409, 'credential name already registered'));
+                        }
+                        else {
+                            if (display && email && credentialName) {
+                                //let's create actual user data
+                                const user_id = (0, uuid_1.v4)();
+                                let invite = undefined;
+                                let confirm = (0, uuid_1.v4)().substring(0, 6).toUpperCase();
+                                if (settings_1.authSettings.allowTestMode() && settings_1.authSettings.testMode()) {
+                                    confirm = 'M6K513';
+                                }
+                                if (isInvited) {
+                                    invite = confirm;
+                                    confirm = undefined;
+                                    password = '';
+                                }
+                                core_1.promise.check(repository_1.repository.credential.create(new models_1.Credential().createPassword((0, uuid_1.v4)(), credentialName, user_id, 'pending', password, confirm, invite)), reject)
+                                    .then((cred) => {
+                                    //now, create user
+                                    core_1.promise.check(repository_1.repository.user.create(new models_1.User().create(user_id, account_id, admin ? 'admin' : 'standard', 'created', display, email)), reject)
+                                        .then((dataItem) => {
+                                        //and send the code to confirm
+                                        emails.confirm(email, display, isInvited, isInvited ? cred.invite : cred.confirmation, baseUrl)
                                             .then(() => {
-                                            repository_1.repository.credential.remove(cred.id)
-                                                .then(() => {
-                                                reject(reason);
-                                            }).catch((reasonCred) => {
-                                                //we have 2 errors, and needs to combine them
-                                                reject(core_1.ResponseError.getCollectionResponse([reason, reasonCred]));
-                                            });
-                                        }).catch((reasonUser) => {
-                                            //despite error, let's try to clean up other data
-                                            repository_1.repository.credential.remove(cred.id)
+                                            resolve({ user: dataItem, credentials: cred });
+                                        }).catch((reason) => {
+                                            console.error(reason.message);
+                                            //in case of error, we need to remove all created data
+                                            repository_1.repository.user.remove(dataItem.id)
                                                 .then(() => {
-                                                //we have 2 errors, and needs to combine them
-                                                reject(core_1.ResponseError.getCollectionResponse([reason, reasonUser]));
-                                            }).catch((reasonCred) => {
-                                                //we have 3 errors, and needs to combine them
-                                                reject(core_1.ResponseError.getCollectionResponse([reason, reasonUser, reasonCred]));
+                                                repository_1.repository.credential.remove(cred.id)
+                                                    .then(() => {
+                                                    reject(reason);
+                                                }).catch((reasonCred) => {
+                                                    //we have 2 errors, and needs to combine them
+                                                    reject(core_1.ResponseError.getCollectionResponse([reason, reasonCred]));
+                                                });
+                                            }).catch((reasonUser) => {
+                                                //despite error, let's try to clean up other data
+                                                repository_1.repository.credential.remove(cred.id)
+                                                    .then(() => {
+                                                    //we have 2 errors, and needs to combine them
+                                                    reject(core_1.ResponseError.getCollectionResponse([reason, reasonUser]));
+                                                }).catch((reasonCred) => {
+                                                    //we have 3 errors, and needs to combine them
+                                                    reject(core_1.ResponseError.getCollectionResponse([reason, reasonUser, reasonCred]));
+                                                });
                                             });
                                         });
                                     });
                                 });
-                            });
-                        }
-                        else {
-                            reject(core_1.ResponseError.getMessageResponse(400, 'data is not valid'));
+                            }
+                            else {
+                                reject(core_1.ResponseError.getMessageResponse(400, 'data is not valid'));
+                            }
                         }
-                    }
-                });
+                    });
+                }
             });
         }
         users.registerPassword = registerPassword;
@@ -229,6 +238,12 @@ var authenticationService;
             });
         }
         general.initData = initData;
+        function testMode() {
+            return core_1.promise.createDelayedPromise((resolve, _reject) => {
+                resolve({ testMode: settings_1.authSettings.changeTestMode() });
+            });
+        }
+        general.testMode = testMode;
         function get(user_id) {
             return repository_1.repository.user.getById(user_id);
         }

package/dist/service/settings.d.ts

@@ -16,6 +16,7 @@ export interface IAuthPerformers {
 export interface IAuthSettings {
     allowSelfRegistration: boolean;
     allowMultiLogin: boolean;
+    allowTestMode: boolean;
     passwordHashLength: number;
     passwordHashIterations: number;
     firstAdmin: {
@@ -30,6 +31,9 @@ export declare namespace authSettings {
     function init(settings: IAuthSettings, performers: IAuthPerformers): void;
     function allowSelfRegistration(): boolean;
     function allowMultiLogin(): boolean;
+    function allowTestMode(): boolean;
+    function testMode(): boolean;
+    function changeTestMode(): boolean;
     function passwordHashLength(): number;
     function passwordHashIterations(): number;
     function firstAdmin(): {

package/dist/service/settings.js

@@ -4,9 +4,11 @@ exports.authSettings = void 0;
 const core_1 = require("@hapiboo/core");
 var authSettings;
 (function (authSettings) {
+    let _test = false;
     let _settings = {
         allowSelfRegistration: true,
         allowMultiLogin: false,
+        allowTestMode: false,
         passwordHashLength: 1024,
         passwordHashIterations: 32,
         firstAdmin: {
@@ -30,6 +32,19 @@ var authSettings;
         return _settings.allowMultiLogin;
     }
     authSettings.allowMultiLogin = allowMultiLogin;
+    function allowTestMode() {
+        return _settings.allowTestMode;
+    }
+    authSettings.allowTestMode = allowTestMode;
+    function testMode() {
+        return _test;
+    }
+    authSettings.testMode = testMode;
+    function changeTestMode() {
+        _test = !_test;
+        return _test;
+    }
+    authSettings.changeTestMode = changeTestMode;
     function passwordHashLength() {
         return _settings.passwordHashLength;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hapiboo/module-auth",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "MK13 Studio Hapiboo - Auth Module",
   "author": "MK13 Studio",
   "license": "ISC",