@lifeready/core 0.6.0-beta.1

package/lib/api/lr-graphql/lr-mutation-base.d.ts

@@ -0,0 +1,28 @@
+import { OperationVariables } from '@apollo/client/core';
+import { FragmentSpreadNode } from 'graphql';
+import { TypedDocumentNode } from '../../_common/ast';
+import { DeferredPromise } from '../../_common/deferred-promise';
+export interface LrMutationData<T, TVariables = OperationVariables> {
+    mutation: TypedDocumentNode<T>;
+    variables?: TVariables;
+}
+export declare const fragmentSpreadAstSelection: FragmentSpreadNode;
+/**
+ * DECISION: LrMutationBase does not provide a convenience method to call lrGraphQL.lrMutate()
+ * because this class could be made independent of what lib is used to call the API. If we
+ * provided a configurable call back to make the API call, then the typing for that callback
+ * needs to be known. But since the API lib (eg. Apollo) has it's own unique return type, so
+ * it's not possible to do in general.
+ */
+export declare abstract class LrMutationBase<T, TVariables = OperationVariables> {
+    protected mutation: TypedDocumentNode<T>;
+    protected variables?: TVariables;
+    protected _executed: boolean;
+    readonly deferredPromise: DeferredPromise<T>;
+    get promise(): Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: any): void;
+    get lrMutationData(): LrMutationData<T, TVariables>;
+    get executed(): boolean;
+    setExecuted(): void;
+}

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

@@ -0,0 +1,8 @@
+import { OperationVariables } from '@apollo/client/core';
+import { TypedDocumentNode } from '../../_common/ast';
+import { LrMutationData } from './lr-mutation-base';
+import { LrMutationBase } from './lr-mutation-base';
+export declare class LrMutation<T extends any, TVariables = OperationVariables> extends LrMutationBase<T, TVariables> {
+    constructor(options: LrMutationData<T, TVariables>);
+    select<TResult>(fragments: TypedDocumentNode<TResult>): LrMutation<TResult, TVariables>;
+}

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

@@ -0,0 +1,9 @@
+import { Injector } from '@angular/core';
+import { LrGraphQLService, LrMutationOptions, LrQueryOptions } from './lr-graphql.service';
+import { LrMutationBase } from './lr-mutation-base';
+export declare class LrService {
+    protected lrGraphQL: LrGraphQLService;
+    constructor(injector: Injector);
+    protected mutate<T, TVariables>(lrMutation: LrMutationBase<T, TVariables> | Promise<LrMutationBase<T, TVariables>>, options?: LrMutationOptions<T, TVariables>): Promise<T>;
+    protected query<T, V>(options: LrQueryOptions<T, V>): Promise<T>;
+}

package/lib/api/message.service.d.ts

@@ -0,0 +1,58 @@
+import { JWK } from 'node-jose';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyExchangeService } from './key-exchange.service';
+import { LrApolloService } from './lr-apollo.service';
+export declare const SendMessageMutation: import("graphql").DocumentNode;
+export declare const MessageQuery: import("graphql").DocumentNode;
+export interface SendMessage {
+    message: {
+        id: string;
+    };
+}
+export interface SendMessageInput {
+    username?: string;
+    userId?: string;
+    plainMessageJson?: any;
+    plainCipherMessageJson?: any;
+}
+export interface Message {
+    id: string;
+    sender: {
+        id: string;
+        username: string;
+    };
+    receiver: {
+        id: string;
+        username: string;
+    };
+    plainMessage: string;
+    plainMessageJson?: any;
+    signedCipherMessage: string;
+    plainSignedCipherMessageJson?: any;
+    senderSigPbk: {
+        id: string;
+    };
+    sharedKey: {
+        id: string;
+    };
+}
+interface DecryptMessageOptions {
+    sharedKey: JWK.Key;
+    senderSigPbk: JWK.Key;
+}
+export declare class MessageService {
+    private lrApollo;
+    private keyGraph;
+    private encryptionService;
+    private keyExchangeService;
+    private readonly encrypt;
+    private readonly decrypt;
+    private readonly sign;
+    private readonly verify;
+    constructor(lrApollo: LrApolloService, keyGraph: KeyGraphService, encryptionService: EncryptionService, keyExchangeService: KeyExchangeService);
+    sendMessage({ username, userId, plainMessageJson, plainCipherMessageJson, }: SendMessageInput): Promise<SendMessage>;
+    decryptMessage(message: Message, { sharedKey, senderSigPbk }: DecryptMessageOptions): Promise<void>;
+    getMessage(id: string): Promise<Message>;
+}
+export {};

package/lib/api/persist.service.d.ts

@@ -0,0 +1,31 @@
+import { JWK } from 'node-jose';
+import { Injector } from '@angular/core';
+import { CookieService } from 'ngx-cookie-service';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+export declare class PersistService {
+    private keyFactory;
+    private cookieService;
+    private encryptionService;
+    private injector;
+    private readonly KEY_PREFIX;
+    private cookieSecure;
+    private serverSessionEncryptionKey;
+    constructor(keyFactory: KFS, cookieService: CookieService, encryptionService: EncryptionService, injector: Injector);
+    setServerSessionEncryptionKey(key: JWK.Key): void;
+    clearServerSessionEncryptionKey(): void;
+    private getCookieParams;
+    clear(): void;
+    setCookieSecure(value: boolean): void;
+    private prefixName;
+    delete(name: string): void;
+    private deletePrefixedName;
+    set({ name, value, serverSession, expiry, }: {
+        name: string;
+        value: any;
+        serverSession: boolean;
+        expiry?: Date;
+    }): Promise<void>;
+    get(name: string): Promise<any>;
+    private getImpl;
+}

package/lib/api/query-processor/common-processors.service.d.ts

@@ -0,0 +1,36 @@
+import { NgZone } from '@angular/core';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { Connection } from '../types';
+export interface ProcessorOptions {
+    hasKeys: boolean;
+}
+export declare const DefaultProcessorOptions: ProcessorOptions;
+export interface ProcessorContext {
+    path: ReadonlyArray<string>;
+    processChildren: boolean;
+}
+export interface ProcessorCallbackParams<T = any> {
+    field: T;
+    context: ProcessorContext;
+    options: ProcessorOptions;
+}
+export declare type ProcessorCallback<T = any> = (params: ProcessorCallbackParams<T>) => T | Promise<T>;
+interface ParseJsonProcessorOptions {
+    plainFieldName?: string;
+    jsonFieldSuffix?: string;
+}
+interface DecryptionProcessorOptions {
+    cipherFieldName?: string;
+    clearFieldSuffix?: string;
+    getKeyId?: (params: ProcessorCallbackParams) => Promise<string> | string;
+}
+export declare function processConnection<Node>(field: Connection<Node>, processNode: (node: Node) => Node | Promise<Node>): Promise<Connection<Node>>;
+export declare class CommonProcessorsService {
+    private ngZone;
+    private keyGraph;
+    constructor(ngZone: NgZone, keyGraph: KeyGraphService);
+    series(processors: ProcessorCallback[]): ProcessorCallback;
+    makeJsonParseProcessor({ plainFieldName, jsonFieldSuffix, }?: ParseJsonProcessorOptions): ProcessorCallback;
+    makeDecryptionProcessor({ cipherFieldName, clearFieldSuffix, getKeyId, }?: DecryptionProcessorOptions): ProcessorCallback;
+}
+export {};

package/lib/api/query-processor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './query-processor.service';
+export * from './common-processors.service';

package/lib/api/query-processor/query-processor.service.d.ts

@@ -0,0 +1,18 @@
+import { NgZone } from '@angular/core';
+import { KeyService } from '../../cryptography/key.service';
+import { CommonProcessorsService, ProcessorOptions } from './common-processors.service';
+import { TpPasswordResetProcessorService } from './tp-password-reset-processor.service';
+export declare class QueryProcessorService {
+    private ngZone;
+    private keyService;
+    private common;
+    private tpprProcessor;
+    readonly TYPENAME = "__typename";
+    private processors;
+    constructor(ngZone: NgZone, keyService: KeyService, common: CommonProcessorsService, tpprProcessor: TpPasswordResetProcessorService);
+    processQuery(fields: {
+        [key: string]: any;
+    }, options: ProcessorOptions): Promise<any>;
+    private processField;
+    private registerProcessor;
+}

package/lib/api/query-processor/tp-password-reset-processor.service.d.ts

@@ -0,0 +1,15 @@
+import { NgZone } from '@angular/core';
+import { KeyGraphService } from '../../cryptography/key-graph.service';
+import { ProcessorCallbackParams } from './common-processors.service';
+import { TpPasswordResetUserNode, TpPasswordResetNode } from '../types';
+export declare class TpPasswordResetProcessorService {
+    private ngZone;
+    private keyGraph;
+    constructor(ngZone: NgZone, keyGraph: KeyGraphService);
+    processTpPasswordResetUserNode(node: TpPasswordResetUserNode): Promise<TpPasswordResetUserNode>;
+    private processTpPasswordResetUserApprovalNode;
+    makeTpPasswordResetNodeProcessor(): ({ field, }: ProcessorCallbackParams) => Promise<TpPasswordResetNode>;
+    private processTpAssemblyNode;
+    private processTpSubAssemblyNode;
+    private processTpAssemblyApproverNode;
+}

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

@@ -0,0 +1,33 @@
+import { Key } from '../cryptography/cryptography.types';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { SharedTrustedPartyDetails } from '../trusted-parties/trusted-party.types';
+import { TrustedPartyDetails } from '../users/profile.types';
+import { User } from '../users/user.types';
+import { LrApolloService } from './lr-apollo.service';
+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;
+    owner: User;
+    ownerKey: Key;
+    ownerCipherData: string;
+    receiver: User;
+    receiverKey: Key;
+    receiverCipherData: string;
+    sharedKey: Key;
+    sharedCipherData: string;
+    plainOwnerCipherDataJson: any;
+    plainReceiverCipherDataJson: any;
+    plainSharedCipherDataJson: any;
+}
+export declare class SharedContactCardService {
+    private keyService;
+    private lrApollo;
+    private keyGraph;
+    private encryptionService;
+    constructor(keyService: KeyService, lrApollo: LrApolloService, keyGraph: KeyGraphService, encryptionService: EncryptionService);
+    decryptSharedTrustedPartyDetails(cc: SharedContactCard): Promise<SharedTrustedPartyDetails>;
+    decryptTrustedPartyDetails(cc: SharedContactCard): Promise<TrustedPartyDetails>;
+    updateMySharedContactCard(id: string, ownedKeyId: string, sharedKeyId: string, contactCard: TrustedPartyDetails): Promise<void>;
+}

package/lib/api/shared-contact-card2.gql.d.ts

@@ -0,0 +1,36 @@
+import { ID } from './types';
+export interface UpdateOwnedContactCardMutation {
+    updateOwnedContactCard: {
+        ownedContactCard: {
+            id: ID;
+        };
+    };
+}
+export declare const UpdateOwnedContactCardMutation: import("../_common/ast").TypedDocumentNode<UpdateOwnedContactCardMutation>;
+export interface UpdateReceivedContactCardMutation {
+    updateReceivedContactCard: {
+        receivedContactCard: {
+            id: ID;
+        };
+    };
+}
+export declare const UpdateReceivedContactCardMutation: import("../_common/ast").TypedDocumentNode<UpdateReceivedContactCardMutation>;
+export interface GetOwnedContactCardKeyIdsQuery {
+    ownedContactCard: {
+        sharedKey: {
+            id: ID;
+        };
+        ownerKey: {
+            id: ID;
+        };
+    };
+}
+export declare const GetOwnedContactCardKeyIdsQuery: import("../_common/ast").TypedDocumentNode<GetOwnedContactCardKeyIdsQuery>;
+export interface GetReceivedContactCardKeyIdQuery {
+    receivedContactCard: {
+        receiverKey: {
+            id: ID;
+        };
+    };
+}
+export declare const GetReceivedContactCardKeyIdQuery: import("../_common/ast").TypedDocumentNode<GetReceivedContactCardKeyIdQuery>;

package/lib/api/shared-contact-card2.service.d.ts

@@ -0,0 +1,45 @@
+import { NgZone } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { ContactCardReceiverCipherData, SendContactCardInput } from './key-exchange2.service';
+import { LrGraphQLService, LrMutation } from './lr-graphql';
+import { UpdateOwnedContactCardMutation, UpdateReceivedContactCardMutation } from './shared-contact-card2.gql';
+import { LrRelayIdInput } from './types';
+export interface UpdateOwnedContactCardInput extends SendContactCardInput {
+    id: LrRelayIdInput;
+    ownerKeyId?: LrRelayIdInput;
+    sharedKeyId?: LrRelayIdInput;
+}
+export interface UpdateReceivedContactCardInput extends ContactCardReceiverCipherData {
+    id: LrRelayIdInput;
+    receiverKeyId?: LrRelayIdInput;
+}
+export declare class SharedContactCard2Service {
+    private ngZone;
+    private keyService;
+    private keyGraph;
+    private encryptionService;
+    private lrGraphQL;
+    constructor(ngZone: NgZone, keyService: KeyService, keyGraph: KeyGraphService, encryptionService: EncryptionService, lrGraphQL: LrGraphQLService);
+    private getOwnedContactCardKeyIds;
+    private getReceivedContactCardKeyId;
+    updateOwnedContactCard({ id, ownerKeyId, sharedKeyId, ownerPlainDataJson, ownerCipherDataClearJson, sharedCipherDataClearJson, }: UpdateOwnedContactCardInput): Promise<LrMutation<UpdateOwnedContactCardMutation, {
+        input: {
+            id: string;
+            ownerCipherData: string;
+            ownerKeyId: string;
+            sharedCipherDataSig: string;
+            sharedKeyId: string;
+            sigPxkId: string;
+            ownerPlainDataSig: string;
+        };
+    }>>;
+    updateReceivedContactCard({ id, receiverKeyId, receiverCipherDataClearJson, }: UpdateReceivedContactCardInput): Promise<LrMutation<UpdateReceivedContactCardMutation, {
+        input: {
+            id: string;
+            receiverCipherData: string;
+            receiverKeyId: string;
+        };
+    }>>;
+}

package/lib/api/time.service.d.ts

@@ -0,0 +1,16 @@
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { Apollo } from 'apollo-angular';
+export declare const ServerTimeQuery: import("graphql").DocumentNode;
+export declare class TimeService {
+    private auth;
+    private apollo;
+    VERIFY_ENABLED: boolean;
+    private readonly MAX_DIFF_MSEC;
+    offsetMs: number;
+    verified: boolean;
+    constructor(auth: AuthClass, apollo: Apollo);
+    private getAccessToken;
+    private verifyCognito;
+    private refresh;
+    serverNow(): Promise<number>;
+}

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

@@ -0,0 +1,29 @@
+export declare type ID = string;
+export declare type LrRelayIdInput = string;
+export declare type DateTime = string;
+export declare type LrJSONString = string;
+export declare type JSONString = string;
+export declare type LrEmail = string;
+export declare type GenericScalar = any;
+export declare type UUID = string;
+export interface Node {
+    id?: string;
+}
+export interface TimeStamped {
+    created?: DateTime;
+    modified?: DateTime;
+}
+export interface Edge<NodeType extends Node> {
+    node?: NodeType;
+    cursor?: string;
+}
+export interface Connection<NodeType> {
+    pageInfo?: PageInfo;
+    edges?: Edge<NodeType>[];
+}
+export interface PageInfo {
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+    startCursor?: string;
+    endCursor?: string;
+}

package/lib/api/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './graphql.types';
+export * from './lr-graphql.types';