@tstdl/base 0.85.14 → 0.86.0-beta2

package/api/server/gateway.js

@@ -1,230 +1,224 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var gateway_exports = {};
-__export(gateway_exports, {
-  ApiGateway: () => ApiGateway
-});
-module.exports = __toCommonJS(gateway_exports);
-var import_urlpattern_polyfill = require("urlpattern-polyfill");
-var import_container = require("../../container/index.js");
-var import_bad_request_error = require("../../error/bad-request.error.js");
-var import_not_found_error = require("../../error/not-found.error.js");
-var import_not_implemented_error = require("../../error/not-implemented.error.js");
-var import_server = require("../../http/server/index.js");
-var import_logger = require("../../logger/index.js");
-var import_schema = require("../../schema/index.js");
-var import_server_sent_events_source = require("../../sse/server-sent-events-source.js");
-var import_array = require("../../utils/array/array.js");
-var import_middleware = require("../../utils/middleware.js");
-var import_throw = require("../../utils/throw.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_units = require("../../utils/units.js");
-var import_types = require("../types.js");
-var import_utils = require("../utils.js");
-var import_api_controller = require("./api-controller.js");
-var import_api_request_token_provider = require("./api-request-token.provider.js");
-var import_error_handler = require("./error-handler.js");
-var import_middlewares = require("./middlewares/index.js");
-var import_tokens = require("./tokens.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
-const defaultMaxBytes = 10 * import_units.mebibyte;
-let ApiGateway = class ApiGateway2 {
-  requestTokenProvider;
-  logger;
-  prefix;
-  apis;
-  middlewares;
-  supressedErrors;
-  catchErrorMiddleware;
-  options;
-  handler;
-  constructor(requestTokenProvider, logger, options = {}) {
-    this.requestTokenProvider = requestTokenProvider;
-    this.logger = logger;
-    this.options = options;
-    this.prefix = (0, import_type_guards.isNull)(options.prefix) ? null : options.prefix ?? "api";
-    this.apis = /* @__PURE__ */ new Map();
-    this.middlewares = options.middlewares ?? [];
-    this.supressedErrors = new Set(options.supressedErrors);
-    this.catchErrorMiddleware = (0, import_middlewares.catchErrorMiddleware)(this.supressedErrors, logger);
-    this.updateMiddleware();
-  }
-  addMiddleware(middleware) {
-    this.middlewares.push(middleware);
-    this.updateMiddleware();
-  }
-  supressErrors(...errorTypes) {
-    for (const type of errorTypes) {
-      this.supressedErrors.add(type);
+import 'urlpattern-polyfill'; // eslint-disable-line import/no-unassigned-import
+import { container, injectArg, resolveArg, resolveArgumentType, singleton } from '../../container/index.js';
+import { BadRequestError } from '../../error/bad-request.error.js';
+import { NotFoundError } from '../../error/not-found.error.js';
+import { NotImplementedError } from '../../error/not-implemented.error.js';
+import { HttpServerResponse } from '../../http/server/index.js';
+import { Logger } from '../../logger/index.js';
+import { Schema } from '../../schema/index.js';
+import { ServerSentEventsSource } from '../../sse/server-sent-events-source.js';
+import { toArray } from '../../utils/array/array.js';
+import { composeAsyncMiddleware } from '../../utils/middleware.js';
+import { deferThrow } from '../../utils/throw.js';
+import { isArray, isBlob, isDefined, isNull, isNullOrUndefined, isObject, isReadableStream, isUint8Array, isUndefined } from '../../utils/type-guards.js';
+import { mebibyte } from '../../utils/units.js';
+import { normalizedApiDefinitionEndpointsEntries } from '../types.js';
+import { getFullApiEndpointResource } from '../utils.js';
+import { getApiControllerDefinition } from './api-controller.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 { API_MODULE_OPTIONS } from './tokens.js';
+const defaultMaxBytes = 10 * mebibyte;
+/**
+ * router for {@link ApiTransport} requests to {@link ApiImplementation}
+ * @todo error handling (standardized format, serialization etc.)
+ */
+export let ApiGateway = class ApiGateway {
+    requestTokenProvider;
+    logger;
+    prefix;
+    apis;
+    middlewares;
+    supressedErrors;
+    catchErrorMiddleware;
+    options;
+    handler;
+    constructor(requestTokenProvider, logger, options = {}) {
+        this.requestTokenProvider = requestTokenProvider;
+        this.logger = logger;
+        this.options = options;
+        this.prefix = isNull(options.prefix) ? null : (options.prefix ?? 'api');
+        this.apis = new Map();
+        this.middlewares = options.middlewares ?? [];
+        this.supressedErrors = new Set(options.supressedErrors);
+        this.catchErrorMiddleware = catchErrorMiddleware(this.supressedErrors, logger);
+        this.updateMiddleware();
     }
-  }
-  async registerApiController(controller) {
-    const definition = (0, import_api_controller.getApiControllerDefinition)(controller);
-    const instance = await import_container.container.resolveAsync(controller);
-    this.registerApi(definition, instance);
-  }
-  registerApi(definition, implementation) {
-    for (const [name, endpointDefinition] of (0, import_types.normalizedApiDefinitionEndpointsEntries)(definition.endpoints)) {
-      const versionArray = (0, import_type_guards.isUndefined)(endpointDefinition.version) ? [1] : (0, import_array.toArray)(endpointDefinition.version);
-      for (const version of versionArray) {
-        const resource = (0, import_utils.getFullApiEndpointResource)({ api: definition, endpoint: endpointDefinition, defaultPrefix: this.prefix, explicitVersion: version });
-        const methods = (0, import_type_guards.isArray)(endpointDefinition.method) ? endpointDefinition.method : [endpointDefinition.method ?? "GET"];
-        if (methods.length == 0) {
-          throw new Error(`No method provided for resource ${resource}.`);
-        }
-        let resourceApis = this.apis.get(resource);
-        if ((0, import_type_guards.isUndefined)(resourceApis)) {
-          resourceApis = {
-            resource,
-            pattern: new URLPattern({
-              pathname: resource,
-              baseURL: "http://localhost",
-              username: "*",
-              password: "*",
-              protocol: "*",
-              hostname: "*",
-              port: "*",
-              search: "*",
-              hash: "*"
-            }),
-            endpoints: /* @__PURE__ */ new Map()
-          };
-          this.apis.set(resource, resourceApis);
+    addMiddleware(middleware) {
+        this.middlewares.push(middleware);
+        this.updateMiddleware();
+    }
+    supressErrors(...errorTypes) {
+        for (const type of errorTypes) {
+            this.supressedErrors.add(type);
         }
-        const endpointImplementation = implementation[name]?.bind(implementation) ?? (0, import_throw.deferThrow)(new import_not_implemented_error.NotImplementedError(`Endpoint ${name} for resource ${resource} not implemented.`));
-        for (const method of methods) {
-          resourceApis.endpoints.set(method, { definition: endpointDefinition, implementation: endpointImplementation });
+    }
+    async registerApiController(controller) {
+        const definition = getApiControllerDefinition(controller);
+        const instance = await container.resolveAsync(controller);
+        this.registerApi(definition, instance);
+    }
+    registerApi(definition, implementation) {
+        for (const [name, endpointDefinition] of normalizedApiDefinitionEndpointsEntries(definition.endpoints)) {
+            const versionArray = isUndefined(endpointDefinition.version) ? [1] : toArray(endpointDefinition.version);
+            for (const version of versionArray) {
+                const resource = getFullApiEndpointResource({ api: definition, endpoint: endpointDefinition, defaultPrefix: this.prefix, explicitVersion: version });
+                const methods = isArray(endpointDefinition.method) ? endpointDefinition.method : [endpointDefinition.method ?? 'GET'];
+                if (methods.length == 0) {
+                    throw new Error(`No method provided for resource ${resource}.`);
+                }
+                let resourceApis = this.apis.get(resource);
+                if (isUndefined(resourceApis)) {
+                    resourceApis = {
+                        resource,
+                        pattern: new URLPattern({
+                            pathname: resource,
+                            baseURL: 'http://localhost',
+                            username: '*',
+                            password: '*',
+                            protocol: '*',
+                            hostname: '*',
+                            port: '*',
+                            search: '*',
+                            hash: '*'
+                        }),
+                        endpoints: new Map()
+                    };
+                    this.apis.set(resource, resourceApis);
+                }
+                const endpointImplementation = implementation[name]?.bind(implementation) ?? deferThrow(new NotImplementedError(`Endpoint ${name} for resource ${resource} not implemented.`));
+                for (const method of methods) {
+                    resourceApis.endpoints.set(method, { definition: endpointDefinition, implementation: endpointImplementation });
+                }
+            }
         }
-      }
     }
-  }
-  async handleHttpServerRequestContext({ request, respond, close }) {
-    let responded = false;
-    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 });
-      responded = true;
-      await respond(response);
-    } catch (error) {
-      try {
-        const response = (0, import_error_handler.handleApiError)(error, this.supressedErrors, this.logger);
-        if (responded) {
-          await close();
-        } else {
-          try {
+    async handleHttpServerRequestContext({ request, respond, close }) {
+        let responded = false;
+        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 });
+            responded = true;
             await respond(response);
-          } catch (errorRespondError) {
-            this.logger.error(errorRespondError);
-            await close();
-          }
         }
-      } catch {
-      }
+        catch (error) {
+            try {
+                const response = handleApiError(error, this.supressedErrors, this.logger);
+                if (responded) {
+                    await close();
+                }
+                else {
+                    try {
+                        await respond(response);
+                    }
+                    catch (errorRespondError) {
+                        this.logger.error(errorRespondError);
+                        await close();
+                    }
+                }
+            }
+            catch { /* ignore */ }
+        }
     }
-  }
-  getApiMetadata(resource) {
-    const urlWithoutPort = new URL(resource);
-    urlWithoutPort.port = "";
-    for (const api of this.apis.values()) {
-      const result = api.pattern.exec(urlWithoutPort);
-      if ((0, import_type_guards.isNullOrUndefined)(result)) {
-        continue;
-      }
-      return { api, patternResult: result };
+    getApiMetadata(resource) {
+        const urlWithoutPort = new URL(resource);
+        urlWithoutPort.port = '';
+        for (const api of this.apis.values()) {
+            const result = api.pattern.exec(urlWithoutPort);
+            if (isNullOrUndefined(result)) {
+                continue;
+            }
+            return { api, patternResult: result };
+        }
+        throw new NotFoundError(`Resource ${resource.pathname} not available.`);
     }
-    throw new import_not_found_error.NotFoundError(`Resource ${resource.pathname} not available.`);
-  }
-  updateMiddleware() {
-    const middlewares = [import_middlewares.responseTimeMiddleware, (0, import_middlewares.corsMiddleware)(this.options.cors), import_middlewares.allowedMethodsMiddleware, this.catchErrorMiddleware, ...this.middlewares];
-    this.handler = (0, import_middleware.composeAsyncMiddleware)(middlewares, async (request, context) => this.middlewareHandler(request, context));
-  }
-  async middlewareHandler(request, context) {
-    const readBodyOptions = { maxBytes: context.endpoint.definition.maxBytes ?? this.options.defaultMaxBytes ?? defaultMaxBytes };
-    const body = (0, import_type_guards.isDefined)(context.endpoint.definition.body) ? await this.getBody(request, readBodyOptions, context.endpoint.definition.body) : void 0;
-    const bodyAsParameters = (0, import_type_guards.isUndefined)(context.endpoint.definition.body) && request.headers.contentType?.includes("json") == true ? await request.body.readAsJson(readBodyOptions) : void 0;
-    if ((0, import_type_guards.isDefined)(bodyAsParameters) && !(0, import_type_guards.isObject)(bodyAsParameters)) {
-      throw new import_bad_request_error.BadRequestError("Expected json object as body.");
+    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 parameters = { ...request.query.asObject(), ...bodyAsParameters, ...context.resourcePatternResult.pathname.groups };
-    const validatedParameters = (0, import_type_guards.isDefined)(context.endpoint.definition.parameters) ? import_schema.Schema.parse(context.endpoint.definition.parameters, parameters) : parameters;
-    const requestContext = {
-      parameters: validatedParameters,
-      body,
-      request,
-      getToken: async () => this.requestTokenProvider.getToken(requestContext)
-    };
-    const result = await context.endpoint.implementation(requestContext);
-    if (result instanceof import_server.HttpServerResponse) {
-      return result;
+    async middlewareHandler(request, context) {
+        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)
+            : undefined;
+        const bodyAsParameters = (isUndefined(context.endpoint.definition.body) && (request.headers.contentType?.includes('json') == true))
+            ? await request.body.readAsJson(readBodyOptions)
+            : undefined;
+        if (isDefined(bodyAsParameters) && !isObject(bodyAsParameters)) {
+            throw new BadRequestError('Expected json object as body.');
+        }
+        const parameters = { ...request.query.asObject(), ...bodyAsParameters, ...context.resourcePatternResult.pathname.groups };
+        const validatedParameters = isDefined(context.endpoint.definition.parameters)
+            ? Schema.parse(context.endpoint.definition.parameters, parameters)
+            : parameters;
+        const requestContext = {
+            parameters: validatedParameters,
+            body,
+            request,
+            getToken: async () => this.requestTokenProvider.getToken(requestContext)
+        };
+        const result = await context.endpoint.implementation(requestContext);
+        if (result instanceof HttpServerResponse) {
+            return result;
+        }
+        const response = 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 }
+        });
+        return response;
     }
-    const response = new import_server.HttpServerResponse({
-      body: (0, import_type_guards.isUint8Array)(result) ? { buffer: result } : (0, import_type_guards.isBlob)(result) ? { stream: result.stream() } : (0, import_type_guards.isReadableStream)(result) ? { stream: result } : result instanceof import_server_sent_events_source.ServerSentEventsSource ? { events: result } : context.endpoint.definition.result == String ? { text: result } : { json: result }
-    });
-    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);
-      }
+    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);
+            }
+        }
+        return Schema.parse(schema, body);
     }
-    return import_schema.Schema.parse(schema, body);
-  }
 };
 ApiGateway = __decorate([
-  (0, import_container.singleton)({
-    defaultArgumentProvider: (context) => context.resolve(import_tokens.API_MODULE_OPTIONS).gatewayOptions
-  }),
-  __param(1, (0, import_container.resolveArg)("ApiGateway")),
-  __param(2, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [import_api_request_token_provider.ApiRequestTokenProvider, import_logger.Logger, Object])
+    singleton({
+        defaultArgumentProvider: (context) => context.resolve(API_MODULE_OPTIONS).gatewayOptions
+    }),
+    __param(1, resolveArg('ApiGateway')),
+    __param(2, injectArg()),
+    __metadata("design:paramtypes", [ApiRequestTokenProvider, Logger, Object])
 ], ApiGateway);

package/api/server/index.js

@@ -1,22 +1,5 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var server_exports = {};
-module.exports = __toCommonJS(server_exports);
-__reExport(server_exports, require("./api-controller.js"), module.exports);
-__reExport(server_exports, require("./api-request-token.provider.js"), module.exports);
-__reExport(server_exports, require("./gateway.js"), module.exports);
-__reExport(server_exports, require("./module.js"), module.exports);
-__reExport(server_exports, require("./tokens.js"), module.exports);
+export * from './api-controller.js';
+export * from './api-request-token.provider.js';
+export * from './gateway.js';
+export * from './module.js';
+export * from './tokens.js';

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

@@ -1,42 +1,19 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var allowed_methods_middleware_exports = {};
-__export(allowed_methods_middleware_exports, {
-  allowedMethodsMiddleware: () => allowedMethodsMiddleware
-});
-module.exports = __toCommonJS(allowed_methods_middleware_exports);
-var import_method_not_allowed_error = require("../../../error/method-not-allowed.error.js");
-var import_server = require("../../../http/server/index.js");
-var import_type_guards = require("../../../utils/type-guards.js");
-async function allowedMethodsMiddleware(request, next, context) {
-  if (request.method != "OPTIONS") {
-    if ((0, import_type_guards.isUndefined)(context.endpoint)) {
-      throw new import_method_not_allowed_error.MethodNotAllowedError(`Method ${request.method} for resource ${context.api.resource} not available.`);
+import { MethodNotAllowedError } from '../../../error/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) {
+    if (request.method != 'OPTIONS') {
+        if (isUndefined(context.endpoint)) {
+            throw new MethodNotAllowedError(`Method ${request.method} for resource ${context.api.resource} not available.`);
+        }
+        return next(request);
     }
-    return next(request);
-  }
-  const allowMethods = [...context.api.endpoints.keys()].join(", ");
-  return import_server.HttpServerResponse.fromObject({
-    statusCode: 204,
-    statusMessage: "No Content",
-    headers: {
-      Allow: allowMethods
-    }
-  });
+    const allowMethods = [...context.api.endpoints.keys()].join(', ');
+    return HttpServerResponse.fromObject({
+        statusCode: 204,
+        statusMessage: 'No Content',
+        headers: {
+            Allow: allowMethods
+        }
+    });
 }

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

@@ -1,35 +1,14 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var catch_error_middleware_exports = {};
-__export(catch_error_middleware_exports, {
-  catchErrorMiddleware: () => catchErrorMiddleware
-});
-module.exports = __toCommonJS(catch_error_middleware_exports);
-var import_error_handler = require("../error-handler.js");
-function catchErrorMiddleware(supressedErrors, logger) {
-  async function catchErrorMiddleware2(request, next) {
-    try {
-      const response = await next(request);
-      return response;
-    } catch (error) {
-      return (0, import_error_handler.handleApiError)(error, supressedErrors, logger);
+import { handleApiError } from '../error-handler.js';
+export function catchErrorMiddleware(supressedErrors, logger) {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    async function catchErrorMiddleware(request, next) {
+        try {
+            const response = await next(request);
+            return response;
+        }
+        catch (error) {
+            return handleApiError(error, supressedErrors, logger);
+        }
     }
-  }
-  return catchErrorMiddleware2;
+    return catchErrorMiddleware;
 }