@cratis/arc 22.50.5 → 22.50.6

package/for_UrlHelpers/when_replacing_route_parameters/with_regular_expression_metacharacters.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 { describe, it, expect } from 'vitest';
+import { UrlHelpers } from '../../UrlHelpers.js';
+
+describe('when replacing route parameters with regular expression metacharacters', () => {
+    for (const key of ['a[', 'a.b', 'a+b', 'a*b', 'a?b', 'a^b', 'a$b', 'a{b}', 'a(b)', 'a|b', 'a\\b', 'a]b']) {
+        it(`should replace the literal placeholder for ${key}`, () => {
+            const result = UrlHelpers.replaceRouteParameters(`/items/{${key}}/{${key}}`, { [key]: 'value /' });
+            expect(result.route).to.equal('/items/value%20%2F/value%20%2F');
+            expect(result.unusedParameters).to.deep.equal({});
+        });
+
+        it(`should leave ${key} unused on a literal route`, () => {
+            const result = UrlHelpers.replaceRouteParameters('/items/snapshot', { [key]: 'value' });
+            expect(result.route).to.equal('/items/snapshot');
+            expect(result.unusedParameters).to.deep.equal({ [key]: 'value' });
+        });
+    }
+
+    it('should not match a different placeholder through a wildcard', () => {
+        const result = UrlHelpers.replaceRouteParameters('/items/{axb}/{a.b}', { 'a.b': 'value' });
+        expect(result.route).to.equal('/items/{axb}/value');
+    });
+
+    it('should retain case insensitive matching', () => {
+        const result = UrlHelpers.replaceRouteParameters('/items/{A.B}', { 'a.b': 'value' });
+        expect(result.route).to.equal('/items/value');
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "@cratis/arc",
-    "version": "22.50.5",
+    "version": "22.50.6",
     "description": "TypeScript command, query, validation, identity, and messaging runtime for Cratis Arc — the CQRS application framework for ASP.NET Core — used by generated proxies.",
     "keywords": [
         "cratis",
@@ -118,10 +118,10 @@
         "up": "yarn g:up"
     },
     "dependencies": {
-        "@cratis/fundamentals": "^7.19.8",
+        "@cratis/fundamentals": "^7.22.4",
         "rxjs": "^7.8.2"
     },
     "devDependencies": {
-        "@cratis/fundamentals": "7.19.8"
+        "@cratis/fundamentals": "7.22.4"
     }
 }

package/queries/for_QueryFor/when_performing/with_regular_expression_metacharacters_in_parameter_keys.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 { describe, it, beforeEach, afterEach, expect } from 'vitest';
+import * as sinon from 'sinon';
+import { QueryFor } from '../../QueryFor.js';
+import { QueryHttpMethod } from '../../QueryHttpMethod.js';
+import { ParameterDescriptor } from '../../../reflection/ParameterDescriptor.js';
+import { createFetchHelper } from '../../../helpers/fetchHelper.js';
+
+class QueryWithLiteralParameterKeys extends QueryFor<string, Record<string, string>> {
+    readonly defaultValue = '';
+    readonly parameterDescriptors: ParameterDescriptor[] = [];
+    readonly requiredRequestParameters: string[] = [];
+
+    constructor(readonly route: string) {
+        super(String, false);
+    }
+}
+
+for (const method of [QueryHttpMethod.Get, QueryHttpMethod.Query]) {
+    describe(`when performing ${method} with metacharacters in parameter keys`, () => {
+        let fetchHelper: ReturnType<typeof createFetchHelper>;
+        let fetchStub: sinon.SinonStub;
+
+        beforeEach(() => {
+            fetchHelper = createFetchHelper();
+            fetchStub = fetchHelper.stubFetch();
+            fetchStub.resolves({
+                ok: true,
+                status: 200,
+                json: sinon.stub().resolves({
+                    data: 'result', isSuccess: true, isAuthorized: true, isValid: true,
+                    hasExceptions: false, validationResults: [], exceptionMessages: [],
+                    exceptionStackTrace: '', paging: { totalItems: 0, totalPages: 0, page: 0, size: 0 }
+                })
+            } as unknown as Response);
+        });
+
+        afterEach(() => fetchHelper.restore());
+
+        for (const route of ['/items/snapshot', '/items/{a[}/{a.b}']) {
+            it(`should fetch ${route} with literal keys`, async () => {
+                const query = new QueryWithLiteralParameterKeys(route);
+                query.setOrigin('https://api.example.com');
+                query.setHttpMethod(method);
+                const parameters = { 'a[': 'first', 'a.b': 'second' };
+
+                const result = await query.perform(parameters);
+
+                expect(result.isSuccess).to.be.true;
+                expect(fetchStub.calledOnce).to.be.true;
+                const [url, options] = fetchStub.firstCall.args as [URL, RequestInit];
+                expect(options.method).to.equal(method.toUpperCase());
+                expect(url.pathname).to.equal(route.includes('{') ? '/items/first/second' : '/items/snapshot');
+                if (!route.includes('{')) {
+                    if (method === QueryHttpMethod.Get) {
+                        expect(url.searchParams.get('a[')).to.equal('first');
+                        expect(url.searchParams.get('a.b')).to.equal('second');
+                    } else {
+                        expect(JSON.parse(options.body as string).arguments).to.deep.equal(parameters);
+                    }
+                }
+            });
+        }
+    });
+}