@cratis/arc 20.55.1 → 20.57.0

package/queries/for_executeQueryHttpRequest/when_performing/with_auto_and_an_application_error.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { makeOptions } from '../options';
+
+describe('when performing with auto and an application error', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+    let result: Response;
+
+    beforeEach(async () => {
+        resetQueryHttpMethodResolution();
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        // 400 is an application-level failure, not a transport signal — it must not trigger a fallback.
+        fetchStub.resolves({ status: 400 } as unknown as Response);
+        result = await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions());
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should send a single request', () => fetchStub.callCount.should.equal(1));
+    it('should keep using QUERY', () => fetchStub.getCall(0).args[1].method.should.equal('QUERY'));
+    it('should return the QUERY response', () => result.status.should.equal(400));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_auto_and_multiple_backends.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { makeOptions } from '../options';
+
+describe('when performing with auto and multiple backends', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+    const unsupportedOrigin = 'https://legacy.example.com';
+    const supportedOrigin = 'https://modern.example.com';
+
+    beforeEach(async () => {
+        resetQueryHttpMethodResolution();
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        // The legacy backend rejects QUERY; the modern backend supports it.
+        fetchStub.callsFake((url: URL, init: RequestInit) => {
+            const rejectsQuery = url.origin === unsupportedOrigin && init.method === 'QUERY';
+            return Promise.resolve({ status: rejectsQuery ? 405 : 200 } as unknown as Response);
+        });
+
+        // Probe the legacy backend first — it pins to GET.
+        await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions({ origin: unsupportedOrigin }));
+        // The modern backend should still be probed and settle on QUERY.
+        await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions({ origin: supportedOrigin }));
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should use QUERY for the backend that supports it', () => {
+        const modernCalls = fetchStub.getCalls().filter(call => (call.args[0] as URL).origin === supportedOrigin);
+        modernCalls.some(call => call.args[1].method === 'QUERY').should.be.true;
+    });
+
+    it('should not downgrade the supported backend to GET', () => {
+        const modernCalls = fetchStub.getCalls().filter(call => (call.args[0] as URL).origin === supportedOrigin);
+        modernCalls.every(call => call.args[1].method === 'QUERY').should.be.true;
+    });
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_auto_and_query_supported.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 * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { makeOptions } from '../options';
+
+describe('when performing with auto and query supported', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    beforeEach(async () => {
+        resetQueryHttpMethodResolution();
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.resolves({ status: 200 } as unknown as Response);
+        await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions());
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should send a single request', () => fetchStub.callCount.should.equal(1));
+    it('should use the QUERY method', () => fetchStub.getCall(0).args[1].method.should.equal('QUERY'));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_auto_and_query_unsupported.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 * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { makeOptions } from '../options';
+
+describe('when performing with auto and query unsupported', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+    let result: Response;
+
+    beforeEach(async () => {
+        resetQueryHttpMethodResolution();
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.callsFake((_url: URL, init: RequestInit) =>
+            Promise.resolve({ status: init.method === 'QUERY' ? 405 : 200 } as unknown as Response));
+        result = await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions());
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should attempt QUERY first', () => fetchStub.getCall(0).args[1].method.should.equal('QUERY'));
+    it('should fall back to GET', () => fetchStub.getCall(1).args[1].method.should.equal('GET'));
+    it('should send exactly two requests', () => fetchStub.callCount.should.equal(2));
+    it('should return the GET response', () => result.status.should.equal(200));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_get_method.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 * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { makeOptions } from '../options';
+
+describe('when performing with get method', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    beforeEach(async () => {
+        resetQueryHttpMethodResolution();
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.resolves({ status: 200 } as unknown as Response);
+        await executeQueryHttpRequest(QueryHttpMethod.Get, makeOptions());
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should send a single request', () => fetchStub.callCount.should.equal(1));
+    it('should use the GET method', () => fetchStub.getCall(0).args[1].method.should.equal('GET'));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_query_method_and_server_rejecting_the_verb.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 * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { makeOptions } from '../options';
+
+describe('when performing with query method and server rejecting the verb', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    beforeEach(async () => {
+        resetQueryHttpMethodResolution();
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.resolves({ status: 405 } as unknown as Response);
+        await executeQueryHttpRequest(QueryHttpMethod.Query, makeOptions());
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should send a single request', () => fetchStub.callCount.should.equal(1));
+    it('should not fall back when the method was chosen explicitly', () => fetchStub.getCall(0).args[1].method.should.equal('QUERY'));
+});

package/queries/for_lengthBasedQueryHttpMethod/when_resolving/with_a_long_url.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 { lengthBasedQueryHttpMethod } from '../../QueryHttpMethodResolver';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+
+describe('when resolving with a long url', () => {
+    let result: QueryHttpMethod;
+
+    beforeEach(() => {
+        const resolve = lengthBasedQueryHttpMethod({ threshold: 100 });
+        const longValue = 'x'.repeat(500);
+        result = resolve({ url: new URL(`https://api.example.com/api/test?search=${longValue}`), route: '/api/test', args: {} });
+    });
+
+    it('should prefer QUERY with fallback', () => result.should.equal(QueryHttpMethod.Auto));
+});

package/queries/for_lengthBasedQueryHttpMethod/when_resolving/with_a_long_url_and_a_custom_method.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 { lengthBasedQueryHttpMethod } from '../../QueryHttpMethodResolver';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+
+describe('when resolving with a long url and a custom method', () => {
+    let result: QueryHttpMethod;
+
+    beforeEach(() => {
+        const resolve = lengthBasedQueryHttpMethod({ threshold: 100, whenLong: QueryHttpMethod.Query });
+        const longValue = 'x'.repeat(500);
+        result = resolve({ url: new URL(`https://api.example.com/api/test?search=${longValue}`), route: '/api/test', args: {} });
+    });
+
+    it('should use the configured method', () => result.should.equal(QueryHttpMethod.Query));
+});

package/queries/for_lengthBasedQueryHttpMethod/when_resolving/with_a_short_url.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { lengthBasedQueryHttpMethod } from '../../QueryHttpMethodResolver';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+
+describe('when resolving with a short url', () => {
+    let result: QueryHttpMethod;
+
+    beforeEach(() => {
+        const resolve = lengthBasedQueryHttpMethod({ threshold: 100 });
+        result = resolve({ url: new URL('https://api.example.com/api/test?id=1'), route: '/api/test', args: {} });
+    });
+
+    it('should choose GET', () => result.should.equal(QueryHttpMethod.Get));
+});

package/queries/index.ts

@@ -12,6 +12,9 @@ export * from './SortingActions';
 export * from './SortingActionsForQuery';
 export * from './SortingActionsForObservableQuery';
 export * from './QueryFor';
+export * from './QueryHttpMethod';
+export * from './QueryHttpMethodResolver';
+export * from './QueryHttpRequest';
 export * from './QueryResult';
 export * from './QueryResultWithState';
 export * from './IObservableQueryFor';