@furystack/rest-service 4.0.19

package/dist/http-authentication-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-authentication-settings.d.ts","sourceRoot":"","sources":["../src/http-authentication-settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAc,MAAM,mBAAmB,CAAA;AAE7D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAEzD;;GAEG;AACH,qBACa,0BAA0B,CAAC,KAAK,SAAS,IAAI,EAAE,QAAQ,SAAS,cAAc;IAClF,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAA+B;IAE1D,YAAY,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,aAAa,CAAC,KAAK,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,MAAM,KAAK,CAAC,CAEtB;IAEhF,eAAe,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,aAAa,CAAC,QAAQ,EAAE,MAAM,QAAQ,CAAC,CACI;IAE5F,UAAU,SAAQ;IAClB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAkD;IACvF,eAAe,UAAO;CAC9B"}

package/dist/http-authentication-settings.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAuthenticationSettings = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@furystack/core");
+const inject_1 = require("@furystack/inject");
+const hash_js_1 = require("hash.js");
+const default_session_1 = require("./models/default-session");
+/**
+ * Authentication settings object for FuryStack HTTP Api
+ */
+let HttpAuthenticationSettings = class HttpAuthenticationSettings {
+    constructor() {
+        this.model = core_1.User;
+        this.getUserStore = (sm) => sm.getStoreFor(core_1.User, 'username');
+        this.getSessionStore = (sm) => sm.getStoreFor(default_session_1.DefaultSession, 'sessionId');
+        this.cookieName = 'fss';
+        this.hashMethod = (plain) => (0, hash_js_1.sha256)().update(plain).digest('hex');
+        this.enableBasicAuth = true;
+    }
+};
+HttpAuthenticationSettings = (0, tslib_1.__decorate)([
+    (0, inject_1.Injectable)({ lifetime: 'singleton' })
+], HttpAuthenticationSettings);
+exports.HttpAuthenticationSettings = HttpAuthenticationSettings;
+//# sourceMappingURL=http-authentication-settings.js.map

package/dist/http-authentication-settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-authentication-settings.js","sourceRoot":"","sources":["../src/http-authentication-settings.ts"],"names":[],"mappings":";;;;AAAA,0CAAmE;AACnE,8CAA6D;AAC7D,qCAAgC;AAChC,8DAAyD;AAEzD;;GAEG;AAEH,IAAa,0BAA0B,GAAvC,MAAa,0BAA0B;IAAvC;QACS,UAAK,GAAyB,WAA4B,CAAA;QAE1D,iBAAY,GAA6F,CAC9G,EAAE,EACF,EAAE,CAAC,EAAE,CAAC,WAAW,CAA4C,WAAW,EAAE,UAAU,CAAC,CAAA;QAEhF,oBAAe,GAA4E,CAAC,EAAE,EAAE,EAAE,CACvG,EAAE,CAAC,WAAW,CAAC,gCAAc,EAAE,WAAW,CAAuD,CAAA;QAE5F,eAAU,GAAG,KAAK,CAAA;QAClB,eAAU,GAA8B,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,gBAAM,GAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;QACvF,oBAAe,GAAG,IAAI,CAAA;IAC/B,CAAC;CAAA,CAAA;AAbY,0BAA0B;IADtC,IAAA,mBAAU,EAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;GACzB,0BAA0B,CAatC;AAbY,gEAA0B"}

package/dist/http-user-context.d.ts

@@ -0,0 +1,54 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { User, StoreManager } from '@furystack/core';
+import { HttpAuthenticationSettings } from './http-authentication-settings';
+import { DefaultSession } from 'models/default-session';
+/**
+ * Injectable UserContext for FuryStack HTTP Api
+ */
+export declare class HttpUserContext {
+    readonly authentication: HttpAuthenticationSettings<User, DefaultSession>;
+    private readonly storeManager;
+    getUserStore: () => import("@furystack/core").PhysicalStore<User & {
+        password: string;
+    }, keyof User>;
+    getSessionStore: () => import("@furystack/core").PhysicalStore<DefaultSession, keyof DefaultSession>;
+    private user?;
+    /**
+     * @param request The request to be authenticated
+     * @returns if the current user is authenticated
+     */
+    isAuthenticated(request: IncomingMessage): Promise<boolean>;
+    /**
+     * Returns if the current user can be authorized with ALL of the specified roles
+     *
+     * @param request The request to be authenticated
+     * @param roles The list of roles to authorize
+     * @returns a boolean value that indicates if the user is authenticated
+     */
+    isAuthorized(request: IncomingMessage, ...roles: string[]): Promise<boolean>;
+    /**
+     * Checks if the system contains a user with the provided name and password, throws an error otherwise
+     *
+     * @param userName The username
+     * @param password The password
+     * @returns the authenticated User
+     */
+    authenticateUser(userName: string, password: string): Promise<{
+        username: string;
+        roles: string[];
+    }>;
+    getCurrentUser(request: IncomingMessage): Promise<User>;
+    getSessionIdFromRequest(request: IncomingMessage): string | null;
+    authenticateRequest(request: IncomingMessage): Promise<User>;
+    /**
+     * Creates and sets up a cookie-based session for the provided user
+     *
+     * @param user The user to create a session for
+     * @param serverResponse A serverResponse to set the cookie
+     * @returns the current User
+     */
+    cookieLogin(user: User, serverResponse: ServerResponse): Promise<User>;
+    cookieLogout(request: IncomingMessage, response: ServerResponse): Promise<void>;
+    constructor(authentication: HttpAuthenticationSettings<User, DefaultSession>, storeManager: StoreManager);
+}
+//# sourceMappingURL=http-user-context.d.ts.map

package/dist/http-user-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-user-context.d.ts","sourceRoot":"","sources":["../src/http-user-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAA;AACtD,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAGpD,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAEvD;;GAEG;AACH,qBACa,eAAe;aAiJR,cAAc,EAAE,0BAA0B,CAAC,IAAI,EAAE,cAAc,CAAC;IAChF,OAAO,CAAC,QAAQ,CAAC,YAAY;IAjJxB,YAAY;;mBAA4D;IAExE,eAAe,sFAA+D;IAErF,OAAO,CAAC,IAAI,CAAC,CAAM;IAEnB;;;OAGG;IACU,eAAe,CAAC,OAAO,EAAE,eAAe;IASrD;;;;;;OAMG;IACU,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAUzF;;;;;;OAMG;IACU,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;IAkBnD,cAAc,CAAC,OAAO,EAAE,eAAe;IAQ7C,uBAAuB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI;IAkB1D,mBAAmB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BzE;;;;;;OAMG;IACU,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtE,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,cAAc;gBAY1D,cAAc,EAAE,0BAA0B,CAAC,IAAI,EAAE,cAAc,CAAC,EAC/D,YAAY,EAAE,YAAY;CAE9C"}

package/dist/http-user-context.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpUserContext = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@furystack/core");
+const inject_1 = require("@furystack/inject");
+const uuid_1 = require("uuid");
+const http_authentication_settings_1 = require("./http-authentication-settings");
+/**
+ * Injectable UserContext for FuryStack HTTP Api
+ */
+let HttpUserContext = class HttpUserContext {
+    constructor(authentication, storeManager) {
+        this.authentication = authentication;
+        this.storeManager = storeManager;
+        this.getUserStore = () => this.authentication.getUserStore(this.storeManager);
+        this.getSessionStore = () => this.authentication.getSessionStore(this.storeManager);
+    }
+    /**
+     * @param request The request to be authenticated
+     * @returns if the current user is authenticated
+     */
+    async isAuthenticated(request) {
+        try {
+            const currentUser = await this.getCurrentUser(request);
+            return currentUser !== null;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Returns if the current user can be authorized with ALL of the specified roles
+     *
+     * @param request The request to be authenticated
+     * @param roles The list of roles to authorize
+     * @returns a boolean value that indicates if the user is authenticated
+     */
+    async isAuthorized(request, ...roles) {
+        const currentUser = await this.getCurrentUser(request);
+        for (const role of roles) {
+            if (!currentUser || !currentUser.roles.some((c) => c === role)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Checks if the system contains a user with the provided name and password, throws an error otherwise
+     *
+     * @param userName The username
+     * @param password The password
+     * @returns the authenticated User
+     */
+    async authenticateUser(userName, password) {
+        const match = (password &&
+            password.length &&
+            (await this.getUserStore().find({
+                filter: {
+                    username: { $eq: userName },
+                    password: { $eq: this.authentication.hashMethod(password) },
+                },
+            }))) ||
+            [];
+        if (match.length === 1) {
+            const { password: pw, ...user } = match[0];
+            return user;
+        }
+        throw Error('Failed to authenticate.');
+    }
+    async getCurrentUser(request) {
+        if (!this.user) {
+            this.user = await this.authenticateRequest(request);
+            return this.user;
+        }
+        return this.user;
+    }
+    getSessionIdFromRequest(request) {
+        if (request.headers.cookie) {
+            const cookies = request.headers.cookie
+                .toString()
+                .split(';')
+                .filter((val) => val.length > 0)
+                .map((val) => {
+                const [name, value] = val.split('=');
+                return { name: name.trim(), value: value.trim() };
+            });
+            const sessionCookie = cookies.find((c) => c.name === this.authentication.cookieName);
+            if (sessionCookie) {
+                return sessionCookie.value;
+            }
+        }
+        return null;
+    }
+    async authenticateRequest(request) {
+        // Basic auth
+        if (this.authentication.enableBasicAuth && request.headers.authorization) {
+            const authData = Buffer.from(request.headers.authorization.toString().split(' ')[1], 'base64');
+            const [userName, password] = authData.toString().split(':');
+            return await this.authenticateUser(userName, password);
+        }
+        // Cookie auth
+        const sessionId = this.getSessionIdFromRequest(request);
+        if (sessionId) {
+            const [session] = await this.getSessionStore().find({ filter: { sessionId: { $eq: sessionId } }, top: 2 });
+            if (session) {
+                const userResult = await this.getUserStore().find({
+                    filter: {
+                        username: { $eq: session.username },
+                    },
+                    top: 2,
+                });
+                if (userResult.length === 1) {
+                    const { password, ...user } = userResult[0];
+                    return user;
+                }
+                throw Error('Inconsistent session result');
+            }
+        }
+        throw Error('Failed to authenticate request');
+    }
+    /**
+     * Creates and sets up a cookie-based session for the provided user
+     *
+     * @param user The user to create a session for
+     * @param serverResponse A serverResponse to set the cookie
+     * @returns the current User
+     */
+    async cookieLogin(user, serverResponse) {
+        const sessionId = (0, uuid_1.v1)();
+        await this.getSessionStore().add({ sessionId, username: user.username });
+        serverResponse.setHeader('Set-Cookie', `${this.authentication.cookieName}=${sessionId}; Path=/; HttpOnly`);
+        this.user = user;
+        return user;
+    }
+    async cookieLogout(request, response) {
+        const sessionId = this.getSessionIdFromRequest(request);
+        response.setHeader('Set-Cookie', `${this.authentication.cookieName}=; Path=/; HttpOnly`);
+        this.user = undefined;
+        if (sessionId) {
+            const sessionStore = this.getSessionStore();
+            const sessions = await sessionStore.find({ filter: { sessionId: { $eq: sessionId } } });
+            await this.getSessionStore().remove(...sessions.map((s) => s[sessionStore.primaryKey]));
+        }
+    }
+};
+HttpUserContext = (0, tslib_1.__decorate)([
+    (0, inject_1.Injectable)({ lifetime: 'scoped' }),
+    (0, tslib_1.__metadata)("design:paramtypes", [http_authentication_settings_1.HttpAuthenticationSettings,
+        core_1.StoreManager])
+], HttpUserContext);
+exports.HttpUserContext = HttpUserContext;
+//# sourceMappingURL=http-user-context.js.map

package/dist/http-user-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-user-context.js","sourceRoot":"","sources":["../src/http-user-context.ts"],"names":[],"mappings":";;;;AACA,0CAAoD;AACpD,8CAA8C;AAC9C,+BAAyB;AACzB,iFAA2E;AAG3E;;GAEG;AAEH,IAAa,eAAe,GAA5B,MAAa,eAAe;IAgJ1B,YACkB,cAAgE,EAC/D,YAA0B;QAD3B,mBAAc,GAAd,cAAc,CAAkD;QAC/D,iBAAY,GAAZ,YAAY,CAAc;QAjJtC,iBAAY,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;QAExE,oBAAe,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;IAgJlF,CAAC;IA5IJ;;;OAGG;IACI,KAAK,CAAC,eAAe,CAAC,OAAwB;QACnD,IAAI;YACF,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAA;YACtD,OAAO,WAAW,KAAK,IAAI,CAAA;SAC5B;QAAC,OAAO,KAAK,EAAE;YACd,OAAO,KAAK,CAAA;SACb;IACH,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,YAAY,CAAC,OAAwB,EAAE,GAAG,KAAe;QACpE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAA;QACtD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,IAAI,CAAC,WAAW,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE;gBAC9D,OAAO,KAAK,CAAA;aACb;SACF;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,gBAAgB,CAAC,QAAgB,EAAE,QAAgB;QAC9D,MAAM,KAAK,GACT,CAAC,QAAQ;YACP,QAAQ,CAAC,MAAM;YACf,CAAC,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC;gBAC9B,MAAM,EAAE;oBACN,QAAQ,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE;oBAC3B,QAAQ,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;iBAC5D;aACF,CAAC,CAAC,CAAC;YACN,EAAE,CAAA;QACJ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YAC1C,OAAO,IAAI,CAAA;SACZ;QACD,MAAM,KAAK,CAAC,yBAAyB,CAAC,CAAA;IACxC,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,OAAwB;QAClD,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YACd,IAAI,CAAC,IAAI,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAA;YACnD,OAAO,IAAI,CAAC,IAAI,CAAA;SACjB;QACD,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAEM,uBAAuB,CAAC,OAAwB;QACrD,IAAI,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE;YAC1B,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM;iBACnC,QAAQ,EAAE;iBACV,KAAK,CAAC,GAAG,CAAC;iBACV,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;iBAC/B,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;gBACX,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;gBACpC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAA;YACnD,CAAC,CAAC,CAAA;YACJ,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAA;YACpF,IAAI,aAAa,EAAE;gBACjB,OAAO,aAAa,CAAC,KAAK,CAAA;aAC3B;SACF;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAEM,KAAK,CAAC,mBAAmB,CAAC,OAAwB;QACvD,aAAa;QACb,IAAI,IAAI,CAAC,cAAc,CAAC,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE;YACxE,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAA;YAC9F,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YAC3D,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;SACvD;QAED,cAAc;QACd,MAAM,SAAS,GAAG,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAA;QACvD,IAAI,SAAS,EAAE;YACb,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAA;YAC1G,IAAI,OAAO,EAAE;gBACX,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC;oBAChD,MAAM,EAAE;wBACN,QAAQ,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,QAAQ,EAAE;qBACpC;oBACD,GAAG,EAAE,CAAC;iBACP,CAAC,CAAA;gBACF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;oBAC3B,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAA;oBAC3C,OAAO,IAAI,CAAA;iBACZ;gBACD,MAAM,KAAK,CAAC,6BAA6B,CAAC,CAAA;aAC3C;SACF;QAED,MAAM,KAAK,CAAC,gCAAgC,CAAC,CAAA;IAC/C,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,WAAW,CAAC,IAAU,EAAE,cAA8B;QACjE,MAAM,SAAS,GAAG,IAAA,SAAE,GAAE,CAAA;QACtB,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAA;QACxE,cAAc,CAAC,SAAS,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,IAAI,SAAS,oBAAoB,CAAC,CAAA;QAC1G,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,OAAO,IAAI,CAAA;IACb,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,OAAwB,EAAE,QAAwB;QAC1E,MAAM,SAAS,GAAG,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAA;QACvD,QAAQ,CAAC,SAAS,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,qBAAqB,CAAC,CAAA;QACxF,IAAI,CAAC,IAAI,GAAG,SAAS,CAAA;QACrB,IAAI,SAAS,EAAE;YACb,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,CAAA;YAC3C,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAA;YACvF,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;SACxF;IACH,CAAC;CAMF,CAAA;AApJY,eAAe;IAD3B,IAAA,mBAAU,EAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;kDAkJC,yDAA0B;QAC3B,mBAAY;GAlJlC,eAAe,CAoJ3B;AApJY,0CAAe"}

package/dist/http-user-context.spec.d.ts

@@ -0,0 +1,4 @@
+import { Injector } from '@furystack/inject';
+import './injector-extensions';
+export declare const prepareInjector: (i: Injector) => Promise<void>;
+//# sourceMappingURL=http-user-context.spec.d.ts.map

package/dist/http-user-context.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-user-context.spec.d.ts","sourceRoot":"","sources":["../src/http-user-context.spec.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAI5C,OAAO,uBAAuB,CAAA;AAE9B,eAAO,MAAM,eAAe,MAAa,QAAQ,kBAShD,CAAA"}

package/dist/http-user-context.spec.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareInjector = void 0;
+const utils_1 = require("@furystack/utils");
+const inject_1 = require("@furystack/inject");
+const core_1 = require("@furystack/core");
+const default_session_1 = require("./models/default-session");
+const http_user_context_1 = require("./http-user-context");
+require("./injector-extensions");
+const prepareInjector = async (i) => {
+    i.setupStores((sm) => sm
+        .addStore(new core_1.InMemoryStore({ model: core_1.User, primaryKey: 'username' }))
+        .addStore(new core_1.InMemoryStore({ model: default_session_1.DefaultSession, primaryKey: 'sessionId' })));
+    i.useHttpAuthentication();
+    // await i.getInstance(ServerManager).getOrCreate({ port: 19999 })
+};
+exports.prepareInjector = prepareInjector;
+describe('HttpUserContext', () => {
+    const request = { headers: {} };
+    const response = {};
+    const testUser = { username: 'testUser', roles: ['grantedRole1', 'grantedRole2'] };
+    it('Should be constructed with the extension method', async () => {
+        await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+            await (0, exports.prepareInjector)(i);
+            const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+            expect(ctx).toBeInstanceOf(http_user_context_1.HttpUserContext);
+        });
+    });
+    describe('isAuthenticated', () => {
+        it('Should return true for authenticated users', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.getCurrentUser = jest.fn(async () => testUser);
+                const value = await ctx.isAuthenticated(request);
+                expect(value).toBe(true);
+                expect(ctx.getCurrentUser).toBeCalled();
+            });
+        });
+        it('Should return false for unauthenticated users', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.getCurrentUser = jest.fn(async () => {
+                    throw Error(':(');
+                });
+                await expect(ctx.isAuthenticated(request)).resolves.toEqual(false);
+                expect(ctx.getCurrentUser).toBeCalled();
+            });
+        });
+    });
+    describe('isAuthorized', () => {
+        it('Should return true if all roles are authorized', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.getCurrentUser = jest.fn(async () => testUser);
+                const value = await ctx.isAuthorized(request, 'grantedRole1', 'grantedRole2');
+                expect(value).toBe(true);
+                expect(ctx.getCurrentUser).toBeCalled();
+            });
+        });
+        it('Should return false if not all roles are authorized', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.getCurrentUser = jest.fn(async () => testUser);
+                const value = await ctx.isAuthorized(request, 'grantedRole1', 'nonGrantedRole2');
+                expect(value).toBe(false);
+                expect(ctx.getCurrentUser).toBeCalled();
+            });
+        });
+    });
+    describe('authenticateUser', () => {
+        it('Should fail when the store is empty', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                await expect(ctx.authenticateUser('user', 'password')).rejects.toThrow('');
+            });
+        });
+        it('Should fail when the password not equals', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authentication
+                    .getUserStore(i.getInstance(core_1.StoreManager))
+                    .add({ username: 'user', password: ctx.authentication.hashMethod('pass123'), roles: [] });
+                await expect(ctx.authenticateUser('user', 'pass321')).rejects.toThrow('');
+            });
+        });
+        it('Should fail when the username not equals', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authentication
+                    .getUserStore(i.getInstance(core_1.StoreManager))
+                    .add({ username: 'otherUser', password: ctx.authentication.hashMethod('pass123'), roles: [] });
+                expect(ctx.authenticateUser('user', 'pass123')).rejects.toThrow('');
+            });
+        });
+        it('Should fail when password not provided', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authentication
+                    .getUserStore(i.getInstance(core_1.StoreManager))
+                    .add({ username: 'otherUser', password: ctx.authentication.hashMethod('pass123'), roles: [] });
+                await expect(ctx.authenticateUser('user', '')).rejects.toThrow('');
+            });
+        });
+        it('Should return the user without the password hash when the username and password matches', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                const store = ctx.authentication.getUserStore(i.getInstance(core_1.StoreManager));
+                const loginUser = { username: 'user', roles: [] };
+                store.add({ ...loginUser, password: ctx.authentication.hashMethod('pass123') });
+                const value = await ctx.authenticateUser('user', 'pass123');
+                expect(value).toEqual(loginUser);
+            });
+        });
+    });
+    describe('getSessionIdFromRequest', () => {
+        it('Should return null if no headers present', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                const sid = ctx.getSessionIdFromRequest(request);
+                expect(sid).toBeNull();
+            });
+        });
+        it('Should return null if no session ID cookie present', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const requestWithCookie = { ...request, cookie: 'a=2;b=3;c=4;' };
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                const sid = ctx.getSessionIdFromRequest(requestWithCookie);
+                expect(sid).toBeNull();
+            });
+        });
+        it('Should return the Session ID value if session ID cookie present', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                const requestWithAuthCookie = {
+                    ...request,
+                    headers: { cookie: `a=2;b=3;${ctx.authentication.cookieName}=666;c=4;` },
+                };
+                const sid = ctx.getSessionIdFromRequest(requestWithAuthCookie);
+                expect(sid).toBe('666');
+            });
+        });
+    });
+    describe('authenticateRequest', () => {
+        it('Should try to authenticate with Basic, if enabled', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authenticateUser = jest.fn(async () => testUser);
+                const result = await ctx.authenticateRequest({
+                    headers: { authorization: `Basic dGVzdHVzZXI6cGFzc3dvcmQ=` },
+                });
+                expect(ctx.authenticateUser).toBeCalledWith('testuser', 'password');
+                expect(result).toBe(testUser);
+            });
+        });
+        it('Should NOT try to authenticate with Basic, if disabled', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authentication.enableBasicAuth = false;
+                ctx.authenticateUser = jest.fn(async () => testUser);
+                await expect(ctx.authenticateRequest({
+                    headers: { authorization: `Basic dGVzdHVzZXI6cGFzc3dvcmQ=` },
+                })).rejects.toThrow('');
+                expect(ctx.authenticateUser).not.toBeCalled();
+            });
+        });
+        it('Should fail with no session in the store', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                await expect(ctx.authenticateRequest({
+                    headers: { cookie: `${ctx.authentication.cookieName}=666;a=3` },
+                })).rejects.toThrow('');
+            });
+        });
+        it('Should fail with valid session Id but no user', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authentication
+                    .getSessionStore(i.getInstance(core_1.StoreManager))
+                    .add({ sessionId: '666', username: testUser.username });
+                await expect(ctx.authenticateRequest({
+                    headers: { cookie: `${ctx.authentication.cookieName}=666;a=3` },
+                })).rejects.toThrow('');
+            });
+        });
+        it('Should authenticate with cookie, if the session IDs matches', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authentication
+                    .getSessionStore(i.getInstance(core_1.StoreManager))
+                    .add({ sessionId: '666', username: testUser.username });
+                ctx.authentication.getUserStore(i.getInstance(core_1.StoreManager)).add({ ...testUser, password: '' });
+                const result = await ctx.authenticateRequest({
+                    headers: { cookie: `${ctx.authentication.cookieName}=666;a=3` },
+                });
+                expect(result).toEqual(testUser);
+            });
+        });
+    });
+    describe('getCurrentUser', () => {
+        it('Should return the current user from authenticateRequest() once per request', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                ctx.authenticateRequest = jest.fn(async () => testUser);
+                const result = await ctx.getCurrentUser(request);
+                const result2 = await ctx.getCurrentUser(request);
+                expect(ctx.authenticateRequest).toBeCalledTimes(1);
+                expect(result).toBe(testUser);
+                expect(result2).toBe(testUser);
+            });
+        });
+    });
+    describe('cookieLogin', () => {
+        it('Should return the current user from authenticateRequest() once per request', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                const setHeader = jest.fn();
+                ctx.getSessionStore().add = jest.fn(async () => {
+                    return {};
+                });
+                const authResult = await ctx.cookieLogin(testUser, { setHeader });
+                expect(authResult).toBe(testUser);
+                expect(setHeader).toBeCalled();
+                expect(ctx.getSessionStore().add).toBeCalled();
+            });
+        });
+    });
+    describe('cookieLogout', () => {
+        it('Should invalidate the current session id cookie', async () => {
+            await (0, utils_1.usingAsync)(new inject_1.Injector(), async (i) => {
+                await (0, exports.prepareInjector)(i);
+                const ctx = i.getInstance(http_user_context_1.HttpUserContext);
+                const setHeader = jest.fn();
+                ctx.getSessionStore().add = jest.fn(async () => {
+                    return {};
+                });
+                ctx.authenticateRequest = jest.fn(async () => testUser);
+                ctx.getSessionStore().remove = jest.fn(async () => undefined);
+                ctx.getSessionIdFromRequest = () => 'example-session-id';
+                response.setHeader = jest.fn(() => response);
+                await ctx.cookieLogin(testUser, { setHeader });
+                await ctx.cookieLogout(request, response);
+                expect(response.setHeader).toBeCalledWith('Set-Cookie', 'fss=; Path=/; HttpOnly');
+                expect(ctx.getSessionStore().remove).toBeCalled();
+            });
+        });
+    });
+});
+//# sourceMappingURL=http-user-context.spec.js.map