@sprucelabs/mercury-client 42.0.554 → 42.0.556

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

@@ -1,40 +0,0 @@
-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

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

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

@@ -1,26 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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 {};