@hapiboo/module-auth 1.0.0

package/dist/service/security.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.securityService = void 0;
+const jsonwebtoken_1 = require("jsonwebtoken");
+let _jwt_secret;
+const _client_secrets = [];
+var helpers;
+(function (helpers) {
+    function __validateTokenAndGetPayload(token) {
+        let response = {};
+        (0, jsonwebtoken_1.verify)(token, _jwt_secret, (error, data) => {
+            if (error) {
+                if (error instanceof jsonwebtoken_1.TokenExpiredError) {
+                    console.error('jwt expired');
+                }
+                throw error;
+            }
+            if (typeof data !== 'string') {
+                response = data ?? {};
+            }
+        });
+        return response;
+    }
+    helpers.__validateTokenAndGetPayload = __validateTokenAndGetPayload;
+    function __retractRequestToken(request) {
+        let token = '';
+        if (request.headers['authorization']) {
+            const auth = request.headers['authorization'];
+            const elements = auth.split(' ');
+            if (elements.length === 2 && elements[0].toLowerCase() === 'bearer') {
+                token = elements[1];
+            }
+            else {
+                throw Error('incorrect authentication type');
+            }
+        }
+        else {
+            throw Error('not authenticated');
+        }
+        return token;
+    }
+    helpers.__retractRequestToken = __retractRequestToken;
+    function __generateTokenString(payload, expirationInHours) {
+        return (0, jsonwebtoken_1.sign)(payload, _jwt_secret, { expiresIn: `${expirationInHours}h` });
+    }
+    helpers.__generateTokenString = __generateTokenString;
+})(helpers || (helpers = {}));
+var securityService;
+(function (securityService) {
+    function initialize(jwt_secret) {
+        _jwt_secret = jwt_secret;
+        _client_secrets.length = 0;
+    }
+    securityService.initialize = initialize;
+    function registerClient(client_secret) {
+        _client_secrets.push(client_secret);
+    }
+    securityService.registerClient = registerClient;
+    let token;
+    (function (token) {
+        function refresh(user_id, refreshCode, expirationInHours) {
+            return helpers.__generateTokenString({ user_id: user_id, code: refreshCode }, expirationInHours);
+        }
+        token.refresh = refresh;
+        function data(user_id, account_id, admin, expirationInHours, data) {
+            return helpers.__generateTokenString({ user_id: user_id, account_id: account_id, admin: admin, data: data }, expirationInHours);
+        }
+        token.data = data;
+        function client(client) {
+            return helpers.__generateTokenString({ client: client }, 1);
+        }
+        token.client = client;
+    })(token = securityService.token || (securityService.token = {}));
+    let middleware;
+    (function (middleware) {
+        function client(request, response, next) {
+            try {
+                const payload = helpers.__validateTokenAndGetPayload(helpers.__retractRequestToken(request));
+                if (payload.client && payload.client != undefined && payload.client != '' && _client_secrets.find((secret) => { return secret == payload.client; }) != undefined) {
+                    next();
+                }
+                else {
+                    response.status(401);
+                    response.json({ error: 'auth token validation error' });
+                    return;
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    response.status(401);
+                    response.json({ error: error.message });
+                    return;
+                }
+                else {
+                    response.status(401);
+                    response.json({ error: 'auth token validation error' });
+                    return;
+                }
+            }
+        }
+        middleware.client = client;
+        function refresh(request, response, next) {
+            request.payload = undefined;
+            try {
+                const payload = helpers.__validateTokenAndGetPayload(helpers.__retractRequestToken(request));
+                request.payload = { user_id: payload.user_id, code: payload.code };
+                next();
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    response.status(410);
+                    response.json({ error: error.message });
+                    return;
+                }
+                else {
+                    response.status(410);
+                    response.json({ error: 'refresh token validation error' });
+                    return;
+                }
+            }
+        }
+        middleware.refresh = refresh;
+        function simple(request, response, next) {
+            request.payload = undefined;
+            try {
+                const payload = helpers.__validateTokenAndGetPayload(helpers.__retractRequestToken(request));
+                request.payload = { user_id: payload.user_id, account_id: undefined, admin: payload.admin };
+                next();
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    response.status(401);
+                    response.json({ error: error.message });
+                    return;
+                }
+                else {
+                    response.status(401);
+                    response.json({ error: 'auth token validation error' });
+                    return;
+                }
+            }
+        }
+        middleware.simple = simple;
+        function full(request, response, next) {
+            request.payload = undefined;
+            try {
+                const payload = helpers.__validateTokenAndGetPayload(helpers.__retractRequestToken(request));
+                request.payload = { user_id: payload.user_id, account_id: payload.account_id, admin: payload.admin, data: payload.data };
+                next();
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    response.status(401);
+                    response.json({ error: error.message });
+                    return;
+                }
+                else {
+                    response.status(401);
+                    response.json({ error: 'auth token validation error' });
+                    return;
+                }
+            }
+        }
+        middleware.full = full;
+        function admin(request, response, next) {
+            if (request.payload && request.payload.admin) {
+                next();
+            }
+            else {
+                response.status(403);
+                response.json({ error: 'insufficient priviledges' });
+            }
+        }
+        middleware.admin = admin;
+        function data(request, response, next) {
+            if (request.payload && request.payload.data && request.payload.data != undefined) {
+                next();
+            }
+            else {
+                response.status(400);
+                response.json({ error: 'malformed payload data' });
+            }
+        }
+        middleware.data = data;
+        function checkAdmin(request, response, next) {
+            simple(request, response, () => {
+                admin(request, response, next);
+            });
+        }
+        middleware.checkAdmin = checkAdmin;
+        function checkData(request, response, next) {
+            full(request, response, () => {
+                data(request, response, next);
+            });
+        }
+        middleware.checkData = checkData;
+    })(middleware = securityService.middleware || (securityService.middleware = {}));
+})(securityService || (exports.securityService = securityService = {}));

package/dist/service/settings.d.ts

@@ -0,0 +1,45 @@
+import { IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+import { User } from '../models';
+export interface IAuthEmailLink {
+    url: string;
+    title: string;
+}
+export interface IAuthPerformers {
+    sendConfirmation(emailAddress: string, displayName: string, isInvited: boolean, confirmationLink: IAuthEmailLink): IResponsePromiseVoid;
+    sendRecover(emailAddress: string, recoverLink: IAuthEmailLink): IResponsePromiseVoid;
+    sendAfterPasswordChanged(emailAddress: string): IResponsePromiseVoid;
+    afterRegistration(account_id: string, user_id: string, account_name: string, account_email: string): IResponsePromise<{
+        id: string;
+    }>;
+    getTokenPayload<T>(user: User): IResponsePromise<T>;
+}
+export interface IAuthSettings {
+    allowSelfRegistration: boolean;
+    allowMultiLogin: boolean;
+    passwordHashLength: number;
+    passwordHashIterations: number;
+    firstAdmin: {
+        name: string;
+        email: string;
+    };
+    overrulingPermission: string | undefined;
+}
+export declare namespace authSettings {
+    function init(settings: IAuthSettings, performers: IAuthPerformers): void;
+    const allowSelfRegistration: boolean;
+    const allowMultiLogin: boolean;
+    const passwordHashLength: number;
+    const passwordHashIterations: number;
+    const firstAdmin: {
+        name: string;
+        email: string;
+    };
+    const overrulingPermission: string | undefined;
+    function sendConfirmation(emailAddress: string, displayName: string, isInvited: boolean, confirmationLink: IAuthEmailLink): IResponsePromiseVoid;
+    function sendRecover(emailAddress: string, confirmationLink: IAuthEmailLink): IResponsePromiseVoid;
+    function sendAfterPasswordChanged(emailAddress: string): IResponsePromiseVoid;
+    function afterRegistration(account_id: string, user_id: string, account_name: string, account_email: string): IResponsePromise<{
+        id: string;
+    }>;
+    function getTokenPayload<T>(user: User): IResponsePromise<T>;
+}

package/dist/service/settings.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authSettings = void 0;
+const core_1 = require("@hapiboo/core");
+var authSettings;
+(function (authSettings) {
+    let _settings = {
+        allowSelfRegistration: true,
+        allowMultiLogin: false,
+        passwordHashLength: 1024,
+        passwordHashIterations: 32,
+        firstAdmin: {
+            name: 'admin',
+            email: 'admin@mk13.studio'
+        },
+        overrulingPermission: undefined
+    };
+    let _performers = undefined;
+    function init(settings, performers) {
+        _settings = settings;
+        _performers = performers;
+    }
+    authSettings.init = init;
+    authSettings.allowSelfRegistration = (() => {
+        return _settings.allowSelfRegistration;
+    })();
+    authSettings.allowMultiLogin = (() => {
+        return _settings.allowMultiLogin;
+    })();
+    authSettings.passwordHashLength = (() => {
+        return _settings.passwordHashLength;
+    })();
+    authSettings.passwordHashIterations = (() => {
+        return _settings.passwordHashIterations;
+    })();
+    authSettings.firstAdmin = (() => {
+        return {
+            name: _settings.firstAdmin.name,
+            email: _settings.firstAdmin.email
+        };
+    })();
+    authSettings.overrulingPermission = (() => {
+        return _settings.overrulingPermission;
+    })();
+    function sendConfirmation(emailAddress, displayName, isInvited, confirmationLink) {
+        if (_performers) {
+            return _performers.sendConfirmation(emailAddress, displayName, isInvited, confirmationLink);
+        }
+        else {
+            return core_1.promise.createFailedVoidPromise(core_1.ResponseError.getMessageResponse(400, 'Email performers not set in authentication settings.'));
+        }
+    }
+    authSettings.sendConfirmation = sendConfirmation;
+    function sendRecover(emailAddress, confirmationLink) {
+        if (_performers) {
+            return _performers.sendRecover(emailAddress, confirmationLink);
+        }
+        else {
+            return core_1.promise.createFailedVoidPromise(core_1.ResponseError.getMessageResponse(400, 'Email performers not set in authentication settings.'));
+        }
+    }
+    authSettings.sendRecover = sendRecover;
+    function sendAfterPasswordChanged(emailAddress) {
+        if (_performers) {
+            return _performers.sendAfterPasswordChanged(emailAddress);
+        }
+        else {
+            return core_1.promise.createFailedVoidPromise(core_1.ResponseError.getMessageResponse(400, 'Email performers not set in authentication settings.'));
+        }
+    }
+    authSettings.sendAfterPasswordChanged = sendAfterPasswordChanged;
+    function afterRegistration(account_id, user_id, account_name, account_email) {
+        if (_performers) {
+            return _performers.afterRegistration(account_id, user_id, account_name, account_email);
+        }
+        else {
+            return core_1.promise.createFailedPromise(core_1.ResponseError.getMessageResponse(400, 'Email performers not set in authentication settings.'));
+        }
+    }
+    authSettings.afterRegistration = afterRegistration;
+    function getTokenPayload(user) {
+        if (_performers) {
+            return _performers.getTokenPayload(user);
+        }
+        else {
+            return core_1.promise.createFailedPromise(core_1.ResponseError.getMessageResponse(400, 'Email performers not set in authentication settings.'));
+        }
+    }
+    authSettings.getTokenPayload = getTokenPayload;
+})(authSettings || (exports.authSettings = authSettings = {}));

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@hapiboo/module-auth",
+  "version": "1.0.0",
+  "description": "MK13 Studio Hapiboo - Auth Module",
+  "author": "MK13 Studio",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hapiboo/core": "^3.0.1",
+    "@hapiboo/crypto": "^3.0.0",
+    "@hapiboo/date": "^3.0.1",
+    "@hapiboo/flux": "^1.1.1",
+    "@hapiboo/server": "^3.0.0",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.2",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "eslint": "^9.39.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0"
+  },
+  "scripts": {
+    "version-to-publish": "pnpm exec tsx ../../scripts/version_update.ts packages/_auth --publish-version",
+    "publish-check": "bash ../../scripts/publish.sh ./",
+    "version-to-children": "pnpm exec tsx ../../scripts/version_update.ts packages/_auth --update-children",
+    "ci:publish-prepare": "rm -f pnpm-lock.yaml && rm -rf node_modules dist && pnpm install --ignore-workspace --no-frozen-lockfile && eslint 'src/*.ts' && echo \"Linter OK\" && tsc && echo \"Build OK\"",
+    "ci:publish": "pnpm ci:publish-prepare && pnpm version-to-publish && pnpm publish-check && pnpm version-to-children"
+  }
+}