@lifeready/core 5.0.9 → 5.0.11

package/lib/_common/key.d.ts

@@ -0,0 +1,14 @@
+export declare class KeyContainer {
+    private _key;
+    private timer;
+    constructor(_key: CryptoKey, timeout: number);
+    get key(): CryptoKey;
+    /**
+     * Clears the reference to the key, clears the timer, return the key.
+     * It's important to call this function when the key is no longer needed because
+     * the anonymous function in setTimeout() holds a reference to "this", and hence
+     * keeps the "this._key" reference until the timer expired. So if we have used
+     * the key before it expired, we should clear the "this._key" reference immediately.
+     */
+    pop(): CryptoKey;
+}

package/lib/_common/types.d.ts

@@ -1,4 +1,10 @@
+/**
+ * Change a set of specified keys to optional, while the rest remain unchanged
+ */
 export declare type SomePartial<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+/**
+ * Change a set of specified keys to required, while the rest remain unchanged
+ */
 export declare type SomeRequired<T, K extends keyof T> = Pick<Required<T>, K> & Omit<T, K>;
 export interface Edge<T> {
     node: T;

package/lib/api/types/lr-graphql.types.d.ts

@@ -67,6 +67,7 @@ export interface UserNode extends Node {
     availablePlans?: AvailablePlanField[];
     config?: JSONString;
     configJson?: JSONObject;
+    dateJoined?: string;
 }
 export interface UserFeatureState extends TimeStamped {
     notificationsLastViewed?: DateTime;

package/lib/auth/auth.types.d.ts

@@ -45,12 +45,6 @@ export declare class LoginResult {
     user?: CurrentUser;
     resetUser?: TpPasswordResetUserNode;
 }
-export declare class RegisterResult {
-    username: string;
-    userId: string;
-    preSignUpToken: string;
-    userSub: string;
-}
 export declare enum RecoveryStatus {
     NONE = "none",
     NEW_PASSWORD = "new-password",

package/lib/auth2/auth2.gql.private.d.ts

@@ -0,0 +1,12 @@
+import { TpPasswordResetUserNode, UserNode } from '../api/types';
+import { UserKeys } from '../key/key.service';
+export interface CurrentUserQueryResult {
+    currentUser: Pick<Required<UserNode>, 'username' | 'sessionEncryptionKey'> & {
+        currentUserKey: UserKeys;
+    };
+}
+export declare const CurrentUserQuery: import("../_common/ast").TypedDocumentNode<CurrentUserQueryResult>;
+export interface ResetUserQueryResult {
+    tpPasswordResetUser: Pick<Required<TpPasswordResetUserNode>, 'username' | 'sessionEncryptionKey' | 'state' | 'passKey' | 'masterKey' | 'pxk' | 'assembly' | 'approvals' | 'assemblyCipherData' | 'wrappedAssemblyKeyVerifierPrk'>;
+}
+export declare const ResetUserQuery: import("../_common/ast").TypedDocumentNode<ResetUserQueryResult>;

package/lib/auth2/auth2.service.d.ts

@@ -0,0 +1,70 @@
+import { HttpClient } from '@angular/common/http';
+import { Injector, NgZone } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { LrGraphQLService, LrService } from '../api/lr-graphql';
+import { EncryptionService } from '../encryption/encryption.service';
+import { IdleService } from '../idle/idle.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import { KcConfig } from '../life-ready.config';
+import { PasswordService } from '../password/password.service';
+import { PersistService } from '../persist/persist.service';
+import { TpPasswordResetAssemblyController } from '../tp-password-reset/tp-password-reset.controller';
+import { AuthUser, LoginChallenge, LoginOptions, LoginResult, LogoutListener } from './auth2.types';
+export declare class Auth2Service extends LrService {
+    private ngZone;
+    private injector;
+    private http;
+    private cognito;
+    private api;
+    private keyService;
+    private keyGraphService;
+    private keyFactoryService;
+    private passwordService;
+    private idleService;
+    private persistService;
+    private encryptionService;
+    private assemblyController;
+    private kcConfig;
+    static CHALLENGE_TIMEOUT: number;
+    private logoutListeners;
+    private user;
+    private password;
+    constructor(ngZone: NgZone, injector: Injector, http: HttpClient, cognito: AuthClass, api: LrGraphQLService, keyService: KeyService, keyGraphService: KeyGraphService, keyFactoryService: KeyFactoryService, passwordService: PasswordService, idleService: IdleService, persistService: PersistService, encryptionService: EncryptionService, assemblyController: TpPasswordResetAssemblyController, kcConfig: KcConfig);
+    importPassword(plainPassword: string): Promise<CryptoKey>;
+    logout(): Promise<void>;
+    addLogoutListener(callback: LogoutListener): void;
+    removeLogoutListener(callback: LogoutListener): void;
+    login(emailOrPhone: string, password: CryptoKey, { tpPasswordResetAutoComplete }?: LoginOptions): Promise<LoginResult>;
+    verifyLogin(options: {
+        challenge: LoginChallenge;
+        code: string;
+        rememberMe: boolean;
+    }): Promise<LoginResult>;
+    getUser(): Promise<AuthUser>;
+    refreshAccessToken(): Promise<unknown>;
+    private fetchCurrentUser;
+    private fetchResetUser;
+    private kcLogout;
+    private fetchPassIdpParams;
+    private loginImpl;
+    private loginIdp;
+    private loginIdpImpl;
+    private handlePostAuth;
+    private handlePasswordRecovery;
+    private handleSessionEncryptionKey;
+    private getCognitoUserAttribute;
+    private loadUserKeys;
+    private loadUser;
+    private loadRegularUser;
+    private loadResetUser;
+    private recoverAssemblyKey;
+    completeResetRequest(newPassword: CryptoKey): Promise<void>;
+    debugLogin(username: string, password: CryptoKey): Promise<AuthUser>;
+    private debugLoadUser;
+    /**
+     * Clears the caches user. So we can simulate a page refresh and test getUser().
+     */
+    debugClearUser(): void;
+}

package/lib/auth2/auth2.types.d.ts

@@ -0,0 +1,50 @@
+import { CognitoUser } from '@aws-amplify/auth';
+import { JSONObject, TpClaimState, UserNode } from '../api/types';
+import { PassIdpParams } from '../key/key.types';
+export declare type AuthUser = Pick<Required<UserNode>, 'username'> & {
+    sub: string;
+    loginEmail: string;
+    resetUser: null | {
+        state: TpClaimState;
+    };
+};
+export declare type LogoutListener = () => void | Promise<void>;
+export interface LoginOptions {
+    tpPasswordResetAutoComplete?: boolean;
+}
+export declare enum RecoveryStatus {
+    NONE = "NONE",
+    NEW_PASSWORD = "NEW_PASSWORD",
+    OLD_PASSWORD = "OLD_PASSWORD"
+}
+export declare enum PasswordChangeStatus {
+    IN_PROGRESS = "IN_PROGRESS",
+    RECOVERY = "RECOVERY"
+}
+export interface PassIdpResult {
+    passwordChangeStatus?: PasswordChangeStatus;
+    currentPassIdpParams: PassIdpParams;
+    newPassIdpParams: PassIdpParams;
+    tpPasswordReset: {
+        passIdpParams: PassIdpParams;
+        resetUsername: string;
+    };
+}
+export declare enum CognitoChallengeName {
+    NEW_PASSWORD_REQUIRED = "NEW_PASSWORD_REQUIRED",
+    SMS_MFA = "SMS_MFA",
+    SOFTWARE_TOKEN_MFA = "SOFTWARE_TOKEN_MFA",
+    MFA_SETUP = "MFA_SETUP"
+}
+export declare type LrCognitoUser = CognitoUser & {
+    challengeName: CognitoChallengeName;
+    challengeParam: JSONObject;
+};
+export interface LoginChallenge {
+    cognitoUser: LrCognitoUser;
+    recoveryStatus: RecoveryStatus;
+}
+export interface LoginResult {
+    challenge?: LoginChallenge;
+    user?: AuthUser;
+}

package/lib/item2/item2.service.d.ts

@@ -1,7 +1,7 @@
 import { Injector, NgZone } from '@angular/core';
 import { LrMutation, LrService } from '../api/lr-graphql';
 import { ID, LrRelayIdInput } from '../api/types';
-import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { Auth2Service } from '../auth2/auth2.service';
 import { FileUploadService } from '../file-upload/file-upload.service';
 import { KeyFactoryService } from '../key/key-factory.service';
 import { KeyGraphService } from '../key/key-graph.service';
@@ -16,9 +16,9 @@ export declare class Item2Service extends LrService {
     private keyFactory;
     private keyGraph;
     private lockService;
-    private authService;
+    private auth2Service;
     private tempDirectory;
-    constructor(ngZone: NgZone, injector: Injector, fileUploadService: FileUploadService, keyService: KeyService, keyFactory: KeyFactoryService, keyGraph: KeyGraphService, lockService: LockService, authService: LifeReadyAuthService);
+    constructor(ngZone: NgZone, injector: Injector, fileUploadService: FileUploadService, keyService: KeyService, keyFactory: KeyFactoryService, keyGraph: KeyGraphService, lockService: LockService, auth2Service: Auth2Service);
     static TEMP_DIRECTORY_PLAIN_META: {
         kcType: string;
     };

package/lib/key/key-factory.service.d.ts

@@ -7,6 +7,7 @@ export declare class KeyFactoryService {
     private webCryptoService;
     constructor(webCryptoService: WebCryptoService);
     private readonly kcCrypto;
+    private readonly store;
     readonly MIN_PASS_IDP_PBKDF_ITER = 100000;
     readonly MIN_PASS_KEY_PBKDF_ITER = 100000;
     readonly MIN_LBOP_KEY_PBKDF_ITER = 100000;

package/lib/key/key-graph.service.d.ts

@@ -1,9 +1,8 @@
 import { JWK } from 'node-jose';
 import { JSONObject } from '../api/types';
 import { DecryptOptions, EncryptionService } from '../encryption/encryption.service';
-import { CurrentUserKey } from '../profile/profile.types';
 import { KeyFactoryService } from './key-factory.service';
-import { KeyService } from './key.service';
+import { KeyService, UserKeys } from './key.service';
 import { Key, KeyGraphEdge, KeyGraphResponse, PassKey } from './key.types';
 export interface GraphKey extends Key {
     task?: Promise<any>;
@@ -15,7 +14,7 @@ export declare class KeyGraphService {
     private graph;
     constructor(encryptionService: EncryptionService, keyService: KeyService, keyFactory: KeyFactoryService);
     purgeKeys(): void;
-    populateKeys(userKey: CurrentUserKey): Promise<void>;
+    populateKeys(userKey: UserKeys): Promise<void>;
     hasKey(keyId: string): boolean;
     private getNode;
     key(id: any): GraphKey;

package/lib/key/key.service.d.ts

@@ -23,12 +23,12 @@ export declare class KeyService {
     constructor(config: KcConfig, persistService: PersistService);
     resetKeys(): void;
     purgeKeys(): void;
-    populateKeys(keys: UserKeys): void;
-    getCurrentPassKey(): Key;
-    getCurrentMasterKey(): Key;
-    getCurrentRootKey(): Key;
-    getCurrentPxk(): Key;
-    getCurrentSigPxk(): Key;
+    setKeys(keys: UserKeys): void;
+    get currentPassKey(): Key;
+    get currentMasterKey(): Key;
+    get currentRootKey(): Key;
+    get currentPxk(): Key;
+    get currentSigPxk(): Key;
     private expiresAfter;
     persistMasterKey(masterKey: Key, expiresAfterSeconds: number): Promise<void>;
     setMasterKeyExpiresAfterSeconds(seconds: number): Promise<void>;

package/lib/key-exchange/key-exchange.service.d.ts

@@ -1,19 +1,17 @@
 import { LrApolloService } from '../api/lr-apollo.service';
-import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { Auth2Service } from '../auth2/auth2.service';
 import { EncryptionService } from '../encryption/encryption.service';
 import { KeyFactoryService as KFS } from '../key/key-factory.service';
 import { KeyService } from '../key/key.service';
-import { UserService } from '../user/user.service';
 import { CompleteOtk, DecryptedKeyExchange, GetKeyExchangeListOptions, GetKeyExchangeOptions, InitiateOtkInput, KeyExchange, RespondOtk, RespondOtkInput, UserSharedKey } from './key-exchange.types';
 export declare class KeyExchangeService {
     private keyFactory;
     private keyService;
     private lrApollo;
     private encryptionService;
-    private authService;
-    private userService;
+    private auth2Service;
     private readonly CLIENT_NONCE_LENGTH;
-    constructor(keyFactory: KFS, keyService: KeyService, lrApollo: LrApolloService, encryptionService: EncryptionService, authService: LifeReadyAuthService, userService: UserService);
+    constructor(keyFactory: KFS, keyService: KeyService, lrApollo: LrApolloService, encryptionService: EncryptionService, auth2Service: Auth2Service);
     getKeyExchangeList(input?: GetKeyExchangeListOptions): Promise<any>;
     /**
      * @param id If the current user can responder the key exchange if they are either the initiator or the receiver.

package/lib/lbop/lbop.service.d.ts

@@ -2,7 +2,7 @@ import { HttpClient } from '@angular/common/http';
 import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
 import { JWK } from 'node-jose';
 import { LrApolloService } from '../api/lr-apollo.service';
-import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { Auth2Service } from '../auth2/auth2.service';
 import { EncryptionService } from '../encryption/encryption.service';
 import { KeyFactoryService as KFS } from '../key/key-factory.service';
 import { KeyGraphService } from '../key/key-graph.service';
@@ -80,7 +80,7 @@ export declare class LbopService {
     private http;
     private lrApollo;
     private auth;
-    private authService;
+    private auth2Service;
     private keyFactory;
     private keyService;
     private encryptionService;
@@ -88,7 +88,7 @@ export declare class LbopService {
     private passwordService;
     private readonly CLIENT_NONCE_LENGTH;
     private readonly LBOP_WORDS;
-    constructor(config: KcConfig, http: HttpClient, lrApollo: LrApolloService, auth: AuthClass, authService: LifeReadyAuthService, keyFactory: KFS, keyService: KeyService, encryptionService: EncryptionService, keyGraph: KeyGraphService, passwordService: PasswordService);
+    constructor(config: KcConfig, http: HttpClient, lrApollo: LrApolloService, auth: AuthClass, auth2Service: Auth2Service, keyFactory: KFS, keyService: KeyService, encryptionService: EncryptionService, keyGraph: KeyGraphService, passwordService: PasswordService);
     private getPartial;
     remove(id: string): Promise<string>;
     update({ id, name }: UpdateLbopParams): Promise<Lbop>;

package/lib/profile/profile.types.d.ts

@@ -9,8 +9,8 @@ export declare class Features {
     shareVault: FeatureAction[];
 }
 export declare class CurrentUserKey {
-    passKey?: PassKey;
-    masterKey?: {
+    passKey: PassKey;
+    masterKey: {
         id: string;
     };
     rootKey?: {

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

@@ -1,10 +1,10 @@
 import { HttpClient } from '@angular/common/http';
 import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
-import { RegisterResult } from '../auth/auth.types';
 import { EncryptionService } from '../encryption/encryption.service';
 import { KeyFactoryService } from '../key/key-factory.service';
 import { KcConfig } from '../life-ready.config';
 import { PasswordService } from '../password/password.service';
+import { RegisterResult } from './register.types';
 export declare class RegisterService {
     private config;
     private auth;

package/lib/register/register.types.d.ts

@@ -0,0 +1,6 @@
+export declare class RegisterResult {
+    username: string;
+    userId: string;
+    preSignUpToken: string;
+    userSub: string;
+}

package/lib/server-config/server-config.gql.d.ts

@@ -1,5 +1,5 @@
 import { ServerConfig } from '../api/types';
 export interface ServerConfigQueryResult {
-    serverConfig: Pick<ServerConfig, 'relayConnectionMaxLimit'>;
+    serverConfig: Pick<Required<ServerConfig>, 'relayConnectionMaxLimit'>;
 }
 export declare const ServerConfigQuery: import("../_common/ast").TypedDocumentNode<ServerConfigQueryResult>;

package/lib/server-config/server-config.service.d.ts

@@ -5,5 +5,5 @@ export declare class ServerConfigService extends LrService {
     private injector;
     private serverConfig;
     constructor(ngZone: NgZone, injector: Injector);
-    getConfig(): Promise<Pick<import("../api/types").ServerConfig, "relayConnectionMaxLimit">>;
+    getConfig(): Promise<Pick<Required<import("../api/types").ServerConfig>, "relayConnectionMaxLimit">>;
 }

package/lib/shared-contact-card/shared-contact-card.service.d.ts

@@ -1,3 +1,5 @@
+import { LrApolloService } from '../api/lr-apollo.service';
+import { JSONObject } from '../api/types';
 import { EncryptionService } from '../encryption/encryption.service';
 import { KeyGraphService } from '../key/key-graph.service';
 import { KeyService } from '../key/key.service';
@@ -5,8 +7,6 @@ import { Key } from '../key/key.types';
 import { TrustedPartyDetails } from '../profile/profile.types';
 import { SharedTrustedPartyDetails } from '../trusted-party/trusted-party.types';
 import { User } from '../user/user.types';
-import { LrApolloService } from '../api/lr-apollo.service';
-import { JSONObject } from '../api/types';
 export declare const SharedContactCardFields = "\n  id\n  owner {\n    id\n    username\n  }\n  ownerKey {\n    id\n  }\n  ownerCipherData\n  receiver {\n    id\n    username\n  }\n  receiverKey {\n    id\n  }\n  receiverCipherData\n  sharedKey {\n    id\n  }\n  sharedCipherData\n  sharedCipherDataSig\n  sharedCipherDataSigPxk {\n    id\n  }\n";
 export interface SharedContactCard {
     id: string;