@lifeready/core 1.0.1 → 1.0.3

package/src/lib/category/category.service.ts

@@ -1,498 +0,0 @@
-import { Injectable } from '@angular/core';
-import { LrApolloService } from '../api/lr-apollo.service';
-import { KeyMetaService } from '../cryptography/key-meta.service';
-import { RecordContentFilter } from '../record/record.gql';
-import { HasEdges, HasKeyGraphEdges } from '../_common/types';
-import {
-  GetRootDirectoryIdsQuery,
-  DefaultVaultFilter,
-  CategoryFilter,
-  CreateVaultMutation,
-  CreateCategoryMutation,
-  DeleteCategoryMutation,
-  DirectoryType,
-  GetCategoriesQuery,
-  GetCategoryQuery,
-  GetMySharedCategoriesQuery,
-  GetMySharedCategoriesQueryType,
-  GetTrustedPartyCategoriesQuery,
-  GetTrustedPartyCategoriesQueryType,
-  RecordFilter,
-  UpdateCategoryMutation,
-  UnarchiveDirectoryMutation,
-  ArchiveDirectoryMutation,
-  GetVaultsQuery,
-} from './category.gql';
-import {
-  AccessLevel,
-  Category,
-  NewCategory,
-  UpdatedCategory,
-  VaultCategory,
-  VaultRecord,
-  Vault,
-} from './category.types';
-import { LrBadStateException } from '../_common/exceptions';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class CategoryService {
-  constructor(
-    private lrApollo: LrApolloService,
-    private keyMetaService: KeyMetaService,
-    private keyGraph: KeyGraphService
-  ) {}
-
-  public async getRootDirectoryIds(
-    input: { archived: boolean } = null
-  ): Promise<string[]> {
-    const { rootDirectories } = await this.lrApollo.query<any>({
-      query: GetRootDirectoryIdsQuery,
-      variables: {
-        archived: input && input.archived,
-      },
-    });
-    return rootDirectories.edges.map((edge) => edge.node.id);
-  }
-
-  public async getDefaultVault(): Promise<Vault> {
-    const { list } = await this.lrApollo.query<HasKeyGraphEdges<any>>({
-      query: GetVaultsQuery,
-      variables: {
-        plainMetaFilter: DefaultVaultFilter,
-      },
-    });
-
-    const defaultVaults = await this.mapVaults(list);
-    if (defaultVaults.length > 1) {
-      throw new LrBadStateException('There are more than one default vaults');
-    }
-
-    return defaultVaults[0] || null;
-  }
-
-  public async getCategories(
-    input: { archived: boolean } = null
-  ): Promise<Category[]> {
-    const res: any = await this.lrApollo.query<HasKeyGraphEdges<any>>({
-      query: GetCategoriesQuery,
-      variables: {
-        vaultFilter: DefaultVaultFilter,
-        categoryFilter: CategoryFilter,
-        recordFilter: RecordFilter,
-        archived: input && input.archived,
-      },
-    });
-
-    if (res.vaults.edges.length > 1) {
-      throw new LrBadStateException('There is more than one default vault');
-    } else if (res.vaults.edges.length < 1) {
-      console.error('There is no default vault.');
-      return [];
-    } else {
-      return await this.mapCategories(
-        res.vaults.edges[0].node.childDirectoryLinks
-      );
-    }
-  }
-
-  public async getTrustedPartyCategories(
-    trustedPartyId: string
-  ): Promise<{ categories: Category[]; records?: VaultRecord[] }> {
-    const {
-      tp,
-    } = await this.lrApollo.query<GetTrustedPartyCategoriesQueryType>({
-      query: GetTrustedPartyCategoriesQuery,
-      variables: {
-        trustedPartyId,
-        categoryFilter: CategoryFilter,
-        recordFilter: RecordFilter,
-        contentFilter: RecordContentFilter,
-      },
-    });
-    return {
-      categories: await this.mapCategories(tp.sharedItems.list),
-      records: await this.mapRecords(tp.sharedItems.records),
-    };
-  }
-
-  public async getMySharedCategories(
-    trustedPartyId: string
-  ): Promise<{ categories: Category[]; records?: VaultRecord[] }> {
-    const { tp } = await this.lrApollo.query<GetMySharedCategoriesQueryType>({
-      query: GetMySharedCategoriesQuery,
-      variables: {
-        trustedPartyId,
-        categoryFilter: CategoryFilter,
-        recordFilter: RecordFilter,
-        contentFilter: RecordContentFilter,
-      },
-    });
-    return {
-      categories: await this.mapCategories(tp.myItems.list),
-      records: await this.mapRecords(tp.myItems.records),
-    };
-  }
-
-  public async getCategory(categoryId: string): Promise<VaultCategory> {
-    const { category } = await this.lrApollo.query<any>({
-      query: GetCategoryQuery(),
-      variables: {
-        id: categoryId,
-        categoryFilter: CategoryFilter,
-        recordFilter: RecordFilter,
-        contentFilter: RecordContentFilter,
-      },
-    });
-
-    return {
-      category: {
-        ...(await this.mapCategory(category)),
-        parents: await this.mapParentCategories(category),
-      },
-      subCategories: await this.mapCategories(category.subCategories),
-      records: await this.mapRecords(category.records),
-    };
-  }
-
-  private async mapVaults(list: HasEdges<any>): Promise<Vault[]> {
-    return Promise.all<Vault>(
-      list.edges.map((edge) => this.mapVault(edge.node))
-    );
-  }
-
-  private async mapCategories(list: HasEdges<any>) {
-    return (
-      await Promise.all<Category>(
-        list.edges
-          .map((x) => x.node)
-          .map((x) => x.childDirectory || x)
-          .map(
-            (node: {
-              id;
-              keyId;
-              plainMeta;
-              cipherMeta;
-              descendantDirectories;
-              accessRoles;
-              archived;
-            }) => this.mapCategory(node)
-          )
-      )
-    )
-      .filter((x) => x)
-      .sort((x, y) => (x.name === y.name ? 0 : x.name > y.name ? 1 : -1));
-  }
-
-  private async mapRecords(list: HasEdges<any>) {
-    return (
-      await Promise.all<VaultRecord>(
-        list.edges
-          .map((x) => x.node)
-          .map((x) => x.childDirectory || x)
-          .map(
-            (node: {
-              id;
-              keyId;
-              plainMeta;
-              cipherMeta;
-              created;
-              modified;
-              content;
-              accessRoles;
-              archived;
-            }) => this.mapRecord(node)
-          )
-      )
-    )
-      .filter((x) => x)
-      .sort((x, y) => (x.name === y.name ? 0 : x.name > y.name ? 1 : -1));
-  }
-
-  public async createDefaultVault(): Promise<string> {
-    const secureContent = '';
-    const wrappedContent = await this.keyMetaService.wrapContent(secureContent);
-
-    const response = await this.lrApollo.mutate<any>({
-      mutation: CreateVaultMutation,
-      variables: {
-        plainMeta: JSON.stringify({
-          directoryType: DirectoryType.Vault,
-          default: true,
-        }),
-        cipherMeta: wrappedContent.cipherMeta,
-        parentRootDirectory: wrappedContent.rootKey,
-      },
-    });
-
-    return response.new.vault.id;
-  }
-
-  public async createCategory(newCategory: NewCategory): Promise<string> {
-    const secureContent = {
-      name: newCategory.name,
-      code: newCategory.code,
-      isCustom: newCategory.isCustom,
-      allowRecords: newCategory.allowRecords,
-      allowCustomCategories: newCategory.allowCustomCategories,
-    };
-    const wrappedContent = await this.keyMetaService.wrapContent(
-      secureContent,
-      newCategory.categoryIds
-    );
-
-    const response = await this.lrApollo.mutate<any>({
-      mutation: CreateCategoryMutation,
-      variables: {
-        plainMeta: JSON.stringify({
-          directoryType: DirectoryType.Category,
-          isHidden: false,
-        }),
-        cipherMeta: wrappedContent.cipherMeta,
-        parentDirectories: wrappedContent.wrappedKeys,
-        parentRootDirectory: wrappedContent.rootKey,
-      },
-    });
-
-    return response.new.category.id;
-  }
-
-  public async updateCategory(
-    categoryId: string,
-    keyId: string,
-    updatedCategory: UpdatedCategory
-  ): Promise<void> {
-    const secureContent = {
-      name: updatedCategory.name,
-      code: updatedCategory.code,
-      isCustom: updatedCategory.isCustom,
-      allowRecords: updatedCategory.allowRecords,
-      allowCustomCategories: updatedCategory.allowCustomCategories,
-    };
-
-    const cipherMeta = await this.keyGraph.encryptToString(
-      keyId,
-      secureContent
-    );
-
-    await this.lrApollo.mutate({
-      mutation: UpdateCategoryMutation,
-      variables: {
-        input: {
-          directoryId: categoryId,
-          cipherMeta,
-        },
-      },
-    });
-  }
-
-  public async setCategoryVisibility(
-    categoryId: string,
-    hide: boolean
-  ): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: UpdateCategoryMutation,
-      variables: {
-        input: {
-          directoryId: categoryId,
-          plainMeta: JSON.stringify({
-            directoryType: DirectoryType.Category,
-            isHidden: hide,
-          }),
-        },
-      },
-    });
-  }
-
-  public async deleteCategory(categoryId: string): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: DeleteCategoryMutation,
-      variables: { categoryId },
-    });
-  }
-
-  public async archiveCategory(
-    categoryId: string,
-    recursive: boolean
-  ): Promise<void> {
-    return this.archiveDirectory(categoryId, recursive);
-  }
-
-  public async unarchiveCategory(
-    categoryId: string,
-    recursive: boolean
-  ): Promise<void> {
-    return this.unarchiveDirectory(categoryId, recursive);
-  }
-
-  public async archiveDirectory(
-    directoryId: string,
-    recursive: boolean
-  ): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: ArchiveDirectoryMutation,
-      variables: {
-        input: {
-          directoryId,
-          recursive,
-        },
-      },
-    });
-  }
-
-  public async unarchiveDirectory(
-    directoryId: string,
-    recursive: boolean
-  ): Promise<void> {
-    await this.lrApollo.mutate({
-      mutation: UnarchiveDirectoryMutation,
-      variables: {
-        input: {
-          directoryId,
-          recursive,
-        },
-      },
-    });
-  }
-
-  public async mapVault(node: {
-    id;
-    keyId;
-    plainMeta;
-    cipherMeta;
-  }): Promise<Vault> {
-    try {
-      const { name } = (await this.keyMetaService.decryptMeta(node)) || {};
-      return {
-        id: node.id,
-        keyId: node.keyId,
-        name,
-      };
-    } catch (e) {
-      console.error('Failed to decrypt Vault.', e, node);
-      return null;
-    }
-  }
-
-  public async mapParentCategories(category: {
-    parentCategories: any;
-  }): Promise<Category[]> {
-    if (
-      !category.parentCategories ||
-      !category.parentCategories.edges ||
-      !category.parentCategories.edges.length
-    ) {
-      return [];
-    }
-    const node = category.parentCategories.edges[0].node.parentDirectory;
-
-    return [
-      ...(await this.mapParentCategories(node)),
-      await this.mapCategory(node),
-    ];
-  }
-
-  public async mapCategory(node: {
-    id;
-    keyId;
-    plainMeta;
-    cipherMeta;
-    descendantDirectories;
-    accessRoles: any[];
-    archived;
-  }): Promise<Category> {
-    try {
-      const { name, isCustom, allowRecords, allowCustomCategories, code } =
-        (await this.keyMetaService.decryptMeta(node)) || {};
-      const { isHidden } = (node.plainMeta && JSON.parse(node.plainMeta)) || {};
-
-      const isOwner =
-        node.accessRoles &&
-        node.accessRoles.some((x) => x.role === AccessLevel.Owner);
-
-      return {
-        id: node.id,
-        keyId: node.keyId,
-        code,
-        name,
-        isHidden: !!isHidden,
-        isCustom: !!isCustom,
-        isArchived: !!node.archived,
-        allowRecords: !!allowRecords,
-        allowCustomCategories: !!allowCustomCategories,
-        isEmpty: node.descendantDirectories
-          ? node.descendantDirectories.recordsCount === 0
-          : null,
-        allRecordsCount: node.descendantDirectories?.recordsCount, // Need this for testing.
-        myAccessLevel: isOwner ? AccessLevel.Owner : node.accessRoles[0].role,
-        sharedAccess: isOwner
-          ? node.accessRoles
-              .filter((x) => x.role !== AccessLevel.Owner)
-              .map((x) => ({
-                trustedPartyId: x.trustedParty && x.trustedParty.id,
-                accessLevel: x.role,
-                isInherited: x.method === 'inherited',
-                inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,
-              }))
-          : [],
-      };
-    } catch (e) {
-      console.error('Failed to decrypt Category.', e, node);
-      return null;
-    }
-  }
-
-  public async mapRecord(node: {
-    id;
-    keyId;
-    plainMeta;
-    cipherMeta;
-    created;
-    modified;
-    content;
-    accessRoles: any[];
-    archived;
-  }): Promise<VaultRecord> {
-    try {
-      const contents = node.content.edges[0].node.childFile;
-      const { name, recordType } =
-        (await this.keyMetaService.decryptMeta(
-          contents.currentVersion.state
-        )) || {};
-
-      const isOwner =
-        node.accessRoles &&
-        node.accessRoles.some((x) => x.role === AccessLevel.Owner);
-
-      return {
-        id: node.id,
-        keyId: node.keyId,
-        name,
-        recordType,
-        isArchived: !!node.archived,
-        createdOn: node.created,
-        lastModified:
-          new Date(node.modified) >
-          new Date(contents.currentVersion.state.modified)
-            ? node.modified
-            : contents.currentVersion.state.modified,
-        myAccessLevel: isOwner ? AccessLevel.Owner : node.accessRoles[0].role,
-        sharedAccess: isOwner
-          ? node.accessRoles
-              .filter((x) => x.role !== AccessLevel.Owner)
-              .map((x) => ({
-                trustedPartyId: x.trustedParty && x.trustedParty.id,
-                accessLevel: x.role,
-                isInherited: x.method === 'inherited',
-                inheritedFrom: x.inheritedFrom && x.inheritedFrom.id,
-              }))
-          : [],
-      };
-    } catch (e) {
-      console.error('Failed to decrypt Record.', e);
-      return null as VaultRecord;
-    }
-  }
-}

package/src/lib/category/category.types.ts

@@ -1,89 +0,0 @@
-export enum AccessLevel {
-  Owner = 'OWNER',
-  Admin = 'ADMIN',
-  Writer = 'WRITER',
-  Reader = 'READER',
-  Deny = 'DENY',
-}
-
-export class SharedAccess {
-  trustedPartyId: string;
-  accessLevel: AccessLevel;
-  isInherited: boolean;
-  inheritedFrom?: string;
-}
-
-export class DefaultCategory {
-  code: string;
-  name: string;
-  allowRecords: boolean;
-  allowCustomCategories: boolean;
-  archived: boolean;
-  subCategories?: DefaultCategory[];
-}
-
-export class VaultRecordType {
-  id: string;
-  name: string;
-}
-
-export class VaultRecord {
-  id: string;
-  keyId: string;
-  name: string;
-  recordType: VaultRecordType;
-  createdOn: string | Date;
-  lastModified: string | Date;
-  isArchived: boolean;
-  myAccessLevel: AccessLevel;
-  sharedAccess: SharedAccess[];
-}
-
-export class Category {
-  id: string;
-  keyId: string;
-  code?: string;
-  name: string;
-  isHidden: boolean;
-  isCustom: boolean;
-  isEmpty: boolean;
-  isArchived: boolean;
-  allRecordsCount: number;
-  allowRecords: boolean;
-  allowCustomCategories: boolean;
-  myAccessLevel: AccessLevel;
-  sharedAccess: SharedAccess[];
-}
-
-export class CurrentCategory extends Category {
-  parents: Category[];
-}
-
-export class VaultCategory {
-  category?: CurrentCategory;
-  subCategories?: Category[];
-  records?: VaultRecord[];
-}
-
-export class NewCategory {
-  name: string;
-  code?: string;
-  isCustom: boolean;
-  allowRecords: boolean;
-  allowCustomCategories: boolean;
-  categoryIds?: string[];
-}
-
-export class UpdatedCategory {
-  name: string;
-  code?: string;
-  isCustom: boolean;
-  allowRecords: boolean;
-  allowCustomCategories: boolean;
-}
-
-export class Vault {
-  id: string;
-  keyId: string;
-  name?: string;
-}

package/src/lib/cryptography/cryptography.types.ts

@@ -1,108 +0,0 @@
-import { JWK } from 'node-jose';
-
-export interface Key {
-  id: string;
-  pbk?: string;
-  jwk?: JWK.Key;
-}
-
-export interface PassKeyParams {
-  kid: string;
-  salt: string;
-  iterations: number;
-}
-
-export interface PassIdpParams {
-  salt: string;
-  iterations: number;
-}
-
-export interface LbopKeyParams {
-  kid: string;
-  salt: string;
-  iterations: number;
-}
-
-export interface PassIdpVerifier {
-  wrappedPrK: object;
-  pbk: object;
-}
-
-export interface LbopKeyVerifier {
-  wrappedKey: object;
-  key: object;
-}
-
-export interface PassKey {
-  id: string;
-  passKeyParams?: PassKeyParams;
-  passIdpParams?: PassIdpParams;
-  wrappedPassIdpVerifierPrk?: object;
-  created?: string;
-}
-
-export interface KeyLink {
-  keyId: string;
-  wrappingKeyId: string;
-  wrappedKey: string; // JWE json string
-}
-
-export interface PassKeyLink {
-  keyId: string;
-  passKeyId: string;
-  wrappedKey: string; // JWE json string
-}
-
-export enum NodeType {
-  Key = 'key',
-  PassKey = 'passKey',
-}
-
-export interface Node {
-  type: NodeType;
-  data: Key | PassKey;
-}
-
-export enum EdgeType {
-  KeyLink = 'keyLink',
-  PassKeyLink = 'passKeyLink',
-}
-
-export interface Edge {
-  type: EdgeType;
-  data: KeyLink | PassKeyLink;
-}
-
-export interface KeyGraphResponse {
-  keys?: Key[];
-  keyLinks?: KeyLink[];
-  passKeys?: PassKey[];
-  passKeyLinks?: PassKeyLink[];
-}
-
-export interface HasKeyGraph {
-  // The name of the keyGraph field returned from both queries and mutations are the same
-  keyGraph?: KeyGraphResponse;
-}
-
-// export enum PayloadType {
-//   JSON = 'JSON',
-//   ArrayBuffer = 'ArrayBuffer',
-// }
-export type PayloadType = 'json' | 'ArrayBuffer';
-
-export interface DeriveKeyResult {
-  jwk: JWK.Key;
-}
-
-export interface DerivePassIdpParams extends PassIdpParams {
-  password: string;
-}
-
-export interface DerivePassKeyParams extends PassKeyParams {
-  password: string;
-}
-
-export interface DeriveLbopKeyParams extends PassKeyParams {
-  password: string;
-}