@sprucelabs/mercury-client 42.0.556 → 42.0.558

package/build/esm/.spruce/errors/mercuryClient/unexpectedPayload.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const unexpectedPayloadSchema = {
+    id: 'unexpectedPayload',
+    namespace: 'MercuryClient',
+    name: 'Unexpected payload',
+    fields: {
+        /** . */
+        'eventName': {
+            type: 'text',
+            isRequired: true,
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(unexpectedPayloadSchema);
+exports.default = unexpectedPayloadSchema;
+//# sourceMappingURL=unexpectedPayload.schema.js.map

package/build/esm/.spruce/errors/mercuryClient/unknownError.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const unknownErrorSchema: SpruceErrors.MercuryClient.UnknownErrorSchema;
+export default unknownErrorSchema;

package/build/esm/.spruce/errors/mercuryClient/unknownError.schema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+const unknownErrorSchema = {
+    id: 'unknownError',
+    namespace: 'MercuryClient',
+    name: 'Unknown error',
+    fields: {}
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(unknownErrorSchema);
+exports.default = unknownErrorSchema;
+//# sourceMappingURL=unknownError.schema.js.map

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/.spruce/event-cache.json

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

package/build/esm/.spruce/schemas/fields/fieldClassMap.d.ts

@@ -0,0 +1,2 @@
+import { fieldClassMap } from '@sprucelabs/schema';
+export default fieldClassMap;

package/build/esm/.spruce/schemas/fields/fieldClassMap.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require('@sprucelabs/schema');
+exports.default = schema_1.fieldClassMap;
+//# sourceMappingURL=fieldClassMap.js.map

package/build/esm/.spruce/schemas/fields/fields.types.d.ts

@@ -0,0 +1 @@
+export { FieldDefinitions, FieldDefinitionMap, FieldValueTypeGeneratorMap, FieldMap } from '@sprucelabs/schema';

package/build/esm/.spruce/schemas/fields/fields.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fields.types.js.map

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

@@ -0,0 +1 @@
+export { SpruceSchemas } from '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schemas.types';

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schemas.types.js.map

package/build/esm/.spruce/settings.json

@@ -0,0 +1,26 @@
+{
+  "skipped": [
+    "skill",
+    "event"
+  ],
+  "installed": [
+    "schema",
+    "error",
+    "test"
+  ],
+  "writer": {
+    "skipped": [
+      ".gitignore"
+    ]
+  },
+  "scriptUpdater": {
+    "skipped": [
+      "rebuild",
+      "update.dependencies",
+      "build.tsc",
+      "fix.lint",
+      "lint"
+    ],
+    "skips": []
+  }
+}

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 {};