@lifeready/core 1.0.2 → 1.0.3

package/esm2015/lib/api/persist.service.js

@@ -1,181 +1,181 @@
-import { __awaiter } from "tslib";
-import { Injectable, Injector } from '@angular/core';
-import { CookieService } from 'ngx-cookie-service';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { isDevMode } from '@angular/core';
-import { LrBadArgumentException } from '../_common/exceptions';
-import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../cryptography/key-factory.service";
-import * as i2 from "ngx-cookie-service";
-import * as i3 from "../cryptography/encryption.service";
-export class PersistService {
-    constructor(keyFactory, cookieService, encryptionService, injector) {
-        this.keyFactory = keyFactory;
-        this.cookieService = cookieService;
-        this.encryptionService = encryptionService;
-        this.injector = injector;
-        this.KEY_PREFIX = 'lrSession-';
-        this.cookieSecure = true;
-        this.serverSessionEncryptionKey = null;
-        if (isDevMode()) {
-            this.setCookieSecure(false);
-        }
-    }
-    setServerSessionEncryptionKey(key) {
-        this.serverSessionEncryptionKey = key;
-    }
-    clearServerSessionEncryptionKey() {
-        this.serverSessionEncryptionKey = null;
-    }
-    // It's important that set and delete cookie use exactly the same set of parameters.
-    getCookieParams() {
-        return {
-            path: '/',
-            domain: null,
-            secure: this.cookieSecure,
-            sameSite: 'Lax',
-        };
-    }
-    clear() {
-        // Remove all cookies
-        Object.keys(this.cookieService.getAll()).forEach((key) => {
-            if (key.startsWith(this.KEY_PREFIX)) {
-                this.deletePrefixedName(key);
-            }
-        });
-        // Remove all persisted session variables
-        Object.keys(localStorage).forEach((key) => {
-            if (key.startsWith(this.KEY_PREFIX)) {
-                this.deletePrefixedName(key);
-            }
-        });
-    }
-    setCookieSecure(value) {
-        this.cookieSecure = value;
-        if (!value) {
-            if (isDevMode()) {
-                console.warn('The cookie secure flag in persistService has been set to false, set it to true in production mode');
-            }
-            else {
-                throw new LrBadArgumentException('Can not set PersistService cookie secure flag to false in production mode.');
-            }
-        }
-    }
-    prefixName(name) {
-        return this.KEY_PREFIX + name;
-    }
-    delete(name) {
-        this.deletePrefixedName(this.prefixName(name));
-    }
-    deletePrefixedName(prefixedName) {
-        const params = this.getCookieParams();
-        this.cookieService.delete(prefixedName, // name: string,
-        params.path, // path?: string,
-        params.domain, // domain ?: string,
-        params.secure, // secure ?: boolean,
-        params.sameSite // sameSite ?: 'Lax' | 'None' | 'Strict'): void;
-        );
-        localStorage.removeItem(prefixedName);
-    }
-    set({ name, value, serverSession, expiry, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const prefixedName = this.prefixName(name);
-            let item;
-            if (serverSession) {
-                item = {
-                    serverSession: true,
-                    data: yield this.encryptionService.encryptToString(this.serverSessionEncryptionKey, value),
-                };
-            }
-            else {
-                item = {
-                    data: value,
-                };
-            }
-            if (expiry) {
-                const key = yield this.keyFactory.createKey();
-                item.expiry = expiry.toISOString();
-                item.data = yield this.encryptionService.encryptToString(key, item.data);
-                const cookieItem = {
-                    key: key.toJSON(true),
-                };
-                // If path is set to anything other than "/" then the cookie is only
-                // accessible by JS if the current URL has the same prefix as the path.
-                // Ideally we don't want the encryption key cookie to be sent at all, but
-                // since the encrypted content is held in localstorage, it is not a security
-                // risk, i.e. it is at least as secure as storing only in localstorage.
-                const params = this.getCookieParams();
-                this.cookieService.set(prefixedName, // name: string,
-                JSON.stringify(cookieItem), // value: string,
-                expiry, // expires?: number | Date,
-                params.path, // path?: string,
-                params.domain, // domain?: string,
-                params.secure, // secure?: boolean,
-                params.sameSite // sameSite?: 'Lax' | 'None' | 'Strict'
-                );
-            }
-            localStorage.setItem(prefixedName, JSON.stringify(item));
-        });
-    }
-    get(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const prefixedName = this.prefixName(name);
-            try {
-                const ret = yield this.getImpl(prefixedName);
-                if (ret == null) {
-                    // Clear any cookies to keep things in sync.
-                    this.deletePrefixedName(prefixedName);
-                }
-                return ret;
-            }
-            catch (error) {
-                this.deletePrefixedName(prefixedName);
-                throw error;
-            }
-        });
-    }
-    getImpl(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const itemString = localStorage.getItem(name);
-            if (!itemString) {
-                return null;
-            }
-            const item = JSON.parse(itemString);
-            let data;
-            if (item.expiry) {
-                const cookieItemString = this.cookieService.get(name);
-                if (!cookieItemString) {
-                    // Probably expired, but we won't make any interpretations since if we only used
-                    // cookies we can't tell if it's expired or explicitly removed. So we just make
-                    // the behaviour here consistent with that.
-                    console.log('No cookie.');
-                    return null;
-                }
-                const cookieItem = JSON.parse(cookieItemString);
-                const key = yield KFS.asKey(cookieItem.key);
-                data = yield this.encryptionService.decrypt(key, item.data);
-            }
-            else {
-                data = item.data;
-            }
-            if (item.serverSession) {
-                data = yield this.encryptionService.decrypt(this.serverSessionEncryptionKey, data);
-            }
-            return data;
-        });
-    }
-}
-PersistService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PersistService_Factory() { return new PersistService(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.CookieService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i0.INJECTOR)); }, token: PersistService, providedIn: "root" });
-PersistService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-PersistService.ctorParameters = () => [
-    { type: KFS },
-    { type: CookieService },
-    { type: EncryptionService },
-    { type: Injector }
-];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"persist.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/api/persist.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { JWK } from 'node-jose';\nimport { Injectable, Injector } from '@angular/core';\nimport { CookieService } from 'ngx-cookie-service';\nimport { EncryptionService } from '../cryptography/encryption.service';\nimport { isDevMode } from '@angular/core';\nimport { LrBadArgumentException } from '../_common/exceptions';\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\n\ninterface Item {\n  data: string;\n  expiry?: string; // iso format\n  serverSession?: boolean;\n}\n\ninterface CookieItem {\n  key: any;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PersistService {\n  private readonly KEY_PREFIX = 'lrSession-';\n\n  private cookieSecure = true;\n  private serverSessionEncryptionKey: JWK.Key = null;\n\n  constructor(\n    private keyFactory: KFS,\n    private cookieService: CookieService,\n    private encryptionService: EncryptionService,\n    private injector: Injector\n  ) {\n    if (isDevMode()) {\n      this.setCookieSecure(false);\n    }\n  }\n\n  setServerSessionEncryptionKey(key: JWK.Key) {\n    this.serverSessionEncryptionKey = key;\n  }\n\n  clearServerSessionEncryptionKey() {\n    this.serverSessionEncryptionKey = null;\n  }\n\n  // It's important that set and delete cookie use exactly the same set of parameters.\n  private getCookieParams() {\n    return {\n      path: '/',\n      domain: null, // which means the current domain of the frontend app.\n      secure: this.cookieSecure,\n      sameSite: 'Lax' as 'Lax' | 'None' | 'Strict',\n    };\n  }\n\n  public clear() {\n    // Remove all cookies\n    Object.keys(this.cookieService.getAll()).forEach((key) => {\n      if (key.startsWith(this.KEY_PREFIX)) {\n        this.deletePrefixedName(key);\n      }\n    });\n\n    // Remove all persisted session variables\n    Object.keys(localStorage).forEach((key) => {\n      if (key.startsWith(this.KEY_PREFIX)) {\n        this.deletePrefixedName(key);\n      }\n    });\n  }\n\n  public setCookieSecure(value: boolean) {\n    this.cookieSecure = value;\n    if (!value) {\n      if (isDevMode()) {\n        console.warn(\n          'The cookie secure flag in persistService has been set to false, set it to true in production mode'\n        );\n      } else {\n        throw new LrBadArgumentException(\n          'Can not set PersistService cookie secure flag to false in production mode.'\n        );\n      }\n    }\n  }\n\n  private prefixName(name: string): string {\n    return this.KEY_PREFIX + name;\n  }\n\n  public delete(name: string): void {\n    this.deletePrefixedName(this.prefixName(name));\n  }\n\n  private deletePrefixedName(prefixedName: string): void {\n    const params = this.getCookieParams();\n    this.cookieService.delete(\n      prefixedName, // name: string,\n      params.path, // path?: string,\n      params.domain, // domain ?: string,\n      params.secure, // secure ?: boolean,\n      params.sameSite // sameSite ?: 'Lax' | 'None' | 'Strict'): void;\n    );\n    localStorage.removeItem(prefixedName);\n  }\n\n  public async set({\n    name,\n    value,\n    serverSession,\n    expiry,\n  }: {\n    name: string;\n    value: any;\n    serverSession: boolean;\n    expiry?: Date;\n  }): Promise<void> {\n    const prefixedName = this.prefixName(name);\n\n    let item: Item;\n\n    if (serverSession) {\n      item = {\n        serverSession: true,\n        data: await this.encryptionService.encryptToString(\n          this.serverSessionEncryptionKey,\n          value\n        ),\n      };\n    } else {\n      item = {\n        data: value,\n      };\n    }\n\n    if (expiry) {\n      const key = await this.keyFactory.createKey();\n      item.expiry = expiry.toISOString();\n      item.data = await this.encryptionService.encryptToString(key, item.data);\n\n      const cookieItem: CookieItem = {\n        key: key.toJSON(true),\n      };\n\n      // If path is set to anything other than \"/\" then the cookie is only\n      // accessible by JS if the current URL has the same prefix as the path.\n      // Ideally we don't want the encryption key cookie to be sent at all, but\n      // since the encrypted content is held in localstorage, it is not a security\n      // risk, i.e. it is at least as secure as storing only in localstorage.\n      const params = this.getCookieParams();\n      this.cookieService.set(\n        prefixedName, // name: string,\n        JSON.stringify(cookieItem), // value: string,\n        expiry, // expires?: number | Date,\n        params.path, // path?: string,\n        params.domain, // domain?: string,\n        params.secure, // secure?: boolean,\n        params.sameSite // sameSite?: 'Lax' | 'None' | 'Strict'\n      );\n    }\n\n    localStorage.setItem(prefixedName, JSON.stringify(item));\n  }\n\n  public async get(name: string): Promise<any> {\n    const prefixedName = this.prefixName(name);\n\n    try {\n      const ret = await this.getImpl(prefixedName);\n      if (ret == null) {\n        // Clear any cookies to keep things in sync.\n        this.deletePrefixedName(prefixedName);\n      }\n      return ret;\n    } catch (error) {\n      this.deletePrefixedName(prefixedName);\n      throw error;\n    }\n  }\n\n  private async getImpl(name: string): Promise<any> {\n    const itemString = localStorage.getItem(name);\n    if (!itemString) {\n      return null;\n    }\n\n    const item: Item = JSON.parse(itemString);\n\n    let data: any;\n\n    if (item.expiry) {\n      const cookieItemString = this.cookieService.get(name);\n      if (!cookieItemString) {\n        // Probably expired, but we won't make any interpretations since if we only used\n        // cookies we can't tell if it's expired or explicitly removed. So we just make\n        // the behaviour here consistent with that.\n        console.log('No cookie.');\n        return null;\n      }\n\n      const cookieItem = JSON.parse(cookieItemString);\n\n      const key = await KFS.asKey(cookieItem.key);\n\n      data = await this.encryptionService.decrypt(key, item.data);\n    } else {\n      data = item.data;\n    }\n\n    if (item.serverSession) {\n      data = await this.encryptionService.decrypt(\n        this.serverSessionEncryptionKey,\n        data\n      );\n    }\n\n    return data;\n  }\n}\n"]}
+import { __awaiter } from "tslib";
+import { Injectable, Injector } from '@angular/core';
+import { CookieService } from 'ngx-cookie-service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { isDevMode } from '@angular/core';
+import { LrBadArgumentException } from '../_common/exceptions';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key-factory.service";
+import * as i2 from "ngx-cookie-service";
+import * as i3 from "../cryptography/encryption.service";
+export class PersistService {
+    constructor(keyFactory, cookieService, encryptionService, injector) {
+        this.keyFactory = keyFactory;
+        this.cookieService = cookieService;
+        this.encryptionService = encryptionService;
+        this.injector = injector;
+        this.KEY_PREFIX = 'lrSession-';
+        this.cookieSecure = true;
+        this.serverSessionEncryptionKey = null;
+        if (isDevMode()) {
+            this.setCookieSecure(false);
+        }
+    }
+    setServerSessionEncryptionKey(key) {
+        this.serverSessionEncryptionKey = key;
+    }
+    clearServerSessionEncryptionKey() {
+        this.serverSessionEncryptionKey = null;
+    }
+    // It's important that set and delete cookie use exactly the same set of parameters.
+    getCookieParams() {
+        return {
+            path: '/',
+            domain: null,
+            secure: this.cookieSecure,
+            sameSite: 'Lax',
+        };
+    }
+    clear() {
+        // Remove all cookies
+        Object.keys(this.cookieService.getAll()).forEach((key) => {
+            if (key.startsWith(this.KEY_PREFIX)) {
+                this.deletePrefixedName(key);
+            }
+        });
+        // Remove all persisted session variables
+        Object.keys(localStorage).forEach((key) => {
+            if (key.startsWith(this.KEY_PREFIX)) {
+                this.deletePrefixedName(key);
+            }
+        });
+    }
+    setCookieSecure(value) {
+        this.cookieSecure = value;
+        if (!value) {
+            if (isDevMode()) {
+                console.warn('The cookie secure flag in persistService has been set to false, set it to true in production mode');
+            }
+            else {
+                throw new LrBadArgumentException('Can not set PersistService cookie secure flag to false in production mode.');
+            }
+        }
+    }
+    prefixName(name) {
+        return this.KEY_PREFIX + name;
+    }
+    delete(name) {
+        this.deletePrefixedName(this.prefixName(name));
+    }
+    deletePrefixedName(prefixedName) {
+        const params = this.getCookieParams();
+        this.cookieService.delete(prefixedName, // name: string,
+        params.path, // path?: string,
+        params.domain, // domain ?: string,
+        params.secure, // secure ?: boolean,
+        params.sameSite // sameSite ?: 'Lax' | 'None' | 'Strict'): void;
+        );
+        localStorage.removeItem(prefixedName);
+    }
+    set({ name, value, serverSession, expiry, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefixedName = this.prefixName(name);
+            let item;
+            if (serverSession) {
+                item = {
+                    serverSession: true,
+                    data: yield this.encryptionService.encryptToString(this.serverSessionEncryptionKey, value),
+                };
+            }
+            else {
+                item = {
+                    data: value,
+                };
+            }
+            if (expiry) {
+                const key = yield this.keyFactory.createKey();
+                item.expiry = expiry.toISOString();
+                item.data = yield this.encryptionService.encryptToString(key, item.data);
+                const cookieItem = {
+                    key: key.toJSON(true),
+                };
+                // If path is set to anything other than "/" then the cookie is only
+                // accessible by JS if the current URL has the same prefix as the path.
+                // Ideally we don't want the encryption key cookie to be sent at all, but
+                // since the encrypted content is held in localstorage, it is not a security
+                // risk, i.e. it is at least as secure as storing only in localstorage.
+                const params = this.getCookieParams();
+                this.cookieService.set(prefixedName, // name: string,
+                JSON.stringify(cookieItem), // value: string,
+                expiry, // expires?: number | Date,
+                params.path, // path?: string,
+                params.domain, // domain?: string,
+                params.secure, // secure?: boolean,
+                params.sameSite // sameSite?: 'Lax' | 'None' | 'Strict'
+                );
+            }
+            localStorage.setItem(prefixedName, JSON.stringify(item));
+        });
+    }
+    get(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefixedName = this.prefixName(name);
+            try {
+                const ret = yield this.getImpl(prefixedName);
+                if (ret == null) {
+                    // Clear any cookies to keep things in sync.
+                    this.deletePrefixedName(prefixedName);
+                }
+                return ret;
+            }
+            catch (error) {
+                this.deletePrefixedName(prefixedName);
+                throw error;
+            }
+        });
+    }
+    getImpl(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itemString = localStorage.getItem(name);
+            if (!itemString) {
+                return null;
+            }
+            const item = JSON.parse(itemString);
+            let data;
+            if (item.expiry) {
+                const cookieItemString = this.cookieService.get(name);
+                if (!cookieItemString) {
+                    // Probably expired, but we won't make any interpretations since if we only used
+                    // cookies we can't tell if it's expired or explicitly removed. So we just make
+                    // the behaviour here consistent with that.
+                    console.log('No cookie.');
+                    return null;
+                }
+                const cookieItem = JSON.parse(cookieItemString);
+                const key = yield KFS.asKey(cookieItem.key);
+                data = yield this.encryptionService.decrypt(key, item.data);
+            }
+            else {
+                data = item.data;
+            }
+            if (item.serverSession) {
+                data = yield this.encryptionService.decrypt(this.serverSessionEncryptionKey, data);
+            }
+            return data;
+        });
+    }
+}
+PersistService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PersistService_Factory() { return new PersistService(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.CookieService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i0.INJECTOR)); }, token: PersistService, providedIn: "root" });
+PersistService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+PersistService.ctorParameters = () => [
+    { type: KFS },
+    { type: CookieService },
+    { type: EncryptionService },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"persist.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/api/persist.service.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,iBAAiB,IAAI,GAAG,EAAE,MAAM,qCAAqC,CAAC;;;;;AAe/E,MAAM,OAAO,cAAc;IAMzB,YACU,UAAe,EACf,aAA4B,EAC5B,iBAAoC,EACpC,QAAkB;QAHlB,eAAU,GAAV,UAAU,CAAK;QACf,kBAAa,GAAb,aAAa,CAAe;QAC5B,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,aAAQ,GAAR,QAAQ,CAAU;QATX,eAAU,GAAG,YAAY,CAAC;QAEnC,iBAAY,GAAG,IAAI,CAAC;QACpB,+BAA0B,GAAY,IAAI,CAAC;QAQjD,IAAI,SAAS,EAAE,EAAE;YACf,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;SAC7B;IACH,CAAC;IAED,6BAA6B,CAAC,GAAY;QACxC,IAAI,CAAC,0BAA0B,GAAG,GAAG,CAAC;IACxC,CAAC;IAED,+BAA+B;QAC7B,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC;IACzC,CAAC;IAED,oFAAoF;IAC5E,eAAe;QACrB,OAAO;YACL,IAAI,EAAE,GAAG;YACT,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,IAAI,CAAC,YAAY;YACzB,QAAQ,EAAE,KAAkC;SAC7C,CAAC;IACJ,CAAC;IAEM,KAAK;QACV,qBAAqB;QACrB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACvD,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;gBACnC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;aAC9B;QACH,CAAC,CAAC,CAAC;QAEH,yCAAyC;QACzC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACxC,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;gBACnC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;aAC9B;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,eAAe,CAAC,KAAc;QACnC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,KAAK,EAAE;YACV,IAAI,SAAS,EAAE,EAAE;gBACf,OAAO,CAAC,IAAI,CACV,mGAAmG,CACpG,CAAC;aACH;iBAAM;gBACL,MAAM,IAAI,sBAAsB,CAC9B,4EAA4E,CAC7E,CAAC;aACH;SACF;IACH,CAAC;IAEO,UAAU,CAAC,IAAY;QAC7B,OAAO,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IAChC,CAAC;IAEM,MAAM,CAAC,IAAY;QACxB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;IACjD,CAAC;IAEO,kBAAkB,CAAC,YAAoB;QAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACtC,IAAI,CAAC,aAAa,CAAC,MAAM,CACvB,YAAY,EAAE,gBAAgB;QAC9B,MAAM,CAAC,IAAI,EAAE,iBAAiB;QAC9B,MAAM,CAAC,MAAM,EAAE,oBAAoB;QACnC,MAAM,CAAC,MAAM,EAAE,qBAAqB;QACpC,MAAM,CAAC,QAAQ,CAAC,gDAAgD;SACjE,CAAC;QACF,YAAY,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IACxC,CAAC;IAEY,GAAG,CAAC,EACf,IAAI,EACJ,KAAK,EACL,aAAa,EACb,MAAM,GAMP;;YACC,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAE3C,IAAI,IAAU,CAAC;YAEf,IAAI,aAAa,EAAE;gBACjB,IAAI,GAAG;oBACL,aAAa,EAAE,IAAI;oBACnB,IAAI,EAAE,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAChD,IAAI,CAAC,0BAA0B,EAC/B,KAAK,CACN;iBACF,CAAC;aACH;iBAAM;gBACL,IAAI,GAAG;oBACL,IAAI,EAAE,KAAK;iBACZ,CAAC;aACH;YAED,IAAI,MAAM,EAAE;gBACV,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;gBAC9C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;gBACnC,IAAI,CAAC,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBAEzE,MAAM,UAAU,GAAe;oBAC7B,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;iBACtB,CAAC;gBAEF,oEAAoE;gBACpE,uEAAuE;gBACvE,yEAAyE;gBACzE,4EAA4E;gBAC5E,uEAAuE;gBACvE,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;gBACtC,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,YAAY,EAAE,gBAAgB;gBAC9B,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,iBAAiB;gBAC7C,MAAM,EAAE,2BAA2B;gBACnC,MAAM,CAAC,IAAI,EAAE,iBAAiB;gBAC9B,MAAM,CAAC,MAAM,EAAE,mBAAmB;gBAClC,MAAM,CAAC,MAAM,EAAE,oBAAoB;gBACnC,MAAM,CAAC,QAAQ,CAAC,uCAAuC;iBACxD,CAAC;aACH;YAED,YAAY,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3D,CAAC;KAAA;IAEY,GAAG,CAAC,IAAY;;YAC3B,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAE3C,IAAI;gBACF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;gBAC7C,IAAI,GAAG,IAAI,IAAI,EAAE;oBACf,4CAA4C;oBAC5C,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;iBACvC;gBACD,OAAO,GAAG,CAAC;aACZ;YAAC,OAAO,KAAK,EAAE;gBACd,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;gBACtC,MAAM,KAAK,CAAC;aACb;QACH,CAAC;KAAA;IAEa,OAAO,CAAC,IAAY;;YAChC,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC9C,IAAI,CAAC,UAAU,EAAE;gBACf,OAAO,IAAI,CAAC;aACb;YAED,MAAM,IAAI,GAAS,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAE1C,IAAI,IAAS,CAAC;YAEd,IAAI,IAAI,CAAC,MAAM,EAAE;gBACf,MAAM,gBAAgB,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACtD,IAAI,CAAC,gBAAgB,EAAE;oBACrB,gFAAgF;oBAChF,+EAA+E;oBAC/E,2CAA2C;oBAC3C,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;oBAC1B,OAAO,IAAI,CAAC;iBACb;gBAED,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;gBAEhD,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;gBAE5C,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;aAC7D;iBAAM;gBACL,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;aAClB;YAED,IAAI,IAAI,CAAC,aAAa,EAAE;gBACtB,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACzC,IAAI,CAAC,0BAA0B,EAC/B,IAAI,CACL,CAAC;aACH;YAED,OAAO,IAAI,CAAC;QACd,CAAC;KAAA;;;;YAxMF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YAd6B,GAAG;YAJxB,aAAa;YACb,iBAAiB;YAFL,QAAQ","sourcesContent":["import { JWK } from 'node-jose';\r\nimport { Injectable, Injector } from '@angular/core';\r\nimport { CookieService } from 'ngx-cookie-service';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { isDevMode } from '@angular/core';\r\nimport { LrBadArgumentException } from '../_common/exceptions';\r\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\r\n\r\ninterface Item {\r\n  data: string;\r\n  expiry?: string; // iso format\r\n  serverSession?: boolean;\r\n}\r\n\r\ninterface CookieItem {\r\n  key: any;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class PersistService {\r\n  private readonly KEY_PREFIX = 'lrSession-';\r\n\r\n  private cookieSecure = true;\r\n  private serverSessionEncryptionKey: JWK.Key = null;\r\n\r\n  constructor(\r\n    private keyFactory: KFS,\r\n    private cookieService: CookieService,\r\n    private encryptionService: EncryptionService,\r\n    private injector: Injector\r\n  ) {\r\n    if (isDevMode()) {\r\n      this.setCookieSecure(false);\r\n    }\r\n  }\r\n\r\n  setServerSessionEncryptionKey(key: JWK.Key) {\r\n    this.serverSessionEncryptionKey = key;\r\n  }\r\n\r\n  clearServerSessionEncryptionKey() {\r\n    this.serverSessionEncryptionKey = null;\r\n  }\r\n\r\n  // It's important that set and delete cookie use exactly the same set of parameters.\r\n  private getCookieParams() {\r\n    return {\r\n      path: '/',\r\n      domain: null, // which means the current domain of the frontend app.\r\n      secure: this.cookieSecure,\r\n      sameSite: 'Lax' as 'Lax' | 'None' | 'Strict',\r\n    };\r\n  }\r\n\r\n  public clear() {\r\n    // Remove all cookies\r\n    Object.keys(this.cookieService.getAll()).forEach((key) => {\r\n      if (key.startsWith(this.KEY_PREFIX)) {\r\n        this.deletePrefixedName(key);\r\n      }\r\n    });\r\n\r\n    // Remove all persisted session variables\r\n    Object.keys(localStorage).forEach((key) => {\r\n      if (key.startsWith(this.KEY_PREFIX)) {\r\n        this.deletePrefixedName(key);\r\n      }\r\n    });\r\n  }\r\n\r\n  public setCookieSecure(value: boolean) {\r\n    this.cookieSecure = value;\r\n    if (!value) {\r\n      if (isDevMode()) {\r\n        console.warn(\r\n          'The cookie secure flag in persistService has been set to false, set it to true in production mode'\r\n        );\r\n      } else {\r\n        throw new LrBadArgumentException(\r\n          'Can not set PersistService cookie secure flag to false in production mode.'\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  private prefixName(name: string): string {\r\n    return this.KEY_PREFIX + name;\r\n  }\r\n\r\n  public delete(name: string): void {\r\n    this.deletePrefixedName(this.prefixName(name));\r\n  }\r\n\r\n  private deletePrefixedName(prefixedName: string): void {\r\n    const params = this.getCookieParams();\r\n    this.cookieService.delete(\r\n      prefixedName, // name: string,\r\n      params.path, // path?: string,\r\n      params.domain, // domain ?: string,\r\n      params.secure, // secure ?: boolean,\r\n      params.sameSite // sameSite ?: 'Lax' | 'None' | 'Strict'): void;\r\n    );\r\n    localStorage.removeItem(prefixedName);\r\n  }\r\n\r\n  public async set({\r\n    name,\r\n    value,\r\n    serverSession,\r\n    expiry,\r\n  }: {\r\n    name: string;\r\n    value: any;\r\n    serverSession: boolean;\r\n    expiry?: Date;\r\n  }): Promise<void> {\r\n    const prefixedName = this.prefixName(name);\r\n\r\n    let item: Item;\r\n\r\n    if (serverSession) {\r\n      item = {\r\n        serverSession: true,\r\n        data: await this.encryptionService.encryptToString(\r\n          this.serverSessionEncryptionKey,\r\n          value\r\n        ),\r\n      };\r\n    } else {\r\n      item = {\r\n        data: value,\r\n      };\r\n    }\r\n\r\n    if (expiry) {\r\n      const key = await this.keyFactory.createKey();\r\n      item.expiry = expiry.toISOString();\r\n      item.data = await this.encryptionService.encryptToString(key, item.data);\r\n\r\n      const cookieItem: CookieItem = {\r\n        key: key.toJSON(true),\r\n      };\r\n\r\n      // If path is set to anything other than \"/\" then the cookie is only\r\n      // accessible by JS if the current URL has the same prefix as the path.\r\n      // Ideally we don't want the encryption key cookie to be sent at all, but\r\n      // since the encrypted content is held in localstorage, it is not a security\r\n      // risk, i.e. it is at least as secure as storing only in localstorage.\r\n      const params = this.getCookieParams();\r\n      this.cookieService.set(\r\n        prefixedName, // name: string,\r\n        JSON.stringify(cookieItem), // value: string,\r\n        expiry, // expires?: number | Date,\r\n        params.path, // path?: string,\r\n        params.domain, // domain?: string,\r\n        params.secure, // secure?: boolean,\r\n        params.sameSite // sameSite?: 'Lax' | 'None' | 'Strict'\r\n      );\r\n    }\r\n\r\n    localStorage.setItem(prefixedName, JSON.stringify(item));\r\n  }\r\n\r\n  public async get(name: string): Promise<any> {\r\n    const prefixedName = this.prefixName(name);\r\n\r\n    try {\r\n      const ret = await this.getImpl(prefixedName);\r\n      if (ret == null) {\r\n        // Clear any cookies to keep things in sync.\r\n        this.deletePrefixedName(prefixedName);\r\n      }\r\n      return ret;\r\n    } catch (error) {\r\n      this.deletePrefixedName(prefixedName);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  private async getImpl(name: string): Promise<any> {\r\n    const itemString = localStorage.getItem(name);\r\n    if (!itemString) {\r\n      return null;\r\n    }\r\n\r\n    const item: Item = JSON.parse(itemString);\r\n\r\n    let data: any;\r\n\r\n    if (item.expiry) {\r\n      const cookieItemString = this.cookieService.get(name);\r\n      if (!cookieItemString) {\r\n        // Probably expired, but we won't make any interpretations since if we only used\r\n        // cookies we can't tell if it's expired or explicitly removed. So we just make\r\n        // the behaviour here consistent with that.\r\n        console.log('No cookie.');\r\n        return null;\r\n      }\r\n\r\n      const cookieItem = JSON.parse(cookieItemString);\r\n\r\n      const key = await KFS.asKey(cookieItem.key);\r\n\r\n      data = await this.encryptionService.decrypt(key, item.data);\r\n    } else {\r\n      data = item.data;\r\n    }\r\n\r\n    if (item.serverSession) {\r\n      data = await this.encryptionService.decrypt(\r\n        this.serverSessionEncryptionKey,\r\n        data\r\n      );\r\n    }\r\n\r\n    return data;\r\n  }\r\n}\r\n"]}