@cratis/arc 22.161.0 → 22.162.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "@cratis/arc",
-    "version": "22.161.0",
+    "version": "22.162.0",
     "description": "TypeScript command, query, validation, identity, and messaging runtime for Cratis Arc — the CQRS application framework for ASP.NET Core — used by generated proxies.",
     "keywords": [
         "cratis",

package/queries/QueryInstanceCache.ts

@@ -7,6 +7,7 @@ import type {
     CacheEntryDiagnostics,
 } from './ObservableQueryDiagnosticsSnapshot.js';
 import { reconcileQueryData } from './reconcileQueryData.js';
+import { deepEqual } from '../deepEqual.js';
 
 /**
  * Represents a key that uniquely identifies a query instance in the cache, based on the query type name and its serialized arguments.
@@ -203,13 +204,12 @@ export class QueryInstanceCache {
         entry.lastResult = reconciled as QueryResultWithState<unknown>;
 
         // Reconciliation returns the previous data reference when nothing changed, so identity is
-        // enough to detect it. Data, success, and readiness affect what the user sees; changeSet is
+        // enough to detect it. Data and result metadata affect what the user sees; changeSet is
         // ephemeral and does not independently require a notification.
         if (
             previousResult !== undefined &&
-            previousResult.isSuccess === reconciled.isSuccess &&
-            previousResult.isReady === reconciled.isReady &&
-            previousResult.data === reconciled.data
+            previousResult.data === reconciled.data &&
+            this.hasEquivalentMetadata(previousResult, reconciled)
         ) {
             return;
         }
@@ -253,6 +253,19 @@ export class QueryInstanceCache {
         );
     }
 
+    private hasEquivalentMetadata<TDataType>(result: QueryResultWithState<TDataType>, previous: QueryResultWithState<TDataType>): boolean {
+        return result.isPerforming === previous.isPerforming
+            && result.isSuccess === previous.isSuccess
+            && result.isReady === previous.isReady
+            && result.isAuthorized === previous.isAuthorized
+            && result.isValid === previous.isValid
+            && result.hasExceptions === previous.hasExceptions
+            && result.exceptionStackTrace === previous.exceptionStackTrace
+            && deepEqual(result.paging, previous.paging)
+            && deepEqual(result.exceptionMessages, previous.exceptionMessages)
+            && deepEqual(result.validationResults, previous.validationResults);
+    }
+
     /**
      * Registers a listener that is invoked whenever the cached result for the given key changes.
      * @template TDataType The type of data returned by the query.

package/queries/for_QueryInstanceCache/when_setting_last_result/with_changed_metadata.ts

@@ -0,0 +1,58 @@
+// 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.js';
+import { QueryResultWithState } from '../../QueryResultWithState.js';
+import { PagingInfo } from '../../PagingInfo.js';
+import { ValidationResult } from '../../../validation/ValidationResult.js';
+import { ValidationResultSeverity } from '../../../validation/ValidationResultSeverity.js';
+import { ValidationResultReason } from '../../../validation/ValidationResultReason.js';
+
+type Item = { id: string };
+const validation = new ValidationResult(ValidationResultSeverity.Error, 'first', ['name'], { limit: 1 });
+const changes: [string, Partial<QueryResultWithState<Item[]>>][] = [
+    ['paging total items', { paging: { ...new PagingInfo(), totalItems: 2 } }],
+    ['paging total pages', { paging: { ...new PagingInfo(), totalPages: 2 } }],
+    ['paging page', { paging: { ...new PagingInfo(), page: 1 } }],
+    ['paging size', { paging: { ...new PagingInfo(), size: 10 } }],
+    ['authorization', { isAuthorized: false }],
+    ['validity', { isValid: false }],
+    ['exception flag', { hasExceptions: true }],
+    ['exception messages', { exceptionMessages: ['second'] }],
+    ['exception stack trace', { exceptionStackTrace: 'second stack' }],
+    ['performing state', { isPerforming: true }],
+    ['validation message', { validationResults: [{ ...validation, message: 'second' }] }],
+    ['validation severity', { validationResults: [{ ...validation, severity: ValidationResultSeverity.Warning }] }],
+    ['validation members', { validationResults: [{ ...validation, members: ['other'] }] }],
+    ['validation state', { validationResults: [{ ...validation, state: { limit: 2 } }] }],
+    ['validation reason', { validationResults: [{ ...validation, reason: ValidationResultReason.ConstraintViolation }] }],
+    ['validation reason detail', { validationResults: [{ ...validation, reasonDetail: 'required' }] }]
+];
+
+for (const [field, change] of changes) {
+    describe(`when setting the last result with changed ${field}`, () => {
+        const key = 'MyQuery::';
+        let cache: QueryInstanceCache;
+        let listener: sinon.SinonStub;
+        let first: QueryResultWithState<Item[]>;
+
+        beforeEach(() => {
+            cache = new QueryInstanceCache();
+            cache.getOrCreate(key, () => ({}));
+            first = Object.assign(QueryResultWithState.empty([{ id: 'a' }]), {
+                isSuccess: false,
+                validationResults: [validation],
+                exceptionMessages: ['first']
+            });
+            cache.setLastResult(key, first);
+            listener = sinon.stub();
+            cache.addListener(key, listener);
+            const next = Object.assign(QueryResultWithState.empty([{ id: 'a' }]), first, { data: [{ id: 'a' }] }, change);
+            cache.setLastResult(key, next);
+        });
+
+        it('should notify the listener', () => listener.calledOnce.should.be.true);
+        it('should preserve unchanged row references', () => cache.getLastResult<Item[]>(key)!.data[0].should.equal(first.data[0]));
+    });
+}

package/queries/for_QueryInstanceCache/when_setting_last_result/with_equivalent_metadata.ts

@@ -0,0 +1,39 @@
+// 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.js';
+import { QueryResultWithState } from '../../QueryResultWithState.js';
+import { PagingInfo } from '../../PagingInfo.js';
+import { ValidationResult } from '../../../validation/ValidationResult.js';
+import { ValidationResultSeverity } from '../../../validation/ValidationResultSeverity.js';
+
+for (const changeSetOnly of [false, true]) {
+    describe(`when setting the last result with ${changeSetOnly ? 'only a changed change set' : 'equivalent metadata'}`, () => {
+        let listener: sinon.SinonStub;
+
+        const result = () => new QueryResultWithState(
+            [{ id: 'a' }],
+            { ...new PagingInfo(), totalItems: 1, totalPages: 1 },
+            false, true, false,
+            [new ValidationResult(ValidationResultSeverity.Error, 'invalid', ['name'], { limit: 1 })],
+            true, ['failed'], 'stack', false
+        );
+
+        beforeEach(() => {
+            const cache = new QueryInstanceCache();
+            const key = 'MyQuery::';
+            cache.getOrCreate(key, () => ({}));
+            cache.setLastResult(key, result());
+            listener = sinon.stub();
+            cache.addListener(key, listener);
+            const next = result();
+            if (changeSetOnly) {
+                Object.assign(next, { changeSet: { added: [{ id: 'a' }], replaced: [], removed: [] } });
+            }
+            cache.setLastResult(key, next);
+        });
+
+        it('should suppress the notification', () => listener.notCalled.should.be.true);
+    });
+}