@cratis/arc 22.0.1 → 22.0.2

package/package.json

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

package/queries/ObservableQueryFor.ts

@@ -1,14 +1,14 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { IObservableQueryFor, OnNextResult } from './IObservableQueryFor';
+import type { IObservableQueryFor, OnNextResult } from './IObservableQueryFor';
 import { ObservableQuerySubscription } from './ObservableQuerySubscription';
 import { ValidateRequestArguments } from './ValidateRequestArguments';
-import { QueryValidator } from './QueryValidator';
-import { IObservableQueryConnection } from './IObservableQueryConnection';
+import type { QueryValidator } from './QueryValidator';
+import type { IObservableQueryConnection } from './IObservableQueryConnection';
 import { NullObservableQueryConnection } from './NullObservableQueryConnection';
 import { createObservableQueryConnection } from './ObservableQueryConnectionFactory';
-import { Constructor } from '@cratis/fundamentals';
+import type { Constructor } from '@cratis/fundamentals';
 import { deserializeQueryModel, deserializeQueryModels } from './deserializeQueryModel';
 import { QueryResult } from './QueryResult';
 import { Sorting } from './Sorting';
@@ -16,10 +16,10 @@ import { Paging } from './Paging';
 import { SortDirection } from './SortDirection';
 import { Globals } from '../Globals';
 import { UrlHelpers } from '../UrlHelpers';
-import { GetHttpHeaders } from '../GetHttpHeaders';
-import { ParameterDescriptor } from '../reflection/ParameterDescriptor';
+import type { GetHttpHeaders } from '../GetHttpHeaders';
+import type { ParameterDescriptor } from '../reflection/ParameterDescriptor';
 import { ParametersHelper } from '../reflection/ParametersHelper';
-import { QueryHttpMethod } from './QueryHttpMethod';
+import type { QueryHttpMethod } from './QueryHttpMethod';
 import { executeQueryHttpRequest } from './QueryHttpRequest';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -106,9 +106,7 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
             this._connection = new NullObservableQueryConnection(
                 this.defaultValue,
                 QueryResult.validationFailed(clientValidationErrors, this));
-        } else if (!this.validateArguments(args)) {
-            this._connection = new NullObservableQueryConnection(this.defaultValue);
-        } else {
+        } else if (this.validateArguments(args)) {
             this._connection = createObservableQueryConnection({
                 route: this.route,
                 queryName: this.queryName ?? this.constructor.name,
@@ -117,6 +115,8 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
                 microservice: this._microservice,
                 args: args as object,
             });
+        } else {
+            this._connection = new NullObservableQueryConnection(this.defaultValue);
         }
 
         // Descriptor-backed instance properties provide defaults; fresh args passed to subscribe()

package/queries/for_ObservableQueryFor/given/TestQueries.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { ObservableQueryFor } from '../../ObservableQueryFor';
-import { Constructor } from '@cratis/fundamentals';
+import { Constructor, DateOnly, field, TimeOnly } from '@cratis/fundamentals';
 import { ParameterDescriptor } from '../../../reflection/ParameterDescriptor';
 
 export class TestObservableQuery extends ObservableQueryFor<string, { id: string }> {
@@ -37,6 +37,35 @@ export class TestEnumerableQuery extends ObservableQueryFor<string[], { category
     }
 }
 
+export class TestCalendarChild {
+    @field(DateOnly)
+    date!: DateOnly;
+
+    @field(TimeOnly)
+    time!: TimeOnly;
+}
+
+export class TestCalendarItem {
+    @field(TestCalendarChild, true)
+    children!: TestCalendarChild[];
+}
+
+export class TestCalendarEnumerableQuery extends ObservableQueryFor<TestCalendarItem[], { category: string }> {
+    readonly route = '/api/calendar-items/{category}';
+    readonly defaultValue: TestCalendarItem[] = [];
+    readonly parameterDescriptors: ParameterDescriptor[] = [
+        new ParameterDescriptor('category', String as Constructor)
+    ];
+
+    get requiredRequestParameters(): string[] {
+        return ['category'];
+    }
+
+    constructor() {
+        super(TestCalendarItem, true);
+    }
+}
+
 export class TestObservableQueryWithParameterDescriptorValues extends ObservableQueryFor<string, object> {
     readonly route = '/api/search';
     readonly defaultValue = '';

package/queries/for_ObservableQueryFor/given/an_observable_query_for.ts

@@ -4,6 +4,7 @@
 import {
     TestObservableQuery,
     TestEnumerableQuery,
+    TestCalendarEnumerableQuery,
     TestObservableQueryWithParameterDescriptorValues,
     TestObservableQueryWithRouteAndQueryArgs,
     TestObservableQueryWithMultipleRequiredParameters
@@ -12,6 +13,7 @@ import {
 export class an_observable_query_for {
     query: TestObservableQuery;
     enumerableQuery: TestEnumerableQuery;
+    calendarEnumerableQuery: TestCalendarEnumerableQuery;
     queryWithParameterDescriptorValues: TestObservableQueryWithParameterDescriptorValues;
     queryWithRouteAndQueryArgs: TestObservableQueryWithRouteAndQueryArgs;
     queryWithMultipleRequiredParameters: TestObservableQueryWithMultipleRequiredParameters;
@@ -19,6 +21,7 @@ export class an_observable_query_for {
     constructor() {
         this.query = new TestObservableQuery();
         this.enumerableQuery = new TestEnumerableQuery();
+        this.calendarEnumerableQuery = new TestCalendarEnumerableQuery();
         this.queryWithParameterDescriptorValues = new TestObservableQueryWithParameterDescriptorValues();
         this.queryWithRouteAndQueryArgs = new TestObservableQueryWithRouteAndQueryArgs();
         this.queryWithMultipleRequiredParameters = new TestObservableQueryWithMultipleRequiredParameters();

package/queries/for_ObservableQueryFor/when_receiving_a_result/and_the_model_has_a_calendar_collection.ts

@@ -0,0 +1,76 @@
+// 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 { DateOnly, TimeOnly } from '@cratis/fundamentals';
+import { an_observable_query_for } from '../given/an_observable_query_for';
+import type { TestCalendarItem } from '../given/TestQueries';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import type { EventSourceFactory } from '../../../EventSourceFactory';
+import type { QueryResult } from '../../QueryResult';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import type { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
+
+interface FakeEventSource {
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: (() => void) | null;
+    close: sinon.SinonStub;
+}
+
+describe('and the model has a calendar collection', given(an_observable_query_for, context => {
+    let subscription: ObservableQuerySubscription<TestCalendarItem[]>;
+    let fakeEventSource: FakeEventSource;
+    let received: QueryResult<TestCalendarItem[]>[];
+    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() };
+        // SAFETY: The test double implements the EventSource members exercised by the query connection.
+        Globals.eventSourceFactory = (() => fakeEventSource) as unknown as EventSourceFactory;
+
+        context.calendarEnumerableQuery.setOrigin('https://example.com');
+
+        received = [];
+        subscription = context.calendarEnumerableQuery.subscribe(
+            result => received.push(result),
+            { category: 'test-category' });
+
+        fakeEventSource.onmessage!({
+            data: JSON.stringify({
+                data: [{ children: [{ date: '2026-02-03', time: '14:15:16' }] }],
+                isSuccess: true,
+                isAuthorized: true,
+                isValid: true,
+                hasExceptions: false,
+                validationResults: [],
+                exceptionMessages: [],
+                exceptionStackTrace: '',
+                paging: { page: 0, size: 0, totalItems: 1, totalPages: 1 }
+            })
+        } 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 deserialize the child date', () => received[0].data[0].children[0].date.should.be.instanceOf(DateOnly));
+    it('should preserve the child date', () => received[0].data[0].children[0].date.equals(DateOnly.from(2026, 2, 3)).should.be.true);
+    it('should deserialize the child time', () => received[0].data[0].children[0].time.should.be.instanceOf(TimeOnly));
+    it('should preserve the child time', () => received[0].data[0].children[0].time.equals(TimeOnly.from(14, 15, 16)).should.be.true);
+}));