@sprucelabs/mercury-client 42.0.557 → 42.0.559

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -0,0 +1,324 @@
+import { default as SchemaEntity } from '@sprucelabs/schema';
+import * as SpruceSchema from '@sprucelabs/schema';
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnknownError {
+    }
+    interface UnknownErrorSchema extends SpruceSchema.Schema {
+        id: 'unknownError';
+        namespace: 'MercuryClient';
+        name: 'Unknown error';
+        fields: {};
+    }
+    type UnknownErrorEntity = SchemaEntity<SpruceErrors.MercuryClient.UnknownErrorSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnexpectedPayload {
+        'eventName': string;
+    }
+    interface UnexpectedPayloadSchema extends SpruceSchema.Schema {
+        id: 'unexpectedPayload';
+        namespace: 'MercuryClient';
+        name: 'Unexpected payload';
+        fields: {
+            /** . */
+            'eventName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type UnexpectedPayloadEntity = SchemaEntity<SpruceErrors.MercuryClient.UnexpectedPayloadSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnauthorizedTarget {
+        'locationId'?: string | undefined | null;
+        'personId'?: string | undefined | null;
+        'organizationId'?: string | undefined | null;
+        'skillId'?: string | undefined | null;
+        'roleId'?: string | undefined | null;
+    }
+    interface UnauthorizedTargetSchema extends SpruceSchema.Schema {
+        id: 'unauthorizedTarget';
+        namespace: 'MercuryClient';
+        name: '';
+        fields: {
+            /** . */
+            'locationId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'personId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'organizationId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'skillId': {
+                type: 'id';
+                options: undefined;
+            };
+            /** . */
+            'roleId': {
+                type: 'id';
+                options: undefined;
+            };
+        };
+    }
+    type UnauthorizedTargetEntity = SchemaEntity<SpruceErrors.MercuryClient.UnauthorizedTargetSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface UnauthorizedAccess {
+        'fqen': string;
+        'action': ("emit");
+        'target': SpruceErrors.MercuryClient.UnauthorizedTarget;
+        'permissionContractId': string;
+    }
+    interface UnauthorizedAccessSchema extends SpruceSchema.Schema {
+        id: 'unauthorizedAccess';
+        namespace: 'MercuryClient';
+        name: 'Unauthorized Access';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'action': {
+                type: 'select';
+                isRequired: true;
+                options: {
+                    choices: [{
+                        "value": "emit";
+                        "label": "emit";
+                    }];
+                };
+            };
+            /** . */
+            'target': {
+                type: 'schema';
+                isRequired: true;
+                options: {
+                    schema: SpruceErrors.MercuryClient.UnauthorizedTargetSchema;
+                };
+            };
+            /** . */
+            'permissionContractId': {
+                type: 'id';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type UnauthorizedAccessEntity = SchemaEntity<SpruceErrors.MercuryClient.UnauthorizedAccessSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface Timeout {
+        'eventName': string;
+        'timeoutMs': number;
+        'isConnected'?: boolean | undefined | null;
+        'totalRetries'?: number | undefined | null;
+    }
+    interface TimeoutSchema extends SpruceSchema.Schema {
+        id: 'timeout';
+        namespace: 'MercuryClient';
+        name: 'Timeout';
+        fields: {
+            /** . */
+            'eventName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'timeoutMs': {
+                type: 'number';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'isConnected': {
+                type: 'boolean';
+                options: undefined;
+            };
+            /** . */
+            'totalRetries': {
+                type: 'number';
+                options: undefined;
+            };
+        };
+    }
+    type TimeoutEntity = SchemaEntity<SpruceErrors.MercuryClient.TimeoutSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface NotConnected {
+        'action': string;
+        'fqen': string;
+    }
+    interface NotConnectedSchema extends SpruceSchema.Schema {
+        id: 'notConnected';
+        namespace: 'MercuryClient';
+        name: 'Not connected';
+        fields: {
+            /** . */
+            'action': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'fqen': {
+                type: 'id';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type NotConnectedEntity = SchemaEntity<SpruceErrors.MercuryClient.NotConnectedSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface MustHandleLocally {
+        'fqen': string;
+    }
+    interface MustHandleLocallySchema extends SpruceSchema.Schema {
+        id: 'mustHandleLocally';
+        namespace: 'MercuryClient';
+        name: 'Must handle locally';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type MustHandleLocallyEntity = SchemaEntity<SpruceErrors.MercuryClient.MustHandleLocallySchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface MustCreateEvent {
+        'fqen': string;
+    }
+    interface MustCreateEventSchema extends SpruceSchema.Schema {
+        id: 'mustCreateEvent';
+        namespace: 'MercuryClient';
+        name: 'must create event';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type MustCreateEventEntity = SchemaEntity<SpruceErrors.MercuryClient.MustCreateEventSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface MissingTestCacheDir {
+    }
+    interface MissingTestCacheDirSchema extends SpruceSchema.Schema {
+        id: 'missingTestCacheDir';
+        namespace: 'MercuryClient';
+        name: 'Missing test cache dir';
+        fields: {};
+    }
+    type MissingTestCacheDirEntity = SchemaEntity<SpruceErrors.MercuryClient.MissingTestCacheDirSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface InvalidProtocol {
+        'uri': string;
+    }
+    interface InvalidProtocolSchema extends SpruceSchema.Schema {
+        id: 'invalidProtocol';
+        namespace: 'MercuryClient';
+        name: 'Invalid protocol';
+        fields: {
+            /** . */
+            'uri': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidProtocolEntity = SchemaEntity<SpruceErrors.MercuryClient.InvalidProtocolSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface InvalidPayload {
+        'eventName': string;
+    }
+    interface InvalidPayloadSchema extends SpruceSchema.Schema {
+        id: 'invalidPayload';
+        namespace: 'MercuryClient';
+        name: 'Invalid payload';
+        fields: {
+            /** . */
+            'eventName': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidPayloadEntity = SchemaEntity<SpruceErrors.MercuryClient.InvalidPayloadSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface InvalidEventSignature {
+        'fqen': string;
+        'instructions': string;
+    }
+    interface InvalidEventSignatureSchema extends SpruceSchema.Schema {
+        id: 'invalidEventSignature';
+        namespace: 'MercuryClient';
+        name: 'Invalid event contract';
+        fields: {
+            /** . */
+            'fqen': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'instructions': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type InvalidEventSignatureEntity = SchemaEntity<SpruceErrors.MercuryClient.InvalidEventSignatureSchema>;
+}
+export declare namespace SpruceErrors.MercuryClient {
+    interface ConnectionFailed {
+        'host': string;
+        'statusCode': number;
+    }
+    interface ConnectionFailedSchema extends SpruceSchema.Schema {
+        id: 'connectionFailed';
+        namespace: 'MercuryClient';
+        name: 'Connection failed';
+        fields: {
+            /** . */
+            'host': {
+                type: 'text';
+                isRequired: true;
+                options: undefined;
+            };
+            /** . */
+            'statusCode': {
+                type: 'number';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type ConnectionFailedEntity = SchemaEntity<SpruceErrors.MercuryClient.ConnectionFailedSchema>;
+}

package/build/esm/.spruce/errors/errors.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/.spruce/errors/options.types.d.ts

@@ -0,0 +1,40 @@
+import { SpruceErrors } from "./errors.types";
+import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
+export interface UnknownErrorErrorOptions extends SpruceErrors.MercuryClient.UnknownError, ISpruceErrorOptions {
+    code: 'UNKNOWN_ERROR';
+}
+export interface UnexpectedPayloadErrorOptions extends SpruceErrors.MercuryClient.UnexpectedPayload, ISpruceErrorOptions {
+    code: 'UNEXPECTED_PAYLOAD';
+}
+export interface UnauthorizedAccessErrorOptions extends SpruceErrors.MercuryClient.UnauthorizedAccess, ISpruceErrorOptions {
+    code: 'UNAUTHORIZED_ACCESS';
+}
+export interface TimeoutErrorOptions extends SpruceErrors.MercuryClient.Timeout, ISpruceErrorOptions {
+    code: 'TIMEOUT';
+}
+export interface NotConnectedErrorOptions extends SpruceErrors.MercuryClient.NotConnected, ISpruceErrorOptions {
+    code: 'NOT_CONNECTED';
+}
+export interface MustHandleLocallyErrorOptions extends SpruceErrors.MercuryClient.MustHandleLocally, ISpruceErrorOptions {
+    code: 'MUST_HANDLE_LOCALLY';
+}
+export interface MustCreateEventErrorOptions extends SpruceErrors.MercuryClient.MustCreateEvent, ISpruceErrorOptions {
+    code: 'MUST_CREATE_EVENT';
+}
+export interface MissingTestCacheDirErrorOptions extends SpruceErrors.MercuryClient.MissingTestCacheDir, ISpruceErrorOptions {
+    code: 'MISSING_TEST_CACHE_DIR';
+}
+export interface InvalidProtocolErrorOptions extends SpruceErrors.MercuryClient.InvalidProtocol, ISpruceErrorOptions {
+    code: 'INVALID_PROTOCOL';
+}
+export interface InvalidPayloadErrorOptions extends SpruceErrors.MercuryClient.InvalidPayload, ISpruceErrorOptions {
+    code: 'INVALID_PAYLOAD';
+}
+export interface InvalidEventSignatureErrorOptions extends SpruceErrors.MercuryClient.InvalidEventSignature, ISpruceErrorOptions {
+    code: 'INVALID_EVENT_SIGNATURE';
+}
+export interface ConnectionFailedErrorOptions extends SpruceErrors.MercuryClient.ConnectionFailed, ISpruceErrorOptions {
+    code: 'CONNECTION_FAILED';
+}
+type ErrorOptions = UnknownErrorErrorOptions | UnexpectedPayloadErrorOptions | UnauthorizedAccessErrorOptions | TimeoutErrorOptions | NotConnectedErrorOptions | MustHandleLocallyErrorOptions | MustCreateEventErrorOptions | MissingTestCacheDirErrorOptions | InvalidProtocolErrorOptions | InvalidPayloadErrorOptions | InvalidEventSignatureErrorOptions | ConnectionFailedErrorOptions;
+export default ErrorOptions;

package/build/esm/.spruce/errors/options.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/clients/MercuryClientFactory.d.ts

@@ -0,0 +1,26 @@
+import { EventContract, SkillEventContract } from '@sprucelabs/mercury-types';
+import { ConnectionOptions, MercuryClient } from '../types/client.types';
+import MutableContractClient from './MutableContractClient';
+export default class MercuryClientFactory {
+    private static isTestMode;
+    private static defaultContract;
+    private static timeoutMs;
+    private static totalClients;
+    private static clients;
+    static ClientClass: new (...args: any[]) => MutableContractClient<EventContract>;
+    static Client<Contract extends SkillEventContract = SkillEventContract>(connectionOptions?: ConnectionOptions): Promise<Client<Contract>>;
+    static isInTestMode(): boolean;
+    static setIsTestMode(isTestMode: boolean): void;
+    static setDefaultContract(contract: EventContract): void;
+    static hasDefaultContract(): boolean;
+    static clearDefaultContract(): void;
+    private static resetTestClient;
+    static setDefaultTimeoutMs(ms: number): void;
+    static getTotalClients(): number;
+    static reset(): void;
+    static getClients(): Client<import("@sprucelabs/mercury-types").SpruceSchemas.Mercury.v2020_12_25.EventContract>[];
+}
+export type Client<Contract extends EventContract> = MercuryClient<Contract> & {
+    doesHandleEvent(eventName: string): boolean;
+    mixinContract(eventContract: EventContract): void;
+};

package/build/esm/clients/MercuryClientFactory.js

@@ -0,0 +1,96 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SchemaError } from '@sprucelabs/schema';
+import { eventContractUtil } from '@sprucelabs/spruce-event-utils';
+import { DEFAULT_HOST } from '../constants.js';
+import SpruceError from '../errors/SpruceError.js';
+import MutableContractClient from './MutableContractClient.js';
+class MercuryClientFactory {
+    static Client(connectionOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { host: hostOption, contracts, reconnectDelayMs, allowSelfSignedCrt, emitTimeoutMs = this.timeoutMs, shouldReconnect, maxEmitRetries, connectionRetries, } = connectionOptions || {};
+            const host = hostOption !== null && hostOption !== void 0 ? hostOption : DEFAULT_HOST;
+            if (host.substr(0, 4) !== 'http') {
+                throw new SpruceError({ code: 'INVALID_PROTOCOL', uri: host });
+            }
+            if (contracts && !Array.isArray(contracts)) {
+                throw new SchemaError({
+                    code: 'INVALID_PARAMETERS',
+                    parameters: ['contracts'],
+                });
+            }
+            const eventContract = !contracts && this.defaultContract
+                ? this.defaultContract
+                : //@ts-ignore
+                    eventContractUtil.unifyContracts(contracts !== null && contracts !== void 0 ? contracts : []);
+            let Client = MutableContractClient;
+            if (this.isTestMode) {
+                //TODO, make this something fitxures sets to make the test client available
+                Client = require('../clients/MercuryTestClient.js').default;
+            }
+            const client = new ((_a = MercuryClientFactory.ClientClass) !== null && _a !== void 0 ? _a : 
+            //@ts-ignore
+            Client)({
+                host,
+                reconnection: false,
+                reconnectDelayMs,
+                rejectUnauthorized: !allowSelfSignedCrt,
+                eventContract,
+                emitTimeoutMs,
+                shouldReconnect,
+                maxEmitRetries,
+                connectionRetries,
+            });
+            yield client.connect();
+            this.totalClients++;
+            this.clients.push(client);
+            return client;
+        });
+    }
+    static isInTestMode() {
+        return this.isTestMode;
+    }
+    static setIsTestMode(isTestMode) {
+        this.isTestMode = isTestMode;
+    }
+    static setDefaultContract(contract) {
+        this.defaultContract = contract;
+    }
+    static hasDefaultContract() {
+        return !!this.defaultContract;
+    }
+    static clearDefaultContract() {
+        this.defaultContract = undefined;
+    }
+    static resetTestClient() {
+        const Client = require('../clients/MercuryTestClient.js').default;
+        Client.reset();
+    }
+    static setDefaultTimeoutMs(ms) {
+        this.timeoutMs = ms;
+    }
+    static getTotalClients() {
+        return this.totalClients;
+    }
+    static reset() {
+        this.totalClients = 0;
+        this.clients = [];
+        this.resetTestClient();
+    }
+    static getClients() {
+        return this.clients;
+    }
+}
+MercuryClientFactory.isTestMode = false;
+MercuryClientFactory.timeoutMs = 30000;
+MercuryClientFactory.totalClients = 0;
+MercuryClientFactory.clients = [];
+export default MercuryClientFactory;

package/build/esm/clients/MercurySocketIoClient.d.ts

@@ -0,0 +1,89 @@
+import { EmitCallback, EventContract, EventName, EventSignature, MercuryAggregateResponse, SpruceSchemas } from '@sprucelabs/mercury-types';
+import { Schema, SchemaValues } from '@sprucelabs/schema';
+import { io, SocketOptions, ManagerOptions } from 'socket.io-client';
+import { ConnectionOptions, MercuryClient } from '../types/client.types';
+export default class MercurySocketIoClient<Contract extends EventContract> implements MercuryClient<Contract> {
+    protected _eventContract?: Contract;
+    protected get eventContract(): Contract;
+    protected set eventContract(contract: Contract);
+    static io: typeof io;
+    private log;
+    private host;
+    private ioOptions;
+    private socket?;
+    private proxyToken;
+    private emitTimeoutMs;
+    private reconnectDelayMs;
+    private listenerMap;
+    private isReAuthing;
+    private reconnectPromise;
+    protected lastAuthOptions?: {
+        skillId?: string | undefined;
+        apiKey?: string | undefined;
+        token?: string | undefined;
+    };
+    private shouldReconnect;
+    private connectionRetriesRemaining;
+    private connectionRetries;
+    private registeredListeners;
+    private allowNextEventToBeAuthenticate;
+    protected auth?: {
+        skill?: SpruceSchemas.Spruce.v2020_07_22.Skill;
+        person?: SpruceSchemas.Spruce.v2020_07_22.Person;
+    };
+    private shouldAutoRegisterListeners;
+    private isManuallyDisconnected;
+    private isReconnecting;
+    private id;
+    private skipWaitIfReconnecting;
+    private maxEmitRetries;
+    private authRawResults?;
+    protected authPromise?: any;
+    protected shouldRegisterProxyOnReconnect: boolean;
+    private reconnectKey?;
+    constructor(options: {
+        host: string;
+        eventContract?: Contract;
+    } & IoOptions);
+    connect(): Promise<void>;
+    private emitStatusChange;
+    private attachConnectError;
+    private attemptReconnectAfterDelay;
+    protected reconnect(resolve: any, reject: any, retriesLeft: number): Promise<void>;
+    protected waitIfReconnecting(): Promise<void>;
+    private reRegisterAllListeners;
+    private mapSocketErrorToSpruceError;
+    emit<Name extends EventName<Contract>, IEventSignature extends EventSignature = Contract['eventSignatures'][EventName], EmitSchema extends Schema = IEventSignature['emitPayloadSchema'] extends Schema ? IEventSignature['emitPayloadSchema'] : never, ResponseSchema extends Schema = IEventSignature['responsePayloadSchema'] extends Schema ? IEventSignature['responsePayloadSchema'] : never, ResponsePayload = ResponseSchema extends Schema ? SchemaValues<ResponseSchema> : never>(eventName: Name, targetAndPayload?: (EmitSchema extends Schema ? SchemaValues<EmitSchema> : never) | EmitCallback<Contract, Name>, cb?: EmitCallback<Contract, Name>): Promise<MercuryAggregateResponse<ResponsePayload>>;
+    private handleLocalEmit;
+    emitAndFlattenResponses<Name extends EventName<Contract>, IEventSignature extends EventSignature = Contract['eventSignatures'][EventName], EmitSchema extends Schema = IEventSignature['emitPayloadSchema'] extends Schema ? IEventSignature['emitPayloadSchema'] : never, ResponseSchema extends Schema = IEventSignature['responsePayloadSchema'] extends Schema ? IEventSignature['responsePayloadSchema'] : never, ResponsePayload = ResponseSchema extends Schema ? SchemaValues<ResponseSchema> : never>(eventName: Name, payload?: (EmitSchema extends Schema ? SchemaValues<EmitSchema> : never) | EmitCallback<Contract, Name>, cb?: EmitCallback<Contract, Name>): Promise<ResponsePayload[]>;
+    private _emit;
+    protected assertValidEmitTargetAndPayload<Name extends EventName<Contract>>(eventName: Name, payload: any): void;
+    private handleConfirmPinResponse;
+    protected getEventSignatureByName<Name extends EventName<Contract>>(eventName: Name): SpruceSchemas.Mercury.v2020_12_25.EventSignature;
+    setShouldAutoRegisterListeners(should: boolean): void;
+    on<Name extends EventName<Contract>, IEventSignature extends EventSignature = Contract['eventSignatures'][EventName], EmitSchema extends Schema = IEventSignature['emitPayloadSchema'] extends Schema ? IEventSignature['emitPayloadSchema'] : never>(eventName: Name, cb: (payload: EmitSchema extends Schema ? SchemaValues<EmitSchema> : never) => IEventSignature['responsePayloadSchema'] extends Schema ? Promise<SchemaValues<IEventSignature['responsePayloadSchema']>> | SchemaValues<IEventSignature['responsePayloadSchema']> : Promise<void> | void): Promise<void>;
+    private isEventLocal;
+    off(eventName: EventName<Contract>, cb?: () => void): Promise<number>;
+    private removeLocalListener;
+    getId(): string;
+    disconnect(): Promise<void>;
+    authenticate(options: AuthenticateOptions): Promise<{
+        skill: any;
+        person: any;
+    }>;
+    isAuthenticated(): boolean;
+    isConnected(): boolean;
+    private isSocketConnected;
+    getProxyToken(): string | null;
+    setProxyToken(token: string): void;
+    registerProxyToken(): Promise<any>;
+    getIsTestClient(): boolean;
+}
+type IoOptions = Partial<ManagerOptions & SocketOptions & ConnectionOptions>;
+export declare const authenticateFqen = "authenticate::v2020_12_25";
+export interface AuthenticateOptions {
+    skillId?: string;
+    apiKey?: string;
+    token?: string;
+}
+export {};