@cratis/arc 20.55.1 → 20.57.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/arc",
-    "version": "20.55.1",
+    "version": "20.57.0",
     "description": "",
     "author": "Cratis",
     "license": "MIT",

package/queries/IQuery.ts

@@ -4,11 +4,18 @@
 import { ICanBeConfigured } from '../ICanBeConfigured';
 import { Paging } from './Paging';
 import { Sorting } from './Sorting';
+import { QueryHttpMethod } from './QueryHttpMethod';
 
 /**
  * Defines the commonalities between all query types.
  */
 export interface IQuery extends ICanBeConfigured {
+    /**
+     * Set the HTTP method used to perform the query, overriding the global default.
+     * @param method The {@link QueryHttpMethod} to use.
+     */
+    setHttpMethod(method: QueryHttpMethod): void;
+
     /**
      * Gets the sorting for the query.
      */

package/queries/ObservableQueryFor.ts

@@ -14,11 +14,12 @@ import { Sorting } from './Sorting';
 import { Paging } from './Paging';
 import { SortDirection } from './SortDirection';
 import { Globals } from '../Globals';
-import { joinPaths } from '../joinPaths';
 import { UrlHelpers } from '../UrlHelpers';
 import { GetHttpHeaders } from '../GetHttpHeaders';
 import { ParameterDescriptor } from '../reflection/ParameterDescriptor';
 import { ParametersHelper } from '../reflection/ParametersHelper';
+import { QueryHttpMethod } from './QueryHttpMethod';
+import { executeQueryHttpRequest } from './QueryHttpRequest';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -32,6 +33,7 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
     private _origin: string;
     private _connection?: IObservableQueryConnection<TDataType>;
     private _httpHeadersCallback: GetHttpHeaders;
+    private _httpMethod?: QueryHttpMethod;
 
     abstract readonly route: string;
     abstract readonly defaultValue: TDataType;
@@ -84,6 +86,11 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
         this._httpHeadersCallback = callback;
     }
 
+    /** @inheritdoc */
+    setHttpMethod(method: QueryHttpMethod): void {
+        this._httpMethod = method;
+    }
+
     /** @inheritdoc */
     subscribe(callback: OnNextResult<QueryResult<TDataType>>, args?: TParameters): ObservableQuerySubscription<TDataType> {
         if (this._connection) {
@@ -142,31 +149,9 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
             });
         }
 
-        const { route, unusedParameters } = UrlHelpers.replaceRouteParameters(this.route, args as object);
-        let actualRoute = joinPaths(this._apiBasePath, route);
-        
-        const additionalParams: Record<string, string | number> = {};
-        if (this.paging.hasPaging) {
-            additionalParams.page = this.paging.page;
-            additionalParams.pageSize = this.paging.pageSize;
-        }
-
-        if (this.sorting.hasSorting) {
-            additionalParams.sortBy = this.sorting.field;
-            additionalParams.sortDirection = (this.sorting.direction === SortDirection.descending) ? 'desc' : 'asc';
-        }
-
         // Collect parameter values from parameterDescriptors that are set
         const parameterValues = ParametersHelper.collectParameterValues(this);
 
-        const queryParams = UrlHelpers.buildQueryParams({ ...unusedParameters, ...parameterValues }, additionalParams);
-        const queryString = queryParams.toString();
-        if (queryString) {
-            actualRoute += (actualRoute.includes('?') ? '&' : '?') + queryString;
-        }
-
-        const url = UrlHelpers.createUrlFrom(this._origin, this._apiBasePath, actualRoute);
-
         const headers = {
             ...(this._httpHeadersCallback?.() || {}),
             'Accept': 'application/json',
@@ -177,8 +162,14 @@ export abstract class ObservableQueryFor<TDataType, TParameters = object> implem
             headers[Globals.microserviceHttpHeader] = this._microservice;
         }
 
-        const response = await fetch(url, {
-            method: 'GET',
+        const response = await executeQueryHttpRequest(this._httpMethod, {
+            route: this.route,
+            apiBasePath: this._apiBasePath,
+            origin: this._origin,
+            args: (args as object) ?? {},
+            parameterValues,
+            paging: this.paging,
+            sorting: this.sorting,
             headers
         });
 

package/queries/QueryFor.ts

@@ -9,12 +9,11 @@ import { Constructor } from '@cratis/fundamentals';
 import { Paging } from './Paging';
 import { Globals } from '../Globals';
 import { Sorting } from './Sorting';
-import { SortDirection } from './SortDirection';
-import { joinPaths } from '../joinPaths';
-import { UrlHelpers } from '../UrlHelpers';
 import { GetHttpHeaders } from '../GetHttpHeaders';
 import { ParameterDescriptor } from '../reflection/ParameterDescriptor';
 import { ParametersHelper } from '../reflection/ParametersHelper';
+import { QueryHttpMethod } from './QueryHttpMethod';
+import { executeQueryHttpRequest } from './QueryHttpRequest';
 
 /**
  * Represents an implementation of {@link IQueryFor}.
@@ -25,6 +24,7 @@ export abstract class QueryFor<TDataType, TParameters = object> implements IQuer
     private _apiBasePath: string;
     private _origin: string;
     private _httpHeadersCallback: GetHttpHeaders;
+    private _httpMethod?: QueryHttpMethod;
     abstract readonly route: string;
     /** Backend fully-qualified query name used as cache key. Overridden in generated proxies. */
     readonly queryName?: string;
@@ -74,6 +74,11 @@ export abstract class QueryFor<TDataType, TParameters = object> implements IQuer
         this._httpHeadersCallback = callback;
     }
 
+    /** @inheritdoc */
+    setHttpMethod(method: QueryHttpMethod): void {
+        this._httpMethod = method;
+    }
+
     /** @inheritdoc */
     async perform(args?: TParameters): Promise<QueryResult<TDataType>> {
         const noSuccess = { ...QueryResult.noSuccess, ...{ data: this.defaultValue } } as QueryResult<TDataType>;
@@ -117,31 +122,9 @@ export abstract class QueryFor<TDataType, TParameters = object> implements IQuer
 
         this.abortController = new AbortController();
 
-        const { route, unusedParameters } = UrlHelpers.replaceRouteParameters(this.route, args as object);
-        let actualRoute = joinPaths(this._apiBasePath, route);
-        
-        const additionalParams: Record<string, string | number> = {};
-        if (this.paging.hasPaging) {
-            additionalParams.page = this.paging.page;
-            additionalParams.pageSize = this.paging.pageSize;
-        }
-
-        if (this.sorting.hasSorting) {
-            additionalParams.sortBy = this.sorting.field;
-            additionalParams.sortDirection = (this.sorting.direction === SortDirection.descending) ? 'desc' : 'asc';
-        }
-
         // Collect parameter values from parameterDescriptors that are set
         const parameterValues = ParametersHelper.collectParameterValues(this);
 
-        const queryParams = UrlHelpers.buildQueryParams({ ...unusedParameters, ...parameterValues }, additionalParams);
-        const queryString = queryParams.toString();
-        if (queryString) {
-            actualRoute += (actualRoute.includes('?') ? '&' : '?') + queryString;
-        }
-        
-        const url = UrlHelpers.createUrlFrom(this._origin, this._apiBasePath, actualRoute);
-
         const headers = {
             ... this._httpHeadersCallback?.(), ...
             {
@@ -154,8 +137,14 @@ export abstract class QueryFor<TDataType, TParameters = object> implements IQuer
             headers[Globals.microserviceHttpHeader] = this._microservice;
         }
 
-        const response = await fetch(url, {
-            method: 'GET',
+        const response = await executeQueryHttpRequest(this._httpMethod, {
+            route: this.route,
+            apiBasePath: this._apiBasePath,
+            origin: this._origin,
+            args: (args as object) ?? {},
+            parameterValues,
+            paging: this.paging,
+            sorting: this.sorting,
             headers,
             signal: this.abortController.signal
         });

package/queries/QueryHttpMethod.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Defines the HTTP method used to perform a query over HTTP.
+ */
+export enum QueryHttpMethod {
+    /**
+     * Use the GET method, carrying arguments in the URL query string (default).
+     */
+    Get = 'GET',
+
+    /**
+     * Use the QUERY method (RFC 10008), carrying arguments in a JSON request body.
+     */
+    Query = 'QUERY',
+
+    /**
+     * Prefer the QUERY method and automatically fall back to GET when the server or network path
+     * does not support it. The outcome is remembered for the rest of the session so subsequent
+     * queries go straight to the working transport.
+     */
+    Auto = 'AUTO',
+}

package/queries/QueryHttpMethodResolver.ts

@@ -0,0 +1,51 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryHttpMethod } from './QueryHttpMethod';
+
+/**
+ * The information a {@link QueryHttpMethodResolver} uses to decide the HTTP method for a query.
+ */
+export interface QueryHttpMethodResolverContext {
+    /** The URL the query would use as a GET request (arguments in the query string). */
+    readonly url: URL;
+    /** The route template for the query. */
+    readonly route: string;
+    /** The arguments for the query. */
+    readonly args: object;
+}
+
+/**
+ * A policy that decides, per query, which {@link QueryHttpMethod} to use.
+ * Consulted only when the query has no explicit method set via {@code setHttpMethod}.
+ */
+export type QueryHttpMethodResolver = (context: QueryHttpMethodResolverContext) => QueryHttpMethod;
+
+/**
+ * The default URL length, in characters, above which {@link lengthBasedQueryHttpMethod} prefers QUERY.
+ * 2000 is the widely-safe URL length across browsers, servers and proxies.
+ */
+export const defaultQueryHttpMethodUrlThreshold = 2000;
+
+/**
+ * Options for {@link lengthBasedQueryHttpMethod}.
+ */
+export interface LengthBasedQueryHttpMethodOptions {
+    /** URL length (in characters) above which QUERY is preferred. Defaults to {@link defaultQueryHttpMethodUrlThreshold}. */
+    threshold?: number;
+    /** The method to use when the URL exceeds the threshold. Defaults to {@link QueryHttpMethod.Auto} so it still falls back to GET. */
+    whenLong?: QueryHttpMethod;
+}
+
+/**
+ * Creates a {@link QueryHttpMethodResolver} that keeps short queries on GET and prefers QUERY only when
+ * the GET URL would exceed a threshold — targeting the arguments-too-large-for-a-URL case while leaving
+ * small, cacheable queries on GET.
+ * @param options Optional {@link LengthBasedQueryHttpMethodOptions}.
+ * @returns A {@link QueryHttpMethodResolver}.
+ */
+export function lengthBasedQueryHttpMethod(options?: LengthBasedQueryHttpMethodOptions): QueryHttpMethodResolver {
+    const threshold = options?.threshold ?? defaultQueryHttpMethodUrlThreshold;
+    const whenLong = options?.whenLong ?? QueryHttpMethod.Auto;
+    return context => (context.url.href.length > threshold ? whenLong : QueryHttpMethod.Get);
+}

package/queries/for_QueryFor/when_performing/with_query_http_method.ts

@@ -0,0 +1,63 @@
+// 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';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+
+describe('with query http method', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+    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 () => {
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        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.setHttpMethod(QueryHttpMethod.Query);
+
+        result = await context.query.perform({ id: 'test-id' });
+    });
+
+    afterEach(() => {
+        fetchHelper.restore();
+    });
+
+    it('should return successful result', () => result.isSuccess.should.be.true);
+
+    it('should call fetch with QUERY method', () => {
+        const options = fetchStub.getCall(0).args[1];
+        options.method.should.equal('QUERY');
+    });
+
+    it('should keep the route parameter in the path', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.equal('https://api.example.com/api/v1/api/test/test-id');
+    });
+
+    it('should send a JSON request body', () => {
+        const options = fetchStub.getCall(0).args[1];
+        (options.body === undefined).should.be.false;
+    });
+}));

package/queries/for_buildQueryHttpRequest/when_building/with_get_method.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 { buildQueryHttpRequest } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { Paging } from '../../Paging';
+import { Sorting } from '../../Sorting';
+
+describe('when building with get method', () => {
+    let result: { url: URL; init: RequestInit };
+
+    beforeEach(() => {
+        result = buildQueryHttpRequest(QueryHttpMethod.Get, {
+            route: '/api/test/{id}',
+            apiBasePath: '/api/v1',
+            origin: 'https://api.example.com',
+            args: { id: 'abc', filter: 'active' },
+            parameterValues: {},
+            paging: Paging.noPaging,
+            sorting: Sorting.none,
+            headers: { 'Accept': 'application/json' }
+        });
+    });
+
+    it('should use the GET method', () => result.init.method!.should.equal('GET'));
+
+    it('should substitute route parameters and append remaining arguments to the query string', () =>
+        result.url.href.should.equal('https://api.example.com/api/v1/api/test/abc?filter=active'));
+
+    it('should not have a body', () => (result.init.body === undefined).should.be.true);
+});

package/queries/for_buildQueryHttpRequest/when_building/with_query_method.ts

@@ -0,0 +1,42 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { buildQueryHttpRequest } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { Paging } from '../../Paging';
+import { Sorting } from '../../Sorting';
+
+describe('when building with query method', () => {
+    let result: { url: URL; init: RequestInit };
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    let body: any;
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+
+    beforeEach(() => {
+        result = buildQueryHttpRequest(QueryHttpMethod.Query, {
+            route: '/api/test/{id}',
+            apiBasePath: '/api/v1',
+            origin: 'https://api.example.com',
+            args: { id: 'abc', filter: 'active' },
+            parameterValues: {},
+            paging: Paging.noPaging,
+            sorting: Sorting.none,
+            headers: { 'Accept': 'application/json' }
+        });
+        body = JSON.parse(result.init.body as string);
+    });
+
+    it('should use the QUERY method', () => result.init.method!.should.equal('QUERY'));
+
+    it('should substitute route parameters in the path', () =>
+        result.url.href.should.equal('https://api.example.com/api/v1/api/test/abc'));
+
+    it('should not put arguments in the query string', () => result.url.search.should.equal(''));
+
+    it('should carry non-route arguments in the body', () => body.arguments.filter.should.equal('active'));
+
+    it('should not carry route arguments in the body', () => (body.arguments.id === undefined).should.be.true);
+
+    it('should set the content type to json', () =>
+        new Headers(result.init.headers).get('Content-Type')!.should.equal('application/json'));
+});

package/queries/for_buildQueryHttpRequest/when_building/with_query_method_and_paging_and_sorting.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 { buildQueryHttpRequest } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { Paging } from '../../Paging';
+import { Sorting } from '../../Sorting';
+import { SortDirection } from '../../SortDirection';
+
+describe('when building with query method and paging and sorting', () => {
+    let result: { url: URL; init: RequestInit };
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    let body: any;
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+
+    beforeEach(() => {
+        result = buildQueryHttpRequest(QueryHttpMethod.Query, {
+            route: '/api/all',
+            apiBasePath: '',
+            origin: 'https://api.example.com',
+            args: {},
+            parameterValues: {},
+            paging: new Paging(2, 25),
+            sorting: new Sorting('name', SortDirection.descending),
+            headers: {}
+        });
+        body = JSON.parse(result.init.body as string);
+    });
+
+    it('should carry paging in the body', () => body.paging.should.deep.equal({ page: 2, pageSize: 25 }));
+
+    it('should carry sorting in the body', () => body.sorting.should.deep.equal({ field: 'name', direction: 'desc' }));
+
+    it('should not put paging or sorting in the query string', () => result.url.search.should.equal(''));
+});

package/queries/for_executeQueryHttpRequest/options.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Paging } from '../Paging';
+import { Sorting } from '../Sorting';
+import { BuildQueryHttpRequestOptions } from '../QueryHttpRequest';
+
+/**
+ * Builds a minimal set of options for exercising {@link executeQueryHttpRequest}.
+ * @param overrides Optional property overrides (e.g. a different origin).
+ */
+export function makeOptions(overrides?: Partial<BuildQueryHttpRequestOptions>): BuildQueryHttpRequestOptions {
+    return {
+        route: '/api/test',
+        apiBasePath: '',
+        origin: 'https://api.example.com',
+        args: {},
+        parameterValues: {},
+        paging: Paging.noPaging,
+        sorting: Sorting.none,
+        headers: {},
+        ...overrides
+    };
+}

package/queries/for_executeQueryHttpRequest/when_performing/with_a_resolver.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 * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { Globals } from '../../../Globals';
+import { makeOptions } from '../options';
+
+describe('when performing with a resolver', () => {
+    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);
+        Globals.queryHttpMethodResolver = () => QueryHttpMethod.Query;
+        // No explicit per-query override — the resolver decides.
+        await executeQueryHttpRequest(undefined, makeOptions());
+    });
+
+    afterEach(() => {
+        Globals.queryHttpMethodResolver = undefined;
+        fetchHelper.restore();
+    });
+
+    it('should use the method chosen by the resolver', () => fetchStub.getCall(0).args[1].method.should.equal('QUERY'));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_a_resolver_and_an_explicit_override.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 * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import { executeQueryHttpRequest, resetQueryHttpMethodResolution } from '../../QueryHttpRequest';
+import { QueryHttpMethod } from '../../QueryHttpMethod';
+import { Globals } from '../../../Globals';
+import { makeOptions } from '../options';
+
+describe('when performing with a resolver and an explicit override', () => {
+    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);
+        Globals.queryHttpMethodResolver = () => QueryHttpMethod.Query;
+        // An explicit per-query override must win over the resolver.
+        await executeQueryHttpRequest(QueryHttpMethod.Get, makeOptions());
+    });
+
+    afterEach(() => {
+        Globals.queryHttpMethodResolver = undefined;
+        fetchHelper.restore();
+    });
+
+    it('should honor the explicit override over the resolver', () => fetchStub.getCall(0).args[1].method.should.equal('GET'));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_auto_after_query_was_found_unsupported.ts

@@ -0,0 +1,33 @@
+// 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 after query was found unsupported', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    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));
+
+        // First Auto query learns that QUERY is unsupported and falls back to GET.
+        await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions());
+        // Second Auto query should go straight to GET without probing QUERY again.
+        await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions());
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should only attempt QUERY once across both queries', () =>
+        fetchStub.getCalls().filter(call => call.args[1].method === 'QUERY').length.should.equal(1));
+    it('should send the second query directly as GET', () => fetchStub.getCall(2).args[1].method.should.equal('GET'));
+    it('should send three requests in total', () => fetchStub.callCount.should.equal(3));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_auto_and_a_network_failure.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 * 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 a network failure', () => {
+    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) =>
+            init.method === 'QUERY'
+                ? Promise.reject(new TypeError('Failed to fetch'))
+                : Promise.resolve({ status: 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 on the thrown error', () => fetchStub.getCall(1).args[1].method.should.equal('GET'));
+    it('should return the GET response', () => result.status.should.equal(200));
+});

package/queries/for_executeQueryHttpRequest/when_performing/with_auto_and_an_aborted_request.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 * 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 aborted request', () => {
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+    let error: { name?: string } | undefined;
+
+    beforeEach(async () => {
+        resetQueryHttpMethodResolution();
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.callsFake(() => Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' })));
+        try {
+            await executeQueryHttpRequest(QueryHttpMethod.Auto, makeOptions());
+        } catch (caught) {
+            error = caught as { name?: string };
+        }
+    });
+
+    afterEach(() => fetchHelper.restore());
+
+    it('should rethrow the abort error', () => error!.name!.should.equal('AbortError'));
+    it('should not fall back to GET', () => fetchStub.callCount.should.equal(1));
+});