@cratis/arc 19.9.8 → 19.10.6

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@cratis/arc",
-    "version": "19.9.8",
+    "version": "19.10.6",
     "description": "",
     "author": "Cratis",
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/cratis/arc.git"
+        "url": "git+https://github.com/Cratis/Arc.git"
     },
     "publishConfig": {
         "access": "public"

package/queries/IObservableQueryFor.ts

@@ -21,6 +21,11 @@ export interface IObservableQueryFor<TDataType, TArguments = object> extends IQu
     readonly requiredRequestParameters: string[];
     readonly defaultValue: TDataType;
 
+    /**
+     * Gets the roles required to perform the query. An empty array means no specific roles are required.
+     */
+    readonly roles: string[];
+
     /**
      * Subscribe to the query. This will create a subscription onto the server.
      * @param {OnNextResult} callback The callback that will receive result from the server.

package/queries/IQueryFor.ts

@@ -15,6 +15,11 @@ export interface IQueryFor<TDataType, TArguments = object> extends IQuery, IHave
     readonly requiredRequestParameters: string[];
     readonly defaultValue: TDataType;
 
+    /**
+     * Gets the roles required to perform the query. An empty array means no specific roles are required.
+     */
+    readonly roles: string[];
+
     /**
      * Gets the current arguments for the query.
      */

package/queries/ObservableQueryFor.ts

@@ -35,6 +35,7 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
 
     abstract readonly route: string;
     abstract readonly defaultValue: TDataType;
+    readonly roles: string[] = [];
     abstract readonly parameterDescriptors: ParameterDescriptor[];
     abstract get requiredRequestParameters(): string[];
     sorting: Sorting;

package/queries/QueryFor.ts

@@ -29,6 +29,7 @@ export abstract class QueryFor<TDataType, TParameters = object> implements IQuer
     /* eslint-disable @typescript-eslint/no-explicit-any */
     readonly validation?: QueryValidator<any>;
     /* eslint-enable @typescript-eslint/no-explicit-any */
+    readonly roles: string[] = [];
     abstract readonly parameterDescriptors: ParameterDescriptor[];
     abstract get requiredRequestParameters(): string[];
     abstract defaultValue: TDataType;

package/queries/for_ObservableQueryFor/given/TestQueries.ts

@@ -76,6 +76,28 @@ export class TestObservableQueryWithRouteAndQueryArgs extends ObservableQueryFor
         return ['id'];
     }
 
+    constructor() {
+        super(String as Constructor, false);
+    }
+}
+
+export interface TestObservableQueryWithMultipleRequiredParametersArguments {
+    userId: string;
+    category: string;
+}
+
+export class TestObservableQueryWithMultipleRequiredParameters extends ObservableQueryFor<string, TestObservableQueryWithMultipleRequiredParametersArguments> {
+    readonly route = '/api/filter/{userId}/{category}';
+    readonly defaultValue = '';
+    readonly parameterDescriptors: ParameterDescriptor[] = [
+        new ParameterDescriptor('userId', String as Constructor),
+        new ParameterDescriptor('category', String as Constructor)
+    ];
+
+    get requiredRequestParameters(): string[] {
+        return ['userId', 'category'];
+    }
+
     constructor() {
         super(String as Constructor, false);
     }

package/queries/for_ObservableQueryFor/given/an_observable_query_for.ts

@@ -1,18 +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 { TestObservableQuery, TestEnumerableQuery, TestObservableQueryWithParameterDescriptorValues, TestObservableQueryWithRouteAndQueryArgs } from './TestQueries';
+import {
+    TestObservableQuery,
+    TestEnumerableQuery,
+    TestObservableQueryWithParameterDescriptorValues,
+    TestObservableQueryWithRouteAndQueryArgs,
+    TestObservableQueryWithMultipleRequiredParameters
+} from './TestQueries';
 
 export class an_observable_query_for {
     query: TestObservableQuery;
     enumerableQuery: TestEnumerableQuery;
     queryWithParameterDescriptorValues: TestObservableQueryWithParameterDescriptorValues;
     queryWithRouteAndQueryArgs: TestObservableQueryWithRouteAndQueryArgs;
+    queryWithMultipleRequiredParameters: TestObservableQueryWithMultipleRequiredParameters;
 
     constructor() {
         this.query = new TestObservableQuery();
         this.enumerableQuery = new TestEnumerableQuery();
         this.queryWithParameterDescriptorValues = new TestObservableQueryWithParameterDescriptorValues();
         this.queryWithRouteAndQueryArgs = new TestObservableQueryWithRouteAndQueryArgs();
+        this.queryWithMultipleRequiredParameters = new TestObservableQueryWithMultipleRequiredParameters();
     }
 }

package/queries/for_ObservableQueryFor/when_performing/with_partially_missing_required_arguments.ts

@@ -0,0 +1,45 @@
+// 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_for } from '../given/an_observable_query_for';
+import { given } from '../../../given';
+import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { QueryResult } from '../../QueryResult';
+
+describe('when performing with partially missing required arguments', given(an_observable_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    beforeEach(async () => {
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.resolves({
+            json: sinon.stub().resolves({}),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        result = await context.queryWithMultipleRequiredParameters.perform({
+            userId: 'user-1',
+            category: ''
+        });
+    });
+
+    afterEach(() => {
+        fetchHelper.restore();
+    });
+
+    it('should return unsuccessful result', () => {
+        result.isSuccess.should.be.false;
+    });
+
+    it('should return default value', () => {
+        result.data.should.equal('');
+    });
+
+    it('should not call fetch', () => {
+        fetchStub.should.not.have.been.called;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_partially_missing_required_arguments.ts

@@ -0,0 +1,52 @@
+// 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_for } from '../given/an_observable_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
+
+describe('when subscribing with partially missing required arguments', given(an_observable_query_for, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string>;
+    let webSocketStub: sinon.SinonStub;
+
+    beforeEach(() => {
+        context.queryWithMultipleRequiredParameters.setOrigin('https://example.com');
+        callback = sinon.stub();
+        webSocketStub = sinon.stub(global, 'WebSocket').callsFake(() => ({
+            onopen: null,
+            onclose: null,
+            onerror: null,
+            onmessage: null,
+            close: sinon.stub(),
+            send: sinon.stub()
+        } as unknown as WebSocket));
+
+        subscription = context.queryWithMultipleRequiredParameters.subscribe(callback, {
+            userId: 'user-1',
+            category: ''
+        });
+    });
+
+    afterEach(() => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+        webSocketStub.restore();
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+
+    it('should not create a web socket connection', () => {
+        webSocketStub.should.not.have.been.called;
+    });
+
+    it('should call callback immediately with default value', () => {
+        callback.called.should.be.true;
+        callback.firstCall.args[0].isSuccess.should.be.true;
+    });
+}));

package/queries/for_QueryFor/given/TestQueries.ts

@@ -66,6 +66,28 @@ export class TestQueryForWithParameterDescriptorValues extends QueryFor<string,
         return [];
     }
 
+    constructor() {
+        super(String as Constructor, false);
+    }
+}
+
+export interface TestQueryForWithMultipleRequiredParametersArguments {
+    userId: string;
+    category: string;
+}
+
+export class TestQueryForWithMultipleRequiredParameters extends QueryFor<string, TestQueryForWithMultipleRequiredParametersArguments> {
+    readonly route = '/api/filter/{userId}/{category}';
+    readonly defaultValue = '';
+    readonly parameterDescriptors: ParameterDescriptor[] = [
+        new ParameterDescriptor('userId', String as Constructor),
+        new ParameterDescriptor('category', String as Constructor)
+    ];
+
+    get requiredRequestParameters(): string[] {
+        return ['userId', 'category'];
+    }
+
     constructor() {
         super(String as Constructor, false);
     }

package/queries/for_QueryFor/given/a_query_for.ts

@@ -1,18 +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 { TestQueryFor, TestEnumerableQueryFor, TestQueryForWithoutRequiredParams, TestQueryForWithParameterDescriptorValues } from './TestQueries';
+import {
+    TestQueryFor,
+    TestEnumerableQueryFor,
+    TestQueryForWithoutRequiredParams,
+    TestQueryForWithParameterDescriptorValues,
+    TestQueryForWithMultipleRequiredParameters
+} from './TestQueries';
 
 export class a_query_for {
     query: TestQueryFor;
     enumerableQuery: TestEnumerableQueryFor;
     queryWithoutParams: TestQueryForWithoutRequiredParams;
     queryWithParameterDescriptorValues: TestQueryForWithParameterDescriptorValues;
+    queryWithMultipleRequiredParameters: TestQueryForWithMultipleRequiredParameters;
 
     constructor() {
         this.query = new TestQueryFor();
         this.enumerableQuery = new TestEnumerableQueryFor();
         this.queryWithoutParams = new TestQueryForWithoutRequiredParams();
         this.queryWithParameterDescriptorValues = new TestQueryForWithParameterDescriptorValues();
+        this.queryWithMultipleRequiredParameters = new TestQueryForWithMultipleRequiredParameters();
     }
 }

package/queries/for_QueryFor/when_performing/with_partially_missing_required_arguments.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { QueryResult } from '../../QueryResult';
+
+describe('when performing with partially missing required arguments', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    beforeEach(async () => {
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.resolves({
+            json: sinon.stub().resolves({}),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        result = await context.queryWithMultipleRequiredParameters.perform({
+            userId: 'user-1',
+            category: ''
+        });
+    });
+
+    afterEach(() => {
+        fetchHelper.restore();
+    });
+
+    it('should return unsuccessful result', () => {
+        result.isSuccess.should.be.false;
+    });
+
+    it('should return default value', () => {
+        result.data.should.equal('');
+    });
+
+    it('should not call fetch', () => {
+        fetchStub.should.not.have.been.called;
+    });
+}));