@cratis/arc 20.60.0 → 20.60.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/arc",
-    "version": "20.60.0",
+    "version": "20.60.2",
     "description": "",
     "author": "Cratis",
     "license": "MIT",

package/queries/HubConnectionKeepAlive.ts

@@ -22,7 +22,8 @@
 export class HubConnectionKeepAlive {
     private _lastActivityTime = Date.now();
     private _timer?: ReturnType<typeof setInterval>;
-    private readonly _idleThresholdMs: number;
+    private _intervalMs: number;
+    private _idleThresholdMs: number;
 
     /**
      * Initializes a new instance of {@link HubConnectionKeepAlive}.
@@ -35,11 +36,37 @@ export class HubConnectionKeepAlive {
      *   cadence to account for network latency and timer jitter.
      */
     constructor(
-        private readonly _intervalMs: number,
+        intervalMs: number,
         private readonly _onIdle: () => void,
         idleThresholdMs?: number,
     ) {
-        this._idleThresholdMs = idleThresholdMs ?? _intervalMs;
+        this._intervalMs = intervalMs;
+        this._idleThresholdMs = idleThresholdMs ?? intervalMs;
+    }
+
+    /**
+     * Gets how long (in milliseconds) without activity before the connection is considered idle.
+     */
+    get idleThresholdMs(): number {
+        return this._idleThresholdMs;
+    }
+
+    /**
+     * Change the check interval and idle threshold, restarting the timer when it is already running.
+     *
+     * Used when the peer advertises its actual keep-alive cadence after connecting, so the client
+     * stops relying on an assumed default that may not match the server's configuration.
+     * @param {number} intervalMs How often (in milliseconds) to check for idle connections.
+     * @param {number} idleThresholdMs How long (in milliseconds) without activity before the connection is considered idle.
+     */
+    reconfigure(intervalMs: number, idleThresholdMs: number): void {
+        const wasRunning = this._timer !== undefined;
+        this._intervalMs = intervalMs;
+        this._idleThresholdMs = idleThresholdMs;
+
+        if (wasRunning) {
+            this.start();
+        }
     }
 
     /**

package/queries/NullObservableQueryConnection.ts

@@ -13,8 +13,11 @@ export class NullObservableQueryConnection<TDataType> implements IObservableQuer
     /**
      * Initializes a new instance of the {@link NullObservableQueryConnection} class.
      * @param {TDataType} defaultValue The default value to serve.
+     * @param {QueryResult<TDataType>} result Optional result to serve instead of an empty one. Supply it when the
+     * subscription failed for a reason the subscriber must be able to see — client-side validation in particular,
+     * which would otherwise be indistinguishable from a query that simply has no data yet.
      */
-    constructor(readonly defaultValue: TDataType) {
+    constructor(readonly defaultValue: TDataType, readonly result?: QueryResult<TDataType>) {
     }
 
     /** @inheritdoc */
@@ -29,7 +32,7 @@ export class NullObservableQueryConnection<TDataType> implements IObservableQuer
 
     /** @inheritdoc */
     connect(dataReceived: DataReceived<TDataType>) {
-        dataReceived(QueryResult.empty(this.defaultValue));
+        dataReceived(this.result ?? QueryResult.empty(this.defaultValue));
     }
 
     /** @inheritdoc */

package/queries/ObservableQueryFor.ts

@@ -4,6 +4,7 @@
 import { IObservableQueryFor, OnNextResult } from './IObservableQueryFor';
 import { ObservableQuerySubscription } from './ObservableQuerySubscription';
 import { ValidateRequestArguments } from './ValidateRequestArguments';
+import { QueryValidator } from './QueryValidator';
 import { IObservableQueryConnection } from './IObservableQueryConnection';
 import { NullObservableQueryConnection } from './NullObservableQueryConnection';
 import { createObservableQueryConnection } from './ObservableQueryConnectionFactory';
@@ -38,6 +39,7 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
     abstract readonly route: string;
     abstract readonly defaultValue: TDataType;
     readonly roles: string[] = [];
+    readonly validation?: QueryValidator<any>;
     /** Backend fully-qualified query name used when subscribing via the SSE hub. Overridden in generated proxies. */
     readonly queryName?: string;
     abstract readonly parameterDescriptors: ParameterDescriptor[];
@@ -97,7 +99,14 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
             this._connection.disconnect();
         }
 
-        if (!this.validateArguments(args)) {
+        const clientValidationErrors = this.validation?.validate(args as object || {}) || [];
+        if (clientValidationErrors.length > 0) {
+            // Serve the failure through the connection rather than throwing, so a subscriber sees an invalid result
+            // on its normal callback path instead of the empty result an unestablished connection would emit.
+            this._connection = new NullObservableQueryConnection(
+                this.defaultValue,
+                QueryResult.validationFailed(clientValidationErrors, this));
+        } else if (!this.validateArguments(args)) {
             this._connection = new NullObservableQueryConnection(this.defaultValue);
         } else {
             this._connection = createObservableQueryConnection({
@@ -143,6 +152,11 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
     async perform(args?: TParameters): Promise<QueryResult<TDataType>> {
         const noSuccess = { ...QueryResult.noSuccess, ...{ data: this.defaultValue } } as QueryResult<TDataType>;
 
+        const clientValidationErrors = this.validation?.validate(args as object || {}) || [];
+        if (clientValidationErrors.length > 0) {
+            return QueryResult.validationFailed(clientValidationErrors, this);
+        }
+
         if (!this.validateArguments(args)) {
             return new Promise<QueryResult<TDataType>>((resolve) => {
                 resolve(noSuccess);

package/queries/QueryFor.ts

@@ -87,27 +87,7 @@ export abstract class QueryFor<TDataType, TParameters = object> implements IQuer
 
         const clientValidationErrors = this.validation?.validate(args as object || {}) || [];
         if (clientValidationErrors.length > 0) {
-            return new QueryResult({
-                data: this.defaultValue as object,
-                isSuccess: false,
-                isAuthorized: true,
-                isValid: false,
-                hasExceptions: false,
-                validationResults: clientValidationErrors.map(_ => ({
-                    severity: _.severity,
-                    message: _.message,
-                    members: _.members,
-                    state: _.state
-                })),
-                exceptionMessages: [],
-                exceptionStackTrace: '',
-                paging: {
-                    totalItems: 0,
-                    totalPages: 0,
-                    page: 0,
-                    size: 0
-                }
-            }, this.modelType, this.enumerable) as QueryResult<TDataType>;
+            return QueryResult.validationFailed(clientValidationErrors, this);
         }
 
         if (!ValidateRequestArguments(this.constructor.name, this.requiredRequestParameters, args as object)) {

package/queries/QueryInstanceCache.ts

@@ -3,6 +3,7 @@
 
 import { QueryResultWithState } from './QueryResultWithState';
 import { CacheDiagnostics, CacheEntryDiagnostics } from './ObservableQueryDiagnosticsSnapshot';
+import { reconcileQueryData } from './reconcileQueryData';
 
 /**
  * Represents a key that uniquely identifies a query instance in the cache, based on the query type name and its serialized arguments.
@@ -171,25 +172,68 @@ export class QueryInstanceCache {
     setLastResult<TDataType>(key: QueryCacheKey, result: QueryResultWithState<TDataType>): void {
         const entry = this._entries.get(key);
 
-        if (entry) {
-            const previousResult = entry.lastResult as QueryResultWithState<TDataType> | undefined;
-            entry.lastResult = result as QueryResultWithState<unknown>;
-
-            // Suppress re-renders when the server re-sends identical data after a reconnect.
-            // We only compare `data` and `isSuccess` — other fields (e.g. changeSet) are
-            // ephemeral and do not affect what the user sees.
-            if (
-                previousResult !== undefined &&
-                previousResult.isSuccess === result.isSuccess &&
-                JSON.stringify(previousResult.data) === JSON.stringify(result.data)
-            ) {
-                return;
-            }
+        if (!entry) {
+            return;
+        }
 
-            for (const listener of entry.listeners) {
-                (listener as QueryCacheListener<TDataType>)(result);
-            }
+        const previousResult = entry.lastResult as QueryResultWithState<TDataType> | undefined;
+
+        // Reconcile the incoming payload against the one already held so items that did not actually
+        // change keep their previous references. A full snapshot — which is what the server re-sends
+        // whenever a subscription is re-established — otherwise arrives as all-new references and
+        // makes every consumer treat every item as changed.
+        const reconciled = previousResult !== undefined
+            ? this.withReconciledData(previousResult, result)
+            : result;
+
+        entry.lastResult = reconciled as QueryResultWithState<unknown>;
+
+        // Reconciliation returns the previous data reference when nothing changed, so identity is
+        // enough to detect it. Only `data` and `isSuccess` matter here — the other fields (e.g.
+        // changeSet) are ephemeral and do not affect what the user sees.
+        if (
+            previousResult !== undefined &&
+            previousResult.isSuccess === reconciled.isSuccess &&
+            previousResult.data === reconciled.data
+        ) {
+            return;
         }
+
+        for (const listener of entry.listeners) {
+            (listener as QueryCacheListener<TDataType>)(reconciled);
+        }
+    }
+
+    /**
+     * Returns the incoming result with its data reconciled against the previous result, or the
+     * incoming result unchanged when reconciliation found nothing to carry over.
+     * @template TDataType The type of data returned by the query.
+     * @param previous The previously held result.
+     * @param next The freshly received result.
+     * @returns A result whose data preserves references for everything that did not change.
+     */
+    private withReconciledData<TDataType>(
+        previous: QueryResultWithState<TDataType>,
+        next: QueryResultWithState<TDataType>
+    ): QueryResultWithState<TDataType> {
+        const reconciledData = reconcileQueryData(previous.data, next.data);
+
+        if (reconciledData === next.data) {
+            return next;
+        }
+
+        return new QueryResultWithState<TDataType>(
+            reconciledData,
+            next.paging,
+            next.isSuccess,
+            next.isAuthorized,
+            next.isValid,
+            next.validationResults,
+            next.hasExceptions,
+            next.exceptionMessages,
+            next.exceptionStackTrace,
+            next.isPerforming,
+            next.changeSet);
     }
 
     /**

package/queries/QueryResult.ts

@@ -71,6 +71,40 @@ export class QueryResult<TDataType = object> implements IQueryResult<TDataType>
         }, Object, false);
     }
 
+    /**
+     * Creates a {@link QueryResult} representing a query rejected by client-side validation, mirroring
+     * {@link CommandResult.validationFailed} so a caller reads a failed query the same way it reads a failed command.
+     * @param {ValidationResult[]} validationResults The validation results that caused the failure.
+     * @param {object} query The query being rejected, which describes how to shape its own result.
+     * @returns {QueryResult<TDataType>} A result that is neither successful nor valid.
+     */
+    static validationFailed<TDataType>(
+        validationResults: ValidationResult[],
+        query: { readonly defaultValue: TDataType; readonly modelType: Constructor; readonly enumerable: boolean }): QueryResult<TDataType> {
+        const { defaultValue, modelType, enumerable } = query;
+        return new QueryResult({
+            data: defaultValue as object,
+            isSuccess: false,
+            isAuthorized: true,
+            isValid: false,
+            hasExceptions: false,
+            validationResults: validationResults.map(_ => ({
+                severity: _.severity,
+                message: _.message,
+                members: _.members,
+                state: _.state
+            })),
+            exceptionMessages: [],
+            exceptionStackTrace: '',
+            paging: {
+                totalItems: 0,
+                totalPages: 0,
+                page: 0,
+                size: 0
+            }
+        }, modelType, enumerable) as QueryResult<TDataType>;
+    }
+
     static unauthorized<TDataType>(): QueryResult<TDataType> {
         return new QueryResult({
             data: null as unknown as object,

package/queries/ServerSentEventHubConnection.ts

@@ -17,6 +17,15 @@ interface ActiveSubscription {
     callback: DataReceived<any>;
 }
 
+/**
+ * How many keep-alive intervals of silence are tolerated before the connection is considered dead.
+ *
+ * The server guarantees a message every interval, so this is pure slack for latency and jitter.
+ * It must stay above 1 — a threshold at or below the server's own cadence makes the client and
+ * server timers race, and the client tears down connections the server considers healthy.
+ */
+const IDLE_THRESHOLD_FACTOR = 2;
+
 /**
  * A multiplexed SSE hub connection that uses EventSource for server→client streaming
  * and fetch POST requests for client→server subscribe/unsubscribe commands.
@@ -45,8 +54,9 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
      * @param {string} _subscribeUrl The subscribe POST endpoint URL.
      * @param {string} _unsubscribeUrl The unsubscribe POST endpoint URL.
      * @param {string} _microservice The microservice name to pass as a query argument.
-     * @param {number} keepAliveIntervalMs How long without any server message before the connection
-     *   is considered stale and a reconnect is forced (default: 30 000 ms).
+     * @param {number} keepAliveIntervalMs The keep-alive cadence to assume until the server advertises
+     *   its own on the {@link HubMessageType.Connected} message (default: 30 000 ms). The connection is
+     *   considered stale after {@link IDLE_THRESHOLD_FACTOR} times this without any server message.
      * @param {number} connectTimeoutMs How long to wait for the {@link HubMessageType.Connected}
      *   message after the HTTP connection opens before giving up and retrying (default: 15 000 ms).
      * @param {IReconnectPolicy} _policy The reconnect policy to use (default: {@link ReconnectPolicy}).
@@ -64,18 +74,20 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         // inactivity — if the server stops sending messages (including its own keep-alive
         // pings) for the entire idle threshold, the connection is stale and we reconnect.
         //
-        // The idle threshold is set to 1.5× the check interval so the server's keep-alive
-        // ping (which fires on the same cadence) has time to arrive over the network before
-        // the client declares the connection dead. Without this tolerance the client's timer
-        // and the server's timer race — the client often fires first and reconnects
-        // unnecessarily.
-        const idleThresholdMs = Math.round(keepAliveIntervalMs * 1.5);
+        // The server guarantees a message at least every keep-alive interval, so the threshold
+        // only has to absorb network latency, timer jitter and server-side scheduling hiccups.
+        // A hard TCP drop surfaces immediately through `onerror`, so this watchdog only needs to
+        // catch silent black-holes — that makes a generous tolerance strictly better than a tight
+        // one, which would tear down healthy connections.
+        //
+        // The interval below is only the starting assumption; the server advertises its real
+        // cadence on the Connected message and {@link handleConnected} reconfigures from it.
         this._keepAlive = new HubConnectionKeepAlive(keepAliveIntervalMs, () => {
             if (!this._disconnected && this._subscriptions.size > 0) {
-                console.warn(`SSE hub: no messages received for ${idleThresholdMs}ms, reconnecting '${this._sseUrl}'`);
+                console.warn(`SSE hub: no messages received for ${this._keepAlive.idleThresholdMs}ms, reconnecting '${this._sseUrl}'`);
                 this.reconnect();
             }
-        }, idleThresholdMs);
+        }, keepAliveIntervalMs * IDLE_THRESHOLD_FACTOR);
     }
 
     /** @inheritdoc */
@@ -277,6 +289,8 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         // Connected message arrived — cancel the connect timeout.
         this.clearConnectTimeout();
 
+        this.applyServerKeepAliveInterval(message.keepAliveIntervalMs);
+
         // Send all pending subscriptions now that we have a connection ID.
         for (const [queryId, sub] of this._pendingSubscriptions) {
             this.sendSubscribe(queryId, sub.request);
@@ -284,6 +298,27 @@ export class ServerSentEventHubConnection implements IObservableQueryHubConnecti
         this._pendingSubscriptions.clear();
     }
 
+    /**
+     * Align the idle watchdog with the keep-alive cadence the server actually runs on.
+     *
+     * Without this the client assumes the default interval, so a server configured with a longer
+     * interval — or with keep-alive switched off entirely — would look silent and be reconnected
+     * on a loop even though it is perfectly healthy.
+     * @param {number | undefined} serverIntervalMs The interval advertised by the server, if any.
+     */
+    private applyServerKeepAliveInterval(serverIntervalMs?: number): void {
+        if (serverIntervalMs === undefined) return;
+
+        // Keep-alive disabled server-side: silence is expected, so watching for it would guarantee
+        // an endless reconnect loop. Hard drops still surface through `onerror`.
+        if (serverIntervalMs <= 0) {
+            this._keepAlive.stop();
+            return;
+        }
+
+        this._keepAlive.reconfigure(serverIntervalMs, serverIntervalMs * IDLE_THRESHOLD_FACTOR);
+    }
+
     private handleQueryResult(message: HubMessage): void {
         if (!message.queryId) return;
 

package/queries/WebSocketHubConnection.ts

@@ -33,6 +33,12 @@ export interface HubMessage {
     queryId?: string;
     payload?: any;
     timestamp?: number;
+
+    /**
+     * The server's keep-alive interval in milliseconds, or 0 when keep-alive is disabled.
+     * Only present on {@link HubMessageType.Connected} messages.
+     */
+    keepAliveIntervalMs?: number;
 }
 
 /**

package/queries/for_HubConnectionKeepAlive/when_reconfiguring/while_running.ts

@@ -0,0 +1,50 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { HubConnectionKeepAlive } from '../../HubConnectionKeepAlive';
+
+describe('when reconfiguring a running keep-alive', () => {
+    let clock: sinon.SinonFakeTimers;
+    let onIdle: sinon.SinonStub;
+    let keepAlive: HubConnectionKeepAlive;
+
+    const originalIntervalMs = 500;
+    const originalThresholdMs = 750;
+    const newIntervalMs = 1000;
+    const newThresholdMs = 2000;
+
+    beforeEach(() => {
+        clock = sinon.useFakeTimers();
+        onIdle = sinon.stub();
+        keepAlive = new HubConnectionKeepAlive(originalIntervalMs, onIdle, originalThresholdMs);
+        keepAlive.start();
+        keepAlive.reconfigure(newIntervalMs, newThresholdMs);
+    });
+
+    afterEach(() => {
+        keepAlive.stop();
+        clock.restore();
+        sinon.restore();
+    });
+
+    it('should expose the new idle threshold', () => keepAlive.idleThresholdMs.should.equal(newThresholdMs));
+
+    describe('and the original threshold elapses', () => {
+        beforeEach(() => {
+            // Well past the original 750ms threshold, but short of the new 2000ms one.
+            clock.tick(originalThresholdMs + 1);
+        });
+
+        it('should not invoke the onIdle callback', () => onIdle.called.should.be.false);
+    });
+
+    describe('and the new threshold elapses', () => {
+        beforeEach(() => {
+            // Checks now fire every 1000ms; the tick at 2000ms sees 2000ms of inactivity.
+            clock.tick(newThresholdMs + 1);
+        });
+
+        it('should invoke the onIdle callback', () => onIdle.calledOnce.should.be.true);
+    });
+});

package/queries/for_HubConnectionKeepAlive/when_reconfiguring/while_stopped.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { HubConnectionKeepAlive } from '../../HubConnectionKeepAlive';
+
+describe('when reconfiguring a keep-alive that has not been started', () => {
+    let clock: sinon.SinonFakeTimers;
+    let onIdle: sinon.SinonStub;
+    let keepAlive: HubConnectionKeepAlive;
+
+    beforeEach(() => {
+        clock = sinon.useFakeTimers();
+        onIdle = sinon.stub();
+        keepAlive = new HubConnectionKeepAlive(500, onIdle, 750);
+        keepAlive.reconfigure(1000, 2000);
+        clock.tick(10000);
+    });
+
+    afterEach(() => {
+        keepAlive.stop();
+        clock.restore();
+        sinon.restore();
+    });
+
+    it('should not start the timer', () => onIdle.called.should.be.false);
+    it('should still apply the new idle threshold', () => keepAlive.idleThresholdMs.should.equal(2000));
+});

package/queries/for_ObservableQueryFor/given/an_observable_query_with_validator.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ObservableQueryFor } from '../../ObservableQueryFor';
+import { QueryValidator } from '../../QueryValidator';
+import { ParameterDescriptor } from '../../../reflection/ParameterDescriptor';
+import '../../../validation/RuleBuilderExtensions';
+
+export interface ITestParams {
+    minAge: number;
+}
+
+export class TestObservableQueryValidator extends QueryValidator<ITestParams> {
+    constructor() {
+        super();
+        this.ruleFor((c: ITestParams) => c.minAge).greaterThanOrEqual(0).withMessage('Age must be positive');
+    }
+}
+
+export class TestObservableQuery extends ObservableQueryFor<string, ITestParams> {
+    readonly route = '/test';
+    readonly validation = new TestObservableQueryValidator();
+    readonly parameterDescriptors: ParameterDescriptor[] = [];
+    readonly defaultValue = '';
+
+    constructor() {
+        super(String, false);
+    }
+
+    get requiredRequestParameters(): string[] {
+        return [];
+    }
+}
+
+export class an_observable_query_with_validator {
+    query: TestObservableQuery;
+
+    constructor() {
+        this.query = new TestObservableQuery();
+    }
+}

package/queries/for_ObservableQueryFor/when_performing/with_client_validation_failing.ts

@@ -0,0 +1,30 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { an_observable_query_with_validator } from '../given/an_observable_query_with_validator';
+import { QueryResult } from '../../QueryResult';
+import { given } from '../../../given';
+
+describe('when performing with client validation failing', given(an_observable_query_with_validator, context => {
+    let result: QueryResult<string>;
+
+    beforeEach(async () => {
+        result = await context.query.perform({ minAge: -5 });
+    });
+
+    it('should not be success', () => {
+        result.isSuccess.should.be.false;
+    });
+
+    it('should not be valid', () => {
+        result.isValid.should.be.false;
+    });
+
+    it('should have validation results', () => {
+        result.validationResults.should.not.be.empty;
+    });
+
+    it('should have error for minAge', () => {
+        result.validationResults.some(_ => _.members.includes('minAge')).should.be.true;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_client_validation_failing.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { an_observable_query_with_validator } from '../given/an_observable_query_with_validator';
+import { QueryResult } from '../../QueryResult';
+import { given } from '../../../given';
+
+describe('when subscribing with client validation failing', given(an_observable_query_with_validator, context => {
+    let result: QueryResult<string>;
+
+    beforeEach(() => {
+        context.query.subscribe(_ => result = _, { minAge: -5 });
+    });
+
+    it('should push a result to the subscriber', () => {
+        result.should.not.be.undefined;
+    });
+
+    it('should not be valid', () => {
+        result.isValid.should.be.false;
+    });
+
+    it('should have error for minAge', () => {
+        result.validationResults.some(_ => _.members.includes('minAge')).should.be.true;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_client_validation_passing.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { an_observable_query_with_validator } from '../given/an_observable_query_with_validator';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
+
+describe('when subscribing with client validation passing', given(an_observable_query_with_validator, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string>;
+
+    beforeEach(() => {
+        context.query.setOrigin('https://example.com'); // Set origin to avoid document access
+        callback = sinon.stub();
+
+        subscription = context.query.subscribe(callback, { minAge: 18 });
+    });
+
+    afterEach(() => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    });
+
+    // A real connection is established rather than one that immediately serves a result, which is what
+    // distinguishes a subscription that passed validation from one that was rejected by it.
+    it('should not call callback immediately', () => {
+        callback.called.should.be.false;
+    });
+}));

package/queries/for_QueryInstanceCache/when_setting_last_result/with_a_partially_changed_result.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { QueryInstanceCache } from '../../QueryInstanceCache';
+import { QueryResultWithState } from '../../QueryResultWithState';
+
+type Item = { id: string; name: string };
+
+describe('when a re-delivered snapshot changed only one of its items', () => {
+    const key = 'MyQuery::';
+    let cache: QueryInstanceCache;
+    let listener: sinon.SinonStub;
+    let stored: QueryResultWithState<Item[]>;
+
+    const first = QueryResultWithState.empty<Item[]>([
+        { id: 'a', name: 'First' },
+        { id: 'b', name: 'Second' }
+    ]);
+
+    const second = QueryResultWithState.empty<Item[]>([
+        { id: 'a', name: 'First' },
+        { id: 'b', name: 'Second changed' }
+    ]);
+
+    beforeEach(() => {
+        cache = new QueryInstanceCache();
+        cache.getOrCreate(key, () => ({}));
+        listener = sinon.stub();
+        cache.addListener(key, listener);
+
+        cache.setLastResult(key, first);
+        cache.setLastResult(key, second);
+        stored = cache.getLastResult<Item[]>(key)!;
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('should notify for both results', () => listener.calledTwice.should.be.true);
+    it('should keep the reference of the unchanged item', () => stored.data[0].should.equal(first.data[0]));
+    it('should take the new reference for the changed item', () => stored.data[1].should.equal(second.data[1]));
+    it('should carry the changed value', () => stored.data[1].name.should.equal('Second changed'));
+});