@sprucelabs/mercury-client 42.0.556 → 42.0.558

package/build/esm/clients/MercuryTestClient.js

@@ -0,0 +1,389 @@
+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 { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { eventContractUtil, eventNameUtil, eventResponseUtil, } from '@sprucelabs/spruce-event-utils';
+import clone from 'just-clone';
+import SpruceError from '../errors/SpruceError.js';
+import { authenticateFqen } from './MercurySocketIoClient.js';
+import MutableContractClient from './MutableContractClient.js';
+import { connectionStatusContract } from './statusChangePayloadSchema.js';
+class InternalEmitter extends AbstractEventEmitter {
+    doesHandleEvent(eventName) {
+        try {
+            eventContractUtil.getSignatureByName(this.eventContract, eventName);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    validateEmitPayload(schema, actualPayload, eventName) {
+        const payload = Object.assign({}, actualPayload);
+        delete payload.source;
+        return super.validateEmitPayload(schema, payload, eventName);
+    }
+    mixinOnlyUniqueSignatures(contract) {
+        const fqens = Object.keys(contract.eventSignatures);
+        for (const fqen of fqens) {
+            if (!this.eventContract.eventSignatures[fqen]) {
+                this.eventContract.eventSignatures[fqen] =
+                    contract.eventSignatures[fqen];
+            }
+        }
+    }
+    overrideSignatures(contract) {
+        const fqens = Object.keys(contract.eventSignatures);
+        for (const fqen of fqens) {
+            this.eventContract.eventSignatures[fqen] =
+                contract.eventSignatures[fqen];
+        }
+    }
+    getContract() {
+        return this.eventContract;
+    }
+    setContract(contract) {
+        this.eventContract = contract;
+    }
+}
+class MercuryTestClient extends MutableContractClient {
+    get eventContract() {
+        return MercuryTestClient.emitter.getContract();
+    }
+    set eventContract(contract) { }
+    static setShouldCheckPermissionsOnLocalEvents(should) {
+        this.shouldCheckPermissionsOnLocalEvents = should;
+    }
+    static setNamespacesThatMustBeHandledLocally(namespaces) {
+        this.namespacesThatHaveToBeHandledLocally = namespaces;
+    }
+    static getNamespacesThatMustBeHandledLocally() {
+        return this.namespacesThatHaveToBeHandledLocally;
+    }
+    constructor(options) {
+        const contract = options.eventContract;
+        super(Object.assign(Object.assign({}, options), { eventContract: contract }));
+        this._isConnected = false;
+        this.isConnectedToApi = false;
+        this.shouldHandleAuthenticateLocallyIfListenerSet = true;
+        this.shouldWaitForDelayedConnectIfAuthing = true;
+        if (!MercuryTestClient.emitter) {
+            MercuryTestClient.getInternalEmitter(contract);
+        }
+        else if (contract) {
+            MercuryTestClient.emitter.overrideSignatures(contract);
+        }
+    }
+    /** @ts-ignore */
+    static getInternalEmitter(contract) {
+        if (!MercuryTestClient.emitter) {
+            MercuryTestClient.emitter = new InternalEmitter({
+                eventSignatures: {},
+            });
+        }
+        const mixed = mixinConnectionEvents(contract);
+        MercuryTestClient.emitter.mixinOnlyUniqueSignatures(mixed);
+        /** @ts-ignore */
+        return MercuryTestClient.emitter;
+    }
+    off(eventName, cb) {
+        const _super = Object.create(null, {
+            off: { get: () => super.off }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            yield ((_a = MercuryTestClient.emitter) === null || _a === void 0 ? void 0 : _a.off(eventName, cb));
+            if (((_b = MercuryTestClient.emitter) === null || _b === void 0 ? void 0 : _b.listenCount(eventName)) === 0) {
+                return _super.off.call(this, eventName);
+            }
+            else {
+                return 1;
+            }
+        });
+    }
+    static mixinContract(contract) {
+        MutableContractClient.mixinContract(contract);
+        MercuryTestClient.emitter.mixinContract(contract);
+    }
+    mixinContract(contract) {
+        MutableContractClient.mixinContract(contract);
+        MercuryTestClient.emitter.mixinContract(contract);
+    }
+    doesHandleEvent(eventName) {
+        var _a;
+        return (super.doesHandleEvent(eventName) ||
+            ((_a = MercuryTestClient.emitter) === null || _a === void 0 ? void 0 : _a.doesHandleEvent(eventName)));
+    }
+    on(...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //@ts-ignore
+            return MercuryTestClient.emitter.on(...args);
+        });
+    }
+    emit(...args) {
+        const _super = Object.create(null, {
+            emit: { get: () => super.emit }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            const fqen = args[0];
+            try {
+                if (this.shouldHandleEventLocally(fqen)) {
+                    return this.handleEventLocally(args);
+                }
+                else {
+                    if (MercuryTestClient.shouldRequireLocalListeners &&
+                        fqen !== 'connection-status-change') {
+                        throw new SpruceError({
+                            code: 'MUST_HANDLE_LOCALLY',
+                            fqen,
+                            friendlyMessage: `You need to listen to, fake a response to '${fqen}', or boot your skill. Try 'spruce create.listener', 'eventFaker.on('${fqen}')', or 'await this.bootSkill()'!`,
+                        });
+                    }
+                    yield this.connectIfNotConnected(fqen);
+                    //@ts-ignore
+                    const results = yield _super.emit.call(this, ...args);
+                    const firstError = (_c = (_b = (_a = results.responses) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.errors) === null || _c === void 0 ? void 0 : _c[0];
+                    if (firstError &&
+                        ((_d = firstError.options) === null || _d === void 0 ? void 0 : _d.code) === 'INVALID_EVENT_NAME') {
+                        firstError.message = `Event not found! Make sure you are booting your skill in your test with \`await this.bootSkill()\`. If you haven't, you'll need to create a listener with \`spruce create.listener\`.\n\nOriginal Error:\n\n${firstError.options.friendlyMessage}`;
+                    }
+                    return results;
+                }
+            }
+            catch (err) {
+                if (((_e = err.options) === null || _e === void 0 ? void 0 : _e.code) === 'INVALID_EVENT_NAME') {
+                    err.message = `${err.message} Double check it's spelled correctly (types are passing) and that you've run \`spruce create.event\` to create the event.`;
+                }
+                throw err;
+            }
+        });
+    }
+    shouldHandleEventLocally(fqen) {
+        const emitter = MercuryTestClient.emitter;
+        if (!this.shouldHandleAuthenticateLocallyIfListenerSet &&
+            fqen === authenticateFqen) {
+            return false;
+        }
+        if (fqen === 'connection-status-change') {
+            return true;
+        }
+        const { eventNamespace } = eventNameUtil.split(fqen);
+        if (eventNamespace &&
+            MercuryTestClient.namespacesThatHaveToBeHandledLocally.indexOf(eventNamespace) > -1) {
+            return true;
+        }
+        return emitter.listenCount(fqen) > 0;
+    }
+    handleEventLocally(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const emitter = MercuryTestClient.emitter;
+            const fqen = args[0];
+            const payload = args[1];
+            if (!MercuryTestClient.emitter.doesHandleEvent(fqen)) {
+                throw new SpruceError({
+                    code: 'MUST_CREATE_EVENT',
+                    fqen,
+                });
+            }
+            if (MercuryTestClient.shouldRequireLocalListeners !== false &&
+                MercuryTestClient.emitter.listenCount(fqen) === 0) {
+                if (fqen === 'connection-status-change') {
+                    return {
+                        responses: [],
+                        totalContracts: 0,
+                        totalErrors: 0,
+                        totalResponses: 0,
+                    };
+                }
+                throw new SpruceError({
+                    code: 'MUST_HANDLE_LOCALLY',
+                    fqen,
+                });
+            }
+            this.assertValidEmitTargetAndPayload(fqen, payload);
+            let { argsWithSource } = this.buildSource(args);
+            const contract = emitter.getContract();
+            const sig = eventContractUtil.getSignatureByName(contract, fqen);
+            const { eventNamespace } = eventNameUtil.split(fqen);
+            if (eventNamespace) {
+                this.assertValidEventSignature(sig, fqen);
+            }
+            if (sig.emitPermissionContract && eventNamespace) {
+                const doesHonor = yield this.optionallyCheckPermissions(args, sig.emitPermissionContract.id, fqen);
+                if (typeof doesHonor !== 'boolean') {
+                    return doesHonor;
+                }
+                if (!doesHonor) {
+                    return {
+                        totalContracts: 1,
+                        totalErrors: 1,
+                        totalResponses: 1,
+                        responses: [
+                            {
+                                errors: [
+                                    new SpruceError({
+                                        code: 'UNAUTHORIZED_ACCESS',
+                                        fqen,
+                                        action: 'emit',
+                                        target: (_a = args[1]) !== null && _a !== void 0 ? _a : {},
+                                        permissionContractId: sig.emitPermissionContract.id,
+                                    }),
+                                ],
+                            },
+                        ],
+                    };
+                }
+            }
+            //@ts-ignore
+            const results = (yield emitter.emit(...argsWithSource));
+            return clone(results);
+        });
+    }
+    assertValidEventSignature(sig, fqen) {
+        var _a, _b;
+        if (!sig.isGlobal && !((_b = (_a = sig.emitPayloadSchema) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b.target)) {
+            throw new SpruceError({
+                code: 'INVALID_EVENT_SIGNATURE',
+                fqen,
+                instructions: 'Oh no! You have to either create an event using `spruce create.event`, set your event to global (event.options.ts, which requires special permissions) or add a target that includes an organizationId or locationId. Choose wisely!',
+            });
+        }
+    }
+    optionallyCheckPermissions(args, permissionContractId, fqen) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!MercuryTestClient.shouldCheckPermissionsOnLocalEvents) {
+                return true;
+            }
+            let { target } = (_a = args[1]) !== null && _a !== void 0 ? _a : {};
+            const permTarget = {};
+            if (target === null || target === void 0 ? void 0 : target.organizationId) {
+                permTarget.organizationId = target.organizationId;
+            }
+            if (target === null || target === void 0 ? void 0 : target.locationId) {
+                throw new Error('checking permissions against a location is not supported. Add to mercury-workspace -> mercury-client');
+            }
+            const { eventNamespace } = eventNameUtil.split(fqen);
+            const results = yield this.emit('does-honor-permission-contract::v2020_12_25', {
+                target: permTarget,
+                payload: {
+                    id: `${eventNamespace}.${permissionContractId}`,
+                },
+            });
+            if (results.totalErrors > 0) {
+                return results;
+            }
+            const { doesHonor } = eventResponseUtil.getFirstResponseOrThrow(results);
+            return doesHonor;
+        });
+    }
+    buildSource(args) {
+        var _a, _b, _c;
+        let source = Object.assign({}, (_a = args[1]) === null || _a === void 0 ? void 0 : _a.source);
+        if ((_b = this.auth) === null || _b === void 0 ? void 0 : _b.person) {
+            source.personId = this.auth.person.id;
+        }
+        if ((_c = this.auth) === null || _c === void 0 ? void 0 : _c.skill) {
+            source.skillId = this.auth.skill.id;
+        }
+        if (args[0] !== 'authenticate::v2020_12_25' &&
+            !source.proxyToken &&
+            this.getProxyToken()) {
+            source.proxyToken = this.getProxyToken();
+        }
+        const argsWithSource = [...args];
+        if (typeof argsWithSource[1] !== 'function' &&
+            Object.keys(source).length > 0) {
+            argsWithSource[1] = Object.assign(Object.assign({}, argsWithSource[1]), { source });
+        }
+        return { source, argsWithSource: clone(argsWithSource) };
+    }
+    connectIfNotConnected(fqen) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnectedToApi) {
+                this.isConnectedToApi = true;
+                this.connectPromise = this.delayedConnectAndAuth(fqen);
+            }
+            if (!this.shouldWaitForDelayedConnectIfAuthing &&
+                fqen === authenticateFqen) {
+                return;
+            }
+            yield this.connectPromise;
+        });
+    }
+    delayedConnectAndAuth(fqen) {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.connect.call(this);
+            if (this.lastAuthOptions && fqen !== authenticateFqen) {
+                this.authPromise = undefined;
+                this.shouldHandleAuthenticateLocallyIfListenerSet = false;
+                this.shouldWaitForDelayedConnectIfAuthing = false;
+                yield this.authenticate(this.lastAuthOptions);
+            }
+        });
+    }
+    connect() {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isConnected) {
+                yield _super.connect.call(this);
+            }
+            this._isConnected = true;
+        });
+    }
+    isConnected() {
+        return this._isConnected;
+    }
+    disconnect() {
+        const _super = Object.create(null, {
+            disconnect: { get: () => super.disconnect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnectedToApi) {
+                yield _super.disconnect.call(this);
+            }
+            this._isConnected = false;
+        });
+    }
+    static reset() {
+        MutableContractClient.reset();
+        //@ts-ignore
+        MercuryTestClient.emitter = undefined;
+        //@ts-ignore
+        MercuryTestClient.emitter = MercuryTestClient.getInternalEmitter({
+            eventSignatures: {},
+        });
+    }
+    getIsTestClient() {
+        return true;
+    }
+    static setShouldRequireLocalListeners(shouldRequire) {
+        this.shouldRequireLocalListeners = shouldRequire;
+    }
+    static getShouldRequireLocalListeners() {
+        return this.shouldRequireLocalListeners;
+    }
+}
+MercuryTestClient.shouldCheckPermissionsOnLocalEvents = false;
+MercuryTestClient.namespacesThatHaveToBeHandledLocally = [];
+MercuryTestClient.shouldRequireLocalListeners = true;
+export default MercuryTestClient;
+function mixinConnectionEvents(contract) {
+    return eventContractUtil.unifyContracts([
+        contract !== null && contract !== void 0 ? contract : { eventSignatures: {} },
+        connectionStatusContract,
+    ]);
+}

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

@@ -0,0 +1,10 @@
+import { EventContract, EventSignature, EventNames } from '@sprucelabs/mercury-types';
+import MercurySocketIoClient from './MercurySocketIoClient';
+export default class MutableContractClient<Contract extends EventContract> extends MercurySocketIoClient<Contract> {
+    private static inMemoryContract?;
+    static mixinContract(contract: EventContract): void;
+    mixinContract(contract: EventContract): void;
+    static reset(): void;
+    doesHandleEvent(eventName: string): boolean;
+    protected getEventSignatureByName<EventName extends EventNames<Contract>>(eventName: EventName): EventSignature;
+}

package/build/esm/clients/MutableContractClient.js

@@ -0,0 +1,43 @@
+import { eventContractUtil } from '@sprucelabs/spruce-event-utils';
+import MercurySocketIoClient from './MercurySocketIoClient.js';
+export default class MutableContractClient extends MercurySocketIoClient {
+    static mixinContract(contract) {
+        var _a;
+        this.inMemoryContract = eventContractUtil.unifyContracts([
+            (_a = this.inMemoryContract) !== null && _a !== void 0 ? _a : { eventSignatures: {} },
+            contract,
+        ]);
+    }
+    mixinContract(contract) {
+        MutableContractClient.mixinContract(contract);
+    }
+    static reset() {
+        this.inMemoryContract = {
+            eventSignatures: {},
+        };
+    }
+    doesHandleEvent(eventName) {
+        try {
+            this.getEventSignatureByName(eventName);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    getEventSignatureByName(eventName) {
+        var _a, _b;
+        try {
+            const sig = this.eventContract || MutableContractClient.inMemoryContract
+                ? eventContractUtil.getSignatureByName((_a = this.eventContract) !== null && _a !== void 0 ? _a : { eventSignatures: {} }, eventName)
+                : {};
+            return sig;
+        }
+        catch (err) {
+            const inMemorySig = eventContractUtil.getSignatureByName((_b = MutableContractClient.inMemoryContract) !== null && _b !== void 0 ? _b : {
+                eventSignatures: {},
+            }, eventName);
+            return inMemorySig;
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+declare const statusChangePayloadSchema: {
+    id: string;
+    fields: {
+        status: {
+            type: "select";
+            isRequired: true;
+            options: {
+                choices: ({
+                    readonly label: "Connecting";
+                    readonly value: "connecting";
+                } | {
+                    readonly label: "Connected";
+                    readonly value: "connected";
+                } | {
+                    readonly label: "Disconnected";
+                    readonly value: "disconnected";
+                })[];
+            };
+        };
+    };
+};
+declare const statusChangeTargetAndPayloadSchema: {
+    id: string;
+    fields: {
+        payload: {
+            type: "schema";
+            isRequired: true;
+            options: {
+                schema: {
+                    id: string;
+                    fields: {
+                        status: {
+                            type: "select";
+                            isRequired: true;
+                            options: {
+                                choices: ({
+                                    readonly label: "Connecting";
+                                    readonly value: "connecting";
+                                } | {
+                                    readonly label: "Connected";
+                                    readonly value: "connected";
+                                } | {
+                                    readonly label: "Disconnected";
+                                    readonly value: "disconnected";
+                                })[];
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+type StatusChangeTargetAndPayloadSchema = typeof statusChangeTargetAndPayloadSchema;
+type StatusChangePayloadSchema = typeof statusChangePayloadSchema;
+declare module '@sprucelabs/mercury-types/build/types/mercury.types' {
+    interface SkillEventSignatures {
+        'connection-status-change': {
+            emitPayloadSchema: StatusChangeTargetAndPayloadSchema;
+        };
+    }
+}
+export declare const connectionStatusContract: {
+    id: string;
+    eventSignatures: {
+        'connection-status-change': {
+            emitPayloadSchema: {
+                id: string;
+                fields: {
+                    payload: {
+                        type: "schema";
+                        isRequired: true;
+                        options: {
+                            schema: {
+                                id: string;
+                                fields: {
+                                    status: {
+                                        type: "select";
+                                        isRequired: true;
+                                        options: {
+                                            choices: ({
+                                                readonly label: "Connecting";
+                                                readonly value: "connecting";
+                                            } | {
+                                                readonly label: "Connected";
+                                                readonly value: "connected";
+                                            } | {
+                                                readonly label: "Disconnected";
+                                                readonly value: "disconnected";
+                                            })[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export type ConnectionStatus = StatusChangePayloadSchema['fields']['status']['options']['choices'][number]['value'];
+export {};

package/build/esm/clients/statusChangePayloadSchema.js

@@ -0,0 +1,45 @@
+import { buildEventContract } from '@sprucelabs/mercury-types';
+import { buildSchema } from '@sprucelabs/schema';
+const statusChangePayloadSchema = buildSchema({
+    id: 'connectionStatusChangeEmitPayload',
+    fields: {
+        status: {
+            type: 'select',
+            isRequired: true,
+            options: {
+                choices: [
+                    {
+                        label: 'Connecting',
+                        value: 'connecting',
+                    },
+                    {
+                        label: 'Connected',
+                        value: 'connected',
+                    },
+                    {
+                        label: 'Disconnected',
+                        value: 'disconnected',
+                    },
+                ],
+            },
+        },
+    },
+});
+const statusChangeTargetAndPayloadSchema = buildSchema({
+    id: 'connectionStatusChangeEmitTargetAndPayload',
+    fields: {
+        payload: {
+            type: 'schema',
+            isRequired: true,
+            options: { schema: statusChangePayloadSchema },
+        },
+    },
+});
+export const connectionStatusContract = buildEventContract({
+    id: 'connectionStatus',
+    eventSignatures: {
+        'connection-status-change': {
+            emitPayloadSchema: statusChangeTargetAndPayloadSchema,
+        },
+    },
+});

package/build/esm/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_HOST = "https://mercury.spruce.ai";

package/build/esm/constants.js

@@ -0,0 +1 @@
+export const DEFAULT_HOST = 'https://mercury.spruce.ai';

package/build/esm/errors/SpruceError.d.ts

@@ -0,0 +1,5 @@
+import AbstractSpruceError from '@sprucelabs/error';
+import ErrorOptions from './../.spruce/errors/options.types';
+export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
+    friendlyMessage(): string;
+}

package/build/esm/errors/SpruceError.js

@@ -0,0 +1,66 @@
+import AbstractSpruceError from '@sprucelabs/error';
+export default class SpruceError extends AbstractSpruceError {
+    friendlyMessage() {
+        var _a;
+        const { options } = this;
+        let message;
+        switch (options === null || options === void 0 ? void 0 : options.code) {
+            case 'INVALID_PROTOCOL':
+                message = `Unable to connect to Mercury using the uri you provided. The uri you provide was "${options.uri}"!`;
+                break;
+            case 'UNEXPECTED_PAYLOAD':
+                message = `You passed a payload to "${options.eventName}" that has no emit payload defined.`;
+                break;
+            case 'INVALID_PAYLOAD':
+                message = `The emit payload you passed to "${options.eventName}" is invalid${options.originalError
+                    ? `:\n\n${options.originalError.message}`
+                    : '.'}`;
+                break;
+            case 'CONNECTION_FAILED':
+                message = `I couldn't connect to ${options.host}. The code I got back was ${options.statusCode}.`;
+                break;
+            case 'NOT_CONNECTED':
+                message = `You cannot ${options.action} after you have manually disconnected from Mercury. Event was '${options.fqen}'.`;
+                break;
+            case 'TIMEOUT': {
+                const retries = options.totalRetries
+                    ? ` ${options.totalRetries} times `
+                    : ' ';
+                const each = options.totalRetries ? ' each ' : ' ';
+                message = `Dang it, I didn't hear back after emitting "${options.eventName}"${retries}for ${options.timeoutMs / 1000} seconds${each}...`;
+                if (options.isConnected === false) {
+                    message +=
+                        "\n\nAlso, it appears I'm not connected to the api.";
+                }
+                break;
+            }
+            case 'MISSING_TEST_CACHE_DIR':
+                message =
+                    'You must set a test cache dir to test Mercury. Try MercuryFactory.setTestCacheDir().';
+                break;
+            case 'UNKNOWN_ERROR':
+                message = 'Oh no! An unknown error ocurred.';
+                if (options.originalError) {
+                    message += ' Original error:\n\n';
+                    message += options.originalError.stack;
+                }
+                return message;
+            case 'UNAUTHORIZED_ACCESS':
+                message = `Not authorized! You cannot ${options.action} \`${options.fqen}\`!`;
+                break;
+            case 'INVALID_EVENT_SIGNATURE':
+                message = `The signature for '${options.fqen}' is invalid:\n\n${options.instructions}`;
+                break;
+            case 'MUST_HANDLE_LOCALLY':
+                message = `'${options.fqen}' must be handled locally. You have 2 options:\n\n1. Make sure you have created a listener using 'spruce create.listener' and have booted your skill using 'await this.bootSkill()'\n\n2. Use eventFaker.on(...) to setup a listener in your test!`;
+                break;
+            case 'MUST_CREATE_EVENT':
+                message = `The event '${options.fqen}' was not found! That means it's time to create it with 'spruce create.event'.`;
+                break;
+            default:
+                message = super.friendlyMessage();
+        }
+        message = (_a = options.friendlyMessage) !== null && _a !== void 0 ? _a : message;
+        return message;
+    }
+}