@lifeready/core 0.6.0-beta.1

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

@@ -0,0 +1,192 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { LrBadLogicException } from '../../_common/exceptions';
+import { mapValuesMayAsync, promiseAllMayAsync } from '../../_common/utils';
+import { KeyService } from '../../cryptography/key.service';
+import { CommonProcessorsService, DefaultProcessorOptions, } from './common-processors.service';
+import { RunOutsideAngular } from '../../_common/run-outside-angular';
+import { TpPasswordResetProcessorService } from './tp-password-reset-processor.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../cryptography/key.service";
+import * as i2 from "./common-processors.service";
+import * as i3 from "./tp-password-reset-processor.service";
+function extendPath(context, key) {
+    return Object.assign(Object.assign({}, context), { path: [...context.path, key] });
+}
+let QueryProcessorService = class QueryProcessorService {
+    constructor(ngZone, keyService, common, tpprProcessor) {
+        this.ngZone = ngZone;
+        this.keyService = keyService;
+        this.common = common;
+        this.tpprProcessor = tpprProcessor;
+        this.TYPENAME = '__typename';
+        this.processors = {};
+        this.registerProcessor('DirectoryNode', common.series([
+            common.makeJsonParseProcessor({
+                plainFieldName: 'plainMeta',
+            }),
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'cipherMeta',
+            }),
+        ]));
+        this.registerProcessor('FileStateNode', common.series([
+            common.makeJsonParseProcessor({
+                plainFieldName: 'plainMeta',
+            }),
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'cipherMeta',
+            }),
+        ]));
+        this.registerProcessor('ContactCardNode', common.makeDecryptionProcessor({
+            cipherFieldName: 'cipherData',
+        }));
+        this.registerProcessor('SharedContactCardNode', common.series([
+            common.makeJsonParseProcessor({
+                plainFieldName: 'ownerPlainData',
+            }),
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'ownerCipherData',
+                getKeyId: ({ field }) => {
+                    return field.ownerKey.id;
+                },
+            }),
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'receiverCipherData',
+                getKeyId: ({ field }) => {
+                    return field.receiverKey.id;
+                },
+            }),
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'sharedCipherData',
+                getKeyId: ({ field }) => field.sharedKey.id,
+            }),
+        ]));
+        this.registerProcessor('TpPasswordResetNode', this.tpprProcessor.makeTpPasswordResetNodeProcessor());
+        this.registerProcessor('SharedTpClaimApproverNode', common.series([
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'sharedCipherApprovalData',
+                getKeyId: ({ field }) => field.sharedKey.id,
+            }),
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'sharedCipherPartialAssemblyKey',
+                getKeyId: ({ field }) => field.sharedKey.id,
+            }),
+        ]));
+        this.registerProcessor('TpAssemblyAsApproverNode', common.series([
+            common.makeDecryptionProcessor({
+                cipherFieldName: 'sharedCipherData',
+                getKeyId: ({ field }) => field.sharedKey.id,
+            }),
+        ]));
+    }
+    processQuery(fields, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            options = Object.assign(Object.assign({}, DefaultProcessorOptions), options);
+            // The top level query does not have __typename
+            const ret = mapValuesMayAsync(fields, (field, key) => this.processField({
+                field,
+                context: {
+                    path: [key],
+                    processChildren: true,
+                },
+                options,
+            }));
+            return ret;
+        });
+    }
+    // Either returns a Promise, or a value.
+    // The Promise<any> type is redundant but it shows that it can return a promise
+    // We are not using async on the function because we don't want auto promotion into a Promise, which
+    // always defer execution into the event loops. It is costly and unnecessary for objects
+    // with only native data types.
+    processField({ field, context, options, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (field === null || field === void 0 ? void 0 : field.then) {
+                throw new LrBadLogicException('processField() should not receive thenable.');
+            }
+            if (field == null) {
+                return null;
+            }
+            const newParams = {
+                field,
+                context: Object.assign(Object.assign({}, context), { 
+                    // Processors modifies this field to communicate back to the caller.
+                    processChildren: true }),
+                options,
+            };
+            // TODO allow registering processors by field name so we can process primitive fields as well.
+            // We have common fields like "created", "modified" that be processed based on name.
+            if (field[this.TYPENAME]) {
+                // It's a custom object type
+                const processor = this.processors[field[this.TYPENAME]];
+                if (processor) {
+                    // Returns either a value or a promise.
+                    field = processor(newParams);
+                }
+                const processChildren = (childField) => {
+                    if (context.processChildren &&
+                        childField !== null &&
+                        typeof childField === 'object') {
+                        return mapValuesMayAsync(childField, (x, key) => this.processField({
+                            field: x,
+                            context: extendPath(context, key),
+                            options,
+                        }));
+                    }
+                    else {
+                        return childField;
+                    }
+                };
+                // Keep processing all child fields
+                if (field.then) {
+                    // Wait for field to resolve
+                    field = field.then((resolvedField) => {
+                        return processChildren(resolvedField);
+                    });
+                }
+                else {
+                    // Field is already resolved
+                    field = processChildren(field);
+                }
+            }
+            else {
+                // Keep processing all child fields
+                if (context.processChildren) {
+                    if (Array.isArray(field)) {
+                        field = promiseAllMayAsync(field.map((x, i) => this.processField({
+                            field: x,
+                            context: extendPath(context, i.toString()),
+                            options,
+                        })));
+                    }
+                }
+            }
+            return field;
+        });
+    }
+    registerProcessor(name, processor) {
+        if (this.processors[name]) {
+            throw new LrBadLogicException(`Processor for field ${name} already exists.`);
+        }
+        this.processors[name] = processor;
+    }
+};
+QueryProcessorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function QueryProcessorService_Factory() { return new QueryProcessorService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.KeyService), i0.ɵɵinject(i2.CommonProcessorsService), i0.ɵɵinject(i3.TpPasswordResetProcessorService)); }, token: QueryProcessorService, providedIn: "root" });
+QueryProcessorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+QueryProcessorService.ctorParameters = () => [
+    { type: NgZone },
+    { type: KeyService },
+    { type: CommonProcessorsService },
+    { type: TpPasswordResetProcessorService }
+];
+QueryProcessorService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], QueryProcessorService);
+export { QueryProcessorService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-processor.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/query-processor/query-processor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { LrBadLogicException } from '../../_common/exceptions';\r\nimport { mapValuesMayAsync, promiseAllMayAsync } from '../../_common/utils';\r\nimport { KeyService } from '../../cryptography/key.service';\r\nimport {\r\n  CommonProcessorsService,\r\n  // FieldContext,\r\n  ProcessorCallback,\r\n  ProcessorCallbackParams,\r\n  ProcessorContext,\r\n  ProcessorOptions,\r\n  DefaultProcessorOptions,\r\n} from './common-processors.service';\r\nimport { TpPasswordResetService } from '../../trusted-parties/tp-password-reset.service';\r\nimport { RunOutsideAngular } from '../../_common/run-outside-angular';\r\nimport { TpPasswordResetProcessorService } from './tp-password-reset-processor.service';\r\n\r\nfunction extendPath(context: ProcessorContext, key: string): ProcessorContext {\r\n  return {\r\n    ...context,\r\n    path: [...context.path, key],\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 QueryProcessorService {\r\n  readonly TYPENAME = '__typename';\r\n  private processors: { [key: string]: ProcessorCallback } = {};\r\n\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private keyService: KeyService,\r\n    private common: CommonProcessorsService,\r\n    private tpprProcessor: TpPasswordResetProcessorService\r\n  ) {\r\n    this.registerProcessor(\r\n      'DirectoryNode',\r\n      common.series([\r\n        common.makeJsonParseProcessor({\r\n          plainFieldName: 'plainMeta',\r\n        }),\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'cipherMeta',\r\n        }),\r\n      ])\r\n    );\r\n    this.registerProcessor(\r\n      'FileStateNode',\r\n      common.series([\r\n        common.makeJsonParseProcessor({\r\n          plainFieldName: 'plainMeta',\r\n        }),\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'cipherMeta',\r\n        }),\r\n      ])\r\n    );\r\n    this.registerProcessor(\r\n      'ContactCardNode',\r\n      common.makeDecryptionProcessor({\r\n        cipherFieldName: 'cipherData',\r\n      })\r\n    );\r\n    this.registerProcessor(\r\n      'SharedContactCardNode',\r\n      common.series([\r\n        common.makeJsonParseProcessor({\r\n          plainFieldName: 'ownerPlainData',\r\n        }),\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'ownerCipherData',\r\n          getKeyId: ({ field }) => {\r\n            return field.ownerKey.id;\r\n          },\r\n        }),\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'receiverCipherData',\r\n          getKeyId: ({ field }) => {\r\n            return field.receiverKey.id;\r\n          },\r\n        }),\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'sharedCipherData',\r\n          getKeyId: ({ field }) => field.sharedKey.id,\r\n        }),\r\n      ])\r\n    );\r\n    this.registerProcessor(\r\n      'TpPasswordResetNode',\r\n      this.tpprProcessor.makeTpPasswordResetNodeProcessor()\r\n    );\r\n    this.registerProcessor(\r\n      'SharedTpClaimApproverNode',\r\n      common.series([\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'sharedCipherApprovalData',\r\n          getKeyId: ({ field }) => field.sharedKey.id,\r\n        }),\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'sharedCipherPartialAssemblyKey',\r\n          getKeyId: ({ field }) => field.sharedKey.id,\r\n        }),\r\n      ])\r\n    );\r\n    this.registerProcessor(\r\n      'TpAssemblyAsApproverNode',\r\n      common.series([\r\n        common.makeDecryptionProcessor({\r\n          cipherFieldName: 'sharedCipherData',\r\n          getKeyId: ({ field }) => field.sharedKey.id,\r\n        }),\r\n      ])\r\n    );\r\n  }\r\n\r\n  async processQuery(\r\n    fields: { [key: string]: any },\r\n    options: ProcessorOptions\r\n  ) {\r\n    options = {\r\n      ...DefaultProcessorOptions,\r\n      ...options,\r\n    };\r\n\r\n    // The top level query does not have __typename\r\n    const ret = mapValuesMayAsync(fields, (field, key) =>\r\n      this.processField({\r\n        field,\r\n        context: {\r\n          path: [key],\r\n          processChildren: true,\r\n        },\r\n        options,\r\n      })\r\n    );\r\n    return ret;\r\n  }\r\n\r\n  // Either returns a Promise, or a value.\r\n  // The Promise<any> type is redundant but it shows that it can return a promise\r\n  // We are not using async on the function because we don't want auto promotion into a Promise, which\r\n  // always defer execution into the event loops. It is costly and unnecessary for objects\r\n  // with only native data types.\r\n  private async processField({\r\n    field,\r\n    context,\r\n    options,\r\n  }: ProcessorCallbackParams) {\r\n    if (field?.then) {\r\n      throw new LrBadLogicException(\r\n        'processField() should not receive thenable.'\r\n      );\r\n    }\r\n\r\n    if (field == null) {\r\n      return null;\r\n    }\r\n\r\n    const newParams: ProcessorCallbackParams = {\r\n      field,\r\n      context: {\r\n        ...context,\r\n        // Processors modifies this field to communicate back to the caller.\r\n        processChildren: true,\r\n      },\r\n      options,\r\n    };\r\n\r\n    // TODO allow registering processors by field name so we can process primitive fields as well.\r\n    // We have common fields like \"created\", \"modified\" that be processed based on name.\r\n    if (field[this.TYPENAME]) {\r\n      // It's a custom object type\r\n      const processor = this.processors[field[this.TYPENAME]];\r\n      if (processor) {\r\n        // Returns either a value or a promise.\r\n        field = processor(newParams);\r\n      }\r\n\r\n      const processChildren = (childField) => {\r\n        if (\r\n          context.processChildren &&\r\n          childField !== null &&\r\n          typeof childField === 'object'\r\n        ) {\r\n          return mapValuesMayAsync(childField, (x, key) =>\r\n            this.processField({\r\n              field: x,\r\n              context: extendPath(context, key),\r\n              options,\r\n            })\r\n          );\r\n        } else {\r\n          return childField;\r\n        }\r\n      };\r\n\r\n      // Keep processing all child fields\r\n      if (field.then) {\r\n        // Wait for field to resolve\r\n        field = field.then((resolvedField) => {\r\n          return processChildren(resolvedField);\r\n        });\r\n      } else {\r\n        // Field is already resolved\r\n        field = processChildren(field);\r\n      }\r\n    } else {\r\n      // Keep processing all child fields\r\n      if (context.processChildren) {\r\n        if (Array.isArray(field)) {\r\n          field = promiseAllMayAsync(\r\n            (field as Array<any>).map((x, i) =>\r\n              this.processField({\r\n                field: x,\r\n                context: extendPath(context, i.toString()),\r\n                options,\r\n              })\r\n            )\r\n          );\r\n        }\r\n      }\r\n    }\r\n\r\n    return field;\r\n  }\r\n\r\n  private registerProcessor(name: string, processor: ProcessorCallback) {\r\n    if (this.processors[name]) {\r\n      throw new LrBadLogicException(\r\n        `Processor for field ${name} already exists.`\r\n      );\r\n    }\r\n    this.processors[name] = processor;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/query-processor/tp-password-reset-processor.service.js

@@ -0,0 +1,109 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { RunOutsideAngular } from '../../_common/run-outside-angular';
+import { processConnection, } from './common-processors.service';
+import { LrBadRequestException } from '../../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "../../cryptography/key-graph.service";
+let TpPasswordResetProcessorService = class TpPasswordResetProcessorService {
+    constructor(ngZone, keyGraph) {
+        this.ngZone = ngZone;
+        this.keyGraph = keyGraph;
+    }
+    processTpPasswordResetUserNode(node) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const pxk = ((_a = node.pxk) === null || _a === void 0 ? void 0 : _a.id) && (yield this.keyGraph.getKey(node.pxk.id));
+            const ret = Object.assign({}, node);
+            if (pxk && node.approvals) {
+                ret.approvals = yield Promise.all(node.approvals.map((approval) => this.processTpPasswordResetUserApprovalNode(approval, pxk)));
+            }
+            return ret;
+        });
+    }
+    processTpPasswordResetUserApprovalNode(approval, pxk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = Object.assign({}, approval);
+            if (approval.receiverCipher) {
+                ret.receiverCipherClearJson = this.keyGraph.decryptFromString(pxk, approval.receiverCipher);
+            }
+            if (approval.receiverCipherPartialAssemblyKey) {
+                ret.receiverCipherPartialAssemblyKeyClearJson = this.keyGraph.decryptFromString(pxk, approval.receiverCipherPartialAssemblyKey);
+            }
+            return ret;
+        });
+    }
+    makeTpPasswordResetNodeProcessor() {
+        return ({ field, }) => __awaiter(this, void 0, void 0, function* () {
+            const ret = Object.assign({}, field);
+            if (field.assembly) {
+                if (field.applied == null) {
+                    throw new LrBadRequestException('If you request for field "assembly" in the TpPasswordResetNode, then you must also request the "applied" field');
+                }
+                ret.assembly = yield this.processTpAssemblyNode(field.assembly, field.applied);
+            }
+            return ret;
+        });
+    }
+    processTpAssemblyNode(assembly, applied) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Subject key is encrypted user the master key. So if reset has been applied, then
+            // these keys are not available any more.
+            const { subjectKey, assemblyKey, assemblyCipherData, subAssemblies, } = assembly;
+            const ret = Object.assign(Object.assign({}, assembly), { subAssemblies: yield processConnection(subAssemblies, (node) => this.processTpSubAssemblyNode(node, subjectKey.id, applied)) });
+            if (!applied) {
+                if (assemblyCipherData) {
+                    ret.assemblyCipherDataClearJson = yield this.keyGraph.decryptFromString(assemblyKey.id, assemblyCipherData);
+                }
+            }
+            return ret;
+        });
+    }
+    processTpSubAssemblyNode(subAssembly, subjectKeyId, applied) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { subjectCipherData, approvers } = subAssembly;
+            // const ret: TpSubAssemblyNode = {
+            //   ...subAssembly,
+            //   approvers: {
+            //     ...approvers,
+            //     edges: await Promise.all(
+            //       approvers.edges.map(async (edge) => ({
+            //         ...edge,
+            //         node: await this.processTpAssemblyApproverNode(edge.node, applied),
+            //       }))
+            //     ),
+            //   },
+            // };
+            const ret = Object.assign(Object.assign({}, subAssembly), { approvers: yield processConnection(approvers, (node) => this.processTpAssemblyApproverNode(node, applied)) });
+            if (!applied) {
+                if (subjectCipherData) {
+                    ret.subjectCipherDataClearJson = yield this.keyGraph.decryptFromString(subjectKeyId, subjectCipherData);
+                }
+            }
+            return ret;
+        });
+    }
+    processTpAssemblyApproverNode(approver, applied) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return approver;
+        });
+    }
+};
+TpPasswordResetProcessorService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TpPasswordResetProcessorService_Factory() { return new TpPasswordResetProcessorService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.KeyGraphService)); }, token: TpPasswordResetProcessorService, providedIn: "root" });
+TpPasswordResetProcessorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TpPasswordResetProcessorService.ctorParameters = () => [
+    { type: NgZone },
+    { type: KeyGraphService }
+];
+TpPasswordResetProcessorService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], TpPasswordResetProcessorService);
+export { TpPasswordResetProcessorService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp-password-reset-processor.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/query-processor/tp-password-reset-processor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { KeyGraphService } from '../../cryptography/key-graph.service';\r\nimport { RunOutsideAngular } from '../../_common/run-outside-angular';\r\nimport {\r\n  ID,\r\n  SharedTpAssemblyNode,\r\n  TpAssemblyApproverNode,\r\n  TpAssemblyNode,\r\n  TpSubAssemblyNode,\r\n} from '../types';\r\nimport {\r\n  processConnection,\r\n  ProcessorCallbackParams,\r\n} from './common-processors.service';\r\nimport {\r\n  TpPasswordResetUserNode,\r\n  TpPasswordResetUserApprovalNode,\r\n  TpPasswordResetNode,\r\n} from '../types';\r\nimport { Key } from '../../cryptography/cryptography.types';\r\nimport { LrBadRequestException } from '../../_common/exceptions';\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TpPasswordResetProcessorService {\r\n  constructor(private ngZone: NgZone, private keyGraph: KeyGraphService) {}\r\n\r\n  async processTpPasswordResetUserNode(\r\n    node: TpPasswordResetUserNode\r\n  ): Promise<TpPasswordResetUserNode> {\r\n    const pxk = node.pxk?.id && (await this.keyGraph.getKey(node.pxk.id));\r\n\r\n    const ret = {\r\n      ...node,\r\n    };\r\n\r\n    if (pxk && node.approvals) {\r\n      ret.approvals = await Promise.all(\r\n        node.approvals.map((approval) =>\r\n          this.processTpPasswordResetUserApprovalNode(approval, pxk)\r\n        )\r\n      );\r\n    }\r\n\r\n    return ret;\r\n  }\r\n\r\n  private async processTpPasswordResetUserApprovalNode(\r\n    approval: TpPasswordResetUserApprovalNode,\r\n    pxk: Key\r\n  ) {\r\n    const ret = {\r\n      ...approval,\r\n    };\r\n\r\n    if (approval.receiverCipher) {\r\n      ret.receiverCipherClearJson = this.keyGraph.decryptFromString(\r\n        pxk,\r\n        approval.receiverCipher\r\n      );\r\n    }\r\n\r\n    if (approval.receiverCipherPartialAssemblyKey) {\r\n      ret.receiverCipherPartialAssemblyKeyClearJson = this.keyGraph.decryptFromString(\r\n        pxk,\r\n        approval.receiverCipherPartialAssemblyKey\r\n      );\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  makeTpPasswordResetNodeProcessor() {\r\n    return async ({\r\n      field,\r\n    }: ProcessorCallbackParams): Promise<TpPasswordResetNode> => {\r\n      const ret = {\r\n        ...field,\r\n      };\r\n\r\n      if (field.assembly) {\r\n        if (field.applied == null) {\r\n          throw new LrBadRequestException(\r\n            'If you request for field \"assembly\" in the TpPasswordResetNode, then you must also request the \"applied\" field'\r\n          );\r\n        }\r\n\r\n        ret.assembly = await this.processTpAssemblyNode(\r\n          field.assembly,\r\n          field.applied\r\n        );\r\n      }\r\n\r\n      return ret;\r\n    };\r\n  }\r\n\r\n  private async processTpAssemblyNode(\r\n    assembly: TpAssemblyNode,\r\n    applied: boolean\r\n  ): Promise<TpAssemblyNode> {\r\n    // Subject key is encrypted user the master key. So if reset has been applied, then\r\n    // these keys are not available any more.\r\n    const {\r\n      subjectKey,\r\n      assemblyKey,\r\n      assemblyCipherData,\r\n      subAssemblies,\r\n    } = assembly;\r\n\r\n    const ret: TpAssemblyNode = {\r\n      ...assembly,\r\n      subAssemblies: await processConnection(subAssemblies, (node) =>\r\n        this.processTpSubAssemblyNode(node, subjectKey.id, applied)\r\n      ),\r\n    };\r\n\r\n    if (!applied) {\r\n      if (assemblyCipherData) {\r\n        ret.assemblyCipherDataClearJson = await this.keyGraph.decryptFromString(\r\n          assemblyKey.id,\r\n          assemblyCipherData\r\n        );\r\n      }\r\n    }\r\n\r\n    return ret;\r\n  }\r\n\r\n  private async processTpSubAssemblyNode(\r\n    subAssembly: TpSubAssemblyNode,\r\n    subjectKeyId: ID,\r\n    applied: boolean\r\n  ): Promise<TpSubAssemblyNode> {\r\n    const { subjectCipherData, approvers } = subAssembly;\r\n\r\n    // const ret: TpSubAssemblyNode = {\r\n    //   ...subAssembly,\r\n    //   approvers: {\r\n    //     ...approvers,\r\n    //     edges: await Promise.all(\r\n    //       approvers.edges.map(async (edge) => ({\r\n    //         ...edge,\r\n    //         node: await this.processTpAssemblyApproverNode(edge.node, applied),\r\n    //       }))\r\n    //     ),\r\n    //   },\r\n    // };\r\n    const ret: TpSubAssemblyNode = {\r\n      ...subAssembly,\r\n      approvers: await processConnection(approvers, (node) =>\r\n        this.processTpAssemblyApproverNode(node, applied)\r\n      ),\r\n    };\r\n\r\n    if (!applied) {\r\n      if (subjectCipherData) {\r\n        ret.subjectCipherDataClearJson = await this.keyGraph.decryptFromString(\r\n          subjectKeyId,\r\n          subjectCipherData\r\n        );\r\n      }\r\n    }\r\n\r\n    return ret;\r\n  }\r\n\r\n  private async processTpAssemblyApproverNode(\r\n    approver: TpAssemblyApproverNode,\r\n    applied: boolean\r\n  ) {\r\n    return approver;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/shared-contact-card.service.js

@@ -0,0 +1,119 @@
+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 { KeyService } from '../cryptography/key.service';
+import { ContactCardName } from '../users/profile.types';
+import { LrApolloService } from './lr-apollo.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key.service";
+import * as i2 from "./lr-apollo.service";
+import * as i3 from "../cryptography/key-graph.service";
+import * as i4 from "../cryptography/encryption.service";
+export const SharedContactCardFields = `
+  id
+  owner {
+    id
+    username
+  }
+  ownerKey {
+    id
+  }
+  ownerCipherData
+  receiver {
+    id
+    username
+  }
+  receiverKey {
+    id
+  }
+  receiverCipherData
+  sharedKey {
+    id
+  }
+  sharedCipherData
+  sharedCipherDataSig
+  sharedCipherDataSigPxk {
+    id
+  }
+`;
+const UpdateOwnedContactCard = gql `
+mutation UpdateOwnedContactCard(
+  $input: UpdateOwnedContactCardInput!
+) {
+  updateOwnedContactCard(
+    input: $input
+  ) {
+    ownedContactCard {
+      ${SharedContactCardFields}
+    }
+  }
+}`;
+export class SharedContactCardService {
+    constructor(keyService, lrApollo, keyGraph, encryptionService) {
+        this.keyService = keyService;
+        this.lrApollo = lrApollo;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+    }
+    decryptSharedTrustedPartyDetails(cc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const details = yield this.decryptTrustedPartyDetails(cc);
+            return Object.assign({ id: cc.id, ownedKeyId: cc.ownerKey.id, sharedKeyId: cc.sharedKey.id }, details);
+        });
+    }
+    decryptTrustedPartyDetails(cc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (cc && cc.sharedKey && cc.sharedCipherData) {
+                try {
+                    return yield this.encryptionService.decrypt(yield this.keyGraph.getJwkKey(cc.sharedKey.id), cc.sharedCipherData);
+                }
+                catch (e) {
+                    console.error('Cannot decrypt trusted party details', e);
+                }
+            }
+            return null;
+        });
+    }
+    updateMySharedContactCard(id, ownedKeyId, sharedKeyId, contactCard) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ownerKey = yield this.keyGraph.getKey(ownedKeyId);
+            const sharedKey = yield this.keyGraph.getKey(sharedKeyId);
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const sharedCipherData = yield this.encryptionService.encrypt(sharedKey.jwk, contactCard);
+            const sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+            const ownerPlainData = {
+                name: new ContactCardName(contactCard.name),
+            };
+            const ownerPlainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, ownerPlainData));
+            yield this.lrApollo.mutate({
+                mutation: UpdateOwnedContactCard,
+                variables: {
+                    input: {
+                        id,
+                        ownerCipherData: '',
+                        ownerKeyId: ownerKey.id,
+                        sharedCipherDataSig,
+                        sharedKeyId: sharedKey.id,
+                        sigPxkId: sigPxk.id,
+                        ownerPlainDataSig,
+                    },
+                },
+            });
+        });
+    }
+}
+SharedContactCardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedContactCardService_Factory() { return new SharedContactCardService(i0.ɵɵinject(i1.KeyService), i0.ɵɵinject(i2.LrApolloService), i0.ɵɵinject(i3.KeyGraphService), i0.ɵɵinject(i4.EncryptionService)); }, token: SharedContactCardService, providedIn: "root" });
+SharedContactCardService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+SharedContactCardService.ctorParameters = () => [
+    { type: KeyService },
+    { type: LrApolloService },
+    { type: KeyGraphService },
+    { type: EncryptionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-contact-card.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/shared-contact-card.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport gql from 'graphql-tag';\r\nimport { Key } from '../cryptography/cryptography.types';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { SharedTrustedPartyDetails } from '../trusted-parties/trusted-party.types';\r\nimport { ContactCardName, TrustedPartyDetails } from '../users/profile.types';\r\nimport { User } from '../users/user.types';\r\nimport { KeyGraphField } from '../_common/queries.gql';\r\nimport { LrApolloService } from './lr-apollo.service';\r\n\r\nexport const SharedContactCardFields = `\r\n  id\r\n  owner {\r\n    id\r\n    username\r\n  }\r\n  ownerKey {\r\n    id\r\n  }\r\n  ownerCipherData\r\n  receiver {\r\n    id\r\n    username\r\n  }\r\n  receiverKey {\r\n    id\r\n  }\r\n  receiverCipherData\r\n  sharedKey {\r\n    id\r\n  }\r\n  sharedCipherData\r\n  sharedCipherDataSig\r\n  sharedCipherDataSigPxk {\r\n    id\r\n  }\r\n`;\r\n\r\nconst UpdateOwnedContactCard = gql`\r\nmutation UpdateOwnedContactCard(\r\n  $input: UpdateOwnedContactCardInput!\r\n) {\r\n  updateOwnedContactCard(\r\n    input: $input\r\n  ) {\r\n    ownedContactCard {\r\n      ${SharedContactCardFields}\r\n    }\r\n  }\r\n}`;\r\n\r\ninterface UpdateOwnedContactCard {\r\n  updateOwnedContactCard: {\r\n    ownedContactCard: SharedContactCard;\r\n  };\r\n}\r\n\r\nexport interface SharedContactCard {\r\n  id: string;\r\n  owner: User;\r\n  ownerKey: Key;\r\n  ownerCipherData: string;\r\n  receiver: User;\r\n  receiverKey: Key;\r\n  receiverCipherData: string;\r\n  sharedKey: Key;\r\n  sharedCipherData: string;\r\n  // Decrypted\r\n  plainOwnerCipherDataJson: any;\r\n  plainReceiverCipherDataJson: any;\r\n  plainSharedCipherDataJson: any;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SharedContactCardService {\r\n  constructor(\r\n    private keyService: KeyService,\r\n    private lrApollo: LrApolloService,\r\n    private keyGraph: KeyGraphService,\r\n    private encryptionService: EncryptionService\r\n  ) {}\r\n\r\n  async decryptSharedTrustedPartyDetails(\r\n    cc: SharedContactCard\r\n  ): Promise<SharedTrustedPartyDetails> {\r\n    const details = await this.decryptTrustedPartyDetails(cc);\r\n\r\n    return {\r\n      id: cc.id,\r\n      ownedKeyId: cc.ownerKey.id,\r\n      sharedKeyId: cc.sharedKey.id,\r\n      ...details,\r\n    };\r\n  }\r\n\r\n  async decryptTrustedPartyDetails(\r\n    cc: SharedContactCard\r\n  ): Promise<TrustedPartyDetails> {\r\n    if (cc && cc.sharedKey && cc.sharedCipherData) {\r\n      try {\r\n        return await this.encryptionService.decrypt(\r\n          await this.keyGraph.getJwkKey(cc.sharedKey.id),\r\n          cc.sharedCipherData\r\n        );\r\n      } catch (e) {\r\n        console.error('Cannot decrypt trusted party details', e);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  async updateMySharedContactCard(\r\n    id: string,\r\n    ownedKeyId: string,\r\n    sharedKeyId: string,\r\n    contactCard: TrustedPartyDetails\r\n  ): Promise<void> {\r\n    const ownerKey = await this.keyGraph.getKey(ownedKeyId);\r\n    const sharedKey = await this.keyGraph.getKey(sharedKeyId);\r\n    const sigPxk = await this.keyService.getCurrentSigPxk();\r\n\r\n    const sharedCipherData = await this.encryptionService.encrypt(\r\n      sharedKey.jwk,\r\n      contactCard\r\n    );\r\n    const sharedCipherDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\r\n    );\r\n\r\n    const ownerPlainData = {\r\n      name: new ContactCardName(contactCard.name),\r\n    };\r\n    const ownerPlainDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, ownerPlainData)\r\n    );\r\n\r\n    await this.lrApollo.mutate<UpdateOwnedContactCard>({\r\n      mutation: UpdateOwnedContactCard,\r\n      variables: {\r\n        input: {\r\n          id,\r\n          ownerCipherData: '',\r\n          ownerKeyId: ownerKey.id,\r\n          sharedCipherDataSig,\r\n          sharedKeyId: sharedKey.id,\r\n          sigPxkId: sigPxk.id,\r\n          ownerPlainDataSig,\r\n        },\r\n      },\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/shared-contact-card2.gql.js

@@ -0,0 +1,41 @@
+import { gqlTyped } from '../_common/ast';
+export const UpdateOwnedContactCardMutation = gqlTyped `
+mutation UpdateOwnedContactCardMutation(
+  $input: UpdateOwnedContactCardInput!
+) {
+  updateOwnedContactCard(input: $input) {
+    ownedContactCard {
+      id
+    }
+  }
+}`;
+export const UpdateReceivedContactCardMutation = gqlTyped `
+mutation UpdateReceivedContactCardMutation(
+  $input: UpdateReceivedContactCardInput!
+) {
+  updateReceivedContactCard(input: $input) {
+    receivedContactCard {
+      id
+    }
+  }
+}`;
+export const GetOwnedContactCardKeyIdsQuery = gqlTyped `
+query GetOwnedContactCardKeyIdsQuery($id: LrRelayIdInput!) {
+  ownedContactCard(id: $id) {
+    sharedKey {
+      id
+    }
+    ownerKey {
+      id
+    }
+  }
+}`;
+export const GetReceivedContactCardKeyIdQuery = gqlTyped `
+query GetReceivedContactCardKeyIdQuery($id: LrRelayIdInput!) {
+  receivedContactCard(id: $id) {
+    receiverKey {
+      id
+    }
+  }
+}`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLWNvbnRhY3QtY2FyZDIuZ3FsLmpzIiwic291cmNlUm9vdCI6IkM6L1Byb2plY3RzL3Rlc3QvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvYXBpL3NoYXJlZC1jb250YWN0LWNhcmQyLmdxbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFVMUMsTUFBTSxDQUFDLE1BQU0sOEJBQThCLEdBQUcsUUFBUSxDQUFnQzs7Ozs7Ozs7O0VBU3BGLENBQUM7QUFTSCxNQUFNLENBQUMsTUFBTSxpQ0FBaUMsR0FBRyxRQUFRLENBQW1DOzs7Ozs7Ozs7RUFTMUYsQ0FBQztBQVlILE1BQU0sQ0FBQyxNQUFNLDhCQUE4QixHQUFHLFFBQVEsQ0FBZ0M7Ozs7Ozs7Ozs7RUFVcEYsQ0FBQztBQVNILE1BQU0sQ0FBQyxNQUFNLGdDQUFnQyxHQUFHLFFBQVEsQ0FBa0M7Ozs7Ozs7RUFPeEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdxbFR5cGVkIH0gZnJvbSAnLi4vX2NvbW1vbi9hc3QnO1xyXG5pbXBvcnQgeyBJRCB9IGZyb20gJy4vdHlwZXMnO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBVcGRhdGVPd25lZENvbnRhY3RDYXJkTXV0YXRpb24ge1xyXG4gIHVwZGF0ZU93bmVkQ29udGFjdENhcmQ6IHtcclxuICAgIG93bmVkQ29udGFjdENhcmQ6IHtcclxuICAgICAgaWQ6IElEO1xyXG4gICAgfTtcclxuICB9O1xyXG59XHJcbmV4cG9ydCBjb25zdCBVcGRhdGVPd25lZENvbnRhY3RDYXJkTXV0YXRpb24gPSBncWxUeXBlZDxVcGRhdGVPd25lZENvbnRhY3RDYXJkTXV0YXRpb24+YFxyXG5tdXRhdGlvbiBVcGRhdGVPd25lZENvbnRhY3RDYXJkTXV0YXRpb24oXHJcbiAgJGlucHV0OiBVcGRhdGVPd25lZENvbnRhY3RDYXJkSW5wdXQhXHJcbikge1xyXG4gIHVwZGF0ZU93bmVkQ29udGFjdENhcmQoaW5wdXQ6ICRpbnB1dCkge1xyXG4gICAgb3duZWRDb250YWN0Q2FyZCB7XHJcbiAgICAgIGlkXHJcbiAgICB9XHJcbiAgfVxyXG59YDtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgVXBkYXRlUmVjZWl2ZWRDb250YWN0Q2FyZE11dGF0aW9uIHtcclxuICB1cGRhdGVSZWNlaXZlZENvbnRhY3RDYXJkOiB7XHJcbiAgICByZWNlaXZlZENvbnRhY3RDYXJkOiB7XHJcbiAgICAgIGlkOiBJRDtcclxuICAgIH07XHJcbiAgfTtcclxufVxyXG5leHBvcnQgY29uc3QgVXBkYXRlUmVjZWl2ZWRDb250YWN0Q2FyZE11dGF0aW9uID0gZ3FsVHlwZWQ8VXBkYXRlUmVjZWl2ZWRDb250YWN0Q2FyZE11dGF0aW9uPmBcclxubXV0YXRpb24gVXBkYXRlUmVjZWl2ZWRDb250YWN0Q2FyZE11dGF0aW9uKFxyXG4gICRpbnB1dDogVXBkYXRlUmVjZWl2ZWRDb250YWN0Q2FyZElucHV0IVxyXG4pIHtcclxuICB1cGRhdGVSZWNlaXZlZENvbnRhY3RDYXJkKGlucHV0OiAkaW5wdXQpIHtcclxuICAgIHJlY2VpdmVkQ29udGFjdENhcmQge1xyXG4gICAgICBpZFxyXG4gICAgfVxyXG4gIH1cclxufWA7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEdldE93bmVkQ29udGFjdENhcmRLZXlJZHNRdWVyeSB7XHJcbiAgb3duZWRDb250YWN0Q2FyZDoge1xyXG4gICAgc2hhcmVkS2V5OiB7XHJcbiAgICAgIGlkOiBJRDtcclxuICAgIH07XHJcbiAgICBvd25lcktleToge1xyXG4gICAgICBpZDogSUQ7XHJcbiAgICB9O1xyXG4gIH07XHJcbn1cclxuZXhwb3J0IGNvbnN0IEdldE93bmVkQ29udGFjdENhcmRLZXlJZHNRdWVyeSA9IGdxbFR5cGVkPEdldE93bmVkQ29udGFjdENhcmRLZXlJZHNRdWVyeT5gXHJcbnF1ZXJ5IEdldE93bmVkQ29udGFjdENhcmRLZXlJZHNRdWVyeSgkaWQ6IExyUmVsYXlJZElucHV0ISkge1xyXG4gIG93bmVkQ29udGFjdENhcmQoaWQ6ICRpZCkge1xyXG4gICAgc2hhcmVkS2V5IHtcclxuICAgICAgaWRcclxuICAgIH1cclxuICAgIG93bmVyS2V5IHtcclxuICAgICAgaWRcclxuICAgIH1cclxuICB9XHJcbn1gO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBHZXRSZWNlaXZlZENvbnRhY3RDYXJkS2V5SWRRdWVyeSB7XHJcbiAgcmVjZWl2ZWRDb250YWN0Q2FyZDoge1xyXG4gICAgcmVjZWl2ZXJLZXk6IHtcclxuICAgICAgaWQ6IElEO1xyXG4gICAgfTtcclxuICB9O1xyXG59XHJcbmV4cG9ydCBjb25zdCBHZXRSZWNlaXZlZENvbnRhY3RDYXJkS2V5SWRRdWVyeSA9IGdxbFR5cGVkPEdldFJlY2VpdmVkQ29udGFjdENhcmRLZXlJZFF1ZXJ5PmBcclxucXVlcnkgR2V0UmVjZWl2ZWRDb250YWN0Q2FyZEtleUlkUXVlcnkoJGlkOiBMclJlbGF5SWRJbnB1dCEpIHtcclxuICByZWNlaXZlZENvbnRhY3RDYXJkKGlkOiAkaWQpIHtcclxuICAgIHJlY2VpdmVyS2V5IHtcclxuICAgICAgaWRcclxuICAgIH1cclxuICB9XHJcbn1gO1xyXG4iXX0=