@mis-wis/common 0.1.9 → 0.2.1

package/esm2020/lib/services/session.service.mjs

@@ -0,0 +1,198 @@
+import { Injectable } from '@angular/core';
+import jwtDecode from 'jwt-decode';
+import { getCookie } from '../functions/cookie.function';
+import { getQueryParam } from '../functions/url.functions';
+import { describeClaimFailures, SessionClaimNotFoundError, SessionClaimsMissingError, SessionError, SessionTokenExpiredError, SessionTokenInvalidError, SessionTokenNotFoundError, } from './session.errors';
+import * as i0 from "@angular/core";
+const DEFAULT_SESSION_TOKEN_PREFIX = 'sso-wis-token';
+const DEFAULT_SESSION_TOKEN_FALLBACK_KEY = 'x-wis-token';
+const DEFAULT_VET_TOKEN_PREFIX = 'x-vet-token';
+const LAUNCH_SOURCE_VET = 'VET';
+export class SessionService {
+    constructor() {
+        this.config = {};
+        this.cachedToken = null;
+        this.cachedState = null;
+        this.collecting = null;
+    }
+    init(config) {
+        this.config = { ...config };
+        this.cachedToken = null;
+        this.cachedState = null;
+    }
+    /**
+     * Runs `handlers.next` and returns its result, or `handlers.error(error)` if it throws a `SessionError`.
+     * Centralizes the try/catch mechanics; the caller still supplies the actual handling logic.
+     */
+    read(handlers) {
+        try {
+            return handlers.next(this);
+        }
+        catch (e) {
+            if (e instanceof SessionError) {
+                return handlers.error(e);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Statement-style variant of `read` for blocks of assignments/side effects with no return value.
+     *
+     * `next` always runs to completion: a claim that is absent or blank yields `undefined` instead of
+     * throwing, and every such failure is reported once afterwards via `handlers.error`, as a
+     * `SessionClaimsMissingError` listing all of them. An unusable token (missing, expired,
+     * undecodable) still aborts `next` immediately with the matching `SessionError`.
+     *
+     * Collecting covers the synchronous body of `next` only — claim reads deferred into a subscription,
+     * timeout or promise run after it has returned and throw as usual.
+     *
+     * An error `next` throws for any other reason propagates untouched, except that any claims missing
+     * at the time are appended to its message and attached as `sessionClaimFailures` — a collected
+     * `undefined` reaching the block is the usual cause, and that is the part worth knowing.
+     */
+    run(handlers) {
+        const failures = [];
+        const previous = this.collecting;
+        this.collecting = failures;
+        try {
+            handlers.next(this);
+        }
+        catch (e) {
+            if (e instanceof SessionError) {
+                handlers.error(e);
+                return;
+            }
+            if (failures.length && e instanceof Error) {
+                e.sessionClaimFailures = failures;
+                e.message = `${e.message} — session claims missing during run(): ${describeClaimFailures(failures)}`;
+            }
+            throw e;
+        }
+        finally {
+            this.collecting = previous;
+        }
+        if (failures.length) {
+            handlers.error(new SessionClaimsMissingError(failures));
+        }
+    }
+    get isVET() {
+        return this.state.isVET;
+    }
+    get sub() { return this.getClaim('sub'); }
+    get empGuid() { return this.getClaim('employeeGUID'); }
+    get employeeId() { return this.getClaim('employeeId'); }
+    get internalSsoRole() { return this.getClaim('internal_sso_role'); }
+    get roles() { return this.getClaim('roles'); }
+    get sessionId() { return this.getClaim('sessionId'); }
+    get loggedInUser() { return this.getClaim('loggedInUser'); }
+    get exp() { return this.getClaim('exp'); }
+    get iat() { return this.getClaim('iat'); }
+    get businessUnitId() { return this.getClaim('businessUnitId'); }
+    get allowedBuids() { return this.getClaim('ALLOWED_BUIDS'); }
+    get vetUserEmailId() { return this.getClaim('vetUserEmailId'); }
+    get vetUserId() { return this.getClaim('vetUserId'); }
+    get source() { return this.getClaim('source'); }
+    get roleId() {
+        const raw = this.resolveRole(this.getClaims());
+        if (!raw) {
+            return this.missingClaim('roleId', 'absent');
+        }
+        return Number(raw);
+    }
+    /** First numeric role in `internal_sso_role` then `roles`, or `''` when the token carries none. */
+    resolveRole(claims) {
+        const candidates = [claims.internal_sso_role, ...(claims.roles ?? [])];
+        return candidates
+            .map(value => value?.trim())
+            .find(value => this.isDigitsOnly(value)) ?? '';
+    }
+    isDigitsOnly(value) {
+        return !!value && /^\d+$/.test(value);
+    }
+    getClaims() {
+        const state = this.state;
+        if (state.status === 'ok') {
+            return state.claims;
+        }
+        if (state.status === 'not-found') {
+            throw new SessionTokenNotFoundError();
+        }
+        if (state.status === 'expired') {
+            throw new SessionTokenExpiredError();
+        }
+        throw new SessionTokenInvalidError();
+    }
+    getClaim(key) {
+        const claims = this.getClaims();
+        const value = claims[key];
+        const isEmptyString = typeof value === 'string' && value.trim() === '';
+        if (value === undefined || value === null || isEmptyString) {
+            return this.missingClaim(key, isEmptyString ? 'blank' : 'absent');
+        }
+        return (typeof value === 'string' ? value.trim() : value);
+    }
+    /** Records the failure and yields `undefined` while `run` is collecting; throws otherwise. */
+    missingClaim(claim, reason) {
+        if (this.collecting) {
+            this.collecting.push({ claim, reason });
+            return undefined;
+        }
+        throw new SessionClaimNotFoundError(claim);
+    }
+    get state() {
+        const { token, isVET } = this.findToken();
+        if (!this.cachedState || token !== this.cachedToken) {
+            this.cachedToken = token;
+            this.cachedState = this.build(token, isVET);
+        }
+        return this.cachedState;
+    }
+    build(token, isVET) {
+        if (!token) {
+            return { status: 'not-found', isVET };
+        }
+        let claims;
+        try {
+            claims = jwtDecode(token);
+        }
+        catch {
+            return { status: 'invalid', isVET };
+        }
+        if (this.isExpired(claims)) {
+            return { status: 'expired', isVET };
+        }
+        return { status: 'ok', claims, isVET };
+    }
+    isExpired(claims) {
+        return typeof claims.exp === 'number' && claims.exp * 1000 <= Date.now();
+    }
+    isVETSource() {
+        return getQueryParam('source') === LAUNCH_SOURCE_VET;
+    }
+    resolveBuid() {
+        return getQueryParam('buid') || getCookie('buid') || null;
+    }
+    findToken() {
+        const buid = this.resolveBuid();
+        if (this.isVETSource()) {
+            const vetKey = this.config.vetTokenCookieKey ?? (buid ? `${DEFAULT_VET_TOKEN_PREFIX}-${buid}` : null);
+            const vetToken = (vetKey ? getCookie(vetKey) : '') || '';
+            if (vetToken) {
+                return { token: vetToken, isVET: true };
+            }
+        }
+        const sessionToken = this.config.sessionTokenCookieKey
+            ? getCookie(this.config.sessionTokenCookieKey)
+            : (buid ? getCookie(`${DEFAULT_SESSION_TOKEN_PREFIX}-${buid}`) : '') || getCookie(DEFAULT_SESSION_TOKEN_FALLBACK_KEY);
+        return { token: sessionToken || '', isVET: false };
+    }
+}
+SessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SessionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SessionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.service.js","sourceRoot":"","sources":["../../../../../libraries/wis-common/src/lib/services/session.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,SAAS,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,OAAO,EACL,qBAAqB,EAGrB,yBAAyB,EACzB,yBAAyB,EACzB,YAAY,EACZ,wBAAwB,EACxB,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,kBAAkB,CAAC;;AAE1B,MAAM,4BAA4B,GAAG,eAAe,CAAC;AACrD,MAAM,kCAAkC,GAAG,aAAa,CAAC;AACzD,MAAM,wBAAwB,GAAG,aAAa,CAAC;AAC/C,MAAM,iBAAiB,GAAG,KAAK,CAAC;AAsChC,MAAM,OAAO,cAAc;IAH3B;QAIU,WAAM,GAA0B,EAAE,CAAC;QACnC,gBAAW,GAAkB,IAAI,CAAC;QAClC,gBAAW,GAAwB,IAAI,CAAC;QACxC,eAAU,GAAkC,IAAI,CAAC;KA+L1D;IA7LC,IAAI,CAAC,MAA6B;QAChC,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,IAAI,CAAI,QAAqF;QAC3F,IAAI;YACF,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC5B;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,YAAY,YAAY,EAAE;gBAC7B,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;aAC1B;YACD,MAAM,CAAC,CAAC;SACT;IACH,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,QAA2F;QAC7F,MAAM,QAAQ,GAA2B,EAAE,CAAC;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC;QACjC,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC;QAC3B,IAAI;YACF,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACrB;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,YAAY,YAAY,EAAE;gBAC7B,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAClB,OAAO;aACR;YACD,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,YAAY,KAAK,EAAE;gBACxC,CAA+D,CAAC,oBAAoB,GAAG,QAAQ,CAAC;gBACjG,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC,OAAO,2CAA2C,qBAAqB,CAAC,QAAQ,CAAC,EAAE,CAAC;aACtG;YACD,MAAM,CAAC,CAAC;SACT;gBAAS;YACR,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC;SAC5B;QACD,IAAI,QAAQ,CAAC,MAAM,EAAE;YACnB,QAAQ,CAAC,KAAK,CAAC,IAAI,yBAAyB,CAAC,QAAQ,CAAC,CAAC,CAAC;SACzD;IACH,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;IAC1B,CAAC;IAED,IAAI,GAAG,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClD,IAAI,OAAO,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAC/D,IAAI,UAAU,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAChE,IAAI,eAAe,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAC5E,IAAI,KAAK,KAAe,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACxD,IAAI,SAAS,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAC9D,IAAI,YAAY,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IACpE,IAAI,GAAG,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClD,IAAI,GAAG,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClD,IAAI,cAAc,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACxE,IAAI,YAAY,KAAe,OAAO,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IACvE,IAAI,cAAc,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACxE,IAAI,SAAS,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAC9D,IAAI,MAAM,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAExD,IAAI,MAAM;QACR,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QAC/C,IAAI,CAAC,GAAG,EAAE;YACR,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;SAC9C;QACD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IAED,mGAAmG;IAC3F,WAAW,CAAC,MAAyB;QAC3C,MAAM,UAAU,GAAG,CAAC,MAAM,CAAC,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC;QACvE,OAAO,UAAU;aACd,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC;aAC3B,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;IACnD,CAAC;IAEO,YAAY,CAAC,KAAyB;QAC5C,OAAO,CAAC,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAEO,SAAS;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,EAAE;YACzB,OAAO,KAAK,CAAC,MAAM,CAAC;SACrB;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,WAAW,EAAE;YAChC,MAAM,IAAI,yBAAyB,EAAE,CAAC;SACvC;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE;YAC9B,MAAM,IAAI,wBAAwB,EAAE,CAAC;SACtC;QACD,MAAM,IAAI,wBAAwB,EAAE,CAAC;IACvC,CAAC;IAEO,QAAQ,CAAoC,GAAM;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAC1B,MAAM,aAAa,GAAG,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;QACvE,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,aAAa,EAAE;YAC1D,OAAO,IAAI,CAAC,YAAY,CAAC,GAAa,EAAE,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;SAC7E;QACD,OAAO,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAsC,CAAC;IACjG,CAAC;IAED,8FAA8F;IACtF,YAAY,CAAC,KAAa,EAAE,MAAiC;QACnE,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;YACxC,OAAO,SAAkB,CAAC;SAC3B;QACD,MAAM,IAAI,yBAAyB,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED,IAAY,KAAK;QACf,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC1C,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,KAAK,KAAK,IAAI,CAAC,WAAW,EAAE;YACnD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;YACzB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SAC7C;QACD,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAEO,KAAK,CAAC,KAAa,EAAE,KAAc;QACzC,IAAI,CAAC,KAAK,EAAE;YACV,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;SACvC;QAED,IAAI,MAAyB,CAAC;QAC9B,IAAI;YACF,MAAM,GAAG,SAAS,CAAoB,KAAK,CAAC,CAAC;SAC9C;QAAC,MAAM;YACN,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;SACrC;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC1B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;SACrC;QAED,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IACzC,CAAC;IAEO,SAAS,CAAC,MAAyB;QACzC,OAAO,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,GAAG,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;IAC3E,CAAC;IAEO,WAAW;QACjB,OAAO,aAAa,CAAC,QAAQ,CAAC,KAAK,iBAAiB,CAAC;IACvD,CAAC;IAEO,WAAW;QACjB,OAAO,aAAa,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;IAC5D,CAAC;IAEO,SAAS;QACf,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAEhC,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACtB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,wBAAwB,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACtG,MAAM,QAAQ,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;YACzD,IAAI,QAAQ,EAAE;gBACZ,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;aACzC;SACF;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,qBAAqB;YACpD,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC;YAC9C,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,4BAA4B,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,kCAAkC,CAAC,CAAC;QAExH,OAAO,EAAE,KAAK,EAAE,YAAY,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACrD,CAAC;;2GAlMU,cAAc;+GAAd,cAAc,cAFb,MAAM;2FAEP,cAAc;kBAH1B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport jwtDecode from 'jwt-decode';\n\nimport { getCookie } from '../functions/cookie.function';\nimport { getQueryParam } from '../functions/url.functions';\nimport { NsSession } from '../models/session.model';\nimport {\n  describeClaimFailures,\n  ISessionClaimFailure,\n  SessionClaimFailureReason,\n  SessionClaimNotFoundError,\n  SessionClaimsMissingError,\n  SessionError,\n  SessionTokenExpiredError,\n  SessionTokenInvalidError,\n  SessionTokenNotFoundError,\n} from './session.errors';\n\nconst DEFAULT_SESSION_TOKEN_PREFIX = 'sso-wis-token';\nconst DEFAULT_SESSION_TOKEN_FALLBACK_KEY = 'x-wis-token';\nconst DEFAULT_VET_TOKEN_PREFIX = 'x-vet-token';\nconst LAUNCH_SOURCE_VET = 'VET';\n\n/** The accessors that read a single claim, and so can come back `undefined` inside `run`. */\ntype ClaimAccessor =\n  | 'sub'\n  | 'empGuid'\n  | 'employeeId'\n  | 'internalSsoRole'\n  | 'roles'\n  | 'sessionId'\n  | 'loggedInUser'\n  | 'exp'\n  | 'iat'\n  | 'businessUnitId'\n  | 'allowedBuids'\n  | 'vetUserEmailId'\n  | 'vetUserId'\n  | 'source'\n  | 'roleId';\n\n/**\n * The session as seen inside `run`'s `next`. `run` collects missing claims instead of throwing\n * so the block always completes, which means any claim accessor may yield `undefined`.\n * Outside `run` — direct access, or `read` — the accessors still throw and stay non-optional.\n */\nexport type PartialSession = Omit<SessionService, ClaimAccessor> & {\n  readonly [K in ClaimAccessor]: SessionService[K] | undefined;\n};\n\ntype SessionState =\n  | { status: 'ok'; claims: NsSession.IClaims; isVET: boolean }\n  | { status: 'not-found'; isVET: boolean }\n  | { status: 'expired'; isVET: boolean }\n  | { status: 'invalid'; isVET: boolean };\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SessionService {\n  private config: NsSession.IInitConfig = {};\n  private cachedToken: string | null = null;\n  private cachedState: SessionState | null = null;\n  private collecting: ISessionClaimFailure[] | null = null;\n\n  init(config: NsSession.IInitConfig): void {\n    this.config = { ...config };\n    this.cachedToken = null;\n    this.cachedState = null;\n  }\n\n  /**\n   * Runs `handlers.next` and returns its result, or `handlers.error(error)` if it throws a `SessionError`.\n   * Centralizes the try/catch mechanics; the caller still supplies the actual handling logic.\n   */\n  read<T>(handlers: { next: (session: SessionService) => T; error: (error: SessionError) => T }): T {\n    try {\n      return handlers.next(this);\n    } catch (e) {\n      if (e instanceof SessionError) {\n        return handlers.error(e);\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Statement-style variant of `read` for blocks of assignments/side effects with no return value.\n   *\n   * `next` always runs to completion: a claim that is absent or blank yields `undefined` instead of\n   * throwing, and every such failure is reported once afterwards via `handlers.error`, as a\n   * `SessionClaimsMissingError` listing all of them. An unusable token (missing, expired,\n   * undecodable) still aborts `next` immediately with the matching `SessionError`.\n   *\n   * Collecting covers the synchronous body of `next` only — claim reads deferred into a subscription,\n   * timeout or promise run after it has returned and throw as usual.\n   *\n   * An error `next` throws for any other reason propagates untouched, except that any claims missing\n   * at the time are appended to its message and attached as `sessionClaimFailures` — a collected\n   * `undefined` reaching the block is the usual cause, and that is the part worth knowing.\n   */\n  run(handlers: { next: (session: PartialSession) => void; error: (error: SessionError) => void }): void {\n    const failures: ISessionClaimFailure[] = [];\n    const previous = this.collecting;\n    this.collecting = failures;\n    try {\n      handlers.next(this);\n    } catch (e) {\n      if (e instanceof SessionError) {\n        handlers.error(e);\n        return;\n      }\n      if (failures.length && e instanceof Error) {\n        (e as Error & { sessionClaimFailures?: ISessionClaimFailure[] }).sessionClaimFailures = failures;\n        e.message = `${e.message} — session claims missing during run(): ${describeClaimFailures(failures)}`;\n      }\n      throw e;\n    } finally {\n      this.collecting = previous;\n    }\n    if (failures.length) {\n      handlers.error(new SessionClaimsMissingError(failures));\n    }\n  }\n\n  get isVET(): boolean {\n    return this.state.isVET;\n  }\n\n  get sub(): string { return this.getClaim('sub'); }\n  get empGuid(): string { return this.getClaim('employeeGUID'); }\n  get employeeId(): string { return this.getClaim('employeeId'); }\n  get internalSsoRole(): string { return this.getClaim('internal_sso_role'); }\n  get roles(): string[] { return this.getClaim('roles'); }\n  get sessionId(): string { return this.getClaim('sessionId'); }\n  get loggedInUser(): string { return this.getClaim('loggedInUser'); }\n  get exp(): number { return this.getClaim('exp'); }\n  get iat(): number { return this.getClaim('iat'); }\n  get businessUnitId(): string { return this.getClaim('businessUnitId'); }\n  get allowedBuids(): string[] { return this.getClaim('ALLOWED_BUIDS'); }\n  get vetUserEmailId(): string { return this.getClaim('vetUserEmailId'); }\n  get vetUserId(): number { return this.getClaim('vetUserId'); }\n  get source(): string { return this.getClaim('source'); }\n\n  get roleId(): number {\n    const raw = this.resolveRole(this.getClaims());\n    if (!raw) {\n      return this.missingClaim('roleId', 'absent');\n    }\n    return Number(raw);\n  }\n\n  /** First numeric role in `internal_sso_role` then `roles`, or `''` when the token carries none. */\n  private resolveRole(claims: NsSession.IClaims): string {\n    const candidates = [claims.internal_sso_role, ...(claims.roles ?? [])];\n    return candidates\n      .map(value => value?.trim())\n      .find(value => this.isDigitsOnly(value)) ?? '';\n  }\n\n  private isDigitsOnly(value: string | undefined): value is string {\n    return !!value && /^\\d+$/.test(value);\n  }\n\n  private getClaims(): NsSession.IClaims {\n    const state = this.state;\n    if (state.status === 'ok') {\n      return state.claims;\n    }\n    if (state.status === 'not-found') {\n      throw new SessionTokenNotFoundError();\n    }\n    if (state.status === 'expired') {\n      throw new SessionTokenExpiredError();\n    }\n    throw new SessionTokenInvalidError();\n  }\n\n  private getClaim<K extends keyof NsSession.IClaims>(key: K): NonNullable<NsSession.IClaims[K]> {\n    const claims = this.getClaims();\n    const value = claims[key];\n    const isEmptyString = typeof value === 'string' && value.trim() === '';\n    if (value === undefined || value === null || isEmptyString) {\n      return this.missingClaim(key as string, isEmptyString ? 'blank' : 'absent');\n    }\n    return (typeof value === 'string' ? value.trim() : value) as NonNullable<NsSession.IClaims[K]>;\n  }\n\n  /** Records the failure and yields `undefined` while `run` is collecting; throws otherwise. */\n  private missingClaim(claim: string, reason: SessionClaimFailureReason): never {\n    if (this.collecting) {\n      this.collecting.push({ claim, reason });\n      return undefined as never;\n    }\n    throw new SessionClaimNotFoundError(claim);\n  }\n\n  private get state(): SessionState {\n    const { token, isVET } = this.findToken();\n    if (!this.cachedState || token !== this.cachedToken) {\n      this.cachedToken = token;\n      this.cachedState = this.build(token, isVET);\n    }\n    return this.cachedState;\n  }\n\n  private build(token: string, isVET: boolean): SessionState {\n    if (!token) {\n      return { status: 'not-found', isVET };\n    }\n\n    let claims: NsSession.IClaims;\n    try {\n      claims = jwtDecode<NsSession.IClaims>(token);\n    } catch {\n      return { status: 'invalid', isVET };\n    }\n\n    if (this.isExpired(claims)) {\n      return { status: 'expired', isVET };\n    }\n\n    return { status: 'ok', claims, isVET };\n  }\n\n  private isExpired(claims: NsSession.IClaims): boolean {\n    return typeof claims.exp === 'number' && claims.exp * 1000 <= Date.now();\n  }\n\n  private isVETSource(): boolean {\n    return getQueryParam('source') === LAUNCH_SOURCE_VET;\n  }\n\n  private resolveBuid(): string | null {\n    return getQueryParam('buid') || getCookie('buid') || null;\n  }\n\n  private findToken(): { token: string; isVET: boolean } {\n    const buid = this.resolveBuid();\n\n    if (this.isVETSource()) {\n      const vetKey = this.config.vetTokenCookieKey ?? (buid ? `${DEFAULT_VET_TOKEN_PREFIX}-${buid}` : null);\n      const vetToken = (vetKey ? getCookie(vetKey) : '') || '';\n      if (vetToken) {\n        return { token: vetToken, isVET: true };\n      }\n    }\n\n    const sessionToken = this.config.sessionTokenCookieKey\n      ? getCookie(this.config.sessionTokenCookieKey)\n      : (buid ? getCookie(`${DEFAULT_SESSION_TOKEN_PREFIX}-${buid}`) : '') || getCookie(DEFAULT_SESSION_TOKEN_FALLBACK_KEY);\n\n    return { token: sessionToken || '', isVET: false };\n  }\n}\n"]}

package/esm2020/lib/wis-common.module.mjs

@@ -8,25 +8,30 @@ import { LoaderComponent } from "./components/loader/loader.component";
 import { LoaderService } from "./services/loader.service";
 import { OverlayModule } from "@angular/cdk/overlay";
 import { SidenavComponent } from "./components/sidenav/sidenav.component";
+import { CreateNonShiftModalComponent } from "./components/create-non-shift-modal/create-non-shift-modal.component";
+import { DropdownModule } from "mis-crystal-design-system/dropdown";
+import { ReactiveFormsModule } from "@angular/forms";
+import { DatepickerModuleV2 } from "mis-crystal-design-system/datepicker_v2";
+import { HttpClientModule } from "@angular/common/http";
 import * as i0 from "@angular/core";
 export class WisCommonModule {
     static forRoot(env) {
         return {
             ngModule: WisCommonModule,
-            providers: [{ provide: CONSTANTS_WIS_COMMON, useValue: env }, ConfigurationService, LoaderService]
+            providers: [HttpService, { provide: CONSTANTS_WIS_COMMON, useValue: env }, ConfigurationService, LoaderService]
         };
     }
 }
 WisCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WisCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-WisCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: WisCommonModule, declarations: [LoaderComponent, SidenavComponent], imports: [CommonModule, OverlayModule, LoaderModule], exports: [SidenavComponent] });
-WisCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WisCommonModule, providers: [HttpService], imports: [CommonModule, OverlayModule, LoaderModule] });
+WisCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: WisCommonModule, declarations: [LoaderComponent, SidenavComponent, CreateNonShiftModalComponent], imports: [CommonModule, HttpClientModule, OverlayModule, LoaderModule, DropdownModule, ReactiveFormsModule, DatepickerModuleV2], exports: [SidenavComponent, CreateNonShiftModalComponent] });
+WisCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WisCommonModule, imports: [CommonModule, HttpClientModule, OverlayModule, LoaderModule, DropdownModule, ReactiveFormsModule, DatepickerModuleV2] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: WisCommonModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [LoaderComponent, SidenavComponent],
-                    imports: [CommonModule, OverlayModule, LoaderModule],
-                    providers: [HttpService],
-                    exports: [SidenavComponent]
+                    declarations: [LoaderComponent, SidenavComponent, CreateNonShiftModalComponent],
+                    imports: [CommonModule, HttpClientModule, OverlayModule, LoaderModule, DropdownModule, ReactiveFormsModule, DatepickerModuleV2,],
+                    providers: [],
+                    exports: [SidenavComponent, CreateNonShiftModalComponent]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -16,4 +16,8 @@ export * from "./lib/wis-common.module";
 export * from "./lib/modules/logger/logger.model";
 export * from "./lib/components/sidenav/sidenav.component";
 export * from "./lib/services/mfe-communication.service";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYnJhcmllcy93aXMtY29tbW9uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMsMENBQTBDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHdpcy1jb21tb25cbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9saWIvbW9kdWxlcy9hdXRoL2F1dGguc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL21vZHVsZXMvYXV0aC9hdXRoLm1vZHVsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL3NlcnZpY2VzL2NvbmZpZ3VyYXRpb24uc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL21vZGVscy9jb25maWd1cmF0aW9ucy5tb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2Z1bmN0aW9ucy9uYXYtZmlsdGVyLmZ1bmN0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvZnVuY3Rpb25zL2Nvb2tpZS5mdW5jdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2Z1bmN0aW9ucy91cmwuZnVuY3Rpb25zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvaW50ZXJjZXB0b3JzL2F1dGguaW50ZXJjZXB0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9zZXJ2aWNlcy9sb2FkZXIuc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL21vZHVsZXMvbG9nZ2VyL2xvZ2dlci5tb2R1bGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9tb2R1bGVzL2xvZ2dlci9sb2dnZXIuc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL3dpcy1jb21tb24ubW9kdWxlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvbW9kdWxlcy9sb2dnZXIvbG9nZ2VyLm1vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvY29tcG9uZW50cy9zaWRlbmF2L3NpZGVuYXYuY29tcG9uZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvc2VydmljZXMvbWZlLWNvbW11bmljYXRpb24uc2VydmljZVwiO1xuXG4iXX0=
+export * from "./lib/components/create-non-shift-modal/create-non-shift-modal.component";
+export * from "./lib/services/session.service";
+export * from "./lib/services/session.errors";
+export * from "./lib/models/session.model";
+//# sourceMappingURL=data:application/json;base64,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