@lifeready/core 1.0.0 → 1.0.1

package/src/lib/scenario/receivers/scenario-receiver.gql.ts

@@ -0,0 +1,157 @@
+import gql from 'graphql-tag';
+import { KeyGraphField } from '../../_common/queries.gql';
+import { TrustedPartyProperties } from '../../trusted-parties/trusted-party.gql';
+import { CategoryFields, AccessFields } from '../../category/category.gql';
+
+export const ReceiverFields = `
+  id
+  tp {
+    ${TrustedPartyProperties}
+  }
+  pbk {
+    id
+  }
+  sharedKey {
+    id
+  }
+  sharedCipherData
+  categories: receiverDirectories(plainMeta: $categoryFilter, orderBy: "created") {
+    edges {
+      node {
+        id
+        sharedKey {
+          id
+        }
+        sharedCipherData
+        accessRole
+        wrappedItemKey
+        directory {
+          ${CategoryFields}
+        }
+      }
+    }
+  }
+  records: receiverDirectories(plainMeta: $recordFilter, orderBy: "created") {
+    edges {
+      node {
+        id
+        sharedKey {
+          id
+        }
+        sharedCipherData
+        accessRole
+        wrappedItemKey
+        directory {
+          id
+          keyId
+          archived
+          plainMeta
+          cipherMeta
+          created
+          modified
+          ${AccessFields}
+          content: childFileLinks(plainMeta: $contentFilter) {
+            edges {
+              node {
+                childFile {
+                  id
+                  archived
+                  currentVersion {
+                    state {
+                      keyId
+                      plainMeta
+                      cipherMeta
+                      created
+                      modified
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+export const GetScenarioReceiverQuery = gql`
+query GetScenarioReceiverQuery(
+  $id: LrRelayIdInput!,
+  $categoryFilter: LrJSONFilter!,
+  $recordFilter: LrJSONFilter!,
+  $contentFilter: LrJSONFilter
+) {
+  scenarioReceiver(id: $id) {
+    ${ReceiverFields}
+  }
+  ${KeyGraphField}
+} `;
+
+export const CreateScenarioReceiverMutation = gql`
+  mutation CreateScenarioReceiverMutation(
+    $input: CreateScenarioReceiverInput!
+  ) {
+    createScenarioReceiver(input: $input) {
+      receiver {
+        id
+      }
+    }
+  }
+`;
+
+export const UpdateScenarioReceiverMutation = gql`
+  mutation UpdateScenarioReceiverMutation(
+    $input: UpdateScenarioReceiverInput!
+  ) {
+    updateScenarioReceiver(input: $input) {
+      receiver {
+        id
+      }
+    }
+  }
+`;
+
+export const DeleteScenarioReceiverMutation = gql`
+  mutation DeleteScenarioReceiverMutation(
+    $input: DeleteScenarioReceiverInput!
+  ) {
+    deleteScenarioReceiver(input: $input) {
+      id
+    }
+  }
+`;
+
+export const AddScenarioReceiverDirectoryMutation = gql`
+  mutation AddScenarioReceiverDirectoryMutation(
+    $input: AddScenarioReceiverDirectoryInput!
+  ) {
+    addScenarioReceiverDirectory(input: $input) {
+      receiverDirectory {
+        id
+      }
+    }
+  }
+`;
+
+export const UpdateScenarioReceiverDirectoryMutation = gql`
+  mutation UpdateScenarioReceiverDirectoryMutation(
+    $input: UpdateScenarioReceiverDirectoryInput!
+  ) {
+    updateScenarioReceiverDirectory(input: $input) {
+      receiverDirectory {
+        id
+      }
+    }
+  }
+`;
+
+export const DeleteScenarioReceiverDirectoryMutation = gql`
+  mutation DeleteScenarioReceiverDirectoryMutation(
+    $input: DeleteScenarioReceiverDirectoryInput!
+  ) {
+    deleteScenarioReceiverDirectory(input: $input) {
+      id
+    }
+  }
+`;

package/src/lib/scenario/receivers/scenario-receiver.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+import { ScenarioReceiverService } from './scenario-receiver.service';
+import { lrConfigureTestingModule, lrit } from '../../_common/tests';
+
+describe('ScenarioReceiverService', () => {
+  let service: ScenarioReceiverService;
+
+  beforeEach(() => {
+    lrConfigureTestingModule();
+    service = TestBed.inject(ScenarioReceiverService);
+  });
+
+  lrit('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/scenario/receivers/scenario-receiver.service.ts

@@ -0,0 +1,278 @@
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../../api/lr-apollo.service';
+import { CategoryFilter, RecordFilter } from '../../category/category.gql';
+import { CategoryService } from '../../category/category.service';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { KeyMetaService } from '../../cryptography/key-meta.service';
+import { RecordContentFilter } from '../../record/record.gql';
+import { RecordService } from '../../record/record.service';
+import { TrustedPartyService } from '../../trusted-parties/trusted-party.service';
+import { HasEdges } from '../../_common/types';
+import {
+  AddScenarioReceiverDirectoryMutation,
+  CreateScenarioReceiverMutation,
+  DeleteScenarioReceiverDirectoryMutation,
+  DeleteScenarioReceiverMutation,
+  GetScenarioReceiverQuery,
+  UpdateScenarioReceiverDirectoryMutation,
+  UpdateScenarioReceiverMutation,
+} from './scenario-receiver.gql';
+import {
+  AddScenarioReceiverCategoryInput,
+  AddScenarioReceiverItemInput,
+  AddScenarioReceiverRecordInput,
+  AddScenarioReceiver,
+  Receiver,
+  ReceiverCategory,
+  ReceiverRecord,
+  UpdateScenarioReceiver,
+  UpdateScenarioReceiverItemInput,
+} from './scenario-receiver.types';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ScenarioReceiverService {
+  constructor(
+    private lrApollo: LrApolloService,
+    private keyGraph: KeyGraphService,
+    private keyMetaService: KeyMetaService,
+    private tpService: TrustedPartyService,
+    private categoryService: CategoryService,
+    private recordService: RecordService
+  ) {}
+
+  public async getReceiver(receiverId: string): Promise<Receiver> {
+    const { scenarioReceiver } = await this.lrApollo.query<any>({
+      query: GetScenarioReceiverQuery,
+      variables: {
+        id: receiverId,
+        categoryFilter: CategoryFilter,
+        recordFilter: RecordFilter,
+        contentFilter: RecordContentFilter,
+      },
+    });
+    return this.mapReceiver(scenarioReceiver);
+  }
+
+  public async mapReceiver(receiver: any): Promise<Receiver> {
+    const { message } = await this.keyGraph.decryptFromString<{
+      message: string;
+    }>(receiver.sharedKey.id, receiver.sharedCipherData);
+    return {
+      id: receiver.id,
+      keyId: receiver.sharedKey.id,
+      trustedParty: await this.tpService.mapTrustedParty(receiver.tp),
+      message,
+      categories: await this.mapCategories(receiver.categories),
+      records: await this.mapRecords(receiver.records),
+    };
+  }
+
+  private async mapCategories(list: HasEdges<any>) {
+    return (
+      await Promise.all<ReceiverCategory>(
+        list.edges
+          .map((x) => x.node)
+          .map((x) => x.childDirectory || x)
+          .map((node: any) => this.mapReceiverCategory(node))
+      )
+    )
+      .filter((x) => x)
+      .sort((x, y) =>
+        x.category.name === y.category.name
+          ? 0
+          : x.category.name > y.category.name
+          ? 1
+          : -1
+      );
+  }
+
+  private async mapRecords(list: HasEdges<any>) {
+    return (
+      await Promise.all<ReceiverRecord>(
+        list.edges
+          .map((x) => x.node)
+          .map((x) => x.childDirectory || x)
+          .map((node: any) => this.mapReceiverRecord(node))
+      )
+    )
+      .filter((x) => x)
+      .sort((x, y) =>
+        x.record.name === y.record.name
+          ? 0
+          : x.record.name > y.record.name
+          ? 1
+          : -1
+      );
+  }
+
+  private async mapReceiverCategory(
+    receiverDirectory: any
+  ): Promise<ReceiverCategory> {
+    return {
+      id: receiverDirectory.id,
+      keyId: receiverDirectory.sharedKey.id,
+      accessLevel: receiverDirectory.accessRole,
+      category: await this.categoryService.mapCategory(
+        receiverDirectory.directory
+      ),
+    };
+  }
+
+  private async mapReceiverRecord(
+    receiverDirectory: any
+  ): Promise<ReceiverRecord> {
+    return {
+      id: receiverDirectory.id,
+      keyId: receiverDirectory.sharedKey.id,
+      accessLevel: receiverDirectory.accessRole,
+      record: await this.categoryService.mapRecord(receiverDirectory.directory),
+    };
+  }
+
+  public async addReceiver(receiver: AddScenarioReceiver): Promise<string> {
+    const wrappedContent = await this.keyMetaService.wrapContentWithKey(
+      receiver.plainSharedCipherData,
+      receiver.trustedPartySharedKeyId
+    );
+
+    const { createScenarioReceiver } = await this.lrApollo.mutate<any>({
+      mutation: CreateScenarioReceiverMutation,
+      variables: {
+        input: {
+          scenarioId: receiver.scenarioId,
+          tpId: receiver.trustedPartyId,
+          tpSharedKeyId: receiver.trustedPartySharedKeyId,
+          tpSharedKeyWrappedSharedKey: wrappedContent.rootKey.wrappedKey,
+          sharedCipherData: wrappedContent.cipherMeta,
+        },
+      },
+    });
+    return createScenarioReceiver.receiver.id;
+  }
+
+  public async updateReceiver(receiver: UpdateScenarioReceiver): Promise<void> {
+    const sharedCipherData = await this.keyGraph.encryptToString(
+      receiver.keyId,
+      receiver.plainSharedCipherData
+    );
+
+    await this.lrApollo.mutate<any>({
+      mutation: UpdateScenarioReceiverMutation,
+      variables: {
+        input: {
+          receiverId: receiver.id,
+          sharedKeyId: receiver.keyId,
+          sharedCipherData,
+        },
+      },
+    });
+  }
+
+  public async deleteReceiver(receiverId: string): Promise<void> {
+    await this.lrApollo.mutate<any>({
+      mutation: DeleteScenarioReceiverMutation,
+      variables: { input: { receiverId } },
+    });
+  }
+
+  public async addReceiverCategory(
+    input: AddScenarioReceiverCategoryInput
+  ): Promise<string> {
+    const category = await this.categoryService.getCategory(input.categoryId);
+
+    const res = await this.lrApollo.mutate<any>({
+      mutation: AddScenarioReceiverDirectoryMutation,
+      variables: {
+        input: {
+          ...(await this.addReceiverItem(input, category.category.keyId)),
+          directoryId: category.category.id,
+        },
+      },
+    });
+
+    return res.addScenarioReceiverDirectory.receiverDirectory.id;
+  }
+
+  public async addReceiverRecord(
+    input: AddScenarioReceiverRecordInput
+  ): Promise<string> {
+    const record = await this.recordService.getRecord(input.recordId);
+
+    const { addScenarioReceiverDirectory } = await this.lrApollo.mutate<any>({
+      mutation: AddScenarioReceiverDirectoryMutation,
+      variables: {
+        input: {
+          ...(await this.addReceiverItem(input, record.keyId)),
+          directoryId: record.id,
+        },
+      },
+    });
+    return addScenarioReceiverDirectory.receiverDirectory.id;
+  }
+
+  private async addReceiverItem(
+    input: AddScenarioReceiverItemInput,
+    itemKeyId: string
+  ): Promise<any> {
+    const sharedCipherData = input.plainSharedCipherData
+      ? await this.keyGraph.encryptToString(
+          input.receiverKeyId,
+          input.plainSharedCipherData
+        )
+      : '';
+
+    const itemKey = await this.keyGraph.getKey(itemKeyId);
+    let wrappedItemKey = await this.keyGraph.encryptToString(
+      input.receiverKeyId,
+      itemKey.jwk.toJSON(true)
+    );
+
+    if (input.assemblyKeyId) {
+      wrappedItemKey = await this.keyGraph.encryptToString(
+        input.assemblyKeyId,
+        wrappedItemKey
+      );
+    }
+
+    return {
+      receiverId: input.receiverId,
+      sharedKeyId: input.receiverKeyId,
+      assemblyKeyId: input.assemblyKeyId,
+      wrappedItemKey,
+      accessRole: input.accessRole,
+      sharedCipherData,
+    };
+  }
+
+  public async updateReceiverItem(
+    input: UpdateScenarioReceiverItemInput
+  ): Promise<void> {
+    const sharedCipherData = input.plainSharedCipherData
+      ? await this.keyGraph.encryptToString(
+          input.keyId,
+          input.plainSharedCipherData
+        )
+      : '';
+
+    await this.lrApollo.mutate<any>({
+      mutation: UpdateScenarioReceiverDirectoryMutation,
+      variables: {
+        input: {
+          receiverDirectoryId: input.id,
+          sharedKeyId: input.keyId,
+          accessRole: input.accessRole,
+          sharedCipherData,
+        },
+      },
+    });
+  }
+
+  public async deleteReceiverItem(receiverCategoryId: string): Promise<void> {
+    await this.lrApollo.mutate<any>({
+      mutation: DeleteScenarioReceiverDirectoryMutation,
+      variables: { input: { receiverDirectoryId: receiverCategoryId } },
+    });
+  }
+}

package/src/lib/scenario/receivers/scenario-receiver.types.ts

@@ -0,0 +1,66 @@
+import { AccessLevel } from './../../category/category.types';
+import { TrustedParty } from '../../trusted-parties/trusted-party.types';
+import { Category, VaultRecord } from '../../category/category.types';
+
+export interface Receiver {
+  id: string;
+  keyId: string;
+  trustedParty: TrustedParty;
+  message?: string;
+
+  categories: ReceiverCategory[];
+  records?: ReceiverRecord[];
+}
+
+export interface ReceiverCategory {
+  id: string;
+  keyId: string;
+  accessLevel: AccessLevel;
+  category: Category;
+}
+
+export interface ReceiverRecord {
+  id: string;
+  keyId: string;
+  accessLevel: AccessLevel;
+  record: VaultRecord;
+}
+
+export interface AddScenarioReceiver {
+  scenarioId: string;
+  trustedPartyId: string;
+  trustedPartySharedKeyId: string;
+  plainSharedCipherData: object;
+}
+
+export interface UpdateScenarioReceiver {
+  id: string;
+  keyId: string;
+  plainSharedCipherData: object;
+}
+
+export interface AddScenarioReceiverItemInput {
+  scenarioId: string;
+  assemblyKeyId?: string;
+  receiverId: string;
+  receiverKeyId: string;
+  accessRole: AccessLevel;
+  plainSharedCipherData?: string;
+}
+
+export interface AddScenarioReceiverCategoryInput
+  extends AddScenarioReceiverItemInput {
+  categoryId: string;
+}
+
+export interface AddScenarioReceiverRecordInput
+  extends AddScenarioReceiverItemInput {
+  recordId: string;
+}
+
+export interface UpdateScenarioReceiverItemInput {
+  id: string;
+  keyId: string;
+  accessRole: AccessLevel;
+  plainSharedCipherData?: string;
+}

package/src/lib/scenario/scenario-setup.service.spec.ts

@@ -0,0 +1,22 @@
+import { TestBed } from '@angular/core/testing';
+import { ScenarioSetupService } from './scenario-setup.service';
+import { ScenarioService } from './scenario.service';
+import { lrConfigureTestingModule, lrit } from '../_common/tests';
+
+const scenarioService = jasmine.createSpyObj<ScenarioService>(
+  'ScenarioService',
+  ['getMyScenarios']
+);
+
+describe('ScenarioSetupService', () => {
+  let service: ScenarioSetupService;
+
+  beforeEach(() => {
+    lrConfigureTestingModule();
+    service = TestBed.inject(ScenarioSetupService);
+  });
+
+  lrit('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});