@lifeready/core 1.0.1 → 1.0.2

package/src/lib/trusted-parties/trusted-party2.service.ts

@@ -1,272 +0,0 @@
-import { Injectable, NgZone } from '@angular/core';
-import { min } from 'moment';
-import { JWK } from 'node-jose';
-import { Item2Service } from '../api/item2.service';
-import { LrGraphQLService, LrMutation } from '../api/lr-graphql';
-import { AccessRoleChoice, LrRelayIdInput } from '../api/types';
-import { Key } from '../cryptography/cryptography.types';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyFactoryService } from '../cryptography/key-factory.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { KeyService } from '../cryptography/key.service';
-import { LrBadStateException } from '../_common/exceptions';
-import { RunOutsideAngular } from '../_common/run-outside-angular';
-import {
-  CompleteTpMkReshareMutation,
-  DeleteTpMutation,
-  RequestTpMkReshareMutation,
-  RespondTpMkReshareMutation,
-  ShareDirectoryMutation,
-  ShareFileMutation,
-  TpCurrentUserSharedKeyQuery,
-  UnshareDirectoryMutation,
-  UnshareFileMutation,
-} from './trusted-party2.gql';
-
-// If xxxKeyId not given, then fetch them with API calls
-export interface ShareItemOptions {
-  itemId: LrRelayIdInput;
-  itemKeyId?: LrRelayIdInput;
-  tpId: LrRelayIdInput;
-  tpSharedKeyId?: LrRelayIdInput;
-  accessRole: AccessRoleChoice;
-}
-
-export interface UnshareItemOptions {
-  itemId: string;
-  tpId: string;
-}
-
-@RunOutsideAngular({
-  ngZoneName: 'ngZone',
-})
-@Injectable({
-  providedIn: 'root',
-})
-export class TrustedParty2Service {
-  constructor(
-    private ngZone: NgZone,
-    private keyGraph: KeyGraphService,
-    private lrGraphQL: LrGraphQLService,
-    private item2Service: Item2Service,
-    private keyService: KeyService,
-    private keyFactory: KeyFactoryService,
-    private encryptionService: EncryptionService
-  ) {}
-
-  // TODO: deprecate this
-  public deleteTp(tpId: LrRelayIdInput) {
-    return this.deleteTpMutation(tpId);
-  }
-
-  public deleteTpMutation(tpId: LrRelayIdInput) {
-    return new LrMutation({
-      mutation: DeleteTpMutation,
-      variables: {
-        input: {
-          id: tpId,
-        },
-      },
-    });
-  }
-
-  async getTpCurrentUserSharedKey(tpId: LrRelayIdInput) {
-    return (
-      await this.lrGraphQL.query({
-        query: TpCurrentUserSharedKeyQuery,
-        variables: {
-          id: tpId,
-        },
-      })
-    ).tp.currentUserSharedKey.userSharedKey;
-  }
-
-  async shareDirectory(options: ShareItemOptions) {
-    return this.shareItem({ ...options, isDirectory: true });
-  }
-
-  async shareFile(options: ShareItemOptions) {
-    return this.shareItem({ ...options, isDirectory: false });
-  }
-
-  private async shareItem({
-    itemId,
-    itemKeyId,
-    tpId,
-    tpSharedKeyId,
-    accessRole,
-    isDirectory,
-  }: ShareItemOptions & {
-    isDirectory: boolean;
-  }) {
-    const itemKey = await this.keyGraph.getKey(itemKeyId, () =>
-      isDirectory
-        ? this.item2Service.getDirectoryKeyId(itemId)
-        : this.item2Service.getFileKeyId(itemId)
-    );
-    const wrappingKey = await this.keyGraph.getKey(tpSharedKeyId, () =>
-      this.getTpCurrentUserSharedKey(tpId).then((res) => res.sharedKey.id)
-    );
-    const wrappedKey = await this.keyGraph.wrapKey(wrappingKey, itemKey.jwk);
-
-    return new LrMutation({
-      mutation: isDirectory ? ShareDirectoryMutation : ShareFileMutation,
-      variables: {
-        input: {
-          id: itemId,
-          tpId,
-          accessRole,
-          keyId: itemKey.id,
-          wrappingKeyId: wrappingKey.id,
-          wrappedKey,
-        },
-      },
-    });
-  }
-
-  async unshareDirectory(options: UnshareItemOptions) {
-    return this.unshareItem({ ...options, isDirectory: true });
-  }
-
-  async unshareFile(options: UnshareItemOptions) {
-    return this.unshareItem({ ...options, isDirectory: false });
-  }
-
-  private async unshareItem({
-    itemId,
-    tpId,
-    isDirectory,
-  }: UnshareItemOptions & { isDirectory: boolean }) {
-    return new LrMutation({
-      mutation: isDirectory ? UnshareDirectoryMutation : UnshareFileMutation,
-      variables: {
-        input: {
-          id: itemId,
-          tpId,
-        },
-      },
-    });
-  }
-
-  public async requestMkReshare(tpId: LrRelayIdInput) {
-    const userSharedKey = await this.getTpCurrentUserSharedKey(tpId);
-
-    if (userSharedKey.mkSharedKey) {
-      throw new LrBadStateException('TP already has mkSharedKey');
-    }
-
-    const masterKey = await this.keyService.getCurrentMasterKey();
-    const prk = await this.keyFactory.createPkcKey();
-    const mkWrappedMkPrk = await this.encryptionService.encryptToString(
-      masterKey.jwk,
-      prk.toJSON(true)
-    );
-
-    const sharedKey = await this.keyGraph.getKey(userSharedKey.sharedKey.id);
-    const mkReshareRequestCipher = await this.encryptionService.encryptToString(
-      sharedKey.jwk,
-      {
-        pbk: prk.toJSON(),
-      }
-    );
-
-    return await new LrMutation({
-      mutation: RequestTpMkReshareMutation,
-      variables: {
-        input: {
-          tpId,
-          masterKeyId: masterKey.id,
-          mkPbk: JSON.stringify(prk.toJSON()),
-          mkWrappedMkPrk,
-          sharedKeyId: sharedKey.id,
-          mkReshareRequestCipher,
-        },
-      },
-    });
-  }
-
-  public async respondMkReshare(tpId: LrRelayIdInput) {
-    const userSharedKey = await this.getTpCurrentUserSharedKey(tpId);
-
-    if (!userSharedKey.mkSharedKey) {
-      throw new LrBadStateException(
-        'No access to the mkSharedKey so cannot reshare it with TP'
-      );
-    }
-
-    const sharedKey = await this.keyGraph.getKey(userSharedKey.sharedKey.id);
-    const plainMkReshareRequestCipher = await this.encryptionService.decrypt(
-      sharedKey,
-      userSharedKey.mkReshareRequestCipher
-    );
-    const pbk = await JWK.asKey(plainMkReshareRequestCipher.pbk);
-    const mkSharedKey = await this.keyGraph.getKey(
-      userSharedKey.mkSharedKey.id
-    );
-
-    const plainMkReshareResponseCipher = {
-      mkSharedKey: {
-        id: mkSharedKey.id,
-        jwk: mkSharedKey.jwk.toJSON(true),
-      },
-    };
-
-    // Wrap with sharedKey then again with Pbk
-    const mkReshareResponseCipher = await this.encryptionService.encryptToString(
-      pbk,
-      await this.encryptionService.encryptToString(
-        sharedKey.jwk,
-        plainMkReshareResponseCipher
-      )
-    );
-
-    return new LrMutation({
-      mutation: RespondTpMkReshareMutation,
-      variables: {
-        input: {
-          tpId,
-          mkSharedKeyId: mkSharedKey.id,
-          mkReshareResponseCipher,
-        },
-      },
-    });
-  }
-
-  public async completeMkReshare(tpId: LrRelayIdInput) {
-    const userSharedKey = await this.getTpCurrentUserSharedKey(tpId);
-
-    const sharedKey = await this.keyGraph.getKey(userSharedKey.sharedKey.id);
-    const prk = await this.keyGraph.getKey(userSharedKey.mkPxk.id);
-    const plainMkReshareResponseCipher = await this.encryptionService.decrypt(
-      sharedKey,
-      await this.encryptionService.decrypt(
-        prk,
-        userSharedKey.mkReshareResponseCipher
-      )
-    );
-
-    // Double check it's a valid key.
-    const mkSharedKey: Key = {
-      id: plainMkReshareResponseCipher.mkSharedKey.id,
-      jwk: await JWK.asKey(plainMkReshareResponseCipher.mkSharedKey.jwk),
-    };
-
-    const masterKey = await this.keyService.getCurrentMasterKey();
-    const mkWrappedMkSharedKey = await this.encryptionService.encryptToString(
-      masterKey.jwk,
-      mkSharedKey.jwk.toJSON(true)
-    );
-
-    return new LrMutation({
-      mutation: CompleteTpMkReshareMutation,
-      variables: {
-        input: {
-          tpId,
-          masterKeyId: masterKey.id,
-          mkSharedKeyId: mkSharedKey.id,
-          mkWrappedMkSharedKey,
-        },
-      },
-    });
-  }
-}

package/src/lib/users/profile-details.service.spec.ts

@@ -1,45 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { SharedContactCardService } from '../api/shared-contact-card.service';
-import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
-import { TrustedPartyService } from '../trusted-parties/trusted-party.service';
-import { ProfileDetailsService } from './profile-details.service';
-import { ProfileService } from './profile.service';
-
-const profileService = jasmine.createSpyObj<ProfileService>('ProfileService', [
-  'getCurrentUser',
-]);
-const authService = jasmine.createSpyObj<LifeReadyAuthService>(
-  'LifeReadyAuthService',
-  ['getUser']
-);
-const trustedPartyService = jasmine.createSpyObj<TrustedPartyService>(
-  'TrustedPartyService',
-  ['getTrustedParties']
-);
-const sharedContactCardService = jasmine.createSpyObj<SharedContactCardService>(
-  'SharedContactCardService',
-  ['updateMySharedContactCard']
-);
-
-describe('ProfileDetailsService', () => {
-  let service: ProfileDetailsService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-        { provide: ProfileService, useValue: profileService },
-        { provide: LifeReadyAuthService, useValue: authService },
-        { provide: TrustedPartyService, useValue: trustedPartyService },
-        {
-          provide: SharedContactCardService,
-          useValue: sharedContactCardService,
-        },
-      ],
-    });
-    service = TestBed.inject(ProfileDetailsService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});

package/src/lib/users/profile-details.service.ts

@@ -1,278 +0,0 @@
-import { Injectable } from '@angular/core';
-import { SharedContactCardService } from '../api/shared-contact-card.service';
-import { CurrentUser } from '../auth/auth.types';
-import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
-import { TrustedPartyService } from '../trusted-parties/trusted-party.service';
-import { SharedTrustedPartyDetails } from '../trusted-parties/trusted-party.types';
-import { ProfileService } from './profile.service';
-import {
-  MainContactCardFields,
-  MainContactCardProperty,
-  TrustedPartyDetails,
-} from './profile.types';
-import _ from 'lodash';
-
-enum ContactFields {
-  Name = 'name',
-  Email = 'email',
-  Image = 'image',
-  Phone = 'phone',
-  Address = 'address',
-}
-
-const FieldNames = [
-  ContactFields.Name,
-  ContactFields.Email,
-  ContactFields.Image,
-  ContactFields.Phone,
-  ContactFields.Address,
-];
-
-class FieldChange {
-  field: string;
-  id: string;
-  label: string;
-  oldValue?: any;
-  newValue?: any;
-}
-
-@Injectable({
-  providedIn: 'root',
-})
-export class ProfileDetailsService {
-  constructor(
-    private sharedContactCardService: SharedContactCardService,
-    private trustedPartyService: TrustedPartyService,
-    private profileService: ProfileService,
-    private authService: LifeReadyAuthService
-  ) {}
-
-  public async updateDetails(
-    fields: MainContactCardFields
-  ): Promise<CurrentUser> {
-    const user = await this.authService.getUser();
-    await this.profileService.updateDetails(
-      user.contactCard.id,
-      user.contactCard.keyId,
-      fields
-    );
-    await this.synchronizeContactCards(fields, user.contactCard);
-    return await this.authService.getUser(true);
-  }
-
-  private async synchronizeContactCards(
-    newFields: MainContactCardFields,
-    oldFields: MainContactCardFields
-  ): Promise<void> {
-    if (!oldFields) return;
-
-    const changes = this.getChanges(newFields, oldFields);
-
-    if (changes.length === 0) return;
-
-    const trustedParties = await this.trustedPartyService.getTrustedParties();
-
-    if (trustedParties.length === 0) return;
-
-    for (const details of trustedParties.map((x) => x.mySharedDetails)) {
-      await this.synchronizeSharedContactCard(details, changes);
-    }
-  }
-
-  private getChanges(
-    newFields: MainContactCardFields,
-    oldFields: MainContactCardFields
-  ): FieldChange[] {
-    const changes: FieldChange[] = [];
-
-    for (const field of FieldNames) {
-      const oldField = oldFields[field];
-      if (oldField && oldField.values) {
-        for (const oldValue of oldField.values) {
-          const newValue = (newFields[field].values as any[]).find(
-            (x) => x.id === oldValue.id
-          );
-
-          if (!newValue) {
-            changes.push({
-              field,
-              id: oldValue.id,
-              label: oldValue.label,
-              oldValue: oldValue.value,
-            });
-          } else if (!_.isEqual(newValue.value, oldValue.value)) {
-            changes.push({
-              field,
-              id: oldValue.id,
-              label: oldValue.label,
-              oldValue: oldValue.value,
-              newValue: newValue.value,
-            });
-          }
-        }
-      }
-    }
-    return changes;
-  }
-
-  private async synchronizeSharedContactCard(
-    details: SharedTrustedPartyDetails,
-    changes: FieldChange[]
-  ): Promise<void> {
-    let hasChanged = false;
-    for (const change of changes) {
-      switch (change.field) {
-        case ContactFields.Phone:
-          {
-            const value =
-              details.phones &&
-              details.phones.find((x) => x.label === change.label);
-
-            if (value) {
-              hasChanged = true;
-              value.value = change.newValue;
-            }
-          }
-          break;
-        case ContactFields.Address:
-          {
-            const value =
-              details.addresses &&
-              details.addresses.find((x) => x.label === change.label);
-
-            if (value) {
-              hasChanged = true;
-              value.value = change.newValue;
-            }
-          }
-          break;
-        default: {
-          const value = details[change.field];
-
-          if (_.isEqual(value, change.oldValue)) {
-            hasChanged = true;
-            details[change.field] = change.newValue;
-          }
-        }
-      }
-    }
-    if (hasChanged) {
-      const { id, ownedKeyId, sharedKeyId, ...contactCard } = details;
-
-      await this.sharedContactCardService.updateMySharedContactCard(
-        id,
-        ownedKeyId,
-        sharedKeyId,
-        contactCard
-      );
-    }
-  }
-
-  public async updateTrustedPartyDetails(details: SharedTrustedPartyDetails) {
-    const { id, ownedKeyId, sharedKeyId, ...contactCard } = details;
-
-    await this.sharedContactCardService.updateMySharedContactCard(
-      id,
-      ownedKeyId,
-      sharedKeyId,
-      contactCard
-    );
-
-    await this.synchronizeSharedDetails(details);
-  }
-
-  public async synchronizeSharedDetails(details: TrustedPartyDetails) {
-    let { contactCard } = await this.authService.getUser();
-    let hasNewValues = false;
-    contactCard = { ...contactCard };
-
-    if (details.name) {
-      const property = this.checkField(details.name, contactCard.name);
-
-      if (property) {
-        contactCard.name = property;
-        hasNewValues = true;
-      }
-    }
-
-    if (details.email) {
-      const property = this.checkField(details.email, contactCard.email);
-
-      if (property) {
-        contactCard.email = property;
-        hasNewValues = true;
-      }
-    }
-
-    if (details.image) {
-      const property = this.checkField(details.image, contactCard.image);
-
-      if (property) {
-        contactCard.image = property;
-        hasNewValues = true;
-      }
-    }
-
-    if (details.phones && details.phones.length) {
-      for (const phone of details.phones) {
-        const property = this.checkField(
-          phone.value,
-          contactCard.phone,
-          phone.label
-        );
-
-        if (property) {
-          contactCard.phone = property;
-          hasNewValues = true;
-        }
-      }
-    }
-
-    if (details.addresses && details.addresses.length) {
-      for (const address of details.addresses) {
-        const property = this.checkField(
-          address.value,
-          contactCard.address,
-          address.label
-        );
-
-        if (property) {
-          contactCard.address = property;
-          hasNewValues = true;
-        }
-      }
-    }
-
-    if (hasNewValues) {
-      await this.profileService.updateDetails(
-        contactCard.id,
-        contactCard.keyId,
-        contactCard
-      );
-    }
-  }
-
-  private checkField<T>(
-    field: T,
-    property: MainContactCardProperty<T>,
-    label: string = null
-  ) {
-    property = property || { value: field, hasMultiple: false };
-    property.values = property.values || [];
-
-    if (
-      property.values.length === 0 ||
-      property.values.every((x) => !_.isEqual(field, x.value))
-    ) {
-      property.values.push({
-        id: `${label}-${new Date().getTime()}`,
-        label,
-        value: field,
-      });
-      property.hasMultiple = property.values.length > 1;
-      property.value = property.value || field;
-      return property;
-    }
-    return null;
-  }
-}

package/src/lib/users/profile.gql.ts

@@ -1,108 +0,0 @@
-import { HasEdges } from './../_common/types';
-import { HasKeyGraph, PassKey } from './../cryptography/cryptography.types';
-import { ApiCurrentUser, ApiContactCard } from './profile.types';
-import gql from 'graphql-tag';
-import { KeyGraphFragment } from '../_common/queries.gql';
-
-export interface CurrentUserQueryType extends HasKeyGraph {
-  currentUser: ApiCurrentUser;
-  contactCards: HasEdges<ApiContactCard>;
-  userPlans: any[];
-}
-
-export const CurrentUserQuery = gql`
-  query {
-    currentUser {
-      id
-      username
-      currentUserKey {
-        passKey {
-          id
-          passKeyParams
-          passIdpParams
-          wrappedPassIdpVerifierPrk
-          created
-        }
-        masterKey {
-          id
-        }
-        rootKey {
-          id
-        }
-        pxk {
-          id
-        }
-        sigPxk {
-          id
-        }
-      }
-      userDelete {
-        id
-        created
-        state
-      }
-      features {
-        myVault
-        tpVault
-        shareVault
-      }
-      sessionEncryptionKey
-    }
-    userPlans {
-      id
-      stripe {
-        subscriptionId
-      }
-      plan {
-        name
-        data
-        state
-      }
-      periodEnd
-    }
-    contactCards(orderBy: "created") {
-      edges {
-        node {
-          id
-          key {
-            id
-          }
-          cipherData
-          plainData
-        }
-      }
-    }
-    keyGraph {
-      ...KeyGraphFragment
-    }
-  }
-  ${KeyGraphFragment}
-`;
-
-export const CreateContactCardMutation = gql`
-  mutation CreateContactCardMutation($input: CreateContactCardInput!) {
-    createContactCard(input: $input) {
-      contactCard {
-        id
-        key {
-          id
-        }
-        cipherData
-      }
-    }
-  }
-`;
-
-export const UpdateContactCardMutation = gql`
-  mutation UpdateContactCardMutation($input: UpdateContactCardInput!) {
-    updateContactCard(input: $input) {
-      contactCard {
-        id
-        key {
-          id
-        }
-        cipherData
-      }
-    }
-  }
-`;