@cratis/arc 20.60.0 → 20.60.1

package/package.json

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

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/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/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;
+    });
+}));