@lifeready/core 1.0.1 → 1.0.3

package/src/lib/auth/two-factor.service.ts

@@ -1,69 +0,0 @@
-import { Injectable } from '@angular/core';
-import { CognitoUser } from '@aws-amplify/auth';
-import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
-import { LrBadArgumentException } from '../_common/exceptions';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class TwoFactorService {
-  constructor(private auth: AuthClass) {}
-
-  public async getPreferredMFA(): Promise<string> {
-    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
-
-    return await this.auth.getPreferredMFA(cognitoUser);
-  }
-
-  public async setPreferredMFA(
-    method: 'TOTP' | 'SMS' | 'NOMFA'
-  ): Promise<void> {
-    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
-
-    await this.auth.setPreferredMFA(cognitoUser, method);
-  }
-
-  public async setPhoneNumber(phone): Promise<void> {
-    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
-
-    await this.auth.updateUserAttributes(cognitoUser, {
-      phone_number: phone,
-    });
-  }
-
-  public async getSMSCode() {
-    await this.auth.verifyCurrentUserAttribute('phone_number');
-  }
-
-  public async verifySMSCode(verificationCode: string) {
-    await this.auth.verifyCurrentUserAttributeSubmit(
-      'phone_number',
-      verificationCode
-    );
-  }
-
-  public async getSoftwareToken(): Promise<{ code: string; codeUri: string }> {
-    const [cognitoUser, userInfo] = await Promise.all([
-      this.auth.currentAuthenticatedUser(),
-      this.auth.currentUserInfo(),
-    ]);
-
-    const code = await this.auth.setupTOTP(cognitoUser);
-
-    const email = userInfo.attributes.email;
-    if (!email) {
-      throw new LrBadArgumentException('No email associated with user.');
-    }
-
-    return {
-      code,
-      codeUri: `otpauth://totp/${email}?secret=${code}&issuer=LifeReady`,
-    };
-  }
-
-  public async verifySoftwareToken(totpCode: string): Promise<void> {
-    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
-
-    await this.auth.verifyTotpToken(cognitoUser, totpCode);
-  }
-}

package/src/lib/category/category-meta.service.spec.ts

@@ -1,28 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { CategoryMetaService } from './category-meta.service';
-import { CategoryService } from './category.service';
-import { HttpClient } from '@angular/common/http';
-
-const http = jasmine.createSpyObj('HttpClient', ['']);
-const categoryService = jasmine.createSpyObj<CategoryService>(
-  'CategoryService',
-  ['getCategories', 'getCategory']
-);
-
-describe('CategoryMetaService', () => {
-  let service: CategoryMetaService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-        { provide: CategoryService, useValue: categoryService },
-        { provide: HttpClient, useValue: http },
-      ],
-    });
-    service = TestBed.inject(CategoryMetaService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});

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

@@ -1,125 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { Injectable } from '@angular/core';
-import { CategoryService } from './category.service';
-import {
-  AccessLevel,
-  Category,
-  CurrentCategory,
-  DefaultCategory,
-  VaultCategory,
-} from './category.types';
-
-export class LoadedCategoryTree {
-  categories: CurrentCategory[];
-  missingCategories: string[][];
-}
-
-@Injectable({
-  providedIn: 'root',
-})
-export class CategoryMetaService {
-  private categories: DefaultCategory[];
-
-  constructor(
-    private http: HttpClient,
-    private categoryService: CategoryService
-  ) {}
-
-  public async getCoreCategories(): Promise<DefaultCategory[]> {
-    if (!this.categories) {
-      this.categories = await this.http
-        .get<DefaultCategory[]>('/assets/meta/categories.json')
-        .toPromise();
-    }
-    return Promise.resolve(this.categories);
-  }
-
-  async loadCategories(
-    categoryTrees: string[][],
-    selectedCategoryId?: string,
-    trustedPartyId?: string
-  ): Promise<LoadedCategoryTree> {
-    const rootCategories = trustedPartyId
-      ? (await this.categoryService.getTrustedPartyCategories(trustedPartyId))
-          .categories
-      : await this.categoryService.getCategories();
-
-    const selectedCategory = selectedCategoryId
-      ? await this.categoryService.getCategory(selectedCategoryId)
-      : null;
-
-    const categoryPromises = categoryTrees.map(async (x) => ({
-      categoryTree: x,
-      category: await this.loadCategory(
-        [...x],
-        rootCategories,
-        selectedCategory
-      ),
-    }));
-
-    const loadedCategories = await Promise.all(categoryPromises);
-
-    const loadedCategoryTree: LoadedCategoryTree = {
-      categories: [],
-      missingCategories: [],
-    };
-
-    loadedCategories.forEach((x) =>
-      x.category
-        ? loadedCategoryTree.categories.push(x.category)
-        : loadedCategoryTree.missingCategories.push(x.categoryTree)
-    );
-
-    return loadedCategoryTree;
-  }
-
-  async loadCategoriesForRole(
-    categories: { category: string[]; accessLevel: AccessLevel }[]
-  ): Promise<{ category: CurrentCategory; accessLevel: AccessLevel }[]> {
-    const rootCategories = await this.categoryService.getCategories();
-
-    return await Promise.all(
-      categories.map(async (x) => ({
-        category: await this.loadCategory([...x.category], rootCategories),
-        accessLevel: x.accessLevel,
-      }))
-    );
-  }
-
-  private async loadCategory(
-    categoryTree: string[],
-    categories: Category[],
-    selectedCategory?: VaultCategory
-  ): Promise<CurrentCategory> {
-    const name = categoryTree.shift();
-
-    const currentCategory = categories.find(
-      (x) => x.code === name && !x.isCustom
-    );
-
-    if (currentCategory) {
-      if (categoryTree.length) {
-        const { subCategories } = await this.categoryService.getCategory(
-          currentCategory.id
-        );
-        return this.loadCategory(categoryTree, subCategories, selectedCategory);
-      } else {
-        const { category } = await this.categoryService.getCategory(
-          currentCategory.id
-        );
-
-        if (
-          selectedCategory &&
-          selectedCategory.category.parents.some((x) => x.id === category.id)
-        ) {
-          return selectedCategory.category;
-        }
-        return category;
-      }
-    } else if (categoryTree.length) {
-      return this.loadCategory(categoryTree, categories, selectedCategory);
-    } else {
-      return null;
-    }
-  }
-}

package/src/lib/category/category.gql.ts

@@ -1,449 +0,0 @@
-import { HasKeyGraph } from './../cryptography/cryptography.types';
-import { KeyGraphFragment } from '../_common/queries.gql';
-import gql from 'graphql-tag';
-import { HasKeyGraphEdges, HasEdges } from '../_common/types';
-
-export const DEFAULT_BREADCRUMB_DEPTH = 5;
-export const DEFAULT_DESCENDANTS_DEPTH = 5;
-
-export enum DirectoryType {
-  Vault = 'vault',
-  Category = 'category',
-  Record = 'record',
-}
-
-export const DefaultVaultFilter = JSON.stringify({
-  filter: [
-    {
-      contains: {
-        directoryType: DirectoryType.Vault,
-        default: true,
-      },
-    },
-  ],
-});
-
-export const CategoryFilter = JSON.stringify({
-  filter: [
-    {
-      contains: {
-        directoryType: DirectoryType.Category,
-      },
-    },
-  ],
-});
-
-export const RecordFilter = JSON.stringify({
-  filter: [
-    {
-      contains: {
-        directoryType: DirectoryType.Record,
-      },
-    },
-  ],
-});
-
-export const AccessFields = `
-accessRoles {
-  role
-  method
-  inheritedFrom {
-    id
-  }
-  trustedParty {
-    id
-  }
-  isIssuer
-}`;
-
-const descendantDirectories = `
-descendantDirectories(depth: ${DEFAULT_DESCENDANTS_DEPTH}, plainMeta: $categoryFilter, archived: false) {
-  recordsCount: directoriesCount(plainMeta: $recordFilter, archived: false)
-}
-`;
-
-export const CategoryFields = `
-  id
-  keyId
-  archived
-  plainMeta
-  cipherMeta
-  ${AccessFields}
-  ${descendantDirectories}
-`;
-
-export const VaultFields = `
-  id
-  keyId
-  plainMeta
-  cipherMeta
-`;
-
-export const GetRootDirectoryIdsQuery = gql`
-  query GetRootDirectoryIdsQuery($archived: Boolean) {
-    rootDirectories(archived: $archived) {
-      edges {
-        node {
-          id
-        }
-      }
-    }
-  }
-`;
-
-export const GetCategoriesQuery = gql`
-query GetCategories($vaultFilter: LrJSONFilter!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $archived: Boolean, $cachedKeyIds: [LrRelayIdInput!])
-{
-  vaults: rootDirectories(plainMeta: $vaultFilter) {
-    edges {
-      node {
-        childDirectoryLinks(plainMeta: $categoryFilter, orderBy: "created", archived: $archived) {
-          edges {
-            node {
-              childDirectory {
-                ${CategoryFields}
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  keyGraph(cachedKeyIds: $cachedKeyIds) {
-    ...KeyGraphFragment
-  }
-}
-${KeyGraphFragment}
-`;
-
-export const GetVaultsQuery = gql`
-query GetVaults($plainMetaFilter: LrJSONFilter!, $cachedKeyIds: [LrRelayIdInput!])
-{
-  list: rootDirectories(plainMeta: $plainMetaFilter, orderBy: "created") {
-    edges {
-      node {
-        ${VaultFields}
-      }
-    }
-  }
-  keyGraph(cachedKeyIds: $cachedKeyIds) {
-    ...KeyGraphFragment
-  }
-}
-${KeyGraphFragment}
-`;
-
-export interface GetTrustedPartyCategoriesQueryType extends HasKeyGraph {
-  tp: {
-    sharedItems: {
-      list: HasEdges<any>;
-      records: HasEdges<any>;
-    };
-  };
-}
-
-export const GetTrustedPartyCategoriesQuery = gql`
-query GetTrustedPartyCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])
-{
-  tp(id: $trustedPartyId) {
-    sharedItems {
-      list: directories(plainMeta: $categoryFilter, orderBy: "created") {
-        edges {
-          node {
-            ${CategoryFields}
-          }
-        }
-      }
-      records: directories(plainMeta: $recordFilter, orderBy: "created") {
-        edges {
-          node {
-            id
-            keyId
-            archived
-            plainMeta
-            cipherMeta
-            created
-            modified
-            ${AccessFields}
-            content: childFileLinks(plainMeta: $contentFilter) {
-              edges {
-                node {
-                  childFile {
-                    id
-                    archived
-                    currentVersion {
-                      state {
-                        keyId
-                        plainMeta
-                        cipherMeta
-                        created
-                        modified
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  keyGraph(cachedKeyIds: $cachedKeyIds) {
-    ...KeyGraphFragment
-  }
-}
-${KeyGraphFragment}
-`;
-
-export interface GetMySharedCategoriesQueryType extends HasKeyGraph {
-  tp: {
-    myItems: {
-      list: HasEdges<any>;
-      records: HasEdges<any>;
-    };
-  };
-}
-
-export const GetMySharedCategoriesQuery = gql`
-query GetMySharedCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])
-{
-  tp(id: $trustedPartyId) {
-    myItems {
-      list: directories(plainMeta: $categoryFilter, orderBy: "created") {
-        edges {
-          node {
-            ${CategoryFields}
-          }
-        }
-      }
-      records: directories(plainMeta: $recordFilter, orderBy: "created") {
-        edges {
-          node {
-            id
-            keyId
-            archived
-            plainMeta
-            cipherMeta
-            created
-            modified
-            ${AccessFields}
-            content: childFileLinks(plainMeta: $contentFilter) {
-              edges {
-                node {
-                  childFile {
-                    id
-                    archived
-                    currentVersion {
-                      state {
-                        keyId
-                        plainMeta
-                        cipherMeta
-                        created
-                        modified
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  keyGraph(cachedKeyIds: $cachedKeyIds) {
-    ...KeyGraphFragment
-  }
-}
-${KeyGraphFragment}
-`;
-
-export const parentCategoriesField = (depth = DEFAULT_BREADCRUMB_DEPTH) => {
-  if (!depth) {
-    return '';
-  }
-  return `
-parentCategories: parentDirectoryLinks(plainMeta: $categoryFilter) {
-  edges {
-    node {
-      parentDirectory {
-        id
-        keyId
-        archived
-        plainMeta
-        cipherMeta
-        ${parentCategoriesField(depth - 1)}
-        ${AccessFields}
-      }
-    }
-  }
-}
-`;
-};
-
-export const GetCategoryQuery = (
-  depth: number = DEFAULT_BREADCRUMB_DEPTH
-) => gql`
-query GetCategory(
-  $id: LrRelayIdInput!,
-  $categoryFilter: LrJSONFilter!,
-  $recordFilter: LrJSONFilter!,
-  $contentFilter: LrJSONFilter,
-  $cachedKeyIds: [LrRelayIdInput!]) {
-  category: directory(id: $id) {
-    id
-    keyId
-    archived
-    plainMeta
-    cipherMeta
-    ${AccessFields}
-    ${descendantDirectories}
-    ${parentCategoriesField(depth)}
-    subCategories: childDirectoryLinks(plainMeta: $categoryFilter, orderBy: "created") {
-      edges {
-        node {
-          childDirectory {
-            ${CategoryFields}
-          }
-        }
-      }
-    }
-    records: childDirectoryLinks(plainMeta: $recordFilter, orderBy: "created") {
-      edges {
-        node {
-          childDirectory {
-            id
-            keyId
-            archived
-            plainMeta
-            cipherMeta
-            created
-            modified
-            ${AccessFields}
-            content: childFileLinks(plainMeta: $contentFilter) {
-              edges {
-                node {
-                  childFile {
-                    id
-                    archived
-                    currentVersion {
-                      state {
-                        keyId
-                        plainMeta
-                        cipherMeta
-                        created
-                        modified
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  keyGraph(cachedKeyIds: $cachedKeyIds) {
-    ...KeyGraphFragment
-  }
-}
-${KeyGraphFragment} `;
-
-export const GetCategoryKeyIdQuery = gql`
-  query GetCategoryKeyIdQuery(
-    $id: LrRelayIdInput!
-    $cachedKeyIds: [LrRelayIdInput!]
-  ) {
-    category: directory(id: $id) {
-      keyId
-    }
-    keyGraph(cachedKeyIds: $cachedKeyIds) {
-      ...KeyGraphFragment
-    }
-  }
-  ${KeyGraphFragment}
-`;
-
-export const CreateCategoryMutation = gql`
-  mutation CreateCategory(
-    $plainMeta: LrJSONString
-    $cipherMeta: String
-    $parentDirectories: [ParentDirectoryInput!]
-    $parentRootDirectory: ParentRootDirectoryInput
-  ) {
-    new: createDirectory(
-      input: {
-        plainMeta: $plainMeta
-        cipherMeta: $cipherMeta
-        parentDirectories: $parentDirectories
-        parentRootDirectory: $parentRootDirectory
-      }
-    ) {
-      category: directory {
-        id
-        keyId
-      }
-    }
-  }
-`;
-
-export const CreateVaultMutation = gql`
-  mutation CreateCategory(
-    $plainMeta: LrJSONString
-    $cipherMeta: String
-    $parentRootDirectory: ParentRootDirectoryInput
-  ) {
-    new: createDirectory(
-      input: {
-        plainMeta: $plainMeta
-        cipherMeta: $cipherMeta
-        parentRootDirectory: $parentRootDirectory
-      }
-    ) {
-      vault: directory {
-        id
-        keyId
-      }
-    }
-  }
-`;
-
-export const UpdateCategoryMutation = gql`
-  mutation UpdateCategory($input: UpdateDirectoryInput!) {
-    updateDirectory(input: $input) {
-      directory {
-        id
-      }
-    }
-  }
-`;
-
-export const DeleteCategoryMutation = gql`
-  mutation DeleteCategory($categoryId: LrRelayIdInput!) {
-    deleteDirectory(input: { directoryId: $categoryId }) {
-      id
-    }
-  }
-`;
-
-export const ArchiveDirectoryMutation = gql`
-  mutation ArchiveDirectory($input: ArchiveDirectoryInput!) {
-    archiveDirectory(input: $input) {
-      directory {
-        id
-      }
-    }
-  }
-`;
-
-export const UnarchiveDirectoryMutation = gql`
-  mutation UnarchiveDirectory($input: UnarchiveDirectoryInput!) {
-    unarchiveDirectory(input: $input) {
-      directory {
-        id
-      }
-    }
-  }
-`;

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

@@ -1,26 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { LrApolloService } from '../api/lr-apollo.service';
-import { KeyMetaService } from '../cryptography/key-meta.service';
-import { lrConfigureTestingModule } from '../_common/tests';
-import { CategoryService } from './category.service';
-
-const keyMetaService = jasmine.createSpyObj<KeyMetaService>('PasswordService', [
-  'wrapContent',
-]);
-const lrApollo = jasmine.createSpyObj<LrApolloService>('PasswordService', [
-  'query',
-  'mutate',
-]);
-
-describe('FolderService', () => {
-  let service: CategoryService;
-
-  beforeEach(async () => {
-    lrConfigureTestingModule();
-    service = TestBed.inject(CategoryService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});