@cratis/arc 20.0.0 → 20.1.1

package/for_UrlHelpers/when_building_query_params/with_array_values.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describe, it, beforeEach } from 'vitest';
+import { UrlHelpers } from '../../UrlHelpers';
+
+describe('when building query params with array values', () => {
+    let unusedParameters: object;
+    let result: URLSearchParams;
+
+    beforeEach(() => {
+        unusedParameters = { names: ['Alice', 'Bob', 'Charlie'] };
+
+        result = UrlHelpers.buildQueryParams(unusedParameters);
+    });
+
+    it('should append first value', () => result.getAll('names').should.include('Alice'));
+    it('should append second value', () => result.getAll('names').should.include('Bob'));
+    it('should append third value', () => result.getAll('names').should.include('Charlie'));
+    it('should have three entries for the key', () => result.getAll('names').length.should.equal(3));
+    it('should have only one unique key', () => Array.from(new Set(result.keys())).length.should.equal(1));
+});

package/for_UrlHelpers/when_building_query_params/with_mixed_array_and_scalar_values.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describe, it, beforeEach } from 'vitest';
+import { UrlHelpers } from '../../UrlHelpers';
+
+describe('when building query params with mixed array and scalar values', () => {
+    let unusedParameters: object;
+    let result: URLSearchParams;
+
+    beforeEach(() => {
+        unusedParameters = { filter: 'active', ids: [1, 2, 3] };
+
+        result = UrlHelpers.buildQueryParams(unusedParameters);
+    });
+
+    it('should contain scalar filter parameter', () => result.get('filter')!.should.equal('active'));
+    it('should append first id value', () => result.getAll('ids').should.include('1'));
+    it('should append second id value', () => result.getAll('ids').should.include('2'));
+    it('should append third id value', () => result.getAll('ids').should.include('3'));
+    it('should have three entries for ids key', () => result.getAll('ids').length.should.equal(3));
+    it('should have two unique keys', () => Array.from(new Set(result.keys())).length.should.equal(2));
+});

package/for_UrlHelpers/when_replacing_route_parameters/with_array_parameters.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { describe, it, beforeEach } from 'vitest';
+import { UrlHelpers } from '../../UrlHelpers';
+
+describe('when replacing route parameters with array values', () => {
+    let route: string;
+    let parameters: object;
+    let result: { route: string; unusedParameters: object };
+
+    beforeEach(() => {
+        route = '/api/search?names={names}&ids={ids}';
+        parameters = { names: ['Alice', 'Bob'], ids: [1, 2, 3] };
+
+        result = UrlHelpers.replaceRouteParameters(route, parameters);
+    });
+
+    it('should leave route template placeholders untouched for array values', () => result.route.should.equal('/api/search?names={names}&ids={ids}'));
+    it('should keep all array parameters as unused', () => Object.keys(result.unusedParameters).length.should.equal(2));
+    it('should contain names array in unused parameters', () => (result.unusedParameters as Record<string, string[]>)['names'].should.deep.equal(['Alice', 'Bob']));
+    it('should contain ids array in unused parameters', () => (result.unusedParameters as Record<string, number[]>)['ids'].should.deep.equal([1, 2, 3]));
+});

package/identity/IdentityProvider.ts

@@ -5,7 +5,7 @@ import { Constructor, JsonSerializer } from '@cratis/fundamentals';
 import { IIdentityProvider } from './IIdentityProvider';
 import { IIdentity } from './IIdentity';
 import { IdentityProviderResult } from './IdentityProviderResult';
-import { GetHttpHeaders } from 'GetHttpHeaders';
+import { GetHttpHeaders } from '../GetHttpHeaders';
 import { Globals } from '../Globals';
 import { UrlHelpers } from '../UrlHelpers';
 import { joinPaths } from '../joinPaths';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/arc",
-    "version": "20.0.0",
+    "version": "20.1.1",
     "description": "",
     "author": "Cratis",
     "license": "MIT",
@@ -63,7 +63,7 @@
         "ci": "yarn g:ci",
         "up": "yarn g:up"
     },
-    "dependencies": {
+    "peerDependencies": {
         "@cratis/fundamentals": "^7.7.1"
     }
 }

package/queries/for_QueryFor/given/TestQueries.ts

@@ -71,6 +71,26 @@ export class TestQueryForWithParameterDescriptorValues extends QueryFor<string,
     }
 }
 
+export class TestQueryForWithEnumerableParameterDescriptorValues extends QueryFor<string[], object> {
+    readonly route = '/api/search-by-lists';
+    readonly defaultValue: string[] = [];
+    readonly parameterDescriptors: ParameterDescriptor[] = [
+        new ParameterDescriptor('names', String as Constructor, true),
+        new ParameterDescriptor('ids', Number as Constructor, true)
+    ];
+
+    names?: string[];
+    ids?: number[];
+
+    get requiredRequestParameters(): string[] {
+        return [];
+    }
+
+    constructor() {
+        super(String as Constructor, true);
+    }
+}
+
 export interface TestQueryForWithMultipleRequiredParametersArguments {
     userId: string;
     category: string;

package/queries/for_QueryFor/given/a_query_for.ts

@@ -6,7 +6,8 @@ import {
     TestEnumerableQueryFor,
     TestQueryForWithoutRequiredParams,
     TestQueryForWithParameterDescriptorValues,
-    TestQueryForWithMultipleRequiredParameters
+    TestQueryForWithMultipleRequiredParameters,
+    TestQueryForWithEnumerableParameterDescriptorValues
 } from './TestQueries';
 
 export class a_query_for {
@@ -14,6 +15,7 @@ export class a_query_for {
     enumerableQuery: TestEnumerableQueryFor;
     queryWithoutParams: TestQueryForWithoutRequiredParams;
     queryWithParameterDescriptorValues: TestQueryForWithParameterDescriptorValues;
+    queryWithEnumerableParameterDescriptorValues: TestQueryForWithEnumerableParameterDescriptorValues;
     queryWithMultipleRequiredParameters: TestQueryForWithMultipleRequiredParameters;
 
     constructor() {
@@ -21,6 +23,7 @@ export class a_query_for {
         this.enumerableQuery = new TestEnumerableQueryFor();
         this.queryWithoutParams = new TestQueryForWithoutRequiredParams();
         this.queryWithParameterDescriptorValues = new TestQueryForWithParameterDescriptorValues();
+        this.queryWithEnumerableParameterDescriptorValues = new TestQueryForWithEnumerableParameterDescriptorValues();
         this.queryWithMultipleRequiredParameters = new TestQueryForWithMultipleRequiredParameters();
     }
 }

package/queries/for_QueryFor/when_performing/with_enumerable_parameter_descriptor_values.ts

@@ -0,0 +1,82 @@
+// 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('with enumerable parameter descriptor values', given(a_query_for, context => {
+    let result: QueryResult<string[]>;
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+    const mockResponse = {
+        data: [],
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.queryWithEnumerableParameterDescriptorValues.setOrigin('https://api.example.com');
+        context.queryWithEnumerableParameterDescriptorValues.setApiBasePath('/api/v1');
+
+        // Set enumerable values on the query instance
+        context.queryWithEnumerableParameterDescriptorValues.names = ['Alice', 'Bob'];
+        context.queryWithEnumerableParameterDescriptorValues.ids = [1, 2, 3];
+
+        result = await context.queryWithEnumerableParameterDescriptorValues.perform();
+    });
+
+    afterEach(() => {
+        fetchHelper.restore();
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+
+    it('should include first name in URL as repeated query parameter', () => {
+        const url = fetchStub.getCall(0).args[0].href;
+        url.should.include('names=Alice');
+    });
+
+    it('should include second name in URL as repeated query parameter', () => {
+        const url = fetchStub.getCall(0).args[0].href;
+        url.should.include('names=Bob');
+    });
+
+    it('should include first id in URL as repeated query parameter', () => {
+        const url = fetchStub.getCall(0).args[0].href;
+        url.should.include('ids=1');
+    });
+
+    it('should include second id in URL as repeated query parameter', () => {
+        const url = fetchStub.getCall(0).args[0].href;
+        url.should.include('ids=2');
+    });
+
+    it('should include third id in URL as repeated query parameter', () => {
+        const url = fetchStub.getCall(0).args[0].href;
+        url.should.include('ids=3');
+    });
+}));

package/reflection/ParameterDescriptor.ts

@@ -11,7 +11,8 @@ export class ParameterDescriptor {
      * Initializes a new instance of the {@link ParameterDescriptor} class.
      * @param name Name of the parameter.
      * @param type Type of the parameter.
+     * @param isEnumerable Whether the parameter is an enumerable (collection) type.
      */
-    constructor(readonly name: string, readonly type: Constructor) {
+    constructor(readonly name: string, readonly type: Constructor, readonly isEnumerable: boolean = false) {
     }
 }