@genesislcap/foundation-comms 14.187.1 → 14.188.0

package/dist/esm/datasource/datasource.js

@@ -1,51 +1,47 @@
 import { __awaiter, __decorate, __param, __rest } from "tslib";
 import { observable } from '@microsoft/fast-element';
-import { DI, optional } from '@microsoft/fast-foundation';
+import { DI } from '@microsoft/fast-foundation';
 import { combineLatest, from, timer } from 'rxjs';
 import { switchMap, takeWhile } from 'rxjs/operators';
 import { Auth } from '../auth';
 import { Connect } from '../connect';
 import { extractFieldDefinitions, toFieldMetadata } from '../metadata/metadata.utils';
+import { GenesisResources } from '../resources';
 import { logger } from '../utils';
-import { criteriaFiltersToFields } from './criteriaFiltersToFields';
-import { dataServerResultFilter } from './dataServerResultFilter';
-import { DatasourceConfig, DatasourceDefaults, ResourceType } from './datasource.types';
-/**
- * The default configuration for the Datasource service.
- * @public
- */
-export const defaultDatasourceConfig = {
-    options: {
-        criteria: '',
-        isSnapshot: false,
-        maxRows: DatasourceDefaults.MAX_ROWS_250,
-        maxView: DatasourceDefaults.MAX_VIEW_1000,
-        pollingInterval: DatasourceDefaults.REQ_REP_POLLING_INTERVAL_MS,
-        movingView: false,
-        orderBy: '',
-        resourceName: '',
-        reverse: false,
-    },
-    criteriaToFields: criteriaFiltersToFields,
-    dataServerResultFilter: dataServerResultFilter,
-};
+import { DatasourceConfig } from './datasource.config';
+import { DatasourceStatusChanged, ResourceType } from './datasource.types';
 /**
  * The default implementation for the Datasource interface.
  * @public
  */
 let DefaultDatasource = class DefaultDatasource {
-    constructor(connect, auth, config = defaultDatasourceConfig) {
+    /** {@inheritDoc Datasource.initialized} */
+    get initialized() {
+        var _a;
+        return !!((_a = this.status) === null || _a === void 0 ? void 0 : _a.isInitialized);
+    }
+    constructor(connect, auth, resources, config) {
         this.connect = connect;
         this.auth = auth;
+        this.resources = resources;
         this.config = config;
-        this.initialized = false;
-        this.readOnly = true;
+        /** {@inheritDoc DatasourceMetadata.fetchMetadataRequired} */
+        this.fetchMetadataRequired = true;
+        /** {@inheritDoc DatasourceMetadata.originalFieldDef} */
         this.originalFieldDef = [];
-        this.requestFields = [];
+        /** {@inheritDoc DatasourceMetadata.fieldMetadata} */
         this.fieldMetadata = [];
+        /** {@inheritDoc DatasourceMetadata.requestFields} */
+        this.requestFields = [];
+        /** {@inheritDoc DatasourceMetadata.availableIndexes} */
         this.availableIndexes = [];
+        this.readOnly = true;
     }
+    /**
+     * @deprecated - Please use {@link (GenesisResources:interface).isValidResource} instead.
+     */
     validResourceName(resourceName) {
+        logger.deprecated('Datasource.validResourceName', 'Use `GenesisResources.isValidResource` instead.');
         if (!resourceName)
             return false;
         if (!resourceName.trim().length)
@@ -53,41 +49,46 @@ let DefaultDatasource = class DefaultDatasource {
         // additional checks? regex? or maybe we can ask the server if it's a valid resource in the future
         return true;
     }
-    init(options, fetchMeta = true) {
-        var _a;
+    init(options, fetchMeta = this.fetchMetadataRequired) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.validResourceName(options === null || options === void 0 ? void 0 : options.resourceName)) {
-                return false;
-            }
+            this.fetchMetadataRequired = fetchMeta;
             this.options = Object.assign(Object.assign({}, this.config.options), options);
             const resourceName = this.options.resourceName;
-            if (fetchMeta) {
-                logger.debug(`Initializing ${resourceName} Datasource`);
-                const meta = yield this.connect
-                    .getMetadata(resourceName)
-                    .catch((e) => logger.error(`Metadata Fetch failed for ${resourceName}:`, e));
-                if (!meta) {
-                    this.deinit();
-                    return false;
-                }
-                this.resourceType = meta.TYPE;
-                this.availableIndexes = (_a = meta.INDEXES) !== null && _a !== void 0 ? _a : [];
-                this.originalFieldDef = extractFieldDefinitions(meta);
-                this.fieldMetadata = toFieldMetadata(this.originalFieldDef);
-                this.requestFields = meta.REQUEST_FIELD || [];
-                logger.debug(`Datasource for ${resourceName} is ready`);
+            const connected = this.connect.isConnected || (yield this.connect.connect());
+            if (!connected) {
+                logger.error(`Unable to connect to ${this.connect.host} to get ${resourceName} datasource`);
+                this.reportStatus();
+                return false;
+            }
+            const isValidResource = yield this.resources.isValidResource(resourceName);
+            if (!isValidResource) {
+                logger.error(`${resourceName} datasource does not exist on ${this.connect.host}`);
+                this.reportStatus();
+                return false;
             }
+            this.resourceType = yield this.resources.getResourceTypeFor(resourceName);
+            if (!this.resourceType) {
+                logger.error(`Unable to get the resource type for ${resourceName} datasource from ${this.connect.host}`);
+                this.reportStatus();
+                return false;
+            }
+            logger.debug(`Initializing ${resourceName} datasource from ${this.connect.host}`);
             if (!this.options.isSnapshot) {
-                this._stream = yield this.createStream();
+                this.stream = yield this.createStream();
+            }
+            if (this.fetchMetadataRequired) {
+                yield this.fetchAndApplyMetadata(this.options.resourceName);
             }
-            this.initialized = true;
+            logger.debug(`${resourceName} datasource initialization ${this.initialized ? `success` : 'failed'}`);
+            this.reportStatus();
             return this.initialized;
         });
     }
     deinit() {
         var _a;
         logger.debug('Datasource.deinit', (_a = this.options) === null || _a === void 0 ? void 0 : _a.resourceName);
-        this.initialized = false;
+        this.status = undefined;
+        this.fetchMetadataRequired = undefined;
         this.options = {};
         this.resourceType = undefined;
         this.availableIndexes = [];
@@ -100,12 +101,11 @@ let DefaultDatasource = class DefaultDatasource {
         var _a;
         logger.debug('Datasource.destroy', (_a = this.options) === null || _a === void 0 ? void 0 : _a.resourceName);
         this.deinit();
-        delete this._stream;
-    }
-    get stream() {
-        return this._stream;
+        delete this.stream;
+        this.status = undefined;
     }
     get params() {
+        var _a;
         const params = {
             CRITERIA_MATCH: this.options.criteria,
             FIELDS: this.options.fields,
@@ -118,7 +118,7 @@ let DefaultDatasource = class DefaultDatasource {
             REVERSE: this.options.reverse,
         };
         if (this.options.orderBy) {
-            if (this.availableIndexes.findIndex((i) => i.NAME === this.options.orderBy) > -1) {
+            if (((_a = this.availableIndexes) === null || _a === void 0 ? void 0 : _a.findIndex((i) => i.NAME === this.options.orderBy)) > -1) {
                 params.ORDER_BY = this.options.orderBy;
             }
             else {
@@ -192,20 +192,95 @@ let DefaultDatasource = class DefaultDatasource {
             switchMap(() => from(this.snapshot())));
         }));
     }
+    fetchAndApplyMetadata(resourceName) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger.debug(`Requesting metadata for ${this.options.resourceName} Datasource`);
+                const meta = yield this.connect.getMetadata(this.options.resourceName);
+                if (meta) {
+                    this.availableIndexes = (_a = meta.INDEXES) !== null && _a !== void 0 ? _a : [];
+                    this.originalFieldDef = extractFieldDefinitions(meta);
+                    this.fieldMetadata = toFieldMetadata(this.originalFieldDef);
+                    this.requestFields = meta.REQUEST_FIELD || [];
+                    this.fetchMetadataRequired = false;
+                }
+                this.status = this.normaliseStatus({
+                    isInitialized: true,
+                    metadataRequired: true,
+                    hasMetadata: ((_b = this.fieldMetadata) === null || _b === void 0 ? void 0 : _b.length) > 0,
+                });
+            }
+            catch (e) {
+                logger.error(`Metadata Fetch failed for ${resourceName}:`, e);
+                this.status = this.normaliseStatus({
+                    isInitialized: false,
+                    metadataRequired: true,
+                    hasMetadata: false,
+                });
+            }
+        });
+    }
+    /**
+     * @internal
+     */
+    reportStatus(detail = {}) {
+        var _a;
+        const eventEmitter = (_a = this.config.eventEmitter) !== null && _a !== void 0 ? _a : document;
+        this.status = this.normaliseStatus(detail);
+        logger.debug(`Dispatching '${DatasourceStatusChanged}'`, this.status);
+        eventEmitter === null || eventEmitter === void 0 ? void 0 : eventEmitter.dispatchEvent(new CustomEvent(DatasourceStatusChanged, {
+            detail: this.status,
+            bubbles: eventEmitter !== document,
+            composed: true,
+        }));
+    }
+    /**
+     * @internal
+     */
+    normaliseStatus(status) {
+        var _a, _b, _c, _d, _e;
+        const isInitialized = (_a = status.isInitialized) !== null && _a !== void 0 ? _a : this.initialized;
+        const metadataRequired = (_b = status.metadataRequired) !== null && _b !== void 0 ? _b : this.fetchMetadataRequired;
+        const hasMetadata = (_c = status.hasMetadata) !== null && _c !== void 0 ? _c : ((_d = this.fieldMetadata) === null || _d === void 0 ? void 0 : _d.length) > 0;
+        return {
+            name: (_e = this.options) === null || _e === void 0 ? void 0 : _e.resourceName,
+            type: this.resourceType,
+            isInitialized,
+            metadataRequired,
+            hasMetadata,
+        };
+    }
 };
 __decorate([
     observable
-], DefaultDatasource.prototype, "initialized", void 0);
+], DefaultDatasource.prototype, "status", void 0);
+__decorate([
+    observable
+], DefaultDatasource.prototype, "fetchMetadataRequired", void 0);
+__decorate([
+    observable
+], DefaultDatasource.prototype, "originalFieldDef", void 0);
+__decorate([
+    observable
+], DefaultDatasource.prototype, "fieldMetadata", void 0);
+__decorate([
+    observable
+], DefaultDatasource.prototype, "requestFields", void 0);
+__decorate([
+    observable
+], DefaultDatasource.prototype, "availableIndexes", void 0);
 __decorate([
     observable
 ], DefaultDatasource.prototype, "readOnly", void 0);
 __decorate([
     observable
-], DefaultDatasource.prototype, "_stream", void 0);
+], DefaultDatasource.prototype, "stream", void 0);
 DefaultDatasource = __decorate([
     __param(0, Connect),
     __param(1, Auth),
-    __param(2, optional(DatasourceConfig))
+    __param(2, GenesisResources),
+    __param(3, DatasourceConfig)
 ], DefaultDatasource);
 export { DefaultDatasource };
 /**

package/dist/esm/datasource/datasource.mixins.js

@@ -0,0 +1,86 @@
+import { __decorate } from "tslib";
+import { observable } from '@microsoft/fast-element';
+import { logger } from '../utils';
+import { DatasourceStatusChanged, } from './datasource.types';
+/**
+ * Datasource event handler mixin for target classes that use or are interested in datasource status changes.
+ *
+ * @remarks
+ * Classes that use the mixin are not required to own the datasource itself, there may be several interested parties.
+ *
+ * @example
+ * ```ts
+ * import { DatasourceEventHandler, DatasourceStatus } from '@genesislcap/foundation-comms';
+ * ...
+ * class MyComponent extends DatasourceEventHandler(FASTElement) {
+ *     resourceName: string = 'some-resource';
+ *     ...
+ *     datasourceStatusChanged(prev: DatasourceStatus, next: DatasourceStatus) {
+ *         // Respond to changes in the target datasource.
+ *     }
+ * }
+ * ```
+ *
+ * @privateRemarks
+ * Unfortunately our datasource ui components do not share a common baseclass. Given datasource ui components contain a
+ * Datasource and currently await their `init`, usage is more for example at this point, ie. how could we allow interested
+ * parties to monitor and respond to changes, given they will exist at different levels of DOM hierarchy etc. Datasource
+ * itself is also transient DI injectable, so each interested party would not have access to the same instance, nor would
+ * we necessarily want to expose that via the event to prevent them operating on it to cause unwanted side effects.
+ *
+ * @param Target - The class to mix the event handler with.
+ *
+ * @public
+ */
+export const DatasourceEventHandler = (Target) => {
+    // @ts-ignore
+    class Mixin extends Target {
+        constructor() {
+            super();
+            if (!this.hasOwnProperty('onDatasourceStatusChanged')) {
+                this.onDatasourceStatusChanged = (event) => {
+                    var _a;
+                    if (!this.resourceName) {
+                        logger.warn(`Target classes must have a resourceName property to use the DatasourceEventHandler mixin.`);
+                    }
+                    const next = event.detail;
+                    if (next.name === this.resourceName) {
+                        const prev = (_a = this.datasourceStatus) !== null && _a !== void 0 ? _a : {
+                            isInitialized: false,
+                            hasMetadata: false,
+                        };
+                        const hasChanged = prev.isInitialized !== next.isInitialized ||
+                            (next.metadataRequired && prev.hasMetadata !== next.hasMetadata);
+                        if (hasChanged) {
+                            this.datasourceStatus = next;
+                        }
+                    }
+                };
+            }
+        }
+        /**
+         * @remarks
+         * Override this method to respond to changes in the target datasource.
+         */
+        datasourceStatusChanged(prev, next) {
+            logger.debug('Target classes should override the datasourceStatusChanged method of the DatasourceEventHandler mixin to respond to changes in the target datasource.');
+        }
+        connectedCallback() {
+            super.connectedCallback();
+            document.addEventListener(DatasourceStatusChanged, this.onDatasourceStatusChanged, {
+                passive: true,
+                capture: true,
+            });
+        }
+        disconnectedCallback() {
+            super.disconnectedCallback();
+            document.removeEventListener(DatasourceStatusChanged, this.onDatasourceStatusChanged, {
+                capture: true,
+            });
+        }
+    }
+    __decorate([
+        observable
+    ], Mixin.prototype, "datasourceStatus", void 0);
+    return Mixin;
+};

package/dist/esm/datasource/datasource.types.js

@@ -1,4 +1,3 @@
-import { DI } from '@microsoft/fast-foundation';
 /**
  * Types of Genesis resources.
  * @public
@@ -10,22 +9,7 @@ export var ResourceType;
     ResourceType["REQUEST_SERVER"] = "REQUEST_SERVER";
 })(ResourceType || (ResourceType = {}));
 /**
- * Default values for a DatasourceConfig
+ * DatasourceStatusChanged.
  * @public
  */
-export class DatasourceDefaults {
-}
-DatasourceDefaults.MAX_ROWS_250 = 250;
-DatasourceDefaults.MAX_VIEW_1000 = 1000;
-DatasourceDefaults.REQ_REP_POLLING_INTERVAL_MS = 10000;
-DatasourceDefaults.DATASERVER_ROW_ID = 'ROW_REF';
-DatasourceDefaults.REQUEST_SERVER_ROW_ID = 'RECORD_ID';
-/**
- * The DI token for the DatasourceConfig interface.
- *
- * @privateRemarks
- * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
- *
- * @internal
- */
-export const DatasourceConfig = DI.createInterface();
+export const DatasourceStatusChanged = 'datasource-status-changed';

package/dist/esm/datasource/entityDatasource.js

@@ -42,6 +42,12 @@ export class DefaultEntityDatasource extends DefaultDatasource {
             this.entityCache = [];
         };
     }
+    get initialized() {
+        return this._initialized;
+    }
+    set initialized(value) {
+        this._initialized = value;
+    }
     /** {@inheritDoc EntityDatasource.cache} */
     get cache() {
         if (!this.initialized) {

package/dist/esm/datasource/index.js

@@ -1,5 +1,7 @@
 export * from './criteriaFiltersToFields';
 export * from './dataServerResultFilter';
+export * from './datasource.config';
+export * from './datasource.mixins';
 export * from './datasource';
 export * from './datasource.types';
 export * from './entityDatasource';

package/dist/esm/index.js

@@ -5,6 +5,7 @@ export * from './credentialManager';
 export * from './datasource';
 export * from './metadata';
 export * from './networkMonitor';
+export * from './resources';
 export * from './session';
 export * from './storage';
 export * from './testing';

package/dist/esm/resources/genesis/config.js

@@ -0,0 +1,51 @@
+import { registerTypedBroadcastChannel, } from '@genesislcap/foundation-broadcast-channel';
+import { DI } from '@microsoft/fast-foundation';
+import { GenesisResourcesChannelId } from './types';
+/**
+ * Default GenesisResourcesConfig implementation.
+ * @public
+ */
+export const defaultGenesisResourcesConfig = {
+    throwWhenUnavailable: true,
+    throwWhenUnknown: false,
+};
+/**
+ * GenesisResourcesConfig DI key.
+ * @internal
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ */
+export const GenesisResourcesConfig = DI.createInterface((x) => x.instance(defaultGenesisResourcesConfig));
+/**
+ * GenesisResourcesChannel DI key.
+ * @internal
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ */
+export const GenesisResourcesChannel = registerTypedBroadcastChannel(GenesisResourcesChannelId);
+/**
+ * Gets GenesisResourcesChannel from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getGenesisResourcesChannel } from '@genesislcap/foundation-comms';
+ * ...
+ * const channel = getGenesisResourcesChannel();
+ * ...
+ * channel.onmessage = (e) => {
+ *  if (channel.isMessageType('resources-loaded', e)) {
+ *    logger.debug('resources-loaded', e.data.detail);
+ *    return;
+ *  }
+ * }
+ * ...
+ * channel.close();
+ * ```
+ * @public
+ */
+export function getGenesisResourcesChannel() {
+    return DI.getOrCreateDOMContainer().get(GenesisResourcesChannel);
+}

package/dist/esm/resources/genesis/genesis.js

@@ -0,0 +1,114 @@
+import { __awaiter, __decorate, __param } from "tslib";
+import { DI } from '@microsoft/fast-foundation';
+import { Connect } from '../../connect';
+import { logger } from '../../utils';
+import { GenesisResourcesConfig, getGenesisResourcesChannel } from './config';
+/**
+ * Default GenesisResources implementation.
+ * @public
+ */
+let DefaultGenesisResources = class DefaultGenesisResources {
+    constructor(connect, config) {
+        this.connect = connect;
+        this.config = config;
+    }
+    /** {@inheritDoc GenesisResources.isValidResource} */
+    isValidResource(resourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            resourceName = resourceName === null || resourceName === void 0 ? void 0 : resourceName.trim();
+            if (!resourceName) {
+                return false;
+            }
+            yield this.getResources();
+            const resourceItem = this.resources.find((item) => item.RESOURCE_NAME === resourceName);
+            return !!resourceItem;
+        });
+    }
+    /** {@inheritDoc GenesisResources.getResourceTypeFor} */
+    getResourceTypeFor(resourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getResources();
+            const resourceItem = this.resources.find((item) => item.RESOURCE_NAME === resourceName);
+            if (resourceItem) {
+                return resourceItem.RESOURCE_TYPE;
+            }
+            const message = `${resourceName} resource does not exist.`;
+            logger.error(message);
+            if (this.config.throwWhenUnknown) {
+                throw new Error(message);
+            }
+        });
+    }
+    /** {@inheritDoc GenesisResources.destroy} */
+    destroy() {
+        this.resources = undefined;
+        this.resourcesPromise = undefined;
+    }
+    getResources() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.resourcesPromise) {
+                /**
+                 * Await a resources request
+                 */
+                this.resourcesPromise = this.connect.getAvailableResources();
+                const data = yield this.resourcesPromise;
+                this.resources = data === null || data === void 0 ? void 0 : data.RESOURCES;
+                if (!((_a = this.resources) === null || _a === void 0 ? void 0 : _a.length)) {
+                    const message = `Genesis resources unavailable.`;
+                    logger.error(message);
+                    if (this.config.throwWhenUnavailable) {
+                        throw new Error(message);
+                    }
+                }
+                this.postLoadedMessage();
+                this.resourcesPromise = undefined;
+            }
+            else {
+                /**
+                 * Await the in-progress resources request
+                 */
+                yield this.resourcesPromise;
+            }
+        });
+    }
+    postLoadedMessage() {
+        /**
+         * Normally we'd inject channels into components and call their `channel.close()` api on `disconnectedCallback`.
+         * However, in shared long-lived service instances like this, channels may lead to tests failing to exit as they are
+         * not garbage collected by default. Creating and destroying the channel on on-demand poses less risk.
+         */
+        const channel = getGenesisResourcesChannel();
+        channel.postMessage('resources-loaded', this.resources);
+        channel.close();
+    }
+};
+DefaultGenesisResources = __decorate([
+    __param(0, Connect),
+    __param(1, GenesisResourcesConfig)
+], DefaultGenesisResources);
+export { DefaultGenesisResources };
+/**
+ * GenesisResources DI key.
+ * @internal
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ */
+export const GenesisResources = DI.createInterface((x) => x.singleton(DefaultGenesisResources));
+/**
+ * Gets GenesisResources from the DI container.
+ *
+ * @remarks
+ * A utility method for host applications that are not using decorators or the DI container.
+ *
+ * @example
+ * ```ts
+ * import { getGenesisResources } from '@genesislcap/foundation-comms';
+ * ...
+ * const genesisResources = getGenesisResources();
+ * ```
+ * @public
+ */
+export function getGenesisResources() {
+    return DI.getOrCreateDOMContainer().get(GenesisResources);
+}

package/dist/esm/resources/genesis/index.js

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './genesis';
+export * from './types';

package/dist/esm/resources/genesis/types.js

@@ -0,0 +1,4 @@
+/**
+ * @public
+ */
+export const GenesisResourcesChannelId = 'genesis-resources';

package/dist/esm/resources/index.js

@@ -0,0 +1 @@
+export * from './genesis';

package/dist/esm/testing/mocks/auth/auth.js

@@ -1,4 +1,5 @@
 import { __awaiter, __decorate } from "tslib";
+import { DefaultUser } from '@genesislcap/foundation-user';
 import { observable } from '@microsoft/fast-element';
 /**
  * @internal
@@ -25,6 +26,15 @@ export class AuthMock {
             return Promise.resolve(this.nextReAuthResult);
         });
     }
+    setTestUser(properties = {}) {
+        this.currentUser = new DefaultUser();
+        this.currentUser.set(Object.assign({ userName: 'JaneDee', profile: ['USER'], permission: ['CreateRules'] }, properties));
+        this.isLoggedIn = true;
+    }
+    resetTestUser() {
+        this.currentUser = null;
+        this.isLoggedIn = false;
+    }
 }
 __decorate([
     observable

package/dist/esm/testing/mocks/connect/connect.js

@@ -1,3 +1,4 @@
+import { __awaiter } from "tslib";
 import { from } from 'rxjs';
 /**
  * @internal
@@ -7,6 +8,9 @@ export class ConnectMock {
         this.isConnected = true;
         this.isWorking = false;
     }
+    get host() {
+        return this.socket.host;
+    }
     get isConnectedSubject() {
         return this.socket.isConnectedSubject;
     }
@@ -27,6 +31,7 @@ export class ConnectMock {
         return Promise.resolve(this.nextMessage);
     }
     connect(host) {
+        this.socket.host = host;
         return Promise.resolve(this.isConnected);
     }
     disconnect() { }
@@ -38,8 +43,10 @@ export class ConnectMock {
         return Promise.resolve(this.nextMessage);
     }
     getAvailableResources(params) {
-        this.requestParams = params;
-        return Promise.resolve(this.nextMessage);
+        return __awaiter(this, void 0, void 0, function* () {
+            this.requestParams = params;
+            return Promise.resolve(this.nextMessage);
+        });
     }
     snapshot(resourceName, params) {
         return Promise.resolve(this.nextMessage);

package/dist/esm/testing/mocks/connect/socket.js

@@ -6,9 +6,11 @@ import { SocketSubject } from '../../../connect/socket';
 export class SocketMock {
     constructor() {
         this.isConnectedSubject = new BehaviorSubject(true);
+        this.host = 'mock-host';
         this.socketMessagesSubject = new SocketSubject();
     }
     connect(host, options, reconnectOptions) {
+        this.host = host;
         return Promise.resolve(true);
     }
     disconnect() { }