@cratis/arc 20.66.0 → 20.66.1

package/package.json

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

package/queries/ObservableQueryFor.ts

@@ -9,7 +9,7 @@ import { IObservableQueryConnection } from './IObservableQueryConnection';
 import { NullObservableQueryConnection } from './NullObservableQueryConnection';
 import { createObservableQueryConnection } from './ObservableQueryConnectionFactory';
 import { Constructor } from '@cratis/fundamentals';
-import { JsonSerializer } from '@cratis/fundamentals';
+import { deserializeQueryModel, deserializeQueryModels } from './deserializeQueryModel';
 import { QueryResult } from './QueryResult';
 import { Sorting } from './Sorting';
 import { Paging } from './Paging';
@@ -219,13 +219,9 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
 
     private deserializeResult(result: any): void {
         if (this.enumerable) {
-            if (Array.isArray(result.data)) {
-                result.data = JsonSerializer.deserializeArrayFromInstance(this.modelType, result.data);
-            } else {
-                result.data = [];
-            }
+            result.data = deserializeQueryModels(this.modelType, result.data);
         } else if (result.data) {
-            result.data = JsonSerializer.deserializeFromInstance(this.modelType, result.data);
+            result.data = deserializeQueryModel(this.modelType, result.data);
         }
     }
 }

package/queries/QueryResult.ts

@@ -1,11 +1,12 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { Constructor, JsonSerializer } from '@cratis/fundamentals';
+import { Constructor } from '@cratis/fundamentals';
 import { ValidationResult } from '../validation/ValidationResult';
 import { IQueryResult } from './IQueryResult';
 import { PagingInfo } from './PagingInfo';
 import { ChangeSet } from './ChangeSet';
+import { deserializeQueryModel, deserializeQueryModels } from './deserializeQueryModel';
 
 type ServerQueryResult = {
     /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -162,37 +163,18 @@ export class QueryResult<TDataType = object> implements IQueryResult<TDataType>
         this.paging.totalPages = result.paging.totalPages;
 
         if (result.data) {
-            let data: object = result.data;
-            const isPrimitive = instanceType === String || instanceType === Number || instanceType === Boolean;
-            if (enumerable) {
-                if (Array.isArray(result.data)) {
-                    data = isPrimitive
-                        ? Array.from(result.data)
-                        : JsonSerializer.deserializeArrayFromInstance(instanceType, data);
-                } else {
-                    data = [];
-                }
-            } else {
-                data = isPrimitive ? data : JsonSerializer.deserializeFromInstance(instanceType, data);
-            }
-
-            this.data = data as TDataType;
+            this.data = (enumerable
+                ? deserializeQueryModels(instanceType, result.data)
+                : deserializeQueryModel(instanceType, result.data)) as TDataType;
         } else {
             this.data = (enumerable ? [] : null) as TDataType;
         }
 
         if (enumerable && result.changeSet) {
-            const isPrimitive = instanceType === String || instanceType === Number || instanceType === Boolean;
             this.changeSet = {
-                added: isPrimitive
-                    ? Array.from(result.changeSet.added ?? [])
-                    : JsonSerializer.deserializeArrayFromInstance(instanceType, result.changeSet.added ?? []),
-                replaced: isPrimitive
-                    ? Array.from(result.changeSet.replaced ?? [])
-                    : JsonSerializer.deserializeArrayFromInstance(instanceType, result.changeSet.replaced ?? []),
-                removed: isPrimitive
-                    ? Array.from(result.changeSet.removed ?? [])
-                    : JsonSerializer.deserializeArrayFromInstance(instanceType, result.changeSet.removed ?? []),
+                added: deserializeQueryModels(instanceType, result.changeSet.added ?? []),
+                replaced: deserializeQueryModels(instanceType, result.changeSet.replaced ?? []),
+                removed: deserializeQueryModels(instanceType, result.changeSet.removed ?? []),
             } as ChangeSet<unknown>;
         }
     }

package/queries/deserializeQueryModel.ts

@@ -0,0 +1,66 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor, JsonSerializer } from '@cratis/fundamentals';
+
+/*
+ * ⚠️ deserializeQueryModel / deserializeQueryModels are for use WITHIN this package only.
+ *
+ * JsonSerializer's converter registry is module state, and a consumer package can easily resolve a
+ * different physical copy of @cratis/fundamentals than this one. Calling these from another package
+ * therefore looks up Guid/Date/concept converters in the wrong registry and silently degrades those
+ * values to plain deserialization. Other packages should use isPrimitiveModelType - which compares
+ * against the JavaScript globals and is safe across copies - and deserialize through their own
+ * JsonSerializer.
+ */
+
+/**
+ * Determines whether a model type is a JavaScript primitive wrapper rather than a real model.
+ *
+ * A query whose backend returns a primitive collection - `IEnumerable<string>`, `IEnumerable<int>` -
+ * generates a proxy with `String`, `Number` or `Boolean` as its model type.
+ * @param {Constructor} modelType The model type the query describes itself with.
+ * @returns {boolean} True when the type is a primitive wrapper.
+ */
+export function isPrimitiveModelType(modelType: Constructor | null | undefined): boolean {
+    return modelType === String || modelType === Number || modelType === Boolean;
+}
+
+/**
+ * Deserializes a single query payload into its model type, passing primitives through untouched.
+ *
+ * {@link JsonSerializer.deserializeFromInstance} is destructive for primitive wrapper types: it
+ * constructs `new String()` and copies declared fields onto it, which for a primitive means the
+ * value is discarded and an empty wrapper object is produced. Primitives therefore need to bypass
+ * deserialization entirely - they already arrive in their final shape.
+ * @param {Constructor} modelType The model type to deserialize into.
+ * @param {unknown} data The payload to deserialize.
+ * @returns {TDataType} The deserialized instance, or the payload unchanged for primitive types.
+ */
+export function deserializeQueryModel<TDataType>(modelType: Constructor | null | undefined, data: unknown): TDataType {
+    if (!modelType || modelType === Object || isPrimitiveModelType(modelType)) {
+        return data as TDataType;
+    }
+
+    return JsonSerializer.deserializeFromInstance(modelType, data) as TDataType;
+}
+
+/**
+ * Deserializes a query payload collection into its model type, passing primitives through untouched.
+ *
+ * See {@link deserializeQueryModel} for why primitive model types must bypass deserialization.
+ * @param {Constructor} modelType The instance type of the items to deserialize into.
+ * @param {unknown} data The payload to deserialize. A non-array payload yields an empty collection.
+ * @returns {TDataType[]} The deserialized items, or the items unchanged for primitive types.
+ */
+export function deserializeQueryModels<TDataType>(modelType: Constructor | null | undefined, data: unknown): TDataType[] {
+    if (!Array.isArray(data)) {
+        return [];
+    }
+
+    if (!modelType || modelType === Object || isPrimitiveModelType(modelType)) {
+        return Array.from(data) as TDataType[];
+    }
+
+    return JsonSerializer.deserializeArrayFromInstance(modelType, data) as TDataType[];
+}

package/queries/for_ObservableQueryFor/when_receiving_a_result/and_the_model_type_is_a_primitive_collection.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import * as sinon from 'sinon';
+import { an_observable_query_for } from '../given/an_observable_query_for';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { EventSourceFactory } from '../../../EventSourceFactory';
+import { QueryResult } from '../../QueryResult';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
+
+interface FakeEventSource {
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: (() => void) | null;
+    close: sinon.SinonStub;
+}
+
+describe('and the model type is a primitive collection', given(an_observable_query_for, context => {
+    let subscription: ObservableQuerySubscription<string[]>;
+    let fakeEventSource: FakeEventSource;
+    let received: QueryResult<string[]>[];
+    let originalQueryDirectMode: boolean;
+    let originalTransportMethod: QueryTransportMethod;
+    let originalFactory: EventSourceFactory | undefined;
+
+    beforeEach(() => {
+        originalQueryDirectMode = Globals.queryDirectMode;
+        originalTransportMethod = Globals.queryTransportMethod;
+        originalFactory = Globals.eventSourceFactory;
+
+        Globals.queryDirectMode = true;
+        Globals.queryTransportMethod = QueryTransportMethod.ServerSentEvents;
+
+        fakeEventSource = { onmessage: null, onerror: null, close: sinon.stub() };
+        Globals.eventSourceFactory = (() => fakeEventSource) as unknown as EventSourceFactory;
+
+        context.enumerableQuery.setOrigin('https://example.com');
+
+        received = [];
+        subscription = context.enumerableQuery.subscribe(
+            result => received.push(result),
+            { category: 'test-category' });
+
+        fakeEventSource.onmessage!({
+            data: JSON.stringify({
+                data: ['first', 'second'],
+                isSuccess: true,
+                isAuthorized: true,
+                isValid: true,
+                hasExceptions: false,
+                validationResults: [],
+                exceptionMessages: [],
+                exceptionStackTrace: '',
+                paging: { page: 0, size: 0, totalItems: 0, totalPages: 0 }
+            })
+        } as MessageEvent);
+    });
+
+    afterEach(() => {
+        subscription?.unsubscribe();
+        Globals.queryDirectMode = originalQueryDirectMode;
+        Globals.queryTransportMethod = originalTransportMethod;
+        Globals.eventSourceFactory = originalFactory;
+        sinon.restore();
+    });
+
+    it('should deliver the result to the subscriber', () => received.length.should.equal(1));
+    it('should keep every item a primitive string', () => received[0].data.every(_ => typeof _ === 'string').should.be.true);
+    it('should keep the values intact', () => received[0].data.should.deep.equal(['first', 'second']));
+}));

package/queries/for_deserializeQueryModel/when_deserializing_a_collection_of_models.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor, field } from '@cratis/fundamentals';
+import { deserializeQueryModels } from '../deserializeQueryModel';
+
+class Item {
+    @field(String)
+    name!: string;
+}
+
+describe('when deserializing a collection of models', () => {
+    const result = deserializeQueryModels<Item>(Item as Constructor, [{ name: 'first' }, { name: 'second' }]);
+
+    it('should produce instances of the model type', () => result.every(_ => _ instanceof Item).should.be.true);
+    it('should carry the values over', () => result.map(_ => _.name).should.deep.equal(['first', 'second']));
+});

package/queries/for_deserializeQueryModel/when_deserializing_a_collection_of_numbers.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { deserializeQueryModels } from '../deserializeQueryModel';
+
+describe('when deserializing a collection of numbers', () => {
+    const result = deserializeQueryModels<number>(Number as Constructor, [42, 43]);
+
+    it('should keep every item a primitive number', () => result.every(_ => typeof _ === 'number').should.be.true);
+    it('should keep the values intact', () => result.should.deep.equal([42, 43]));
+});

package/queries/for_deserializeQueryModel/when_deserializing_a_collection_of_strings.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { deserializeQueryModels } from '../deserializeQueryModel';
+
+describe('when deserializing a collection of strings', () => {
+    const result = deserializeQueryModels<string>(String as Constructor, ['first', 'second']);
+
+    it('should keep every item a primitive string', () => result.every(_ => typeof _ === 'string').should.be.true);
+    it('should keep the values intact', () => result.should.deep.equal(['first', 'second']));
+});

package/queries/for_deserializeQueryModel/when_deserializing_a_non_array_as_a_collection.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { deserializeQueryModels } from '../deserializeQueryModel';
+
+describe('when deserializing a non array as a collection', () => {
+    const result = deserializeQueryModels<string>(String as Constructor, null);
+
+    it('should produce an empty collection', () => result.should.be.empty);
+});

package/queries/for_deserializeQueryModel/when_deserializing_a_single_string.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { deserializeQueryModel } from '../deserializeQueryModel';
+
+describe('when deserializing a single string', () => {
+    const result = deserializeQueryModel<string>(String as Constructor, 'the value');
+
+    it('should keep it a primitive string', () => (typeof result).should.equal('string'));
+    it('should keep the value intact', () => result.should.equal('the value'));
+});

package/queries/index.ts

@@ -36,6 +36,7 @@ export * from './WebSocketMessage';
 export * from './QueryTransportMethod';
 export * from './QueryInstanceCache';
 export * from './reconcileQueryData';
+export * from './deserializeQueryModel';
 export * from './IQueryProvider';
 export * from './QueryProvider';
 export * from './QueryValidator';