@lifeready/core 0.6.0-beta.1

package/esm2015/lib/api/lr-graphql/lr-mutation-base.js

@@ -0,0 +1,51 @@
+import gql from 'graphql-tag';
+import { getQuery } from '../../_common/ast';
+import { DeferredPromise } from '../../_common/deferred-promise';
+import { LrBadStateException } from '../../_common/exceptions';
+export const fragmentSpreadAstSelection = getQuery(gql `
+  query {
+    ...FragmentName
+  }
+`).selectionSet.selections[0];
+// const fragmentSpreadAstSelection = () =>
+//   lodash.deepClone(_fragmentSpreadAstSelection) as FragmentSpreadNode;
+/**
+ * DECISION: LrMutationBase does not provide a convenience method to call lrGraphQL.lrMutate()
+ * because this class could be made independent of what lib is used to call the API. If we
+ * provided a configurable call back to make the API call, then the typing for that callback
+ * needs to be known. But since the API lib (eg. Apollo) has it's own unique return type, so
+ * it's not possible to do in general.
+ */
+export class LrMutationBase {
+    constructor() {
+        /* tslint:disable:variable-name */
+        this._executed = false;
+        // protected promises: DeferredPromise<T>[] = [];
+        this.deferredPromise = new DeferredPromise();
+    }
+    get promise() {
+        return this.deferredPromise.promise;
+    }
+    resolve(value) {
+        this.deferredPromise.resolve(value);
+    }
+    reject(reason) {
+        this.deferredPromise.reject(reason);
+    }
+    get lrMutationData() {
+        return {
+            mutation: this.mutation,
+            variables: this.variables,
+        };
+    }
+    get executed() {
+        return this._executed;
+    }
+    setExecuted() {
+        if (this._executed) {
+            throw new LrBadStateException('Already executed');
+        }
+        this._executed = true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/lr-graphql/lr-mutation.js

@@ -0,0 +1,48 @@
+import * as lodash from 'lodash';
+import { getAliasOrName, getFragments, getMutation, } from '../../_common/ast';
+import * as ast from '../../_common/ast';
+import { fragmentSpreadAstSelection, LrMutationBase } from './lr-mutation-base';
+export class LrMutation extends LrMutationBase {
+    constructor(options) {
+        super();
+        this.mutation = options.mutation;
+        this.variables = options.variables;
+    }
+    select(fragments) {
+        // Don't touch the original
+        const mutationDoc = lodash.cloneDeep(this.mutation);
+        const mutationNode = getMutation(mutationDoc);
+        const fragmentMap = {};
+        getFragments(fragments).forEach((fragment) => {
+            fragmentMap[fragment.name.value] = fragment;
+        });
+        const replaceFieldSelection = (selection) => {
+            const field = selection;
+            const fieldName = getAliasOrName(field);
+            const fragment = fragmentMap[fieldName];
+            if (!fragment) {
+                return;
+            }
+            // Make the entire selection of the mutation a spread of
+            // a fragment using the same name as the mutation field.
+            // We will also rename the fragment to the same name.
+            field.selectionSet.selections = [
+                Object.assign(Object.assign({}, fragmentSpreadAstSelection), { name: ast.name(fieldName) }),
+            ];
+        };
+        mutationNode.selectionSet.selections.forEach((selection) => {
+            if (selection.kind === 'Field') {
+                replaceFieldSelection(selection);
+            }
+        });
+        return new LrMutation({
+            mutation: Object.assign(Object.assign({}, mutationDoc), { definitions: [
+                    // Remove all existing fragments
+                    ...mutationDoc.definitions.filter((def) => def.kind !== 'FragmentDefinition'),
+                    ...fragments.definitions,
+                ] }),
+            variables: this.variables,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/lr-graphql/lr.service.js

@@ -0,0 +1,18 @@
+import { __awaiter } from "tslib";
+import { LrGraphQLService, } from './lr-graphql.service';
+export class LrService {
+    constructor(injector) {
+        this.lrGraphQL = injector.get(LrGraphQLService);
+    }
+    mutate(lrMutation, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lrGraphQL.lrMutate(lrMutation, options);
+        });
+    }
+    query(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.lrGraphQL.query(options);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiJDOi9Qcm9qZWN0cy90ZXN0L3Byb2plY3RzL2NvcmUvc3JjLyIsInNvdXJjZXMiOlsibGliL2FwaS9sci1ncmFwaHFsL2xyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLE9BQU8sRUFDTCxnQkFBZ0IsR0FHakIsTUFBTSxzQkFBc0IsQ0FBQztBQUc5QixNQUFNLE9BQU8sU0FBUztJQUdwQixZQUFZLFFBQWtCO1FBQzVCLElBQUksQ0FBQyxTQUFTLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFZSxNQUFNLENBQ3BCLFVBRTBDLEVBQzFDLE9BQTBDOztZQUUxQyxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUN0RCxDQUFDO0tBQUE7SUFFZSxLQUFLLENBQU8sT0FBNkI7O1lBQ3ZELE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDdkMsQ0FBQztLQUFBO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQge1xyXG4gIExyR3JhcGhRTFNlcnZpY2UsXHJcbiAgTHJNdXRhdGlvbk9wdGlvbnMsXHJcbiAgTHJRdWVyeU9wdGlvbnMsXHJcbn0gZnJvbSAnLi9sci1ncmFwaHFsLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBMck11dGF0aW9uQmFzZSB9IGZyb20gJy4vbHItbXV0YXRpb24tYmFzZSc7XHJcblxyXG5leHBvcnQgY2xhc3MgTHJTZXJ2aWNlIHtcclxuICBwcm90ZWN0ZWQgbHJHcmFwaFFMOiBMckdyYXBoUUxTZXJ2aWNlO1xyXG5cclxuICBjb25zdHJ1Y3RvcihpbmplY3RvcjogSW5qZWN0b3IpIHtcclxuICAgIHRoaXMubHJHcmFwaFFMID0gaW5qZWN0b3IuZ2V0KExyR3JhcGhRTFNlcnZpY2UpO1xyXG4gIH1cclxuXHJcbiAgcHJvdGVjdGVkIGFzeW5jIG11dGF0ZTxULCBUVmFyaWFibGVzPihcclxuICAgIGxyTXV0YXRpb246XHJcbiAgICAgIHwgTHJNdXRhdGlvbkJhc2U8VCwgVFZhcmlhYmxlcz5cclxuICAgICAgfCBQcm9taXNlPExyTXV0YXRpb25CYXNlPFQsIFRWYXJpYWJsZXM+PixcclxuICAgIG9wdGlvbnM/OiBMck11dGF0aW9uT3B0aW9uczxULCBUVmFyaWFibGVzPlxyXG4gICkge1xyXG4gICAgcmV0dXJuIHRoaXMubHJHcmFwaFFMLmxyTXV0YXRlKGxyTXV0YXRpb24sIG9wdGlvbnMpO1xyXG4gIH1cclxuXHJcbiAgcHJvdGVjdGVkIGFzeW5jIHF1ZXJ5PFQsIFY+KG9wdGlvbnM6IExyUXVlcnlPcHRpb25zPFQsIFY+KSB7XHJcbiAgICByZXR1cm4gdGhpcy5sckdyYXBoUUwucXVlcnkob3B0aW9ucyk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,138 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import gql from 'graphql-tag';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyGraphFragment } from '../_common/queries.gql';
+import { KeyExchangeService } from './key-exchange.service';
+import { LrApolloService } from './lr-apollo.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./lr-apollo.service";
+import * as i2 from "../cryptography/key-graph.service";
+import * as i3 from "../cryptography/encryption.service";
+import * as i4 from "./key-exchange.service";
+export const SendMessageMutation = gql `
+  mutation SendMessage($input: SendMessageInput!) {
+    sendMessage(input: $input) {
+      message {
+        id
+      }
+    }
+  }
+`;
+export const MessageQuery = gql `
+  query Message($id: LrRelayIdInput!) {
+    message(id: $id) {
+      id
+      sender {
+        username
+      }
+      receiver {
+        username
+      }
+      plainMessage
+      signedCipherMessage
+      sharedKey {
+        id
+      }
+      senderSigPbk {
+        id
+      }
+    }
+    keyGraph {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+export class MessageService {
+    constructor(lrApollo, keyGraph, encryptionService, keyExchangeService) {
+        this.lrApollo = lrApollo;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+        this.keyExchangeService = keyExchangeService;
+        this.encrypt = this.encryptionService.encrypt.bind(this.encryptionService);
+        this.decrypt = this.encryptionService.decrypt.bind(this.encryptionService);
+        this.sign = this.encryptionService.sign.bind(this.encryptionService);
+        this.verify = this.encryptionService.verify.bind(this.encryptionService);
+    }
+    sendMessage({ username, userId, plainMessageJson, plainCipherMessageJson, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userSharedKey = yield this.keyExchangeService.currentUserSharedKey({
+                username,
+                userId,
+            });
+            const input = {
+                receiverUsername: username,
+                receiverId: userId,
+                sharedKeyId: userSharedKey.sharedKey.id,
+                senderSigPbkId: userSharedKey.userSigPrk.id,
+            };
+            if (plainCipherMessageJson) {
+                const sharedKey = yield this.keyGraph.getJwkKey(userSharedKey.sharedKey.id);
+                const cipherMessage = yield this.encrypt(sharedKey, plainCipherMessageJson);
+                const senderSigPrk = yield this.keyGraph.getJwkKey(userSharedKey.userSigPrk.id);
+                const signedCipherMessage = yield this.sign(senderSigPrk, cipherMessage);
+                input.signedCipherMessage = JSON.stringify(signedCipherMessage);
+            }
+            if (plainMessageJson) {
+                input.plainMessage = JSON.stringify(plainMessageJson);
+            }
+            const res = yield this.lrApollo.query({
+                query: SendMessageMutation,
+                variables: {
+                    input,
+                },
+            });
+            return res.sendMessage;
+        });
+    }
+    decryptMessage(message, { sharedKey, senderSigPbk }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedCipherMessage = yield this.verify(senderSigPbk, JSON.parse(message.signedCipherMessage));
+            message.plainSignedCipherMessageJson = yield this.decrypt(sharedKey, signedCipherMessage);
+        });
+    }
+    getMessage(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.query({
+                query: MessageQuery,
+                variables: {
+                    id,
+                },
+            });
+            this.keyGraph.addKeys(res.keyGraph);
+            const message = res.message;
+            const sharedKey = yield this.keyGraph.getJwkKey(message.sharedKey.id);
+            // The sender would be getting the Prk back. The receiver gets the Pbk back.
+            // But only the Pbk is needed here to verify signature.
+            // So both sender and receiver can access this message.
+            const senderSigPbk = yield this.keyGraph.getJwkKey(message.senderSigPbk.id);
+            // Test bad signature
+            // senderSigPbk = senderSigPbk.toJSON();
+            // senderSigPbk.n = "x" + senderSigPbk.n.substring(1);
+            // senderSigPbk = await KFS.asKey(senderSigPbk);
+            yield this.decryptMessage(message, {
+                sharedKey,
+                senderSigPbk,
+            });
+            if (message.plainMessage) {
+                message.plainMessageJson = JSON.parse(message.plainMessage);
+            }
+            return res.message;
+        });
+    }
+}
+MessageService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MessageService_Factory() { return new MessageService(i0.ɵɵinject(i1.LrApolloService), i0.ɵɵinject(i2.KeyGraphService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyExchangeService)); }, token: MessageService, providedIn: "root" });
+MessageService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+MessageService.ctorParameters = () => [
+    { type: LrApolloService },
+    { type: KeyGraphService },
+    { type: EncryptionService },
+    { type: KeyExchangeService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/message.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport gql from 'graphql-tag';\r\nimport { JWK } from 'node-jose';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyGraphFragment } from '../_common/queries.gql';\r\nimport { KeyExchangeService } from './key-exchange.service';\r\nimport { LrApolloService } from './lr-apollo.service';\r\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\r\n\r\nexport const SendMessageMutation = gql`\r\n  mutation SendMessage($input: SendMessageInput!) {\r\n    sendMessage(input: $input) {\r\n      message {\r\n        id\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\nexport const MessageQuery = gql`\r\n  query Message($id: LrRelayIdInput!) {\r\n    message(id: $id) {\r\n      id\r\n      sender {\r\n        username\r\n      }\r\n      receiver {\r\n        username\r\n      }\r\n      plainMessage\r\n      signedCipherMessage\r\n      sharedKey {\r\n        id\r\n      }\r\n      senderSigPbk {\r\n        id\r\n      }\r\n    }\r\n    keyGraph {\r\n      ...KeyGraphFragment\r\n    }\r\n  }\r\n  ${KeyGraphFragment}\r\n`;\r\n\r\nexport interface SendMessage {\r\n  message: {\r\n    id: string;\r\n  };\r\n}\r\n\r\nexport interface SendMessageInput {\r\n  username?: string;\r\n  userId?: string;\r\n  plainMessageJson?: any;\r\n  plainCipherMessageJson?: any;\r\n}\r\n\r\nexport interface Message {\r\n  id: string;\r\n  sender: {\r\n    id: string;\r\n    username: string;\r\n  };\r\n  receiver: {\r\n    id: string;\r\n    username: string;\r\n  };\r\n  plainMessage: string;\r\n  plainMessageJson?: any;\r\n  signedCipherMessage: string;\r\n  plainSignedCipherMessageJson?: any;\r\n  senderSigPbk: {\r\n    id: string;\r\n  };\r\n  sharedKey: {\r\n    id: string;\r\n  };\r\n}\r\n\r\ninterface DecryptMessageOptions {\r\n  sharedKey: JWK.Key;\r\n  senderSigPbk: JWK.Key;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class MessageService {\r\n  private readonly encrypt = this.encryptionService.encrypt.bind(\r\n    this.encryptionService\r\n  );\r\n  private readonly decrypt = this.encryptionService.decrypt.bind(\r\n    this.encryptionService\r\n  );\r\n  private readonly sign = this.encryptionService.sign.bind(\r\n    this.encryptionService\r\n  );\r\n  private readonly verify = this.encryptionService.verify.bind(\r\n    this.encryptionService\r\n  );\r\n\r\n  constructor(\r\n    private lrApollo: LrApolloService,\r\n    private keyGraph: KeyGraphService,\r\n    private encryptionService: EncryptionService,\r\n    private keyExchangeService: KeyExchangeService\r\n  ) {}\r\n\r\n  async sendMessage({\r\n    username,\r\n    userId,\r\n    plainMessageJson,\r\n    plainCipherMessageJson,\r\n  }: SendMessageInput): Promise<SendMessage> {\r\n    const userSharedKey = await this.keyExchangeService.currentUserSharedKey({\r\n      username,\r\n      userId,\r\n    });\r\n\r\n    const input: any = {\r\n      receiverUsername: username,\r\n      receiverId: userId,\r\n      sharedKeyId: userSharedKey.sharedKey.id,\r\n      senderSigPbkId: userSharedKey.userSigPrk.id,\r\n    };\r\n\r\n    if (plainCipherMessageJson) {\r\n      const sharedKey = await this.keyGraph.getJwkKey(\r\n        userSharedKey.sharedKey.id\r\n      );\r\n      const cipherMessage = await this.encrypt(\r\n        sharedKey,\r\n        plainCipherMessageJson\r\n      );\r\n\r\n      const senderSigPrk = await this.keyGraph.getJwkKey(\r\n        userSharedKey.userSigPrk.id\r\n      );\r\n      const signedCipherMessage = await this.sign(senderSigPrk, cipherMessage);\r\n\r\n      input.signedCipherMessage = JSON.stringify(signedCipherMessage);\r\n    }\r\n\r\n    if (plainMessageJson) {\r\n      input.plainMessage = JSON.stringify(plainMessageJson);\r\n    }\r\n\r\n    const res = await this.lrApollo.query<any>({\r\n      query: SendMessageMutation,\r\n      variables: {\r\n        input,\r\n      },\r\n    });\r\n\r\n    return res.sendMessage;\r\n  }\r\n\r\n  async decryptMessage(\r\n    message: Message,\r\n    { sharedKey, senderSigPbk }: DecryptMessageOptions\r\n  ): Promise<void> {\r\n    const signedCipherMessage = await this.verify(\r\n      senderSigPbk,\r\n      JSON.parse(message.signedCipherMessage)\r\n    );\r\n\r\n    message.plainSignedCipherMessageJson = await this.decrypt(\r\n      sharedKey,\r\n      signedCipherMessage\r\n    );\r\n  }\r\n\r\n  async getMessage(id: string): Promise<Message> {\r\n    const res = await this.lrApollo.query<any>({\r\n      query: MessageQuery,\r\n      variables: {\r\n        id,\r\n      },\r\n    });\r\n\r\n    this.keyGraph.addKeys(res.keyGraph);\r\n\r\n    const message = res.message as Message;\r\n\r\n    const sharedKey = await this.keyGraph.getJwkKey(message.sharedKey.id);\r\n\r\n    // The sender would be getting the Prk back. The receiver gets the Pbk back.\r\n    // But only the Pbk is needed here to verify signature.\r\n    // So both sender and receiver can access this message.\r\n    const senderSigPbk = await this.keyGraph.getJwkKey(message.senderSigPbk.id);\r\n\r\n    // Test bad signature\r\n    // senderSigPbk = senderSigPbk.toJSON();\r\n    // senderSigPbk.n = \"x\" + senderSigPbk.n.substring(1);\r\n    // senderSigPbk = await KFS.asKey(senderSigPbk);\r\n\r\n    await this.decryptMessage(message, {\r\n      sharedKey,\r\n      senderSigPbk,\r\n    });\r\n\r\n    if (message.plainMessage) {\r\n      message.plainMessageJson = JSON.parse(message.plainMessage);\r\n    }\r\n\r\n    return res.message;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +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":"C:/Projects/test/projects/core/src/","sources":["lib/api/persist.service.ts"],"names":[],"mappings":"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","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"]}

package/esm2015/lib/api/query-processor/common-processors.service.js

@@ -0,0 +1,93 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { LrBadLogicException } from '../../_common/exceptions';
+import { RunOutsideAngular } from '../../_common/run-outside-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "../../cryptography/key-graph.service";
+export const DefaultProcessorOptions = {
+    hasKeys: true,
+};
+export function processConnection(field, processNode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Object.assign(Object.assign({}, field), { edges: yield Promise.all(field.edges.map((edge) => __awaiter(this, void 0, void 0, function* () {
+                return (Object.assign(Object.assign({}, edge), { node: yield processNode(edge.node) }));
+            }))) });
+    });
+}
+let CommonProcessorsService = class CommonProcessorsService {
+    constructor(ngZone, keyGraph) {
+        this.ngZone = ngZone;
+        this.keyGraph = keyGraph;
+    }
+    series(processors) {
+        return ({ field, context, options }) => __awaiter(this, void 0, void 0, function* () {
+            for (const processor of processors) {
+                field = yield processor({ field, context, options });
+            }
+            return field;
+        });
+    }
+    makeJsonParseProcessor({ plainFieldName, jsonFieldSuffix = 'Json', } = {}) {
+        const jsonFieldName = plainFieldName + jsonFieldSuffix;
+        return ({ field }) => {
+            if (field[plainFieldName] == null || jsonFieldName in field) {
+                // if plainFieldName is undefined or null, then don't parse it.
+                // if you parse it, then JSON.parse(null) and JSON.parse("null") both return null, so
+                // you can't distinguish between the two.
+                // If clearFieldName already exists in node as a property, then we don't
+                // need to process it again, even if it's value can be undefined or null even.
+                return field;
+            }
+            try {
+                return Object.assign(Object.assign({}, field), { [jsonFieldName]: JSON.parse(field[plainFieldName]) });
+            }
+            catch (error) {
+                return field;
+            }
+        };
+    }
+    makeDecryptionProcessor({ cipherFieldName, clearFieldSuffix = 'ClearJson', getKeyId = null, } = {}) {
+        const clearFieldName = cipherFieldName + clearFieldSuffix;
+        return (params) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { field, context, options } = params;
+            // Can't decrypt anything if key graph is not returned
+            if (!options.hasKeys) {
+                return field;
+            }
+            const cipherField = field[cipherFieldName];
+            // cipherField can be empty string, null or undefined.
+            if (!cipherField || clearFieldName in field) {
+                return field;
+            }
+            const keyId = getKeyId
+                ? yield getKeyId(params)
+                : field.keyId || ((_a = field.key) === null || _a === void 0 ? void 0 : _a.id);
+            if (!keyId) {
+                const keyIdName = getKeyId ? 'key-id' : 'keyId or key.id';
+                throw new LrBadLogicException(`Query response does not contain ${keyIdName} field: ${context.path.join('.')}`);
+            }
+            return this.keyGraph
+                .decryptFromString(keyId, cipherField)
+                .then((clear) => (Object.assign(Object.assign({}, field), { [clearFieldName]: clear })));
+        });
+    }
+};
+CommonProcessorsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CommonProcessorsService_Factory() { return new CommonProcessorsService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.KeyGraphService)); }, token: CommonProcessorsService, providedIn: "root" });
+CommonProcessorsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+CommonProcessorsService.ctorParameters = () => [
+    { type: NgZone },
+    { type: KeyGraphService }
+];
+CommonProcessorsService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], CommonProcessorsService);
+export { CommonProcessorsService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-processors.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/query-processor/common-processors.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { EncryptionService } from '../../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../../cryptography/key-graph.service';\r\nimport { LrBadLogicException } from '../../_common/exceptions';\r\nimport { RunOutsideAngular } from '../../_common/run-outside-angular';\r\nimport { Connection } from '../types';\r\n\r\nexport interface ProcessorOptions {\r\n  hasKeys: boolean;\r\n}\r\n\r\nexport const DefaultProcessorOptions: ProcessorOptions = {\r\n  hasKeys: true,\r\n};\r\n\r\n// Sent to each processor for context information\r\nexport interface ProcessorContext {\r\n  path: ReadonlyArray<string>;\r\n  // processor can set this to false if child fields should\r\n  // not be processed any further\r\n  processChildren: boolean;\r\n}\r\n\r\nexport interface ProcessorCallbackParams<T = any> {\r\n  field: T;\r\n  context: ProcessorContext;\r\n  options: ProcessorOptions;\r\n}\r\n\r\nexport type ProcessorCallback<T = any> = (\r\n  params: ProcessorCallbackParams<T>\r\n) => T | Promise<T>;\r\n\r\ninterface ParseJsonProcessorOptions {\r\n  plainFieldName?: string;\r\n  jsonFieldSuffix?: string;\r\n}\r\n\r\ninterface DecryptionProcessorOptions {\r\n  cipherFieldName?: string;\r\n  clearFieldSuffix?: string;\r\n  getKeyId?: (params: ProcessorCallbackParams) => Promise<string> | string;\r\n}\r\n\r\nexport async function processConnection<Node>(\r\n  field: Connection<Node>,\r\n  processNode: (node: Node) => Node | Promise<Node>\r\n): Promise<Connection<Node>> {\r\n  return {\r\n    ...field,\r\n    edges: await Promise.all(\r\n      field.edges.map(async (edge) => ({\r\n        ...edge,\r\n        node: await processNode(edge.node),\r\n      }))\r\n    ),\r\n  };\r\n}\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class CommonProcessorsService {\r\n  constructor(private ngZone: NgZone, private keyGraph: KeyGraphService) {}\r\n\r\n  series(processors: ProcessorCallback[]): ProcessorCallback {\r\n    return async ({ field, context, options }) => {\r\n      for (const processor of processors) {\r\n        field = await processor({ field, context, options });\r\n      }\r\n      return field;\r\n    };\r\n  }\r\n\r\n  makeJsonParseProcessor({\r\n    plainFieldName,\r\n    jsonFieldSuffix = 'Json',\r\n  }: ParseJsonProcessorOptions = {}): ProcessorCallback {\r\n    const jsonFieldName = plainFieldName + jsonFieldSuffix;\r\n\r\n    return ({ field }) => {\r\n      if (field[plainFieldName] == null || jsonFieldName in field) {\r\n        // if plainFieldName is undefined or null, then don't parse it.\r\n        // if you parse it, then JSON.parse(null) and JSON.parse(\"null\") both return null, so\r\n        // you can't distinguish between the two.\r\n        // If clearFieldName already exists in node as a property, then we don't\r\n        // need to process it again, even if it's value can be undefined or null even.\r\n        return field;\r\n      }\r\n\r\n      try {\r\n        return {\r\n          ...field,\r\n          [jsonFieldName]: JSON.parse(field[plainFieldName]),\r\n        };\r\n      } catch (error) {\r\n        return field;\r\n      }\r\n    };\r\n  }\r\n\r\n  makeDecryptionProcessor({\r\n    cipherFieldName,\r\n    clearFieldSuffix = 'ClearJson',\r\n    getKeyId = null,\r\n  }: DecryptionProcessorOptions = {}): ProcessorCallback {\r\n    const clearFieldName = cipherFieldName + clearFieldSuffix;\r\n\r\n    return async (params) => {\r\n      const { field, context, options } = params;\r\n\r\n      // Can't decrypt anything if key graph is not returned\r\n      if (!options.hasKeys) {\r\n        return field;\r\n      }\r\n\r\n      const cipherField = field[cipherFieldName];\r\n\r\n      // cipherField can be empty string, null or undefined.\r\n      if (!cipherField || clearFieldName in field) {\r\n        return field;\r\n      }\r\n\r\n      const keyId = getKeyId\r\n        ? await getKeyId(params)\r\n        : field.keyId || field.key?.id;\r\n\r\n      if (!keyId) {\r\n        const keyIdName = getKeyId ? 'key-id' : 'keyId or key.id';\r\n        throw new LrBadLogicException(\r\n          `Query response does not contain ${keyIdName} field: ${context.path.join(\r\n            '.'\r\n          )}`\r\n        );\r\n      }\r\n\r\n      return this.keyGraph\r\n        .decryptFromString(keyId, cipherField)\r\n        .then((clear) => ({\r\n          ...field,\r\n          [clearFieldName]: clear,\r\n        }));\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/query-processor/index.js

@@ -0,0 +1,3 @@
+export * from './query-processor.service';
+export * from './common-processors.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVjdHMvdGVzdC9wcm9qZWN0cy9jb3JlL3NyYy8iLCJzb3VyY2VzIjpbImxpYi9hcGkvcXVlcnktcHJvY2Vzc29yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcXVlcnktcHJvY2Vzc29yLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi1wcm9jZXNzb3JzLnNlcnZpY2UnO1xyXG4iXX0=