@lifeready/core 1.0.2 → 1.0.4

package/lib/auth/password.service.d.ts

@@ -1,78 +1,78 @@
-import { HttpClient } from '@angular/common/http';
-import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
-import { JWK } from 'node-jose';
-import { ProfileService } from '../users/profile.service';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { LifeReadyConfig } from '../life-ready.config';
-import { LrApolloService } from './../api/lr-apollo.service';
-import { PassKeyBundle } from './auth.types';
-import { WebCryptoService } from '../cryptography/web-crypto.service';
-import { Duration } from 'moment';
-import { IdleService } from '../auth/idle.service';
-import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
-export interface PasswordChangeConfig {
-    maxAuthAgeSeconds: number;
-    authTime: string | Date;
-    serverTime: string | Date;
-}
-export declare class PasswordCheck {
-    length?: number;
-    timeToCrack?: Duration;
-    passwordExposed?: number;
-}
-export declare class PasswordService {
-    private config;
-    private http;
-    private apollo;
-    private auth;
-    private profileService;
-    private keyFactory;
-    private encryptionService;
-    private keyGraph;
-    private webCryptoService;
-    private idleService;
-    private readonly CLIENT_NONCE_LENGTH;
-    constructor(config: LifeReadyConfig, http: HttpClient, apollo: LrApolloService, auth: AuthClass, profileService: ProfileService, keyFactory: KFS, encryptionService: EncryptionService, keyGraph: KeyGraphService, webCryptoService: WebCryptoService, idleService: IdleService);
-    checkPassword(password: string): Promise<PasswordCheck>;
-    getExposureCount(password: string): Promise<number>;
-    getPassIdpString(passIdp: JWK.Key): any;
-    createPassKeyBundle(password: string): Promise<PassKeyBundle>;
-    /**
-     * We need to allow for interruption of the process at any point. Each API call can be considered
-     * atomic and either succeeds or fails.
-     *
-     * The LR server APIs use semaphore tokens for locking critical operations, so concurrent calls will
-     * fail.
-     *
-     * We assume the worst case for IdP API calls. So we use the semaphore token from LR to prevent
-     * concurrent calls to IdP APIs, but we have to assume that the IdP API calls will either succeed or
-     * fail within a reasonable amount of time.
-     *
-     * Each location where the server state changes can be a potential point of interruption.
-     * Potential points of interruption are marked with: --Potential Failure Point--
-     *
-     * Places for timeout:
-     * - Login age too old at call to: verifyPassword()
-     * - Login age too old at call to: changePasswordMutation()
-     * - Semaphore token expires at call to: changePasswordComplete()
-     *
-     * Tests:
-     * - Potential Failure Point 1: should be able to restart the process, user remains signed in.
-     * - Potential Failure Point 2: should enter recovery flow
-     * - Potential Failure Point 3: should enter recovery flow
-     * - Potential Failure Point 4: should enter recovery flow
-     *
-     */
-    isLoginRequired(): Promise<boolean>;
-    changePassword(password: string, newPassword: string): Promise<void>;
-    changePasswordComplete(accessToken: string, useNewPassword: boolean, token?: string): Promise<any>;
-    private getVerifierPrK;
-    private verifyPassword;
-    private changePasswordMutation;
-    getChangePasswordConfig(): Promise<PasswordChangeConfig>;
-    passwordStrength(password: any): {
-        years: number;
-        bits: number;
-    };
-}
+import { HttpClient } from '@angular/common/http';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { JWK } from 'node-jose';
+import { ProfileService } from '../users/profile.service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { LifeReadyConfig } from '../life-ready.config';
+import { LrApolloService } from './../api/lr-apollo.service';
+import { PassKeyBundle } from './auth.types';
+import { WebCryptoService } from '../cryptography/web-crypto.service';
+import { Duration } from 'moment';
+import { IdleService } from '../auth/idle.service';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+export interface PasswordChangeConfig {
+    maxAuthAgeSeconds: number;
+    authTime: string | Date;
+    serverTime: string | Date;
+}
+export declare class PasswordCheck {
+    length?: number;
+    timeToCrack?: Duration;
+    passwordExposed?: number;
+}
+export declare class PasswordService {
+    private config;
+    private http;
+    private apollo;
+    private auth;
+    private profileService;
+    private keyFactory;
+    private encryptionService;
+    private keyGraph;
+    private webCryptoService;
+    private idleService;
+    private readonly CLIENT_NONCE_LENGTH;
+    constructor(config: LifeReadyConfig, http: HttpClient, apollo: LrApolloService, auth: AuthClass, profileService: ProfileService, keyFactory: KFS, encryptionService: EncryptionService, keyGraph: KeyGraphService, webCryptoService: WebCryptoService, idleService: IdleService);
+    checkPassword(password: string): Promise<PasswordCheck>;
+    getExposureCount(password: string): Promise<number>;
+    getPassIdpString(passIdp: JWK.Key): any;
+    createPassKeyBundle(password: string): Promise<PassKeyBundle>;
+    /**
+     * We need to allow for interruption of the process at any point. Each API call can be considered
+     * atomic and either succeeds or fails.
+     *
+     * The LR server APIs use semaphore tokens for locking critical operations, so concurrent calls will
+     * fail.
+     *
+     * We assume the worst case for IdP API calls. So we use the semaphore token from LR to prevent
+     * concurrent calls to IdP APIs, but we have to assume that the IdP API calls will either succeed or
+     * fail within a reasonable amount of time.
+     *
+     * Each location where the server state changes can be a potential point of interruption.
+     * Potential points of interruption are marked with: --Potential Failure Point--
+     *
+     * Places for timeout:
+     * - Login age too old at call to: verifyPassword()
+     * - Login age too old at call to: changePasswordMutation()
+     * - Semaphore token expires at call to: changePasswordComplete()
+     *
+     * Tests:
+     * - Potential Failure Point 1: should be able to restart the process, user remains signed in.
+     * - Potential Failure Point 2: should enter recovery flow
+     * - Potential Failure Point 3: should enter recovery flow
+     * - Potential Failure Point 4: should enter recovery flow
+     *
+     */
+    isLoginRequired(): Promise<boolean>;
+    changePassword(password: string, newPassword: string): Promise<void>;
+    changePasswordComplete(accessToken: string, useNewPassword: boolean, token?: string): Promise<any>;
+    private getVerifierPrK;
+    private verifyPassword;
+    private changePasswordMutation;
+    getChangePasswordConfig(): Promise<PasswordChangeConfig>;
+    passwordStrength(password: any): {
+        years: number;
+        bits: number;
+    };
+}

package/lib/auth/register.service.d.ts

@@ -1,25 +1,25 @@
-import { HttpClient } from '@angular/common/http';
-import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyFactoryService } from '../cryptography/key-factory.service';
-import { LifeReadyConfig } from '../life-ready.config';
-import { PasswordService } from './password.service';
-import { RegisterResult } from './auth.types';
-export declare class RegisterService {
-    private config;
-    private auth;
-    private http;
-    private keyFactory;
-    private encryptionService;
-    private passwordService;
-    constructor(config: LifeReadyConfig, auth: AuthClass, http: HttpClient, keyFactory: KeyFactoryService, encryptionService: EncryptionService, passwordService: PasswordService);
-    /**
-     * Request a verification code to be sent out to an email.
-     * @return Info needed to be submitted along with the verification code
-     */
-    verifyEmail(email: string): Promise<string>;
-    verifyPhone(phoneNumber: string): Promise<string>;
-    confirmVerificationCode(verificationId: string, verificationCode: string): Promise<string>;
-    register(email: string, password: string, verificationId: string, verificationToken: string, verificationType?: 'email' | 'phone'): Promise<RegisterResult>;
-    hibpBreachedAccounts(account: string): Promise<any>;
-}
+import { HttpClient } from '@angular/common/http';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { LifeReadyConfig } from '../life-ready.config';
+import { PasswordService } from './password.service';
+import { RegisterResult } from './auth.types';
+export declare class RegisterService {
+    private config;
+    private auth;
+    private http;
+    private keyFactory;
+    private encryptionService;
+    private passwordService;
+    constructor(config: LifeReadyConfig, auth: AuthClass, http: HttpClient, keyFactory: KeyFactoryService, encryptionService: EncryptionService, passwordService: PasswordService);
+    /**
+     * Request a verification code to be sent out to an email.
+     * @return Info needed to be submitted along with the verification code
+     */
+    verifyEmail(email: string): Promise<string>;
+    verifyPhone(phoneNumber: string): Promise<string>;
+    confirmVerificationCode(verificationId: string, verificationCode: string): Promise<string>;
+    register(email: string, password: string, verificationId: string, verificationToken: string, verificationType?: 'email' | 'phone'): Promise<RegisterResult>;
+    hibpBreachedAccounts(account: string): Promise<any>;
+}

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

@@ -1,15 +1,15 @@
-import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
-export declare class TwoFactorService {
-    private auth;
-    constructor(auth: AuthClass);
-    getPreferredMFA(): Promise<string>;
-    setPreferredMFA(method: 'TOTP' | 'SMS' | 'NOMFA'): Promise<void>;
-    setPhoneNumber(phone: any): Promise<void>;
-    getSMSCode(): Promise<void>;
-    verifySMSCode(verificationCode: string): Promise<void>;
-    getSoftwareToken(): Promise<{
-        code: string;
-        codeUri: string;
-    }>;
-    verifySoftwareToken(totpCode: string): Promise<void>;
-}
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+export declare class TwoFactorService {
+    private auth;
+    constructor(auth: AuthClass);
+    getPreferredMFA(): Promise<string>;
+    setPreferredMFA(method: 'TOTP' | 'SMS' | 'NOMFA'): Promise<void>;
+    setPhoneNumber(phone: any): Promise<void>;
+    getSMSCode(): Promise<void>;
+    verifySMSCode(verificationCode: string): Promise<void>;
+    getSoftwareToken(): Promise<{
+        code: string;
+        codeUri: string;
+    }>;
+    verifySoftwareToken(totpCode: string): Promise<void>;
+}

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

@@ -1,23 +1,23 @@
-import { HttpClient } from '@angular/common/http';
-import { CategoryService } from './category.service';
-import { AccessLevel, CurrentCategory, DefaultCategory } from './category.types';
-export declare class LoadedCategoryTree {
-    categories: CurrentCategory[];
-    missingCategories: string[][];
-}
-export declare class CategoryMetaService {
-    private http;
-    private categoryService;
-    private categories;
-    constructor(http: HttpClient, categoryService: CategoryService);
-    getCoreCategories(): Promise<DefaultCategory[]>;
-    loadCategories(categoryTrees: string[][], selectedCategoryId?: string, trustedPartyId?: string): Promise<LoadedCategoryTree>;
-    loadCategoriesForRole(categories: {
-        category: string[];
-        accessLevel: AccessLevel;
-    }[]): Promise<{
-        category: CurrentCategory;
-        accessLevel: AccessLevel;
-    }[]>;
-    private loadCategory;
-}
+import { HttpClient } from '@angular/common/http';
+import { CategoryService } from './category.service';
+import { AccessLevel, CurrentCategory, DefaultCategory } from './category.types';
+export declare class LoadedCategoryTree {
+    categories: CurrentCategory[];
+    missingCategories: string[][];
+}
+export declare class CategoryMetaService {
+    private http;
+    private categoryService;
+    private categories;
+    constructor(http: HttpClient, categoryService: CategoryService);
+    getCoreCategories(): Promise<DefaultCategory[]>;
+    loadCategories(categoryTrees: string[][], selectedCategoryId?: string, trustedPartyId?: string): Promise<LoadedCategoryTree>;
+    loadCategoriesForRole(categories: {
+        category: string[];
+        accessLevel: AccessLevel;
+    }[]): Promise<{
+        category: CurrentCategory;
+        accessLevel: AccessLevel;
+    }[]>;
+    private loadCategory;
+}

package/lib/category/category.gql.d.ts

@@ -1,45 +1,45 @@
-import { HasKeyGraph } from './../cryptography/cryptography.types';
-import { HasEdges } from '../_common/types';
-export declare const DEFAULT_BREADCRUMB_DEPTH = 5;
-export declare const DEFAULT_DESCENDANTS_DEPTH = 5;
-export declare enum DirectoryType {
-    Vault = "vault",
-    Category = "category",
-    Record = "record"
-}
-export declare const DefaultVaultFilter: string;
-export declare const CategoryFilter: string;
-export declare const RecordFilter: string;
-export declare const AccessFields = "\naccessRoles {\n  role\n  method\n  inheritedFrom {\n    id\n  }\n  trustedParty {\n    id\n  }\n  isIssuer\n}";
-export declare const CategoryFields: string;
-export declare const VaultFields = "\n  id\n  keyId\n  plainMeta\n  cipherMeta\n";
-export declare const GetRootDirectoryIdsQuery: import("graphql").DocumentNode;
-export declare const GetCategoriesQuery: import("graphql").DocumentNode;
-export declare const GetVaultsQuery: import("graphql").DocumentNode;
-export interface GetTrustedPartyCategoriesQueryType extends HasKeyGraph {
-    tp: {
-        sharedItems: {
-            list: HasEdges<any>;
-            records: HasEdges<any>;
-        };
-    };
-}
-export declare const GetTrustedPartyCategoriesQuery: import("graphql").DocumentNode;
-export interface GetMySharedCategoriesQueryType extends HasKeyGraph {
-    tp: {
-        myItems: {
-            list: HasEdges<any>;
-            records: HasEdges<any>;
-        };
-    };
-}
-export declare const GetMySharedCategoriesQuery: import("graphql").DocumentNode;
-export declare const parentCategoriesField: (depth?: number) => any;
-export declare const GetCategoryQuery: (depth?: number) => import("graphql").DocumentNode;
-export declare const GetCategoryKeyIdQuery: import("graphql").DocumentNode;
-export declare const CreateCategoryMutation: import("graphql").DocumentNode;
-export declare const CreateVaultMutation: import("graphql").DocumentNode;
-export declare const UpdateCategoryMutation: import("graphql").DocumentNode;
-export declare const DeleteCategoryMutation: import("graphql").DocumentNode;
-export declare const ArchiveDirectoryMutation: import("graphql").DocumentNode;
-export declare const UnarchiveDirectoryMutation: import("graphql").DocumentNode;
+import { HasKeyGraph } from './../cryptography/cryptography.types';
+import { HasEdges } from '../_common/types';
+export declare const DEFAULT_BREADCRUMB_DEPTH = 5;
+export declare const DEFAULT_DESCENDANTS_DEPTH = 5;
+export declare enum DirectoryType {
+    Vault = "vault",
+    Category = "category",
+    Record = "record"
+}
+export declare const DefaultVaultFilter: string;
+export declare const CategoryFilter: string;
+export declare const RecordFilter: string;
+export declare const AccessFields = "\naccessRoles {\n  role\n  method\n  inheritedFrom {\n    id\n  }\n  trustedParty {\n    id\n  }\n  isIssuer\n}";
+export declare const CategoryFields: string;
+export declare const VaultFields = "\n  id\n  keyId\n  plainMeta\n  cipherMeta\n";
+export declare const GetRootDirectoryIdsQuery: import("graphql").DocumentNode;
+export declare const GetCategoriesQuery: import("graphql").DocumentNode;
+export declare const GetVaultsQuery: import("graphql").DocumentNode;
+export interface GetTrustedPartyCategoriesQueryType extends HasKeyGraph {
+    tp: {
+        sharedItems: {
+            list: HasEdges<any>;
+            records: HasEdges<any>;
+        };
+    };
+}
+export declare const GetTrustedPartyCategoriesQuery: import("graphql").DocumentNode;
+export interface GetMySharedCategoriesQueryType extends HasKeyGraph {
+    tp: {
+        myItems: {
+            list: HasEdges<any>;
+            records: HasEdges<any>;
+        };
+    };
+}
+export declare const GetMySharedCategoriesQuery: import("graphql").DocumentNode;
+export declare const parentCategoriesField: (depth?: number) => any;
+export declare const GetCategoryQuery: (depth?: number) => import("graphql").DocumentNode;
+export declare const GetCategoryKeyIdQuery: import("graphql").DocumentNode;
+export declare const CreateCategoryMutation: import("graphql").DocumentNode;
+export declare const CreateVaultMutation: import("graphql").DocumentNode;
+export declare const UpdateCategoryMutation: import("graphql").DocumentNode;
+export declare const DeleteCategoryMutation: import("graphql").DocumentNode;
+export declare const ArchiveDirectoryMutation: import("graphql").DocumentNode;
+export declare const UnarchiveDirectoryMutation: import("graphql").DocumentNode;

package/lib/category/category.service.d.ts

@@ -1,67 +1,67 @@
-import { LrApolloService } from '../api/lr-apollo.service';
-import { KeyMetaService } from '../cryptography/key-meta.service';
-import { Category, NewCategory, UpdatedCategory, VaultCategory, VaultRecord, Vault } from './category.types';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-export declare class CategoryService {
-    private lrApollo;
-    private keyMetaService;
-    private keyGraph;
-    constructor(lrApollo: LrApolloService, keyMetaService: KeyMetaService, keyGraph: KeyGraphService);
-    getRootDirectoryIds(input?: {
-        archived: boolean;
-    }): Promise<string[]>;
-    getDefaultVault(): Promise<Vault>;
-    getCategories(input?: {
-        archived: boolean;
-    }): Promise<Category[]>;
-    getTrustedPartyCategories(trustedPartyId: string): Promise<{
-        categories: Category[];
-        records?: VaultRecord[];
-    }>;
-    getMySharedCategories(trustedPartyId: string): Promise<{
-        categories: Category[];
-        records?: VaultRecord[];
-    }>;
-    getCategory(categoryId: string): Promise<VaultCategory>;
-    private mapVaults;
-    private mapCategories;
-    private mapRecords;
-    createDefaultVault(): Promise<string>;
-    createCategory(newCategory: NewCategory): Promise<string>;
-    updateCategory(categoryId: string, keyId: string, updatedCategory: UpdatedCategory): Promise<void>;
-    setCategoryVisibility(categoryId: string, hide: boolean): Promise<void>;
-    deleteCategory(categoryId: string): Promise<void>;
-    archiveCategory(categoryId: string, recursive: boolean): Promise<void>;
-    unarchiveCategory(categoryId: string, recursive: boolean): Promise<void>;
-    archiveDirectory(directoryId: string, recursive: boolean): Promise<void>;
-    unarchiveDirectory(directoryId: string, recursive: boolean): Promise<void>;
-    mapVault(node: {
-        id: any;
-        keyId: any;
-        plainMeta: any;
-        cipherMeta: any;
-    }): Promise<Vault>;
-    mapParentCategories(category: {
-        parentCategories: any;
-    }): Promise<Category[]>;
-    mapCategory(node: {
-        id: any;
-        keyId: any;
-        plainMeta: any;
-        cipherMeta: any;
-        descendantDirectories: any;
-        accessRoles: any[];
-        archived: any;
-    }): Promise<Category>;
-    mapRecord(node: {
-        id: any;
-        keyId: any;
-        plainMeta: any;
-        cipherMeta: any;
-        created: any;
-        modified: any;
-        content: any;
-        accessRoles: any[];
-        archived: any;
-    }): Promise<VaultRecord>;
-}
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { Category, NewCategory, UpdatedCategory, VaultCategory, VaultRecord, Vault } from './category.types';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+export declare class CategoryService {
+    private lrApollo;
+    private keyMetaService;
+    private keyGraph;
+    constructor(lrApollo: LrApolloService, keyMetaService: KeyMetaService, keyGraph: KeyGraphService);
+    getRootDirectoryIds(input?: {
+        archived: boolean;
+    }): Promise<string[]>;
+    getDefaultVault(): Promise<Vault>;
+    getCategories(input?: {
+        archived: boolean;
+    }): Promise<Category[]>;
+    getTrustedPartyCategories(trustedPartyId: string): Promise<{
+        categories: Category[];
+        records?: VaultRecord[];
+    }>;
+    getMySharedCategories(trustedPartyId: string): Promise<{
+        categories: Category[];
+        records?: VaultRecord[];
+    }>;
+    getCategory(categoryId: string): Promise<VaultCategory>;
+    private mapVaults;
+    private mapCategories;
+    private mapRecords;
+    createDefaultVault(): Promise<string>;
+    createCategory(newCategory: NewCategory): Promise<string>;
+    updateCategory(categoryId: string, keyId: string, updatedCategory: UpdatedCategory): Promise<void>;
+    setCategoryVisibility(categoryId: string, hide: boolean): Promise<void>;
+    deleteCategory(categoryId: string): Promise<void>;
+    archiveCategory(categoryId: string, recursive: boolean): Promise<void>;
+    unarchiveCategory(categoryId: string, recursive: boolean): Promise<void>;
+    archiveDirectory(directoryId: string, recursive: boolean): Promise<void>;
+    unarchiveDirectory(directoryId: string, recursive: boolean): Promise<void>;
+    mapVault(node: {
+        id: any;
+        keyId: any;
+        plainMeta: any;
+        cipherMeta: any;
+    }): Promise<Vault>;
+    mapParentCategories(category: {
+        parentCategories: any;
+    }): Promise<Category[]>;
+    mapCategory(node: {
+        id: any;
+        keyId: any;
+        plainMeta: any;
+        cipherMeta: any;
+        descendantDirectories: any;
+        accessRoles: any[];
+        archived: any;
+    }): Promise<Category>;
+    mapRecord(node: {
+        id: any;
+        keyId: any;
+        plainMeta: any;
+        cipherMeta: any;
+        created: any;
+        modified: any;
+        content: any;
+        accessRoles: any[];
+        archived: any;
+    }): Promise<VaultRecord>;
+}