@cratis/arc 18.0.0

package/queries/for_ObservableQueryFor/when_performing/with_partial_parameter_descriptor_values.ts

@@ -0,0 +1,67 @@
+// 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 { QueryResult } from '../../QueryResult';
+
+describe('with partial parameter descriptor values', given(an_observable_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.queryWithParameterDescriptorValues.setOrigin('https://api.example.com');
+        context.queryWithParameterDescriptorValues.setApiBasePath('/api/v1');
+
+        // Only set one parameter value, leave the other undefined
+        context.queryWithParameterDescriptorValues.filter = 'active';
+        // limit is not set (undefined)
+
+        result = await context.queryWithParameterDescriptorValues.perform();
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+
+    it('should include only set parameter descriptor values in URL', () => {
+        fetchStub.should.have.been.calledOnce;
+        const call = fetchStub.getCall(0);
+        const url = call.args[0].href;
+        url.should.include('filter=active');
+    });
+
+    it('should not include undefined parameter descriptor values in URL', () => {
+        const call = fetchStub.getCall(0);
+        const url = call.args[0].href;
+        url.should.not.include('limit=');
+    });
+}));

package/queries/for_ObservableQueryFor/when_performing/with_route_parameters_and_unused_parameters.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 { an_observable_query_for } from '../given/an_observable_query_for';
+import { given } from '../../../given';
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+import { expect } from 'chai';
+
+describe('when performing with route parameters and unused parameters', given(an_observable_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.query.setOrigin('https://api.example.com');
+        context.query.setApiBasePath('/api/v1');
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        result = await context.query.perform({ id: 'test-id', status: 'completed', priority: 'high' } as any);
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        expect(result.isSuccess).to.be.true;
+    });
+    
+    it('should return correct data', () => {
+        expect(result.data).to.equal('test-result');
+    });
+    
+    it('should include route parameter in path', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.include('/test-id');
+    });
+    
+    it('should include unused status parameter in query string', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.include('status=completed');
+    });
+    
+    it('should include unused priority parameter in query string', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.include('priority=high');
+    });
+}));

package/queries/for_ObservableQueryFor/when_performing/with_sorting.ts

@@ -0,0 +1,56 @@
+// 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 { Sorting } from '../../Sorting';
+import { SortDirection } from '../../SortDirection';
+
+describe('when performing with sorting', given(an_observable_query_for, context => {
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.query.setOrigin('https://api.example.com');
+        context.query.sorting = new Sorting('name', SortDirection.ascending);
+
+        await context.query.perform({ id: 'test-id' });
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should include sortBy parameter in URL', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.contain('sortBy=name');
+    });
+
+    it('should include sortDirection parameter in URL', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.contain('sortDirection=asc');
+    });
+}));

package/queries/for_ObservableQueryFor/when_performing/with_valid_arguments.ts

@@ -0,0 +1,79 @@
+// 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 { QueryResult } from '../../QueryResult';
+
+describe('when performing with valid arguments', given(an_observable_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.query.setOrigin('https://api.example.com');
+        context.query.setApiBasePath('/api/v1');
+        context.query.setMicroservice('test-service');
+
+        result = await context.query.perform({ id: 'test-id' });
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+
+    it('should return correct data', () => {
+        result.data.should.equal('test-result');
+    });
+
+    it('should have data', () => {
+        result.hasData.should.be.true;
+    });
+
+    it('should call fetch with correct URL', () => {
+        fetchStub.should.have.been.calledOnce;
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.equal('https://api.example.com/api/v1/api/test/test-id');
+    });
+
+    it('should call fetch with correct headers', () => {
+        const call = fetchStub.getCall(0);
+        const options = call.args[1];
+        options.headers['Accept'].should.equal('application/json');
+        options.headers['Content-Type'].should.equal('application/json');
+        options.headers['x-cratis-microservice'].should.equal('test-service');
+    });
+
+    it('should call fetch with GET method', () => {
+        const call = fetchStub.getCall(0);
+        const options = call.args[1];
+        options.method.should.equal('GET');
+    });
+}));

package/queries/for_ObservableQueryFor/when_setting_api_base_path.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 { TestObservableQuery } from './given/TestQueries';
+
+
+describe('when setting api base path', () => {
+    let query: TestObservableQuery;
+
+    beforeEach(() => {
+        query = new TestObservableQuery();
+    });
+
+    it('should not throw when setting api base path', () => {
+        (() => query.setApiBasePath('/api/v1')).should.not.throw();
+    });
+});

package/queries/for_ObservableQueryFor/when_setting_microservice.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 { TestObservableQuery } from './given/TestQueries';
+
+
+describe('when setting microservice', () => {
+    let query: TestObservableQuery;
+
+    beforeEach(() => {
+        query = new TestObservableQuery();
+    });
+
+    it('should not throw when setting microservice', () => {
+        (() => query.setMicroservice('new-microservice')).should.not.throw();
+    });
+});

package/queries/for_ObservableQueryFor/when_setting_origin.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 { TestObservableQuery } from './given/TestQueries';
+
+
+describe('when setting origin', () => {
+    let query: TestObservableQuery;
+
+    beforeEach(() => {
+        query = new TestObservableQuery();
+    });
+
+    it('should not throw when setting origin', () => {
+        (() => query.setOrigin('https://example.com')).should.not.throw();
+    });
+});

package/queries/for_ObservableQueryFor/when_subscribing/with_enumerable_query.ts

@@ -0,0 +1,34 @@
+// 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('with enumerable query', given(an_observable_query_for, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string[]>;
+
+    beforeEach(() => {
+        context.enumerableQuery.setOrigin('https://example.com'); // Set origin to avoid document access
+        callback = sinon.stub();
+        
+        subscription = context.enumerableQuery.subscribe(callback, { category: 'test-category' });
+    });
+
+    afterEach(() => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+
+    it('should not call callback immediately', () => {
+        callback.called.should.be.false;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_invalid_arguments.ts

@@ -0,0 +1,40 @@
+// 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('with invalid arguments', given(an_observable_query_for, 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();
+        
+        // Subscribe with missing required arguments
+        subscription = context.query.subscribe(callback);
+    });
+
+    afterEach(() => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+
+    it('should call callback immediately with default value', () => {
+        callback.called.should.be.true;
+        // The NullObservableQueryConnection returns QueryResult.empty with defaultValue
+        // but the data might be transformed, so let's check the actual structure
+        const result = callback.firstCall.args[0];
+        result.should.not.be.undefined;
+        result.isSuccess.should.be.true;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_paging.ts

@@ -0,0 +1,36 @@
+// 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';
+import { Paging } from '../../Paging';
+
+describe('with paging', given(an_observable_query_for, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string>;
+
+    beforeEach(() => {
+        context.query.setOrigin('https://example.com'); // Set origin to avoid document access
+        context.query.paging = new Paging(1, 10); // page 1, page size 10
+        callback = sinon.stub();
+        
+        subscription = context.query.subscribe(callback, { id: 'test-id' });
+    });
+
+    afterEach(() => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+
+    it('should not call callback immediately', () => {
+        callback.called.should.be.false;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_sorting.ts

@@ -0,0 +1,37 @@
+// 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';
+import { Sorting } from '../../Sorting';
+import { SortDirection } from '../../SortDirection';
+
+describe('with sorting', given(an_observable_query_for, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string>;
+
+    beforeEach(() => {
+        context.query.setOrigin('https://example.com'); // Set origin to avoid document access
+        context.query.sorting = new Sorting('name', SortDirection.ascending);
+        callback = sinon.stub();
+        
+        subscription = context.query.subscribe(callback, { id: 'test-id' });
+    });
+
+    afterEach(() => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+
+    it('should not call callback immediately', () => {
+        callback.called.should.be.false;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_valid_arguments.ts

@@ -0,0 +1,35 @@
+// 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('with valid arguments', given(an_observable_query_for, 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();
+        
+        // Subscribe with valid arguments
+        subscription = context.query.subscribe(callback, { id: 'test-id' });
+    });
+
+    afterEach(() => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+
+    it('should not call callback immediately', () => {
+        callback.called.should.be.false;
+    });
+}));

package/queries/for_QueryFor/given/TestQueries.ts

@@ -0,0 +1,72 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryFor } from '../../QueryFor';
+import { Constructor } from '@cratis/fundamentals';
+import { ParameterDescriptor } from '../../../reflection/ParameterDescriptor';
+
+export class TestQueryFor extends QueryFor<string, { id: string }> {
+    readonly route = '/api/test/{id}';
+    readonly defaultValue = '';
+    readonly parameterDescriptors: ParameterDescriptor[] = [
+        new ParameterDescriptor('id', String as Constructor)
+    ];
+
+    get requiredRequestParameters(): string[] {
+        return ['id'];
+    }
+
+    constructor() {
+        super(String as Constructor, false);
+    }
+}
+
+export class TestEnumerableQueryFor extends QueryFor<string[], { category: string }> {
+    readonly route = '/api/items/{category}';
+    readonly defaultValue: string[] = [];
+    readonly parameterDescriptors: ParameterDescriptor[] = [
+        new ParameterDescriptor('category', String as Constructor)
+    ];
+
+    get requiredRequestParameters(): string[] {
+        return ['category'];
+    }
+
+    constructor() {
+        super(String as Constructor, true);
+    }
+}
+
+export class TestQueryForWithoutRequiredParams extends QueryFor<string, object> {
+    readonly route = '/api/all';
+    readonly defaultValue = '';
+    readonly parameterDescriptors: ParameterDescriptor[] = [];
+
+    get requiredRequestParameters(): string[] {
+        return [];
+    }
+
+    constructor() {
+        super(String as Constructor, false);
+    }
+}
+
+export class TestQueryForWithParameterDescriptorValues extends QueryFor<string, object> {
+    readonly route = '/api/search';
+    readonly defaultValue = '';
+    readonly parameterDescriptors: ParameterDescriptor[] = [
+        new ParameterDescriptor('filter', String as Constructor),
+        new ParameterDescriptor('limit', Number as Constructor)
+    ];
+
+    filter?: string;
+    limit?: number;
+
+    get requiredRequestParameters(): string[] {
+        return [];
+    }
+
+    constructor() {
+        super(String as Constructor, false);
+    }
+}

package/queries/for_QueryFor/given/a_query_for.ts

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

package/queries/for_QueryFor/when_constructing.ts

@@ -0,0 +1,31 @@
+// 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 { Sorting } from '../Sorting';
+import { Paging } from '../Paging';
+import { Globals } from '../../Globals';
+
+describe('when constructing', given(a_query_for, context => {
+    let originalMicroservice: string | undefined;
+
+    beforeEach(() => {
+        originalMicroservice = Globals.microservice;
+        Globals.microservice = 'test-microservice';
+    });
+
+    afterEach(() => {
+        if (originalMicroservice !== undefined) {
+            Globals.microservice = originalMicroservice;
+        }
+    });
+
+    it('should set sorting to none', () => context.query.sorting.should.equal(Sorting.none));
+    it('should set paging to no paging', () => context.query.paging.should.equal(Paging.noPaging));
+    it('should set model type to String', () => context.query.modelType.should.equal(String));
+    it('should set enumerable to false', () => context.query.enumerable.should.be.false);
+    it('should have default required request parameters', () => context.query.requiredRequestParameters.should.deep.equal(['id']));
+    it('should have default route', () => context.query.route.should.equal('/api/test/{id}'));
+    it('should have default value as empty string', () => context.query.defaultValue.should.equal(''));
+}));

package/queries/for_QueryFor/when_constructing_enumerable.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 { a_query_for } from './given/a_query_for';
+import { given } from '../../given';
+import { Sorting } from '../Sorting';
+import { Paging } from '../Paging';
+
+describe('when constructing enumerable', given(a_query_for, context => {
+    it('should set sorting to none', () => context.enumerableQuery.sorting.should.equal(Sorting.none));
+    it('should set paging to no paging', () => context.enumerableQuery.paging.should.equal(Paging.noPaging));
+    it('should set model type to String', () => context.enumerableQuery.modelType.should.equal(String));
+    it('should set enumerable to true', () => context.enumerableQuery.enumerable.should.be.true);
+    it('should have default required request parameters', () => context.enumerableQuery.requiredRequestParameters.should.deep.equal(['category']));
+    it('should have default route', () => context.enumerableQuery.route.should.equal('/api/items/{category}'));
+    it('should have default value as empty array', () => context.enumerableQuery.defaultValue.should.deep.equal([]));
+}));