@lifeready/core 1.0.1 → 1.0.3

package/src/lib/api/item2.service.ts

@@ -1,481 +0,0 @@
-import { Injectable, Injector, NgZone } from '@angular/core';
-import { JWK } from 'node-jose';
-import { KeyFactoryService } from '../cryptography/key-factory.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { KeyMetaService } from '../cryptography/key-meta.service';
-import { KeyService } from '../cryptography/key.service';
-import { LrBadArgumentException } from '../_common/exceptions';
-import { RunOutsideAngular } from '../_common/run-outside-angular';
-import { FileService } from './file.service';
-import { LrGraphQLService, LrMutation, LrService } from './lr-graphql';
-import {
-  DirectoryKeyQuery,
-  CreateDirectoryMutation,
-  DeleteDirectoryMutation,
-  CreateFileMutation,
-  DeleteFileMutation,
-  FileKeyQuery,
-  FileStateKeyQuery,
-  UpdateFileMutation,
-  UpdateDirectoryMutation,
-  ArchiveDirectoryMutation,
-  UnarchiveDirectoryMutation,
-  ChangeDirectoryParentsMutation,
-  ChangeFileParentsMutation,
-} from './item2.gql';
-import { ID, LrRelayIdInput } from './types';
-
-export enum DirectoryLinkType {
-  HARD = 'HARD',
-}
-
-// Suffix "Options" are what's need by the KC client.
-export interface ParentDirectoryOptions {
-  directoryId: LrRelayIdInput;
-  // If wrapping key provided, then we can try fetching it from the
-  // key graph. If not found in key graph, then fetch the directory.
-  wrappingKeyId?: LrRelayIdInput;
-  // TODO: this can be other types, but server side implementation has not been
-  // thoroughly tested. So best not use anything else and just leave it out so
-  // server uses the default value of "HARD"
-  linkType?: DirectoryLinkType.HARD;
-}
-
-export interface ParentRootDirectoryInput {
-  wrappedKey: string;
-  wrappingKeyId: LrRelayIdInput;
-}
-
-// Suffix "Input" matched with the graphql types
-// TODO these should be change to be exactly the same on the server since all that differs
-// is the wrappedKey/wrappedFileKey name
-export interface ParentDirectoryInputBase {
-  directoryId: LrRelayIdInput;
-  wrappingKeyId: LrRelayIdInput;
-  linkType?: DirectoryLinkType.HARD;
-}
-
-export interface ParentDirectoryInput extends ParentDirectoryInputBase {
-  wrappedKey: string;
-}
-
-export interface FileParentDirectoryInput extends ParentDirectoryInputBase {
-  wrappedFileKey: string;
-}
-
-export interface DownloadFileContentOptions {
-  fileStateNodeId: LrRelayIdInput;
-  fileStateKeyId?: LrRelayIdInput;
-}
-
-export interface CommonDirectoryOptions {
-  plainMetaJson?: any;
-  cipherMetaClearJson?: any;
-}
-
-export interface CreateDirectoryOptions extends CommonDirectoryOptions {
-  asRootDirectory?: boolean;
-  parentDirectories?: ParentDirectoryOptions[];
-}
-
-export interface UpdateDirectoryOptions extends CommonDirectoryOptions {
-  directoryId: LrRelayIdInput;
-  directoryKeyId?: LrRelayIdInput;
-}
-
-export interface CommonFileOptions {
-  plainMetaJson?: any;
-  cipherMetaClearJson?: any;
-  file?: File;
-  // custom uploader
-  upload?: (cipherFileContent: string) => Promise<string>;
-}
-
-export interface CreateFileOptions extends CommonFileOptions {
-  parentDirectories: ParentDirectoryOptions[];
-}
-
-export interface UpdateFileOptions extends CommonFileOptions {
-  fileId: LrRelayIdInput;
-  fileKeyId?: LrRelayIdInput;
-}
-
-interface ChangeItemParentsOptions {
-  parentsToRemove: LrRelayIdInput[];
-  parentsToAdd: ParentDirectoryOptions[];
-}
-
-export interface ChangeDirectoryParentsOptions
-  extends ChangeItemParentsOptions {
-  directoryId: LrRelayIdInput;
-  directoryKeyId?: LrRelayIdInput;
-}
-
-export interface ChangeFileParentsOptions extends ChangeItemParentsOptions {
-  fileId: LrRelayIdInput;
-  fileKeyId?: LrRelayIdInput;
-}
-
-@RunOutsideAngular({
-  ngZoneName: 'ngZone',
-})
-@Injectable({
-  providedIn: 'root',
-})
-export class Item2Service extends LrService {
-  constructor(
-    private ngZone: NgZone,
-    private injector: Injector,
-    private fileService: FileService,
-    private keyService: KeyService,
-    private keyMeta: KeyMetaService,
-    private keyFactory: KeyFactoryService,
-    private keyGraph: KeyGraphService
-  ) {
-    super(injector);
-  }
-
-  public async downloadFileContent(
-    options: DownloadFileContentOptions
-  ): Promise<ArrayBuffer> {
-    const fileContent = await this.fileService.downloadEncryptedFile2(
-      options.fileStateNodeId
-    );
-
-    const fileStateKey = await this.keyGraph.getKey(
-      options.fileStateKeyId,
-      () => this.getFileStateKeyId(options.fileStateNodeId)
-    );
-
-    return this.keyGraph.decryptFromString(fileStateKey, fileContent, {
-      payloadType: 'ArrayBuffer',
-    });
-  }
-
-  public async createDirectory(options: CreateDirectoryOptions) {
-    const directoryKey = await this.keyFactory.createKey();
-    options.parentDirectories = options.parentDirectories || [];
-    if (!options.asRootDirectory && !options.parentDirectories?.length) {
-      throw new LrBadArgumentException(
-        'A new directory must be either a root directory or a sub-directory. So you must provide either parentDirectories and/or asRootDirectory parameter.'
-      );
-    }
-
-    const parentDirectories = await Promise.all(
-      options.parentDirectories?.map((t) =>
-        this.getParentDirectoryInput(t, directoryKey)
-      )
-    );
-
-    // TODO this is rather an unfortunate name, change it to asRootDirectory.
-    let parentRootDirectory: ParentRootDirectoryInput;
-    if (options.asRootDirectory) {
-      const rootKey = this.keyService.getCurrentRootKey();
-      parentRootDirectory = {
-        wrappingKeyId: rootKey.id,
-        wrappedKey: await this.keyGraph.wrapKey(rootKey, directoryKey),
-      };
-    }
-
-    const input = {
-      ...(await this.getInput(directoryKey, options)),
-      parentDirectories,
-      parentRootDirectory,
-    };
-
-    return new LrMutation({
-      mutation: CreateDirectoryMutation,
-      variables: {
-        input,
-      },
-    });
-  }
-
-  updateDirectoryExec(options: UpdateDirectoryOptions) {
-    return this.mutate(this.updateDirectoryMutation(options));
-  }
-
-  updateDirectory(options: UpdateDirectoryOptions) {
-    return this.updateDirectoryMutation(options);
-  }
-
-  async updateDirectoryMutation(options: UpdateDirectoryOptions) {
-    const directoryKey = await this.getDirectoryKey(
-      options.directoryId,
-      options.directoryKeyId
-    );
-
-    return new LrMutation({
-      mutation: UpdateDirectoryMutation,
-      variables: {
-        input: {
-          ...(await this.getInput(directoryKey.jwk, options)),
-          directoryId: options.directoryId,
-        },
-      },
-    });
-  }
-
-  public deleteDirectory(id: ID) {
-    return new LrMutation({
-      mutation: DeleteDirectoryMutation,
-      variables: {
-        input: {
-          directoryId: id,
-        },
-      },
-    });
-  }
-
-  async createFile(options: CreateFileOptions) {
-    const fileKey = await this.keyFactory.createKey();
-
-    const parentDirectories = await Promise.all(
-      options.parentDirectories.map(async (t) => {
-        const {
-          directoryId,
-          wrappingKeyId,
-          wrappedKey,
-        } = await this.getParentDirectoryInput(t, fileKey);
-        // remap from ParentDirectoryInput to FileParentDirectoryInput
-        // TODO the server should really just use wrappedKey instead of wrappedFileKey
-        return {
-          directoryId,
-          wrappingKeyId,
-          wrappedFileKey: wrappedKey,
-        } as FileParentDirectoryInput;
-      })
-    );
-
-    return new LrMutation({
-      mutation: CreateFileMutation,
-      variables: {
-        input: {
-          ...(await this.createFileState(fileKey, options)),
-          parentDirectories,
-        },
-      },
-    });
-  }
-
-  async updateFile(options: UpdateFileOptions) {
-    const fileKey = await this.getFileKey(options.fileId, options.fileKeyId);
-
-    return new LrMutation({
-      mutation: UpdateFileMutation,
-      variables: {
-        input: {
-          ...(await this.createFileState(fileKey.jwk, options)),
-          fileId: options.fileId,
-        },
-      },
-    });
-  }
-
-  public deleteFile(id: ID) {
-    return new LrMutation({
-      mutation: DeleteFileMutation,
-      variables: {
-        input: {
-          fileId: id,
-        },
-      },
-    });
-  }
-
-  private async getParentDirectoryInput(
-    options: ParentDirectoryOptions,
-    newKey: JWK.Key
-  ): Promise<ParentDirectoryInput> {
-    // If directory's key is not already in the key graph, then need to
-    // fetch the directory's key.
-    const wrappingKey = await this.getDirectoryKey(
-      options.directoryId,
-      options.wrappingKeyId
-    );
-
-    return {
-      directoryId: options.directoryId,
-      wrappingKeyId: wrappingKey.id,
-      wrappedKey: await this.keyGraph.wrapKey(wrappingKey, newKey),
-    };
-  }
-
-  // async getKey(keyId: LrRelayIdInput, getKeyIdCallback: () => Promise<ID>) {
-  //   if (!this.keyGraph.hasKey(keyId)) {
-  //     keyId = await getKeyIdCallback();
-  //   }
-
-  //   return this.keyGraph.getKey(keyId);
-  // }
-
-  async getFileStateKeyId(fileStateNodeId: LrRelayIdInput) {
-    return (
-      await this.query({
-        query: FileStateKeyQuery,
-        variables: {
-          id: fileStateNodeId,
-        },
-      })
-    ).fileState.keyId;
-  }
-
-  async getDirectoryKeyId(directoryId: LrRelayIdInput) {
-    return (
-      await this.query({
-        query: DirectoryKeyQuery,
-        variables: {
-          id: directoryId,
-        },
-      })
-    ).directory.keyId;
-  }
-
-  async getFileKeyId(fileId: LrRelayIdInput) {
-    return (
-      await this.query({
-        query: FileKeyQuery,
-        variables: {
-          id: fileId,
-        },
-      })
-    ).file.keyId;
-  }
-
-  async getDirectoryKey(
-    directoryId: LrRelayIdInput,
-    directoryKeyId?: LrRelayIdInput
-  ) {
-    return this.keyGraph.getKey(directoryKeyId, () =>
-      this.getDirectoryKeyId(directoryId)
-    );
-  }
-
-  async getFileKey(fileId: LrRelayIdInput, fileKeyId?: LrRelayIdInput) {
-    return this.keyGraph.getKey(fileKeyId, () => this.getFileKeyId(fileId));
-  }
-
-  private async getInput(
-    key: JWK.Key,
-    options: { plainMetaJson?: any; cipherMetaClearJson?: any }
-  ) {
-    const { plainMetaJson, cipherMetaClearJson } = options;
-
-    return {
-      plainMeta: plainMetaJson && JSON.stringify(plainMetaJson),
-      cipherMeta:
-        cipherMetaClearJson &&
-        (await this.keyGraph.encryptToString(key, cipherMetaClearJson)),
-    };
-  }
-
-  private async createFileState(
-    fileKey: JWK.Key,
-    options: CreateFileOptions | UpdateFileOptions
-  ) {
-    // Each version of the file is encrypted using a new key.
-    const fileStateKey = await this.keyFactory.createKey();
-
-    const fileContent =
-      options.file && (await this.fileService.loadFile(options.file));
-
-    let contentResource: string;
-    if (fileContent) {
-      const cipherFileContent = await this.keyGraph.encryptToString(
-        fileStateKey,
-        fileContent
-      );
-      if (options.upload) {
-        contentResource = await options.upload(cipherFileContent);
-      } else {
-        contentResource = await this.fileService.uploadEncryptedFile({
-          encryptedContent: cipherFileContent,
-        });
-      }
-      console.log('contentResource', contentResource);
-    }
-
-    return {
-      ...(await this.getInput(fileStateKey, options)),
-      wrappedStateKey: await this.keyGraph.wrapKey(fileKey, fileStateKey),
-      contentResource,
-    };
-  }
-
-  archiveDirectory(directoryId: string, recursive: boolean) {
-    return new LrMutation({
-      mutation: ArchiveDirectoryMutation,
-      variables: {
-        input: {
-          directoryId,
-          recursive,
-        },
-      },
-    });
-  }
-
-  unarchiveDirectory(directoryId: string, recursive: boolean) {
-    return new LrMutation({
-      mutation: UnarchiveDirectoryMutation,
-      variables: {
-        input: {
-          directoryId,
-          recursive,
-        },
-      },
-    });
-  }
-
-  protected async getChangeItemParentsInput(
-    options: ChangeItemParentsOptions,
-    itemKey: JWK.Key
-  ) {
-    const parentsToAdd = await Promise.all(
-      options.parentsToAdd.map((t) => this.getParentDirectoryInput(t, itemKey))
-    );
-
-    return {
-      directoriesToRemove: options.parentsToRemove,
-      directoriesToAdd: parentsToAdd,
-    };
-  }
-
-  changeDirectoryParents(options: ChangeDirectoryParentsOptions) {
-    return this.mutate(this.changeDirectoryParentsMutation(options));
-  }
-
-  async changeDirectoryParentsMutation(options: ChangeDirectoryParentsOptions) {
-    const directoryKey = await this.getDirectoryKey(
-      options.directoryId,
-      options.directoryKeyId
-    );
-
-    return new LrMutation({
-      mutation: ChangeDirectoryParentsMutation,
-      variables: {
-        input: {
-          ...(await this.getChangeItemParentsInput(options, directoryKey.jwk)),
-          directoryId: options.directoryId,
-        },
-      },
-    });
-  }
-
-  async changeFileParents(options: ChangeFileParentsOptions) {
-    return this.mutate(this.changeFileParentsMutation(options));
-  }
-
-  async changeFileParentsMutation(options: ChangeFileParentsOptions) {
-    const fileKey = await this.getFileKey(options.fileId, options.fileKeyId);
-
-    return new LrMutation({
-      mutation: ChangeFileParentsMutation,
-      variables: {
-        input: {
-          ...(await this.getChangeItemParentsInput(options, fileKey.jwk)),
-          fileId: options.fileId,
-        },
-      },
-    });
-  }
-}

package/src/lib/api/key-exchange.gql.ts

@@ -1,196 +0,0 @@
-import gql from 'graphql-tag';
-import { FetchKeyGraphField, KeyGraphFragment } from '../_common/queries.gql';
-
-export const KeyExchangeFields = `
-  id
-  token
-  state
-  mode
-  isInitiator
-  initiator {
-    id
-    username
-  }
-  responder {
-    id
-    username
-  }
-  created
-  modified
-  tokenExpiryTime
-  isExpired
-  initiatorRootKeyCipher
-  initiatorActionRequired
-  responderActionRequired
-  responderEmailAddress
-  otk {
-    state
-    otKeyParams
-    otKeyCipher
-    sharedKey {
-      id
-    }
-    mkSharedKey {
-      id
-    }
-    initiatorSigPxk {
-      id
-    }
-    responderSigPxk {
-      id
-    }
-    initiatorOneTimePbkCipher
-    responderPbkCipher
-}`;
-
-export const UserSharedKeyFields = `
-  userSigPrk {
-    id
-  }
-  otherSigPbk {
-    id
-  }
-  sharedKey {
-    id
-  }
-  mkSharedKey {
-    id
-  }
-  mkPxk {
-    id
-    pbk
-  }
-  mkReshareRequestCipher
-  mkReshareResponseCipher
-  mkReshareRequestSent
-  mkReshareResponseSent
-`;
-
-export const CurrentUserSharedKeyQuery = gql`
-query CurrentUserSharedKeyQuery(
-  $username: String
-  $userId: LrRelayIdInput
-  $cachedKeyIds: [LrRelayIdInput!]
-) {
-  currentUserSharedKey(
-    username: $username
-    userId: $userId
-  ) {
-    userSharedKey {
-      ${UserSharedKeyFields}
-    }
-  }
-  keyGraph(cachedKeyIds: $cachedKeyIds) {
-    ...KeyGraphFragment
-  }
-}
-${KeyGraphFragment}`;
-
-export const KeyExchangesQuery = gql`
-query KeyExchangeQuery(
-$orderBy: String
-$isExpired: Boolean
-$initiatorActionRequired: Boolean
-$responderActionRequired: Boolean
-$initiator: ID
-$responder: ID
-$state: String
-) {
-keyExchanges(
-  orderBy: $orderBy
-  isExpired: $isExpired
-  initiatorActionRequired: $initiatorActionRequired
-  responderActionRequired: $responderActionRequired
-  initiator: $initiator
-  responder: $responder
-  state: $state
-) {
-  edges {
-    node {
-      ${KeyExchangeFields}
-    }
-  }
-}
-keyGraph {
-  ...KeyGraphFragment
-}
-}
-${KeyGraphFragment}
-`;
-
-export const KeyExchangeQuery = gql`
-query KeyExchangeQuery(
-  $id: LrRelayIdInput!
-) {
-  keyExchange(
-    id: $id
-  ) {
-    ${KeyExchangeFields}
-  }
-  keyGraph {
-    ...KeyGraphFragment
-  }
-}
-${KeyGraphFragment}
-`;
-
-// Key graph is only available for authenticated users. This query
-// is for unauthenticated users.
-export const KeyExchangeTokenQuery = gql`
-query KeyExchangeQuery(
-  $id: LrRelayIdInput!
-  $token: String
-) {
-  keyExchange(
-    id: $id
-    token: $token
-  ) {
-    ${KeyExchangeFields}
-  }
-}`;
-
-export const InitiateOtkMutation = gql`
-mutation InitiateKeyExchangeOtk(
-$input: InitiateKeyExchangeOtkInput!
-) {
-initiateKeyExchangeOtk(input: $input) {
-  keyExchange {
-    ${KeyExchangeFields}
-  }
-}
-${FetchKeyGraphField}
-}`;
-
-export const RespondOtkMutation = gql`
-mutation RespondKeyExchangeOtk(
-  $input: RespondKeyExchangeOtkInput!
-) {
-  respondKeyExchangeOtk(input: $input) {
-    keyExchange {
-      ${KeyExchangeFields}
-    }
-    userSharedKey {
-      ${UserSharedKeyFields}
-    }
-    tp {
-      id
-    }
-  }
-}`;
-
-export const CompleteOtkMutation = gql`
-mutation CompleteKeyExchangeOtk(
-  $input: CompleteKeyExchangeOtkInput!
-) {
-  completeKeyExchangeOtk(input: $input) {
-    keyExchange {
-      ${KeyExchangeFields}
-    }
-    userSharedKey {
-      ${UserSharedKeyFields}
-    }
-    tp {
-      id
-    }
-  }
-}`;