@tstdl/base 0.90.32 → 0.90.33

package/.eslintrc.json

@@ -86,6 +86,7 @@
     "capitalized-comments": "off",
     "class-methods-use-this": "off",
     "complexity": "off",
+    "consistent-return": ["error", { "treatUndefinedAsUnspecified": true }],
     "dot-location": ["error", "property"],
     "eqeqeq": "off",
     "func-style": ["error", "declaration", { "allowArrowFunctions": true }],

package/api/server/error-handler.d.ts

@@ -1,4 +1,4 @@
-import { HttpServerResponse } from '../../http/server/index.js';
+import type { HttpServerResponse } from '../../http/server/index.js';
 import type { Logger } from '../../logger/index.js';
 import type { Type } from '../../types.js';
-export declare function handleApiError(error: unknown, supressedErrors: Set<Type<Error>>, logger: Logger): HttpServerResponse;
+export declare function handleApiError(error: unknown, response: HttpServerResponse, supressedErrors: Set<Type<Error>>, logger: Logger): HttpServerResponse;

package/api/server/error-handler.js

@@ -1,8 +1,6 @@
-import { HttpServerResponse } from '../../http/server/index.js';
 import { formatError } from '../../utils/format-error.js';
 import { createErrorResponse, getErrorStatusCode, hasErrorHandler } from '../response.js';
-export function handleApiError(error, supressedErrors, logger) {
-    const response = new HttpServerResponse();
+export function handleApiError(error, response, supressedErrors, logger) {
     if (error instanceof Error) {
         const errorConstructor = error.constructor;
         const supressed = supressedErrors.has(errorConstructor);

package/api/server/gateway.d.ts

@@ -15,9 +15,11 @@ export type ApiGatewayMiddlewareContext = {
     /** can be undefined if used before allowedMethods middleware */
     endpoint: GatewayEndpoint;
     resourcePatternResult: URLPatternResult;
+    request: HttpServerRequest;
+    response: HttpServerResponse;
 };
-export type ApiGatewayMiddlewareNext = AsyncMiddlewareNext<HttpServerRequest, HttpServerResponse>;
-export type ApiGatewayMiddleware = AsyncMiddleware<HttpServerRequest, HttpServerResponse, ApiGatewayMiddlewareContext>;
+export type ApiGatewayMiddlewareNext = AsyncMiddlewareNext;
+export type ApiGatewayMiddleware = AsyncMiddleware<ApiGatewayMiddlewareContext>;
 export declare abstract class ApiGatewayOptions {
     /**
      * Api prefix. Pass `null` to disable prefix.
@@ -64,7 +66,7 @@ export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
     private readonly supressedErrors;
     private readonly catchErrorMiddleware;
     private readonly options;
-    private handler;
+    private composedMiddleware;
     readonly [resolveArgumentType]: ApiGatewayOptions;
     constructor(requestTokenProvider: ApiRequestTokenProvider, logger: Logger, options?: ApiGatewayOptions);
     addMiddleware(middleware: ApiGatewayMiddleware): void;
@@ -73,6 +75,5 @@ export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
     handleHttpServerRequestContext({ request, respond, close }: HttpServerRequestContext): Promise<void>;
     getApiMetadata(resource: URL): ApiMetadata;
     private updateMiddleware;
-    private middlewareHandler;
-    private getBody;
+    private endpointMiddleware;
 }

package/api/server/gateway.js

@@ -29,7 +29,7 @@ import { normalizedApiDefinitionEndpointsEntries } from '../types.js';
 import { getFullApiEndpointResource } from '../utils.js';
 import { ApiRequestTokenProvider } from './api-request-token.provider.js';
 import { handleApiError } from './error-handler.js';
-import { allowedMethodsMiddleware, catchErrorMiddleware, corsMiddleware, responseTimeMiddleware } from './middlewares/index.js';
+import { allowedMethodsMiddleware, getCatchErrorMiddleware, contentTypeMiddleware, corsMiddleware, responseTimeMiddleware } from './middlewares/index.js';
 import { API_MODULE_OPTIONS } from './tokens.js';
 const defaultMaxBytes = 10 * mebibyte;
 export class ApiGatewayOptions {
@@ -63,7 +63,7 @@ let ApiGateway = class ApiGateway {
     supressedErrors;
     catchErrorMiddleware;
     options;
-    handler;
+    composedMiddleware;
     constructor(requestTokenProvider, logger, options = {}) {
         this.requestTokenProvider = requestTokenProvider;
         this.logger = logger;
@@ -72,7 +72,7 @@ let ApiGateway = class ApiGateway {
         this.apis = new Map();
         this.middlewares = options.middlewares ?? [];
         this.supressedErrors = new Set(options.supressedErrors);
-        this.catchErrorMiddleware = catchErrorMiddleware(this.supressedErrors, logger);
+        this.catchErrorMiddleware = getCatchErrorMiddleware(this.supressedErrors, logger);
         this.updateMiddleware();
     }
     addMiddleware(middleware) {
@@ -121,16 +121,18 @@ let ApiGateway = class ApiGateway {
     }
     async handleHttpServerRequestContext({ request, respond, close }) {
         let responded = false;
+        const response = new HttpServerResponse();
         try {
             const { api, patternResult } = this.getApiMetadata(request.url);
             const endpoint = api.endpoints.get(request.method);
-            const response = await this.handler(request, { api, resourcePatternResult: patternResult, endpoint });
+            const context = { api, resourcePatternResult: patternResult, endpoint, request, response };
+            await this.composedMiddleware(context);
             responded = true;
-            await respond(response);
+            await respond(context.response);
         }
         catch (error) {
             try {
-                const response = handleApiError(error, this.supressedErrors, this.logger);
+                handleApiError(error, response, this.supressedErrors, this.logger);
                 if (responded) {
                     await close();
                 }
@@ -160,80 +162,44 @@ let ApiGateway = class ApiGateway {
         throw new NotFoundError(`Resource ${resource.pathname} not available.`);
     }
     updateMiddleware() {
-        const middlewares = [responseTimeMiddleware, corsMiddleware(this.options.cors), allowedMethodsMiddleware, this.catchErrorMiddleware, ...this.middlewares];
-        this.handler = composeAsyncMiddleware(middlewares, async (request, context) => this.middlewareHandler(request, context));
+        const middlewares = [responseTimeMiddleware, contentTypeMiddleware, this.catchErrorMiddleware, corsMiddleware(this.options.cors), allowedMethodsMiddleware, ...this.middlewares, async (context, next) => this.endpointMiddleware(context, next)];
+        this.composedMiddleware = composeAsyncMiddleware(middlewares);
     }
-    async middlewareHandler(request, context) {
+    async endpointMiddleware(context, next) {
         const readBodyOptions = { maxBytes: context.endpoint.definition.maxBytes ?? this.options.defaultMaxBytes ?? defaultMaxBytes };
         const body = isDefined(context.endpoint.definition.body)
-            ? await this.getBody(request, readBodyOptions, context.endpoint.definition.body)
+            ? await getBody(context.request, readBodyOptions, context.endpoint.definition.body)
             : undefined;
-        const bodyAsParameters = (isUndefined(context.endpoint.definition.body) && (request.headers.contentType?.includes('json') == true))
-            ? await request.body.readAsJson(readBodyOptions)
+        const bodyAsParameters = (isUndefined(context.endpoint.definition.body) && (context.request.headers.contentType?.includes('json') == true))
+            ? await context.request.body.readAsJson(readBodyOptions)
             : undefined;
         if (isDefined(bodyAsParameters) && !isObject(bodyAsParameters)) {
             throw new BadRequestError('Expected json object as body.');
         }
         const decodedUrlParameters = mapObjectValues(context.resourcePatternResult.pathname.groups, (value) => isDefined(value) ? decodeURIComponent(value) : undefined);
-        const parameters = { ...request.query.asObject(), ...bodyAsParameters, ...decodedUrlParameters };
+        const parameters = { ...context.request.query.asObject(), ...bodyAsParameters, ...decodedUrlParameters };
         const validatedParameters = isDefined(context.endpoint.definition.parameters)
             ? Schema.parse(context.endpoint.definition.parameters, parameters)
             : parameters;
         const requestContext = {
             parameters: validatedParameters,
             body,
-            request,
+            request: context.request,
             getToken: async () => this.requestTokenProvider.getToken(requestContext)
         };
         const result = await context.endpoint.implementation(requestContext);
-        const response = (result instanceof HttpServerResponse)
-            ? result
-            : new HttpServerResponse({
-                body: isUint8Array(result) ? { buffer: result }
-                    : isBlob(result) ? { stream: result.stream() }
-                        : isReadableStream(result) ? { stream: result }
-                            : (result instanceof ServerSentEventsSource) ? { events: result }
-                                : (context.endpoint.definition.result == String) ? { text: result }
-                                    : { json: result }
-            });
-        if (isUndefined(response.headers.contentType)) {
-            response.headers.contentType =
-                (isDefined(response.body?.json)) ? 'application/json; charset=utf-8'
-                    : (isDefined(response.body?.text)) ? 'text/plain; charset=utf-8'
-                        : (isDefined(response.body?.buffer)) ? 'application/octet-stream'
-                            : (isDefined(response.body?.stream)) ? 'application/octet-stream'
-                                : (isDefined(response.body?.events)) ? 'text/event-stream'
-                                    : undefined;
+        if (result instanceof HttpServerResponse) {
+            context.response = result; // eslint-disable-line require-atomic-updates
         }
-        return response;
-    }
-    async getBody(request, options, schema) {
-        let body;
-        if (request.hasBody) {
-            if (schema == ReadableStream) {
-                body = request.body.readAsBinaryStream(options);
-            }
-            else if (schema == Uint8Array) {
-                body = await request.body.readAsBuffer(options);
-            }
-            else if (schema == Blob) {
-                const buffer = await request.body.readAsBuffer(options);
-                body = new Blob([buffer], { type: request.headers.contentType });
-            }
-            else if (schema == String) {
-                body = await request.body.readAsText(options);
-            }
-            else if (request.headers.contentType?.startsWith('text') == true) {
-                body = await request.body.readAsText(options);
-            }
-            else if (request.headers.contentType?.includes('json') == true) {
-                body = await request.body.readAsJson(options);
-            }
-            else {
-                body = await request.body.readAsBuffer(options);
-            }
+        else {
+            context.response.body = isUint8Array(result) ? { buffer: result } // eslint-disable-line require-atomic-updates
+                : isBlob(result) ? { stream: result.stream() }
+                    : isReadableStream(result) ? { stream: result }
+                        : (result instanceof ServerSentEventsSource) ? { events: result }
+                            : (context.endpoint.definition.result == String) ? { text: result }
+                                : { json: result };
         }
-        return Schema.parse(schema, body);
+        await next();
     }
 };
 ApiGateway = __decorate([
@@ -245,3 +211,31 @@ ApiGateway = __decorate([
     __metadata("design:paramtypes", [ApiRequestTokenProvider, Logger, ApiGatewayOptions])
 ], ApiGateway);
 export { ApiGateway };
+async function getBody(request, options, schema) {
+    let body;
+    if (request.hasBody) {
+        if (schema == ReadableStream) {
+            body = request.body.readAsBinaryStream(options);
+        }
+        else if (schema == Uint8Array) {
+            body = await request.body.readAsBuffer(options);
+        }
+        else if (schema == Blob) {
+            const buffer = await request.body.readAsBuffer(options);
+            body = new Blob([buffer], { type: request.headers.contentType });
+        }
+        else if (schema == String) {
+            body = await request.body.readAsText(options);
+        }
+        else if (request.headers.contentType?.startsWith('text') == true) {
+            body = await request.body.readAsText(options);
+        }
+        else if (request.headers.contentType?.includes('json') == true) {
+            body = await request.body.readAsJson(options);
+        }
+        else {
+            body = await request.body.readAsBuffer(options);
+        }
+    }
+    return Schema.parse(schema, body);
+}

package/api/server/middlewares/allowed-methods.middleware.d.ts

@@ -1,5 +1,2 @@
-import type { HttpServerRequest } from '../../../http/server/index.js';
-import { HttpServerResponse } from '../../../http/server/index.js';
-import type { AsyncMiddlewareNext } from '../../../utils/middleware.js';
-import type { ApiGatewayMiddlewareContext } from '../gateway.js';
-export declare function allowedMethodsMiddleware(request: HttpServerRequest, next: AsyncMiddlewareNext<HttpServerRequest, HttpServerResponse>, context: ApiGatewayMiddlewareContext): Promise<HttpServerResponse>;
+import type { ApiGatewayMiddlewareContext, ApiGatewayMiddlewareNext } from '../gateway.js';
+export declare function allowedMethodsMiddleware({ endpoint, api, request, response }: ApiGatewayMiddlewareContext, next: ApiGatewayMiddlewareNext): Promise<void>;

package/api/server/middlewares/allowed-methods.middleware.js

@@ -1,19 +1,14 @@
 import { MethodNotAllowedError } from '../../../errors/method-not-allowed.error.js';
-import { HttpServerResponse } from '../../../http/server/index.js';
 import { isUndefined } from '../../../utils/type-guards.js';
-export async function allowedMethodsMiddleware(request, next, context) {
+export async function allowedMethodsMiddleware({ endpoint, api, request, response }, next) {
     if (request.method != 'OPTIONS') {
-        if (isUndefined(context.endpoint)) {
-            throw new MethodNotAllowedError(`Method ${request.method} for resource ${context.api.resource} not available.`);
+        if (isUndefined(endpoint)) {
+            throw new MethodNotAllowedError(`Method ${request.method} for resource ${api.resource} not available.`);
         }
-        return next(request);
+        return next();
     }
-    const allowMethods = [...context.api.endpoints.keys()].join(', ');
-    return HttpServerResponse.fromObject({
-        statusCode: 204,
-        statusMessage: 'No Content',
-        headers: {
-            Allow: allowMethods
-        }
-    });
+    const allowMethods = [...api.endpoints.keys()].join(', ');
+    response.statusCode = 204;
+    response.statusMessage = 'No Content';
+    response.headers.setIfMissing('Allow', allowMethods);
 }

package/api/server/middlewares/catch-error.middleware.d.ts

@@ -1,4 +1,4 @@
 import type { Logger } from '../../../logger/index.js';
 import type { Type } from '../../../types.js';
 import type { ApiGatewayMiddleware } from '../gateway.js';
-export declare function catchErrorMiddleware(supressedErrors: Set<Type<Error>>, logger: Logger): ApiGatewayMiddleware;
+export declare function getCatchErrorMiddleware(supressedErrors: Set<Type<Error>>, logger: Logger): ApiGatewayMiddleware;

package/api/server/middlewares/catch-error.middleware.js

@@ -1,13 +1,12 @@
 import { handleApiError } from '../error-handler.js';
-export function catchErrorMiddleware(supressedErrors, logger) {
+export function getCatchErrorMiddleware(supressedErrors, logger) {
     // eslint-disable-next-line @typescript-eslint/no-shadow
-    async function catchErrorMiddleware(request, next) {
+    async function catchErrorMiddleware(context, next) {
         try {
-            const response = await next(request);
-            return response;
+            await next();
         }
         catch (error) {
-            return handleApiError(error, supressedErrors, logger);
+            handleApiError(error, context.response, supressedErrors, logger);
         }
     }
     return catchErrorMiddleware;

package/api/server/middlewares/content-type.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { ApiGatewayMiddlewareContext, ApiGatewayMiddlewareNext } from '../gateway.js';
+export declare function contentTypeMiddleware(context: ApiGatewayMiddlewareContext, next: ApiGatewayMiddlewareNext): Promise<void>;

package/api/server/middlewares/content-type.middleware.js

@@ -0,0 +1,15 @@
+import { isDefined } from '../../../utils/type-guards.js';
+export async function contentTypeMiddleware(context, next) {
+    await next();
+    const { response } = context;
+    if (isDefined(response.headers.contentType)) {
+        return;
+    }
+    response.headers.contentType =
+        (isDefined(response.body?.json)) ? 'application/json; charset=utf-8'
+            : (isDefined(response.body?.text)) ? 'text/plain; charset=utf-8'
+                : (isDefined(response.body?.buffer)) ? 'application/octet-stream'
+                    : (isDefined(response.body?.stream)) ? 'application/octet-stream'
+                        : (isDefined(response.body?.events)) ? 'text/event-stream'
+                            : undefined;
+}

package/api/server/middlewares/cors.middleware.js

@@ -3,8 +3,9 @@ import { toArray } from '../../../utils/array/array.js';
 import { isDefined } from '../../../utils/type-guards.js';
 export function corsMiddleware(options = {}) {
     // eslint-disable-next-line max-statements, @typescript-eslint/no-shadow
-    async function corsMiddleware(request, next, context) {
-        const response = await next(request);
+    async function corsMiddleware(context, next) {
+        await next();
+        const { request, response } = context;
         const requestMethod = request.headers.tryGetSingle('Access-Control-Request-Method') ?? request.method;
         const isOptions = (request.method == 'OPTIONS');
         const endpointDefinition = context.api.endpoints.get(requestMethod)?.definition;
@@ -45,7 +46,6 @@ export function corsMiddleware(options = {}) {
                 response.headers.setIfMissing('Access-Control-Allow-Origin', origin);
             }
         }
-        return response;
     }
     return corsMiddleware;
 }

package/api/server/middlewares/index.d.ts

@@ -1,4 +1,5 @@
 export * from './allowed-methods.middleware.js';
 export * from './catch-error.middleware.js';
+export * from './content-type.middleware.js';
 export * from './cors.middleware.js';
 export * from './response-time.middleware.js';

package/api/server/middlewares/index.js

@@ -1,4 +1,5 @@
 export * from './allowed-methods.middleware.js';
 export * from './catch-error.middleware.js';
+export * from './content-type.middleware.js';
 export * from './cors.middleware.js';
 export * from './response-time.middleware.js';

package/api/server/middlewares/response-time.middleware.d.ts

@@ -1,3 +1,2 @@
-import type { HttpServerRequest, HttpServerResponse } from '../../../http/server/index.js';
-import type { ApiGatewayMiddlewareNext } from '../gateway.js';
-export declare function responseTimeMiddleware(request: HttpServerRequest, next: ApiGatewayMiddlewareNext): Promise<HttpServerResponse>;
+import type { ApiGatewayMiddlewareContext, ApiGatewayMiddlewareNext } from '../gateway.js';
+export declare function responseTimeMiddleware({ response }: ApiGatewayMiddlewareContext, next: ApiGatewayMiddlewareNext): Promise<void>;

package/api/server/middlewares/response-time.middleware.js

@@ -1,9 +1,8 @@
 import { round } from '../../../utils/math.js';
 import { Timer } from '../../../utils/timer.js';
-export async function responseTimeMiddleware(request, next) {
-    const timer = new Timer(true);
-    const response = await next(request);
+export async function responseTimeMiddleware({ response }, next) {
+    const timer = Timer.startNew();
+    await next();
     const time = round(timer.milliseconds, 2);
     response.headers.set('X-Response-Time', `${time}ms`);
-    return response;
 }

package/authentication/client/http-client.middleware.js

@@ -4,15 +4,15 @@ import { dontWaitForValidToken } from '../authentication.api.js';
 export function waitForAuthenticationCredentialsMiddleware(authenticationServiceOrProvider) {
     const getAuthenticationService = cacheAsyncValueOrProvider(authenticationServiceOrProvider);
     // eslint-disable-next-line @typescript-eslint/no-shadow
-    async function waitForAuthenticationCredentialsMiddleware(request, next, context) {
-        const endpoint = context?.endpoint;
+    async function waitForAuthenticationCredentialsMiddleware({ request }, next) {
+        const endpoint = request.context?.endpoint;
         if ((endpoint?.credentials == true) && (endpoint.data?.[dontWaitForValidToken] != true)) {
             const authenticationService = await getAuthenticationService();
             while (!authenticationService.hasValidToken) {
                 await firstValueFrom(authenticationService.validToken$);
             }
         }
-        return next(request);
+        return next();
     }
     return waitForAuthenticationCredentialsMiddleware;
 }

package/examples/api/basic-overview.d.ts

@@ -1 +1 @@
-export {};
+import '../../polyfills.js';

package/examples/api/basic-overview.js

@@ -8,6 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 /* eslint-disable max-classes-per-file */
+import '../../polyfills.js';
 import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/index.js';
 import { apiController, configureApiServer } from '../../api/server/index.js';

package/examples/http/client.d.ts

@@ -1 +1 @@
-export {};
+import '../../polyfills.js';

package/examples/http/client.js

@@ -1,3 +1,4 @@
+import '../../polyfills.js';
 import { Application } from '../../application/application.js';
 import { configureUndiciHttpClientAdapter } from '../../http/client/adapters/undici.adapter.js';
 import { HttpClient } from '../../http/client/index.js';

package/http/client/http-client.d.ts

@@ -13,8 +13,9 @@ export declare class HttpClient implements Resolvable<HttpClientArgument> {
     private readonly adapter;
     private readonly middleware;
     private readonly headers;
-    private readonly internalMiddleware;
-    private callHandler;
+    private readonly internalStartMiddleware;
+    private readonly internalEndMiddleware;
+    private composedMiddleware;
     readonly options: HttpClientOptions;
     readonly [resolveArgumentType]: HttpClientOptions;
     constructor();
@@ -51,6 +52,5 @@ export declare class HttpClient implements Resolvable<HttpClientArgument> {
     deleteStream(url: string, options?: HttpClientRequestOptions): ReadableStream<Uint8Array>;
     request(method: HttpMethod, url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
     rawRequest(request: HttpClientRequest): Promise<HttpClientResponse>;
-    private updateHandlers;
-    private prepareRequest;
+    private updateMiddleware;
 }

package/http/client/http-client.js

@@ -15,7 +15,7 @@ import { encodeUtf8 } from '../../utils/encoding.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../utils/stream/readable-stream-from-promise.js';
-import { isArray, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
+import { assertDefined, isArray, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
 import { buildUrl } from '../../utils/url-builder.js';
 import { HttpHeaders } from '../http-headers.js';
 import { HttpError, HttpErrorReason } from '../http.error.js';
@@ -28,20 +28,24 @@ let HttpClient = class HttpClient {
     adapter = inject(HttpClientAdapter);
     middleware = injectAll(HTTP_CLIENT_MIDDLEWARE, undefined, { optional: true });
     headers = new HttpHeaders();
-    internalMiddleware;
-    callHandler;
+    internalStartMiddleware;
+    internalEndMiddleware;
+    composedMiddleware;
     options = injectArgument(this, { optional: true }) ?? inject(HttpClientOptions, undefined, { optional: true }) ?? {};
     constructor() {
-        this.internalMiddleware = [
+        this.internalStartMiddleware = [
             getBuildRequestUrlMiddleware(this.options.baseUrl),
-            addRequestHeadersMiddleware,
             ...((this.options.enableErrorHandling ?? true) ? [errorMiddleware] : [])
         ];
-        this.updateHandlers();
+        this.internalEndMiddleware = [
+            getAddRequestHeadersMiddleware(this.headers),
+            getAdapterCallMiddleware(this.adapter)
+        ];
+        this.updateMiddleware();
     }
     addMiddleware(middleware) {
         this.middleware.push(middleware);
-        this.updateHandlers();
+        this.updateMiddleware();
     }
     setDefaultHeader(name, value) {
         this.headers.set(name, value);
@@ -174,17 +178,13 @@ let HttpClient = class HttpClient {
         return this.rawRequest(request);
     }
     async rawRequest(request) {
-        const preparedRequest = this.prepareRequest(request);
-        return this.callHandler(preparedRequest, request.context);
-    }
-    updateHandlers() {
-        this.callHandler = composeAsyncMiddleware([...this.middleware, ...this.internalMiddleware], async (request) => this.adapter.call(request), { allowMultipleNextCalls: true });
+        const context = { request };
+        await this.composedMiddleware(context);
+        assertDefined(context.response);
+        return context.response;
     }
-    prepareRequest(request) {
-        const clone = request.clone();
-        clone.headers = new HttpHeaders(this.headers);
-        clone.headers.setMany(request.headers);
-        return clone;
+    updateMiddleware() {
+        this.composedMiddleware = composeAsyncMiddleware([...this.internalStartMiddleware, ...this.middleware, ...this.internalEndMiddleware], { allowMultipleNextCalls: true });
     }
 };
 HttpClient = __decorate([
@@ -193,57 +193,62 @@ HttpClient = __decorate([
 ], HttpClient);
 export { HttpClient };
 function getBuildRequestUrlMiddleware(baseUrl) {
-    async function buildUrlParametersMiddleware(request, next) {
+    async function buildUrlParametersMiddleware({ request }, next) {
         if (!request.mapParameters) {
-            return next(request);
+            return next();
         }
-        const modifiedRequest = mapParameters(request, baseUrl);
-        return next(modifiedRequest);
+        mapParameters(request, baseUrl);
+        return next();
     }
     return buildUrlParametersMiddleware;
 }
-async function addRequestHeadersMiddleware(request, next) {
-    const clone = request.clone();
-    const { body, authorization } = clone;
-    if (isDefined(body) && isUndefined(clone.headers.contentType)) {
-        if (isDefined(body.json)) {
-            clone.headers.contentType = 'application/json';
-        }
-        else if (isDefined(body.text)) {
-            clone.headers.contentType = 'text/plain';
-        }
-        else if (isDefined(body.form)) {
-            clone.headers.contentType = 'application/x-www-form-urlencoded';
-        }
-        else if (isDefined(body.blob)) {
-            clone.headers.contentType = (body.blob.type.length > 0) ? body.blob.type : 'application/octet-stream';
+function getAddRequestHeadersMiddleware(defaultHeaders) {
+    async function addRequestHeadersMiddleware({ request }, next) {
+        await next();
+        const { body, authorization } = request;
+        for (const [key, value] of defaultHeaders) {
+            request.headers.setIfMissing(key, value);
         }
-        else if (isDefined(body.stream) || isDefined(body.buffer)) {
-            clone.headers.contentType = 'application/octet-stream';
-        }
-    }
-    if (isDefined(authorization) && isUndefined(clone.headers.authorization)) {
-        if (isDefined(authorization.basic)) {
-            const base64 = encodeBase64(encodeUtf8(`${authorization.basic.username}:${authorization.basic.password}`));
-            clone.headers.authorization = `Basic ${base64}`;
-        }
-        else if (isDefined(authorization.bearer)) {
-            clone.headers.authorization = `Bearer ${authorization.bearer}`;
+        if (isDefined(body) && isUndefined(request.headers.contentType)) {
+            if (isDefined(body.json)) {
+                request.headers.contentType = 'application/json';
+            }
+            else if (isDefined(body.text)) {
+                request.headers.contentType = 'text/plain';
+            }
+            else if (isDefined(body.form)) {
+                request.headers.contentType = 'application/x-www-form-urlencoded';
+            }
+            else if (isDefined(body.blob)) {
+                request.headers.contentType = (body.blob.type.length > 0) ? body.blob.type : 'application/octet-stream';
+            }
+            else if (isDefined(body.stream) || isDefined(body.buffer)) {
+                request.headers.contentType = 'application/octet-stream';
+            }
         }
-        else if (isDefined(authorization.token)) {
-            clone.headers.authorization = `Token ${authorization.token}`;
+        if (isDefined(authorization) && isUndefined(request.headers.authorization)) {
+            if (isDefined(authorization.basic)) {
+                const base64 = encodeBase64(encodeUtf8(`${authorization.basic.username}:${authorization.basic.password}`));
+                request.headers.authorization = `Basic ${base64}`;
+            }
+            else if (isDefined(authorization.bearer)) {
+                request.headers.authorization = `Bearer ${authorization.bearer}`;
+            }
+            else if (isDefined(authorization.token)) {
+                request.headers.authorization = `Token ${authorization.token}`;
+            }
         }
     }
-    return next(clone);
+    return addRequestHeadersMiddleware;
 }
-async function errorMiddleware(request, next) {
+async function errorMiddleware(context, next) {
     try {
-        const response = await next(request);
-        if (request.throwOnNon200 && ((response.statusCode < 200) || (response.statusCode >= 400))) {
-            const httpError = await HttpError.create(HttpErrorReason.StatusCode, request, response, `Status code ${response.statusCode}.`);
+        await next();
+        assertDefined(context.response);
+        if (context.request.throwOnNon200 && ((context.response.statusCode < 200) || (context.response.statusCode >= 400))) {
+            const httpError = await HttpError.create(HttpErrorReason.StatusCode, context.request, context.response, `Status code ${context.response.statusCode}.`);
             throw httpError;
         }
-        return response;
     }
     catch (error) {
         if (!(error instanceof HttpError) || (error.responseInstance?.headers.contentType?.includes('json') == false)) {
@@ -263,7 +268,6 @@ async function errorMiddleware(request, next) {
 }
 // eslint-disable-next-line max-statements, max-lines-per-function, complexity
 function mapParameters(request, baseUrl) {
-    const clone = request.clone();
     const isGetOrHead = (request.method == 'GET') || (request.method == 'HEAD');
     let url;
     const filteredParameterEntries = objectEntries(request.parameters ?? {}).filter(([_, value]) => isDefined(value));
@@ -278,7 +282,7 @@ function mapParameters(request, baseUrl) {
         parameterEntries = new Set(objectEntries(parametersRest));
     }
     if (request.mapParametersToBody && !isGetOrHead && isUndefined(request.body)) {
-        clone.body = { json: Object.fromEntries(parameterEntries) };
+        request.body = { json: Object.fromEntries(parameterEntries) };
         parameterEntries.clear();
     }
     if (request.mapParametersToQuery) {
@@ -306,6 +310,12 @@ function mapParameters(request, baseUrl) {
             }
         }
     }
-    clone.url = url.href;
-    return clone;
+    request.url = url.href;
+}
+function getAdapterCallMiddleware(adapter) {
+    async function adapterCallMiddleware(context, next) {
+        context.response = await adapter.call(context.request); // eslint-disable-line require-atomic-updates
+        return next();
+    }
+    return adapterCallMiddleware;
 }

package/http/client/middleware.d.ts

@@ -1,6 +1,10 @@
-import type { AsyncMiddleware, AsyncMiddlewareHandler, AsyncMiddlewareNext } from '../../utils/middleware.js';
+import type { AsyncMiddleware, AsyncMiddlewareNext, ComposedAsyncMiddleware } from '../../utils/middleware.js';
 import type { HttpClientRequest } from './http-client-request.js';
 import type { HttpClientResponse } from './http-client-response.js';
-export type HttpClientHandler = AsyncMiddlewareHandler<HttpClientRequest, HttpClientResponse>;
-export type HttpClientMiddleware = AsyncMiddleware<HttpClientRequest, HttpClientResponse>;
-export type HttpClientMiddlewareNext = AsyncMiddlewareNext<HttpClientRequest, HttpClientResponse>;
+export type HttpClientMiddlewareContext = {
+    request: HttpClientRequest;
+    response?: HttpClientResponse;
+};
+export type HttpClientMiddleware = AsyncMiddleware<HttpClientMiddlewareContext>;
+export type HttpClientMiddlewareNext = AsyncMiddlewareNext;
+export type ComposedHttpClientMiddleware = ComposedAsyncMiddleware<HttpClientMiddlewareContext>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.32",
+  "version": "0.90.33",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/utils/middleware.d.ts

@@ -1,13 +1,11 @@
-export type ComposedMiddleware<TIn, TOut, Context = unknown> = (value: TIn, context: Context) => TOut;
-export type MiddlewareHandler<TIn, TOut, Context = unknown> = (value: TIn, context: Context) => TOut;
-export type MiddlewareNext<TIn, TOut> = (value: TIn) => TOut;
-export type Middleware<TIn, TOut, Context = unknown> = (value: TIn, next: MiddlewareNext<TIn, TOut>, context: Context) => TOut | TOut;
-export type ComposedAsyncMiddleware<TIn, TOut, Context = unknown> = (value: TIn, context: Context) => Promise<TOut>;
-export type AsyncMiddlewareHandler<TIn, TOut, Context = unknown> = (value: TIn, context: Context) => TOut | Promise<TOut>;
-export type AsyncMiddlewareNext<TIn, TOut> = (value: TIn) => TOut | Promise<TOut>;
-export type AsyncMiddleware<TIn, TOut, Context = unknown> = (value: TIn, next: AsyncMiddlewareNext<TIn, TOut>, context: Context) => TOut | Promise<TOut>;
+export type ComposedMiddleware<Context = unknown> = (context: Context) => void;
+export type MiddlewareNext = () => void;
+export type Middleware<Context = unknown> = (context: Context, next: MiddlewareNext) => void;
+export type ComposedAsyncMiddleware<Context = unknown> = (context: Context) => Promise<void>;
+export type AsyncMiddlewareNext = () => void | Promise<void>;
+export type AsyncMiddleware<Context = unknown> = (context: Context, next: AsyncMiddlewareNext) => void | Promise<void>;
 export type MiddlewareOptions = {
     allowMultipleNextCalls?: boolean;
 };
-export declare function composeMiddleware<TIn, TOut, Context = unknown>(middlewares: Middleware<TIn, TOut, Context>[], handler: MiddlewareHandler<TIn, TOut, Context>, options?: MiddlewareOptions): ComposedMiddleware<TIn, TOut, Context>;
-export declare function composeAsyncMiddleware<TIn, TOut, Context>(middlewares: AsyncMiddleware<TIn, TOut, Context>[], handler: AsyncMiddlewareHandler<TIn, TOut, Context>, options?: MiddlewareOptions): ComposedAsyncMiddleware<TIn, TOut, Context>;
+export declare function composeMiddleware<Context = unknown>(middlewares: Middleware<Context>[], options?: MiddlewareOptions): ComposedMiddleware<Context>;
+export declare function composeAsyncMiddleware<Context>(middlewares: AsyncMiddleware<Context>[], options?: MiddlewareOptions): ComposedAsyncMiddleware<Context>;

package/utils/middleware.js

@@ -1,42 +1,42 @@
-export function composeMiddleware(middlewares, handler, options = {}) {
-    function composedMiddleware(value, context) {
+export function composeMiddleware(middlewares, options = {}) {
+    function composedMiddleware(context) {
         let currentIndex = -1;
-        function dispatch(index, dispatchedValue) {
+        function dispatch(index) {
             if (index == middlewares.length) {
-                return handler(dispatchedValue, context);
+                return;
             }
             const middleware = middlewares[index];
             currentIndex = index;
-            function next(nextValue) {
+            function next() {
                 if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
                     throw new Error('next() called multiple times');
                 }
-                return dispatch(index + 1, nextValue);
+                dispatch(index + 1);
             }
-            return middleware(dispatchedValue, next, context);
+            middleware(context, next);
         }
-        return dispatch(0, value);
+        dispatch(0);
     }
     return composedMiddleware;
 }
-export function composeAsyncMiddleware(middlewares, handler, options = {}) {
-    async function composedMiddleware(value, context) {
+export function composeAsyncMiddleware(middlewares, options = {}) {
+    async function composedMiddleware(context) {
         let currentIndex = -1;
-        async function dispatch(index, dispatchedValue) {
+        async function dispatch(index) {
             if (index == middlewares.length) {
-                return handler(dispatchedValue, context);
+                return;
             }
             const middleware = middlewares[index];
             currentIndex = index;
-            async function next(nextValue) {
+            async function next() {
                 if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
                     throw new Error('next() called multiple times');
                 }
-                return dispatch(index + 1, nextValue);
+                return dispatch(index + 1);
             }
-            return middleware(dispatchedValue, next, context);
+            return middleware(context, next); // eslint-disable-line consistent-return
         }
-        return dispatch(0, value);
+        return dispatch(0);
     }
     return composedMiddleware;
 }