@lifeready/core 1.0.1 → 1.0.2

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

@@ -1,394 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { Injectable } from '@angular/core';
-import { JWK } from 'node-jose';
-import { materialize } from 'rxjs/operators';
-import { KeyExchangeService } from '../api/key-exchange.service';
-import {
-  DecryptedKeyExchange,
-  RespondOtkInput,
-} from '../api/key-exchange.types';
-import { LrApolloService } from '../api/lr-apollo.service';
-import { SharedContactCardService } from '../api/shared-contact-card.service';
-import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
-import { AccessLevel } from '../category/category.types';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { KeyService } from '../cryptography/key.service';
-import { UserService } from '../users/user.service';
-import { ContactCardName } from '../users/profile.types';
-import {
-  CancelTrustedPartyInvitationMutation,
-  DeclineTrustedPartyInvitationMutation,
-  DeleteTrustedPartyMutation,
-  GetAllTrustedPartiesQuery,
-  GetTrustedPartiesQuery,
-  GetTrustedPartyQuery,
-  ShareCategoryMutation,
-  UnshareCategoryMutation,
-} from './trusted-party.gql';
-import {
-  AcceptTrustedPartyInvite,
-  ConfirmTrustedPartyInvite,
-  FoundTrustedParty,
-  InviteTrustedParty,
-  TrustedParties,
-  TrustedParty,
-  TrustedPartyInvite,
-  TrustedPartyInviteStatus,
-  TrustedPartyRole,
-  TrustedPartyType,
-  TrustedPartyRoleType,
-} from './trusted-party.types';
-import { KeyFactoryService } from '../cryptography/key-factory.service';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class TrustedPartyService {
-  private trustedPartyRoles: TrustedPartyRole[];
-
-  constructor(
-    private http: HttpClient,
-    private lrApollo: LrApolloService,
-    private sharedContactCardService: SharedContactCardService,
-    private userService: UserService,
-    private authService: LifeReadyAuthService,
-    private keyExchangeService: KeyExchangeService,
-    private keyGraphService: KeyGraphService,
-    private keyService: KeyService,
-    private keyFactory: KeyFactoryService,
-    private encryptionService: EncryptionService
-  ) {}
-
-  public async getTrustedParties(): Promise<TrustedParty[]> {
-    const { tps } = await this.lrApollo.query<any>({
-      query: GetTrustedPartiesQuery,
-    });
-    return await Promise.all(
-      tps.edges.map((x) => this.mapTrustedParty(x.node))
-    );
-  }
-
-  public async getAllTrustedParties(): Promise<TrustedParties> {
-    const user = await this.authService.getUser();
-    const { tps, invites, sentInvites } = await this.lrApollo.query<any>({
-      query: GetAllTrustedPartiesQuery,
-      variables: {
-        userId: user.id,
-        isExpired: false,
-      },
-    });
-
-    return {
-      parties: (
-        await Promise.all<TrustedParty>(
-          tps.edges.map((x) => this.mapTrustedParty(x.node))
-        )
-      ).filter((x) => x),
-      invites: (
-        await Promise.all<TrustedPartyInvite>(
-          invites.edges.map(async (x) =>
-            this.mapInvite(
-              await this.keyExchangeService.decryptKeyExchange(x.node)
-            )
-          )
-        )
-      )
-        .filter((x) => x.status !== TrustedPartyInviteStatus.Completed)
-        .filter(
-          (x) =>
-            x.status !== TrustedPartyInviteStatus.Invited || x.actionRequired
-        ),
-      sentInvites: (
-        await Promise.all<TrustedPartyInvite>(
-          sentInvites.edges.map(async (x) =>
-            this.mapInvite(
-              await this.keyExchangeService.decryptKeyExchange(x.node)
-            )
-          )
-        )
-      ).filter((x) => x.status !== TrustedPartyInviteStatus.Completed),
-    };
-  }
-
-  public async getTrustedParty(partyId: string): Promise<TrustedParty> {
-    const { tp } = await this.lrApollo.query<any>({
-      query: GetTrustedPartyQuery,
-      variables: { partyId },
-    });
-    return await this.mapTrustedParty(tp);
-  }
-
-  public async getTrustedPartyRoles(
-    roleType: TrustedPartyRoleType = TrustedPartyRoleType.General
-  ): Promise<TrustedPartyRole[]> {
-    if (!this.trustedPartyRoles) {
-      this.trustedPartyRoles = await this.http
-        .get<TrustedPartyRole[]>('/assets/meta/trusted-party-roles.json')
-        .toPromise();
-    }
-    return Promise.resolve(
-      this.trustedPartyRoles.filter((x) => x.roleType === roleType)
-    );
-  }
-
-  public async findByEmail(email: string): Promise<FoundTrustedParty> {
-    try {
-      const user = await this.userService.getUserByEmail(email);
-
-      return user
-        ? {
-            id: user.id,
-            email,
-            username: user.username,
-            isTrustedParty: user.haveTp,
-            isMe: user.isCurrentUser,
-          }
-        : null;
-    } catch (e) {
-      return null;
-    }
-  }
-
-  public async inviteTrustedParty(invite: InviteTrustedParty): Promise<void> {
-    const params = {
-      responderUsername: invite.party.username,
-      email: invite.party.email,
-      message: {
-        name: invite.party.name,
-        email: invite.party.email,
-        message: invite.party.message,
-        permissions: invite.permissions,
-      },
-      contactCard: {
-        plainOwnerCipherDataJson: null,
-        plainSharedCipherDataJson: invite.mySharedDetails,
-        ownerPlainData: {
-          name: new ContactCardName(invite.mySharedDetails.name),
-        },
-      },
-    };
-    await this.keyExchangeService.initiateOtk(params);
-  }
-
-  public async cancelInvitation(inviteId: string): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: CancelTrustedPartyInvitationMutation,
-      variables: {
-        input: {
-          id: inviteId,
-        },
-      },
-    });
-  }
-
-  public async getInvitation(
-    inviteId: string,
-    inviteToken: string,
-    key: string
-  ): Promise<TrustedPartyInvite> {
-    const exchange = await this.keyExchangeService.getKeyExchange(inviteId, {
-      token: inviteToken,
-      otKeyK: key,
-    });
-
-    return this.mapInvite(exchange);
-  }
-
-  public async acceptInvitation(
-    invite: AcceptTrustedPartyInvite
-  ): Promise<string> {
-    const params: RespondOtkInput = {
-      id: invite.inviteId,
-      token: invite.inviteToken,
-      decryptedOtk: invite.decryptedOtk,
-      initiatorContactCard: null,
-      responderContactCard: {
-        plainOwnerCipherDataJson: null,
-        plainSharedCipherDataJson: invite.mySharedDetails,
-        ownerPlainData: {
-          name: new ContactCardName(invite.mySharedDetails.name),
-        },
-      },
-    };
-
-    const { tp } = await this.keyExchangeService.respondOtk(params);
-
-    return tp.id;
-  }
-
-  public async declineInvitation(
-    inviteId: string,
-    inviteToken: string
-  ): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: DeclineTrustedPartyInvitationMutation,
-      variables: {
-        input: {
-          id: inviteId,
-          token: inviteToken,
-        },
-      },
-    });
-  }
-
-  public async confirmInvitation(
-    confirm: ConfirmTrustedPartyInvite
-  ): Promise<string> {
-    const { tp } = await this.keyExchangeService.completeOtk(
-      confirm.inviteId,
-      confirm.initiatorRootKeyCipher,
-      confirm.initiatorOneTimePbkCipher,
-      null
-    );
-    return tp.id;
-  }
-
-  public async removeTrustedParty(partyId: string): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: DeleteTrustedPartyMutation,
-      variables: {
-        input: {
-          id: partyId,
-        },
-      },
-    });
-  }
-
-  public setCategoryAccessLevel(
-    categoryId: string,
-    keyId: string,
-    trustedParty: TrustedParty,
-    accessLevel?: AccessLevel
-  ): Promise<void> {
-    return accessLevel
-      ? this.shareDirectory(categoryId, keyId, trustedParty, accessLevel)
-      : this.unshareDirectory(categoryId, trustedParty.id);
-  }
-
-  public setRecordAccessLevel(
-    recordId: string,
-    keyId: string,
-    trustedParty: TrustedParty,
-    accessLevel: AccessLevel
-  ): Promise<void> {
-    return accessLevel
-      ? this.shareDirectory(recordId, keyId, trustedParty, accessLevel)
-      : this.unshareDirectory(recordId, trustedParty.id);
-  }
-
-  private async shareDirectory(
-    directoryId: string,
-    keyId: string,
-    trustedParty: TrustedParty,
-    accessLevel: AccessLevel
-  ): Promise<void> {
-    const key = await this.keyGraphService.getKey(keyId);
-    const wrappingKey = await this.keyGraphService.getKey(
-      trustedParty.userSharedKey.sharedKey.id
-    );
-    const wrappedKey = await this.encryptionService.encrypt(
-      wrappingKey.jwk,
-      key.jwk.toJSON(true)
-    );
-
-    await this.lrApollo.mutate({
-      mutation: ShareCategoryMutation,
-      variables: {
-        input: {
-          id: directoryId,
-          tpId: trustedParty.id,
-          accessRole: accessLevel,
-          keyId: key.id,
-          wrappingKeyId: wrappingKey.id,
-          wrappedKey: JSON.stringify(wrappedKey),
-        },
-      },
-    });
-  }
-
-  private async unshareDirectory(
-    directoryId: string,
-    trustedPartyId: string
-  ): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: UnshareCategoryMutation,
-      variables: {
-        input: {
-          id: directoryId,
-          tpId: trustedPartyId,
-        },
-      },
-    });
-  }
-
-  public async mapTrustedParty(tp: any): Promise<TrustedParty> {
-    try {
-      const contactCard =
-        tp.sharedContactCard &&
-        (await this.sharedContactCardService.decryptTrustedPartyDetails(
-          tp.sharedContactCard
-        ));
-      const myContactCard =
-        tp.myContactCard &&
-        (await this.sharedContactCardService.decryptSharedTrustedPartyDetails(
-          tp.myContactCard
-        ));
-
-      return {
-        id: tp.id,
-        type: TrustedPartyType.User, // TODO: when partners
-        hasScenarios: !!tp.sharedScenarios.edges.length,
-        hasSharedVault: !!tp.sharedItems.directories.edges.length,
-        name: contactCard && contactCard.name && contactCard.name.name,
-        details: contactCard,
-        mySharedDetails: myContactCard,
-        userSharedKey: tp.currentUserSharedKey.userSharedKey,
-        username: tp.other.username,
-        features: {
-          sharedVault: {
-            hasAccess:
-              (tp.other.features?.shareVault || ['noaccess'])[0] === 'access',
-          },
-        },
-      };
-    } catch (e) {
-      console.error('Failed to decrypt Trusted Party.', e, tp);
-      return null;
-    }
-  }
-
-  private async mapInvite(
-    exchange: DecryptedKeyExchange
-  ): Promise<TrustedPartyInvite> {
-    const contactCard = exchange.contactCard;
-    const name = exchange.isInitiator
-      ? exchange.myMessage?.name
-      : contactCard && contactCard.name && contactCard.name.name;
-    const email = exchange.isInitiator
-      ? exchange.myMessage?.email
-      : (contactCard && contactCard.email) || exchange.responderEmailAddress;
-
-    return {
-      id: exchange.id,
-      type: TrustedPartyType.User, // todo when partners
-      status: (exchange.state as unknown) as TrustedPartyInviteStatus,
-      token: exchange.token,
-      tokenExpiry: exchange.tokenExpiryTime,
-      decryptedOtk: exchange.decryptedOtk,
-      name,
-      email,
-      isSender: exchange.isInitiator,
-      actionRequired: exchange.isInitiator
-        ? exchange.initiatorActionRequired
-        : exchange.responderActionRequired,
-      rootKeyCipher: exchange.initiatorRootKeyCipher,
-      pbkCipher: exchange.otk.initiatorOneTimePbkCipher,
-      isExpired: exchange.isExpired,
-      details: contactCard,
-      message: exchange.message,
-      mySharedDetails: exchange.myContactCard,
-      mySharedMessage: exchange.myMessage,
-    };
-  }
-}

package/src/lib/trusted-parties/trusted-party.types.ts

@@ -1,119 +0,0 @@
-import {
-  DecryptedOtk,
-  PreparedPermissions,
-  UserSharedKey,
-} from '../api/key-exchange.types';
-import { KeyExchangeMessage } from './../api/key-exchange.types';
-import { AccessLevel } from './../category/category.types';
-import { TrustedPartyDetails } from './../users/profile.types';
-import { FeatureAction } from '../auth/auth.types';
-
-export class TrustedPartyRole {
-  id: string;
-  name: string;
-  roleType: TrustedPartyRoleType;
-  categories: {
-    category: string[];
-    accessLevel: AccessLevel;
-  }[];
-}
-
-export enum TrustedPartyRoleType {
-  General = 'general',
-  Scenario = 'scenario',
-}
-
-export enum TrustedPartyType {
-  User = 'user',
-  Organisation = 'organisation',
-}
-
-export enum TrustedPartyInviteStatus {
-  Invited = 'IN_PROGRESS',
-  Cancelled = 'CANCELLED',
-  Declined = 'DECLINED',
-  Completed = 'COMPLETED',
-}
-
-export class TrustedParties {
-  parties: TrustedParty[];
-  invites: TrustedPartyInvite[];
-  sentInvites: TrustedPartyInvite[];
-}
-
-export class SharedTrustedPartyDetails extends TrustedPartyDetails {
-  id: string;
-  ownedKeyId: string;
-  sharedKeyId: string;
-}
-
-export class TrustedPartyInvite {
-  id: string;
-  type: TrustedPartyType;
-  status: TrustedPartyInviteStatus;
-  token: string;
-  tokenExpiry: string | Date;
-  isExpired: boolean;
-  isSender: boolean;
-  actionRequired: boolean;
-  name: string;
-  email: string;
-
-  details?: TrustedPartyDetails;
-  message?: KeyExchangeMessage;
-  mySharedDetails?: TrustedPartyDetails;
-  mySharedMessage?: KeyExchangeMessage;
-
-  rootKeyCipher: string;
-  pbkCipher: string;
-  decryptedOtk: DecryptedOtk;
-}
-
-export class TPFeatures {
-  sharedVault: SharedVaultFeature;
-}
-
-export class SharedVaultFeature {
-  hasAccess: boolean;
-}
-
-export class TrustedParty {
-  id: string;
-  type: TrustedPartyType;
-  name: string;
-
-  hasScenarios: boolean;
-  hasSharedVault: boolean;
-  details: TrustedPartyDetails;
-  mySharedDetails: SharedTrustedPartyDetails;
-  userSharedKey: UserSharedKey;
-  username: string;
-  features: TPFeatures;
-}
-
-export class FoundTrustedParty {
-  id: string;
-  email: string;
-  username: string;
-  isTrustedParty: boolean;
-  isMe: boolean;
-}
-
-export class InviteTrustedParty {
-  party: { username?: string; email?: string; name?: string; message?: string };
-  permissions?: PreparedPermissions;
-  mySharedDetails: TrustedPartyDetails;
-}
-
-export class AcceptTrustedPartyInvite {
-  inviteId: string;
-  inviteToken: string;
-  decryptedOtk: DecryptedOtk;
-  mySharedDetails: TrustedPartyDetails;
-}
-
-export class ConfirmTrustedPartyInvite {
-  inviteId: string;
-  initiatorRootKeyCipher: string;
-  initiatorOneTimePbkCipher: string;
-}

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

@@ -1,165 +0,0 @@
-import { gqlTyped } from '../_common/ast';
-import { ID } from '../api/types';
-
-export interface DeleteTpMutation {
-  deleteTp: {
-    id: ID;
-  };
-}
-export const DeleteTpMutation = gqlTyped<DeleteTpMutation>`
-mutation DeleteTpMutation($input: DeleteTpInput!) {
-  deleteTp(input: $input) {
-    id
-  }
-}
-`;
-
-export interface ShareDirectoryMutation {
-  shareDirectory: {
-    tpDirectory: {
-      id: ID;
-    };
-  };
-}
-export const ShareDirectoryMutation = gqlTyped<ShareDirectoryMutation>`
-  mutation ShareDirectoryMutation($input: ShareDirectoryInput!) {
-    shareDirectory(input: $input) {
-      tpDirectory {
-        id
-      }
-    }
-  }
-`;
-
-export interface UnshareDirectoryMutation {
-  unshareDirectory: {
-    tpDirectory: {
-      id: ID;
-    };
-  };
-}
-export const UnshareDirectoryMutation = gqlTyped<UnshareDirectoryMutation>`
-  mutation UnshareDirectoryMutation($input: UnshareDirectoryInput!) {
-    unshareDirectory(input: $input) {
-      tpDirectory {
-        id
-      }
-    }
-  }
-`;
-
-export interface ShareFileMutation {
-  shareFile: {
-    tpFile: {
-      id: ID;
-    };
-  };
-}
-export const ShareFileMutation = gqlTyped<ShareFileMutation>`
-  mutation ShareFileMutation($input: ShareFileInput!) {
-    shareFile(input: $input) {
-      tpFile {
-        id
-      }
-    }
-  }
-`;
-
-export interface UnshareFileMutation {
-  unshareFile: {
-    tpFile: {
-      id: ID;
-    };
-  };
-}
-export const UnshareFileMutation = gqlTyped<UnshareFileMutation>`
-  mutation UnshareFileMutation($input: UnshareFileInput!) {
-    unshareFile(input: $input) {
-      tpFile {
-        id
-      }
-    }
-  }
-`;
-
-export interface TpCurrentUserSharedKeyQuery {
-  tp: {
-    currentUserSharedKey: {
-      userSharedKey: {
-        sharedKey: {
-          id: ID;
-        };
-        mkSharedKey: {
-          id: ID;
-        };
-        mkPxk: {
-          id: ID;
-        };
-        mkReshareRequestCipher: string;
-        mkReshareRequestSent: boolean;
-        mkReshareResponseCipher: string;
-        mkReshareResponseSent: boolean;
-      };
-    };
-  };
-}
-export const TpCurrentUserSharedKeyQuery = gqlTyped<TpCurrentUserSharedKeyQuery>`
-query TpCurrentUserSharedKeyQuery($id: LrRelayIdInput!) {
-  tp(id: $id){
-    currentUserSharedKey {
-      userSharedKey {
-        sharedKey {
-          id
-        }
-        mkSharedKey {
-          id
-        }
-        mkPxk {
-          id
-        }
-        mkReshareRequestCipher
-        mkReshareRequestSent
-        mkReshareResponseCipher
-        mkReshareResponseSent
-      }
-    }
-  }
-}
-`;
-
-export interface RequestTpMkReshareMutation {
-  requestTpMkReshare: {
-    id: ID;
-  };
-}
-export const RequestTpMkReshareMutation = gqlTyped<RequestTpMkReshareMutation>`
-mutation RequestTpMkReshareMutation($input: RequestTpMkReshareInput!) {
-  requestTpMkReshare(input: $input) {
-    id
-  }
-}`;
-
-export interface RespondTpMkReshareMutation {
-  respondTpMkReshare: {
-    id: ID;
-  };
-}
-export const RespondTpMkReshareMutation = gqlTyped<RespondTpMkReshareMutation>`
-  mutation RespondTpMkReshareMutation($input: RespondTpMkReshareInput!) {
-    respondTpMkReshare(input: $input) {
-      id
-    }
-  }
-`;
-
-export interface CompleteTpMkReshareMutation {
-  completeTpMkReshare: {
-    id: ID;
-  };
-}
-export const CompleteTpMkReshareMutation = gqlTyped<CompleteTpMkReshareMutation>`
-mutation CompleteTpMkReshareMutation($input: CompleteTpMkReshareInput!) {
-  completeTpMkReshare(input: $input) {
-    id
-  }
-}`;