@lifeready/core 0.6.0-beta.1

package/esm2015/lib/scenario/scenario.types.js

@@ -0,0 +1,64 @@
+// Glossary
+// - Subject: the user that the scenario applies to
+// - Approver: the user that can approve a scenario
+// - Approver sub-assembly: a group of approvers that must reach quorum for the sub-assembly to be considered approved
+// - Approver assembly: a group of sub-assemblies that must reach quorum for the assembly to be considered approved
+// - Receiver: a user that will receive the released information
+// - Claimant: a user that can start the process of release of information
+export var ScenarioState;
+(function (ScenarioState) {
+    // Can not be claimed when DISABLED. Scenarios can be created in this state, then
+    // set to ENABLED once setup is complete.
+    ScenarioState["DISABLED"] = "DISABLED";
+    // Can be claimed when ENABLED. It sits in this state until claimed.
+    ScenarioState["ENABLED"] = "ENABLED";
+    // Claimant has initiated a claim.
+    ScenarioState["CLAIMED"] = "CLAIMED";
+    // Approvers have approved this scenario
+    ScenarioState["APPROVED"] = "APPROVED";
+    ScenarioState["REJECTED"] = "REJECTED";
+})(ScenarioState || (ScenarioState = {}));
+export var ScenarioClaimState;
+(function (ScenarioClaimState) {
+    ScenarioClaimState["Claimed"] = "CLAIMED";
+    ScenarioClaimState["Approved"] = "APPROVED";
+    ScenarioClaimState["Expired"] = "EXPIRED";
+    ScenarioClaimState["Rejected"] = "REJECTED";
+    ScenarioClaimState["Cancelled"] = "CANCELLED";
+    ScenarioClaimState["Reset"] = "RESET";
+})(ScenarioClaimState || (ScenarioClaimState = {}));
+export var ApproverClaimState;
+(function (ApproverClaimState) {
+    ApproverClaimState["Claimed"] = "CLAIMED";
+    ApproverClaimState["Approved"] = "APPROVED";
+    ApproverClaimState["Rejected"] = "REJECTED";
+})(ApproverClaimState || (ApproverClaimState = {}));
+export class NewScenario {
+}
+export class NewScenarioClaimant {
+}
+export class NewScenarioApprovalGroup {
+}
+export class NewScenarioApprover {
+}
+export class NewScenarioReceiver {
+}
+export class UpdateScenario {
+}
+export class UpdatedScenarioClaimant {
+}
+export class UpdatedScenarioApprovalGroup {
+}
+export class UpdatedScenarioApprover {
+}
+export class UpdatedScenarioReceiver {
+}
+export class ScenarioSummary {
+}
+export class ScenarioClaim {
+}
+export class SharedScenarioSummary {
+}
+export class SharedScenario {
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scenario.types.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/scenario/scenario.types.ts"],"names":[],"mappings":"AAQA,WAAW;AACX,mDAAmD;AACnD,mDAAmD;AACnD,sHAAsH;AACtH,mHAAmH;AACnH,gEAAgE;AAChE,0EAA0E;AAE1E,MAAM,CAAN,IAAY,aAWX;AAXD,WAAY,aAAa;IACvB,iFAAiF;IACjF,yCAAyC;IACzC,sCAAqB,CAAA;IACrB,oEAAoE;IACpE,oCAAmB,CAAA;IACnB,kCAAkC;IAClC,oCAAmB,CAAA;IACnB,wCAAwC;IACxC,sCAAqB,CAAA;IACrB,sCAAqB,CAAA;AACvB,CAAC,EAXW,aAAa,KAAb,aAAa,QAWxB;AAED,MAAM,CAAN,IAAY,kBAOX;AAPD,WAAY,kBAAkB;IAC5B,yCAAmB,CAAA;IACnB,2CAAqB,CAAA;IACrB,yCAAmB,CAAA;IACnB,2CAAqB,CAAA;IACrB,6CAAuB,CAAA;IACvB,qCAAe,CAAA;AACjB,CAAC,EAPW,kBAAkB,KAAlB,kBAAkB,QAO7B;AAED,MAAM,CAAN,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,yCAAmB,CAAA;IACnB,2CAAqB,CAAA;IACrB,2CAAqB,CAAA;AACvB,CAAC,EAJW,kBAAkB,KAAlB,kBAAkB,QAI7B;AAED,MAAM,OAAO,WAAW;CAMvB;AAED,MAAM,OAAO,mBAAmB;CAI/B;AAED,MAAM,OAAO,wBAAwB;CAKpC;AAED,MAAM,OAAO,mBAAmB;CAI/B;AAED,MAAM,OAAO,mBAAmB;CAK/B;AAED,MAAM,OAAO,cAAc;CAY1B;AAED,MAAM,OAAO,uBAAuB;CAMnC;AAED,MAAM,OAAO,4BAA4B;CAOxC;AAED,MAAM,OAAO,uBAAuB;CAMnC;AAED,MAAM,OAAO,uBAAuB;CAOnC;AAED,MAAM,OAAO,eAAe;CAS3B;AAED,MAAM,OAAO,aAAa;CAOzB;AAED,MAAM,OAAO,qBAAqB;CAOjC;AAED,MAAM,OAAO,cAAc;CAiB1B","sourcesContent":["import { PreparedPermissions } from '../api/key-exchange.types';\r\nimport { Key } from '../cryptography/cryptography.types';\r\nimport { SecretShare } from '../cryptography/slip39.service';\r\nimport { TrustedParty } from '../trusted-parties/trusted-party.types';\r\nimport { ApprovalGroup } from './approvals/scenario-approval.types';\r\nimport { Claimant } from './claimants/scenario-claimant.types';\r\nimport { Receiver } from './receivers/scenario-receiver.types';\r\n\r\n// Glossary\r\n// - Subject: the user that the scenario applies to\r\n// - Approver: the user that can approve a scenario\r\n// - Approver sub-assembly: a group of approvers that must reach quorum for the sub-assembly to be considered approved\r\n// - Approver assembly: a group of sub-assemblies that must reach quorum for the assembly to be considered approved\r\n// - Receiver: a user that will receive the released information\r\n// - Claimant: a user that can start the process of release of information\r\n\r\nexport enum ScenarioState {\r\n  // Can not be claimed when DISABLED. Scenarios can be created in this state, then\r\n  // set to ENABLED once setup is complete.\r\n  DISABLED = 'DISABLED',\r\n  // Can be claimed when ENABLED. It sits in this state until claimed.\r\n  ENABLED = 'ENABLED',\r\n  // Claimant has initiated a claim.\r\n  CLAIMED = 'CLAIMED',\r\n  // Approvers have approved this scenario\r\n  APPROVED = 'APPROVED',\r\n  REJECTED = 'REJECTED',\r\n}\r\n\r\nexport enum ScenarioClaimState {\r\n  Claimed = 'CLAIMED',\r\n  Approved = 'APPROVED',\r\n  Expired = 'EXPIRED',\r\n  Rejected = 'REJECTED',\r\n  Cancelled = 'CANCELLED',\r\n  Reset = 'RESET',\r\n}\r\n\r\nexport enum ApproverClaimState {\r\n  Claimed = 'CLAIMED',\r\n  Approved = 'APPROVED',\r\n  Rejected = 'REJECTED',\r\n}\r\n\r\nexport class NewScenario {\r\n  name: string;\r\n  event: string;\r\n  claimants: NewScenarioClaimant[];\r\n  approvalGroups: NewScenarioApprovalGroup[];\r\n  receivers: NewScenarioReceiver[];\r\n}\r\n\r\nexport class NewScenarioClaimant {\r\n  trustedPartyId: string;\r\n  trustedPartySharedKeyId: string;\r\n  message?: string;\r\n}\r\n\r\nexport class NewScenarioApprovalGroup {\r\n  name: string;\r\n  quorum: number;\r\n  singleReject: boolean;\r\n  approvers: NewScenarioApprover[];\r\n}\r\n\r\nexport class NewScenarioApprover {\r\n  trustedPartyId: string;\r\n  trustedPartySharedKeyId: string;\r\n  message?: string;\r\n}\r\n\r\nexport class NewScenarioReceiver {\r\n  trustedPartyId: string;\r\n  trustedPartySharedKeyId: string;\r\n  permissions: PreparedPermissions;\r\n  message?: string;\r\n}\r\n\r\nexport class UpdateScenario {\r\n  scenarioId: string;\r\n  keyId: string;\r\n  assemblyKeyId: string;\r\n  name: string;\r\n  event: string;\r\n  claimants: UpdatedScenarioClaimant[];\r\n  deletedClaimantIds: string[];\r\n  approvalGroups: UpdatedScenarioApprovalGroup[];\r\n  deletedGroupIds: string[];\r\n  receivers: UpdatedScenarioReceiver[];\r\n  deletedReceiverIds: string[];\r\n}\r\n\r\nexport class UpdatedScenarioClaimant {\r\n  claimantId?: string;\r\n  keyId?: string;\r\n  trustedPartyId: string;\r\n  trustedPartySharedKeyId: string;\r\n  message?: string;\r\n}\r\n\r\nexport class UpdatedScenarioApprovalGroup {\r\n  subAssemblyId?: string;\r\n  name: string;\r\n  quorum: number;\r\n  singleReject: boolean;\r\n  approvers: UpdatedScenarioApprover[];\r\n  deletedApproverIds: string[];\r\n}\r\n\r\nexport class UpdatedScenarioApprover {\r\n  approverId?: string;\r\n  keyId?: string;\r\n  trustedPartyId: string;\r\n  trustedPartySharedKeyId: string;\r\n  message?: string;\r\n}\r\n\r\nexport class UpdatedScenarioReceiver {\r\n  receiverId?: string;\r\n  keyId?: string;\r\n  trustedPartyId: string;\r\n  trustedPartySharedKeyId: string;\r\n  permissions: PreparedPermissions;\r\n  message?: string;\r\n}\r\n\r\nexport class ScenarioSummary {\r\n  id: string;\r\n  status: ScenarioState;\r\n  name: string;\r\n  event: string;\r\n  claimId?: string;\r\n  claimStatus?: ScenarioClaimState;\r\n  createdOn: string | Date;\r\n  lastModified: string | Date;\r\n}\r\n\r\nexport class ScenarioClaim {\r\n  id: string;\r\n  state: ScenarioClaimState;\r\n  triggeredBy: TrustedParty;\r\n  triggeredOn: string;\r\n  lastModified: string;\r\n  scenario: ScenarioSummary;\r\n}\r\n\r\nexport class SharedScenarioSummary {\r\n  id: string;\r\n  status: ScenarioState;\r\n  event: string;\r\n\r\n  trustedParty: TrustedParty;\r\n  claimStatus?: ScenarioClaimState;\r\n}\r\n\r\nexport class SharedScenario {\r\n  id: string;\r\n  status: ScenarioState;\r\n  event: string;\r\n\r\n  trustedParty: TrustedParty;\r\n  isClaimant: boolean;\r\n  claimantMessage?: string;\r\n  isApprover: boolean;\r\n  approverMessages?: string[];\r\n  isReceiver: boolean;\r\n  receiverMessage?: string;\r\n  receiverKeyId?: string;\r\n  receiverPbkId?: string;\r\n  receiverDirectories?: { id: string; wrappedItemKey: string }[];\r\n\r\n  claim?: SharedScenarioClaim;\r\n}\r\n\r\nexport interface SharedScenarioClaim {\r\n  id: string;\r\n  isClaimant: boolean;\r\n  status: ScenarioClaimState;\r\n  asApprovers?: SharedScenarioClaimApprover[];\r\n  asReceiver?: {\r\n    received: boolean;\r\n    ciphers: string[];\r\n  };\r\n}\r\n\r\nexport interface SharedScenarioClaimApprover {\r\n  approverId: string;\r\n  approverKey: string;\r\n  status: ApproverClaimState;\r\n  receivers: {\r\n    id: string;\r\n    pbkId: string;\r\n  }[];\r\n}\r\n\r\nexport interface Scenario {\r\n  id: string;\r\n  keyId: string;\r\n  assemblyKeyId: string;\r\n  assemblyQuorum: number;\r\n  status: ScenarioState;\r\n  name: string;\r\n  event: string;\r\n  claimants: Claimant[];\r\n  approverGroups: ApprovalGroup[];\r\n  receivers: Receiver[];\r\n  claim: {\r\n    id: string;\r\n    status: ScenarioClaimState;\r\n    claimant: Claimant;\r\n  };\r\n}\r\n\r\nexport interface CreateScenarioInput {\r\n  plainSubjectCipherData: object;\r\n}\r\n\r\nexport interface UpdateScenarioInput {\r\n  scenarioId: string;\r\n  keyId: string;\r\n  plainSubjectCipherData: object;\r\n}\r\n\r\nexport interface PartialAssemblyKey {\r\n  slip39: {\r\n    share: SecretShare;\r\n    // Mainly for debugging.\r\n    subAssembly: {\r\n      quorum: number;\r\n      size: number;\r\n    };\r\n  };\r\n  assemblyKeyParams: object;\r\n}\r\n\r\nexport interface SharedClaimReceiver {\r\n  id: string;\r\n  pbk: Key;\r\n}\r\n\r\nexport interface SharedClaimApprover {\r\n  receivers: {\r\n    id: string;\r\n    pbk: Key;\r\n  }[];\r\n}\r\n\r\nexport interface SharedClaimApproval {\r\n  receiverPbkCipher: string;\r\n  plainReceiverPbkCipher: {\r\n    partialAssemblyKey: PartialAssemblyKey;\r\n  };\r\n}\r\n\r\nexport interface SharedClaimReceiver {\r\n  received: boolean;\r\n  approvals: SharedClaimApproval[];\r\n}\r\n"]}

package/esm2015/lib/search/search.gql.js

@@ -0,0 +1,62 @@
+import gql from 'graphql-tag';
+import { KeyGraphFragment } from '../_common/queries.gql';
+const MAX_CATEGORY_DEPTH = 4;
+const DEFAULT_CATEGORY_DEPTH = 4;
+export const SearchRecordContentsQuery = gql `
+  query GetRecordContents(
+    $id: LrRelayIdInput!
+    $depth: Int
+    $first: Int
+    $after: String
+    $recordContentFilter: LrJSONFilter!
+  ) {
+    category: directory(id: $id) {
+      descendantDirectories(depth: $depth) {
+        recordContents: files(
+          first: $first
+          after: $after
+          plainMeta: $recordContentFilter
+          orderBy: "-created"
+        ) {
+          edges {
+            node {
+              currentVersion {
+                state {
+                  keyId
+                  plainMeta
+                  cipherMeta
+                  contentResource
+                }
+              }
+              nParentDirectoryLinks(n: 1) {
+                list {
+                  parentDirectory {
+                    id
+                    keyId
+                    created
+                    modified
+                    archived
+                    plainMeta
+                    cipherMeta
+                    nParentDirectoryLinks(n: 3) {
+                      list {
+                        parentDirectory {
+                          id
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    keyGraph {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/search/search.service.js

@@ -0,0 +1,156 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { CategoryService } from '../category/category.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { RecordFieldType } from '../record-type/record-type.types';
+import { RecordContentFilter } from '../record/record.gql';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { SearchRecordContentsQuery } from './search.gql';
+import { SearchItemType } from './search.types';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/lr-apollo.service";
+import * as i2 from "../category/category.service";
+import * as i3 from "../cryptography/key-graph.service";
+function debugPopulateCategory(categoryService, recordService, keyFactory, categoryId, recordsPerCategory) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tasks = [];
+        const category = yield categoryService.getCategory(categoryId);
+        // Create records
+        for (let i = category.records.length; i < recordsPerCategory; ++i) {
+            const name = `${category.category.name}+${keyFactory.randomString(16)}`;
+            console.log('Creating record: ', name);
+            yield recordService.createRecord({
+                categoryIds: [category.category.id],
+                name,
+                recordType: {
+                    id: '1',
+                    version: 1,
+                    name: 'Vehicle Details',
+                },
+                fields: [
+                    {
+                        id: '1-vin',
+                        type: RecordFieldType.Text,
+                        label: 'VIN Number',
+                        value: '1234567890',
+                    },
+                    {
+                        id: '1-location',
+                        type: RecordFieldType.Text,
+                        label: 'Location',
+                        value: '10'.repeat(1000),
+                    },
+                ],
+            });
+        }
+        // Delete records
+        for (let i = category.records.length; i > recordsPerCategory; --i) {
+            const id = category.records[i - 1].id;
+            console.log('Deleting record: ', id);
+            yield recordService.deleteRecord(id);
+        }
+    });
+}
+export function debugPopulateRecords(categoryService, recordService, keyFactory, recordsPerCategory) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pillars = yield categoryService.getCategories();
+        // For each category, added records
+        for (const pillar of pillars) {
+            const category = yield categoryService.getCategory(pillar.id);
+            for (const subCategory of category.subCategories) {
+                if (subCategory.allowRecords) {
+                    yield debugPopulateCategory(categoryService, recordService, keyFactory, subCategory.id, recordsPerCategory);
+                }
+            }
+        }
+    });
+}
+let SearchService = class SearchService {
+    constructor(ngZone, lrApollo, categoryService, keyGraph) {
+        this.ngZone = ngZone;
+        this.lrApollo = lrApollo;
+        this.categoryService = categoryService;
+        this.keyGraph = keyGraph;
+        this.vaultItems = {};
+    }
+    mapRecordContent(recordContent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = recordContent.nParentDirectoryLinks.list[0].parentDirectory;
+            const state = recordContent.currentVersion.state;
+            const plainCipherMeta = state.cipherMeta &&
+                (yield this.keyGraph.decryptFromString(state.keyId, state.cipherMeta));
+            return {
+                type: SearchItemType.RECORD,
+                id: record.id,
+                created: new Date(record.created),
+                modified: new Date(record.modified),
+                archived: record.archived,
+                plainMeta: state.plainMeta &&
+                    JSON.parse(recordContent.currentVersion.state.plainMeta),
+                plainCipherMeta,
+                parentCategoryId: record.nParentDirectoryLinks.list[0].parentDirectory.id,
+            };
+        });
+    }
+    mapRecordContents(edges) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(edges.map((edge) => this.mapRecordContent(edge.node)));
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultVault = yield this.categoryService.getDefaultVault();
+            let start;
+            let end;
+            start = Date.now();
+            this.recordContentsResult = yield this.lrApollo.query({
+                query: SearchRecordContentsQuery,
+                variables: {
+                    id: defaultVault.id,
+                    depth: 5,
+                    first: null,
+                    after: null,
+                    recordContentFilter: RecordContentFilter,
+                },
+            });
+            end = Date.now();
+            console.log('Search API time (s): ', (end - start) / 1000);
+            start = Date.now();
+            // try {
+            const items = yield this.mapRecordContents(this.recordContentsResult.category.descendantDirectories.recordContents
+                .edges);
+            for (const item of items) {
+                this.vaultItems[item.id] = item;
+            }
+            end = Date.now();
+            console.log('Search mapCategory time (s): ', (end - start) / 1000);
+        });
+    }
+    refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.load();
+            console.log(Object.values(this.vaultItems));
+            return this.vaultItems;
+        });
+    }
+};
+SearchService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SearchService_Factory() { return new SearchService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.LrApolloService), i0.ɵɵinject(i2.CategoryService), i0.ɵɵinject(i3.KeyGraphService)); }, token: SearchService, providedIn: "root" });
+SearchService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+SearchService.ctorParameters = () => [
+    { type: NgZone },
+    { type: LrApolloService },
+    { type: CategoryService },
+    { type: KeyGraphService }
+];
+SearchService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], SearchService);
+export { SearchService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/search/search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { LrApolloService } from '../api/lr-apollo.service';\r\nimport { CategoryService } from '../category/category.service';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { RecordFieldType } from '../record-type/record-type.types';\r\nimport { RecordContentFilter } from '../record/record.gql';\r\nimport { RecordService } from '../record/record.service';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\nimport { SearchRecordContentsQuery } from './search.gql';\r\nimport { SearchItem, SearchItemType } from './search.types';\r\n\r\nasync function debugPopulateCategory(\r\n  categoryService: CategoryService,\r\n  recordService: RecordService,\r\n  keyFactory: KeyFactoryService,\r\n  categoryId: string,\r\n  recordsPerCategory: number\r\n) {\r\n  const tasks = [];\r\n\r\n  const category = await categoryService.getCategory(categoryId);\r\n\r\n  // Create records\r\n  for (let i = category.records.length; i < recordsPerCategory; ++i) {\r\n    const name = `${category.category.name}+${keyFactory.randomString(16)}`;\r\n    console.log('Creating record: ', name);\r\n    await recordService.createRecord({\r\n      categoryIds: [category.category.id],\r\n      name,\r\n      recordType: {\r\n        id: '1',\r\n        version: 1,\r\n        name: 'Vehicle Details',\r\n      },\r\n      fields: [\r\n        {\r\n          id: '1-vin',\r\n          type: RecordFieldType.Text,\r\n          label: 'VIN Number',\r\n          value: '1234567890',\r\n        },\r\n        {\r\n          id: '1-location',\r\n          type: RecordFieldType.Text,\r\n          label: 'Location',\r\n          value: '10'.repeat(1000),\r\n        },\r\n      ],\r\n      // attachments\r\n    });\r\n  }\r\n\r\n  // Delete records\r\n  for (let i = category.records.length; i > recordsPerCategory; --i) {\r\n    const id = category.records[i - 1].id;\r\n    console.log('Deleting record: ', id);\r\n    await recordService.deleteRecord(id);\r\n  }\r\n}\r\n\r\nexport async function debugPopulateRecords(\r\n  categoryService: CategoryService,\r\n  recordService: RecordService,\r\n  keyFactory: KeyFactoryService,\r\n  recordsPerCategory: number\r\n) {\r\n  const pillars = await categoryService.getCategories();\r\n\r\n  // For each category, added records\r\n  for (const pillar of pillars) {\r\n    const category = await categoryService.getCategory(pillar.id);\r\n    for (const subCategory of category.subCategories) {\r\n      if (subCategory.allowRecords) {\r\n        await debugPopulateCategory(\r\n          categoryService,\r\n          recordService,\r\n          keyFactory,\r\n          subCategory.id,\r\n          recordsPerCategory\r\n        );\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 SearchService {\r\n  vaultItems: { [itemId: string]: SearchItem } = {};\r\n  recordContentsResult: any;\r\n\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private lrApollo: LrApolloService,\r\n    private categoryService: CategoryService,\r\n    private keyGraph: KeyGraphService\r\n  ) {}\r\n\r\n  private async mapRecordContent(recordContent: any): Promise<SearchItem> {\r\n    const record = recordContent.nParentDirectoryLinks.list[0].parentDirectory;\r\n    const state = recordContent.currentVersion.state;\r\n\r\n    const plainCipherMeta =\r\n      state.cipherMeta &&\r\n      (await this.keyGraph.decryptFromString<any>(\r\n        state.keyId,\r\n        state.cipherMeta\r\n      ));\r\n\r\n    return {\r\n      type: SearchItemType.RECORD,\r\n      id: record.id,\r\n      created: new Date(record.created),\r\n      modified: new Date(record.modified),\r\n      archived: record.archived,\r\n      plainMeta:\r\n        state.plainMeta &&\r\n        JSON.parse(recordContent.currentVersion.state.plainMeta),\r\n      plainCipherMeta,\r\n      parentCategoryId: record.nParentDirectoryLinks.list[0].parentDirectory.id,\r\n    };\r\n  }\r\n\r\n  private async mapRecordContents(edges: any[]): Promise<SearchItem[]> {\r\n    return Promise.all(edges.map((edge) => this.mapRecordContent(edge.node)));\r\n  }\r\n\r\n  private async load() {\r\n    const defaultVault = await this.categoryService.getDefaultVault();\r\n    let start;\r\n    let end;\r\n\r\n    start = Date.now();\r\n\r\n    this.recordContentsResult = await this.lrApollo.query<any>({\r\n      query: SearchRecordContentsQuery,\r\n      variables: {\r\n        id: defaultVault.id,\r\n        depth: 5,\r\n        first: null,\r\n        after: null,\r\n        recordContentFilter: RecordContentFilter,\r\n      },\r\n    });\r\n\r\n    end = Date.now();\r\n    console.log('Search API time (s): ', (end - start) / 1000);\r\n\r\n    start = Date.now();\r\n    // try {\r\n    const items = await this.mapRecordContents(\r\n      this.recordContentsResult.category.descendantDirectories.recordContents\r\n        .edges\r\n    );\r\n    for (const item of items) {\r\n      this.vaultItems[item.id] = item;\r\n    }\r\n\r\n    end = Date.now();\r\n    console.log('Search mapCategory time (s): ', (end - start) / 1000);\r\n  }\r\n\r\n  public async refresh() {\r\n    await this.load();\r\n\r\n    console.log(Object.values(this.vaultItems));\r\n    return this.vaultItems;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/search/search.types.js

@@ -0,0 +1,6 @@
+export var SearchItemType;
+(function (SearchItemType) {
+    SearchItemType["RECORD"] = "RECORD";
+    SearchItemType["CATEGORY"] = "CATEGORY";
+})(SearchItemType || (SearchItemType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IkM6L1Byb2plY3RzL3Rlc3QvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvc2VhcmNoL3NlYXJjaC50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQU4sSUFBWSxjQUdYO0FBSEQsV0FBWSxjQUFjO0lBQ3hCLG1DQUFpQixDQUFBO0lBQ2pCLHVDQUFxQixDQUFBO0FBQ3ZCLENBQUMsRUFIVyxjQUFjLEtBQWQsY0FBYyxRQUd6QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBGdXNlIGZyb20gJ2Z1c2UuanMnO1xyXG5cclxuZXhwb3J0IGVudW0gU2VhcmNoSXRlbVR5cGUge1xyXG4gIFJFQ09SRCA9ICdSRUNPUkQnLFxyXG4gIENBVEVHT1JZID0gJ0NBVEVHT1JZJyxcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBTZWFyY2hSZWNvcmRBdHRhY2htZW50IHtcclxuICBuYW1lOiBzdHJpbmc7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgU2VhcmNoSXRlbSB7XHJcbiAgaWQ6IHN0cmluZztcclxuICB0eXBlOiBTZWFyY2hJdGVtVHlwZTtcclxuICBjcmVhdGVkOiBEYXRlO1xyXG4gIG1vZGlmaWVkOiBEYXRlO1xyXG4gIGFyY2hpdmVkOiBib29sZWFuO1xyXG4gIHBsYWluTWV0YTogYW55O1xyXG4gIHBsYWluQ2lwaGVyTWV0YTogYW55O1xyXG4gIHBhcmVudENhdGVnb3J5SWQ/OiBzdHJpbmc7XHJcbiAgYXR0YWNobWVudHM/OiBTZWFyY2hSZWNvcmRBdHRhY2htZW50W107XHJcbn1cclxuXHJcbmV4cG9ydCB0eXBlIFNlYXJjaFJlc3VsdHMgPSBGdXNlLkZ1c2VSZXN1bHQ8U2VhcmNoSXRlbT5bXTtcclxuIl19

package/esm2015/lib/trusted-parties/tp-password-reset-request.service.js

@@ -0,0 +1,112 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { JWK } from 'node-jose';
+import { LrMergedMutation, LrMutation, LrService, } from '../api/lr-graphql';
+import { TpAssemblyState, TpClaimApproverState } from '../api/types';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { LrBadStateException } from '../_common/exceptions';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { ApproveTpPasswordResetRequestMutation, RejectTpPasswordResetRequestMutation, SharedTpPasswordResetQuery, SharedTpPasswordResetsQuery, } from './tp-password-reset.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/encryption.service";
+let TpPasswordResetRequestService = class TpPasswordResetRequestService extends LrService {
+    constructor(ngZone, injector, encryptionService) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.encryptionService = encryptionService;
+    }
+    getSharedResets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.query({
+                query: SharedTpPasswordResetsQuery,
+            })).sharedTpPasswordResets;
+        });
+    }
+    getSharedReset(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.query({
+                query: SharedTpPasswordResetQuery,
+                variables: {
+                    id,
+                },
+            })).sharedTpPasswordReset;
+        });
+    }
+    activeRequestOrRaise(sharedReset) {
+        const state = sharedReset.sharedRequest.claim.state;
+        if (state !== TpAssemblyState.CLAIMED) {
+            throw new LrBadStateException(`Claim is already in ${state} state.`);
+        }
+    }
+    rejectRequest(sharedResetId) {
+        return this.mutate(this.rejectRequestMutation(sharedResetId));
+    }
+    rejectRequestMutation(sharedResetId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sharedReset = yield this.getSharedReset(sharedResetId);
+            this.activeRequestOrRaise(sharedReset);
+            return LrMergedMutation.create(sharedReset.sharedRequest.claim.asClaimApprovers.edges
+                .filter((edge) => edge.node.state === TpClaimApproverState.CLAIMED)
+                .map((edge) => new LrMutation({
+                mutation: RejectTpPasswordResetRequestMutation,
+                variables: { input: { claimApproverId: edge.node.id } },
+            })));
+        });
+    }
+    // ?? TODO The return from this should not be any.
+    approveRequest(sharedResetId, pbkFingerPrint) {
+        return this.mutate(this.approveRequestMutation(sharedResetId, pbkFingerPrint));
+    }
+    approveRequestMutation(sharedResetId, pbkFingerPrint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sharedReset = yield this.getSharedReset(sharedResetId);
+            this.activeRequestOrRaise(sharedReset);
+            const pbk = yield JWK.asKey(JSON.parse(sharedReset.sharedRequest.pxk.pbk));
+            console.log(pbk.toJSON());
+            // TODO <AZ> Verify pbk against pbkFingerPrint
+            const claimApprovers = sharedReset.sharedRequest.claim.asClaimApprovers.edges.filter((edge) => edge.node.state === TpClaimApproverState.CLAIMED);
+            // A single approver may belong to multiple sub-assemblies. We approve them all here in a single
+            // transaction.
+            return LrMergedMutation.create(yield Promise.all(claimApprovers.map((approverEdge) => __awaiter(this, void 0, void 0, function* () {
+                const ca = approverEdge.node;
+                const input = {
+                    claimApproverId: ca.id,
+                    receiverApprovals: yield Promise.all(ca.receiverApprovals.edges.map((receiverEdge) => __awaiter(this, void 0, void 0, function* () {
+                        const ra = receiverEdge.node;
+                        return {
+                            receiverApprovalId: ra.id,
+                            receiverCipher: '',
+                            receiverCipherPartialAssemblyKey: yield this.encryptionService.encryptToString(pbk, ca.sharedCipherPartialAssemblyKeyClearJson),
+                        };
+                    }))),
+                };
+                console.log(input);
+                return new LrMutation({
+                    mutation: ApproveTpPasswordResetRequestMutation,
+                    variables: {
+                        input,
+                    },
+                });
+            }))));
+        });
+    }
+};
+TpPasswordResetRequestService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TpPasswordResetRequestService_Factory() { return new TpPasswordResetRequestService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.EncryptionService)); }, token: TpPasswordResetRequestService, providedIn: "root" });
+TpPasswordResetRequestService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TpPasswordResetRequestService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: EncryptionService }
+];
+TpPasswordResetRequestService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], TpPasswordResetRequestService);
+export { TpPasswordResetRequestService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tp-password-reset-request.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/trusted-parties/tp-password-reset-request.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, NgZone } from '@angular/core';\r\nimport { JWK } from 'node-jose';\r\nimport {\r\n  LrGraphQLService,\r\n  LrMergedMutation,\r\n  LrMutation,\r\n  LrMutationBase,\r\n  LrService,\r\n} from '../api/lr-graphql';\r\nimport { TpAssemblyState, TpClaimApproverState } from '../api/types';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { LrBadStateException } from '../_common/exceptions';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\nimport {\r\n  ApproveTpPasswordResetRequestMutation,\r\n  RejectTpPasswordResetRequestMutation,\r\n  SharedTpPasswordResetQuery,\r\n  SharedTpPasswordResetsQuery,\r\n} from './tp-password-reset.gql';\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TpPasswordResetRequestService extends LrService {\r\n  constructor(\r\n    private ngZone: NgZone,\r\n    private injector: Injector,\r\n    private encryptionService: EncryptionService\r\n  ) {\r\n    super(injector);\r\n  }\r\n\r\n  async getSharedResets() {\r\n    return (\r\n      await this.query({\r\n        query: SharedTpPasswordResetsQuery,\r\n      })\r\n    ).sharedTpPasswordResets;\r\n  }\r\n\r\n  async getSharedReset(id) {\r\n    return (\r\n      await this.query({\r\n        query: SharedTpPasswordResetQuery,\r\n        variables: {\r\n          id,\r\n        },\r\n      })\r\n    ).sharedTpPasswordReset;\r\n  }\r\n\r\n  private activeRequestOrRaise(sharedReset): void {\r\n    const state = sharedReset.sharedRequest.claim.state;\r\n    if (state !== TpAssemblyState.CLAIMED) {\r\n      throw new LrBadStateException(`Claim is already in ${state} state.`);\r\n    }\r\n  }\r\n\r\n  rejectRequest(sharedResetId: string) {\r\n    return this.mutate(this.rejectRequestMutation(sharedResetId));\r\n  }\r\n\r\n  async rejectRequestMutation(sharedResetId: string) {\r\n    const sharedReset = await this.getSharedReset(sharedResetId);\r\n\r\n    this.activeRequestOrRaise(sharedReset);\r\n\r\n    return LrMergedMutation.create(\r\n      sharedReset.sharedRequest.claim.asClaimApprovers.edges\r\n        .filter((edge) => edge.node.state === TpClaimApproverState.CLAIMED)\r\n        .map(\r\n          (edge) =>\r\n            new LrMutation({\r\n              mutation: RejectTpPasswordResetRequestMutation,\r\n              variables: { input: { claimApproverId: edge.node.id } },\r\n            })\r\n        )\r\n    );\r\n  }\r\n\r\n  // ?? TODO The return from this should not be any.\r\n  approveRequest(sharedResetId: string, pbkFingerPrint?: string) {\r\n    return this.mutate(\r\n      this.approveRequestMutation(sharedResetId, pbkFingerPrint)\r\n    );\r\n  }\r\n\r\n  async approveRequestMutation(sharedResetId: string, pbkFingerPrint?: string) {\r\n    const sharedReset = await this.getSharedReset(sharedResetId);\r\n\r\n    this.activeRequestOrRaise(sharedReset);\r\n\r\n    const pbk = await JWK.asKey(JSON.parse(sharedReset.sharedRequest.pxk.pbk));\r\n    console.log(pbk.toJSON());\r\n\r\n    // TODO <AZ> Verify pbk against pbkFingerPrint\r\n\r\n    const claimApprovers = sharedReset.sharedRequest.claim.asClaimApprovers.edges.filter(\r\n      (edge) => edge.node.state === TpClaimApproverState.CLAIMED\r\n    );\r\n\r\n    // A single approver may belong to multiple sub-assemblies. We approve them all here in a single\r\n    // transaction.\r\n    return LrMergedMutation.create(\r\n      await Promise.all(\r\n        claimApprovers.map(async (approverEdge) => {\r\n          const ca = approverEdge.node;\r\n          const input = {\r\n            claimApproverId: ca.id,\r\n            receiverApprovals: await Promise.all(\r\n              ca.receiverApprovals.edges.map(async (receiverEdge) => {\r\n                const ra = receiverEdge.node;\r\n                return {\r\n                  receiverApprovalId: ra.id,\r\n                  receiverCipher: '',\r\n                  receiverCipherPartialAssemblyKey: await this.encryptionService.encryptToString(\r\n                    pbk,\r\n                    ca.sharedCipherPartialAssemblyKeyClearJson\r\n                  ),\r\n                };\r\n              })\r\n            ),\r\n          };\r\n\r\n          console.log(input);\r\n\r\n          return new LrMutation({\r\n            mutation: ApproveTpPasswordResetRequestMutation,\r\n            variables: {\r\n              input,\r\n            },\r\n          });\r\n        })\r\n      )\r\n    );\r\n  }\r\n}\r\n"]}