@lifeready/core 1.0.4 → 1.0.6

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

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