transit-kit 0.7.0 → 0.8.0

package/dist/generator/generateOpenApi.d.ts

@@ -1,13 +1,17 @@
-import { HttpMethod } from "../server/constants/HttpMethods";
-import { ApiEndpointDefinition } from "../server/handlers/api/EndpointDefinition";
-import { GenericResponseSchemaMap } from "../server/handlers/api/responses";
+import { HttpMethod } from "../server/constants/HttpMethods.js";
+import { ApiEndpointDefinition } from "../server/handlers/api/EndpointDefinition.js";
+import { GenericResponseSchemaMap } from "../server/handlers/api/responses/index.js";
 import { ZodType } from "zod";
 import { OpenAPIV3 } from "openapi-types";
-import { Server } from "../server";
+import { Server } from "../server/server.js";
 declare function translateToOpenAPIPathItem(definition: ApiEndpointDefinition<string, HttpMethod, ZodType | undefined, ZodType | undefined, GenericResponseSchemaMap>): [string, OpenAPIV3.PathItemObject];
 interface GeneratorOptions {
     title: string;
     version: string;
+    description?: string;
+    servers?: OpenAPIV3.ServerObject[];
+    contact?: OpenAPIV3.ContactObject;
+    license?: OpenAPIV3.LicenseObject;
 }
 export declare function generateOpenApiDoc(server: Server, options: GeneratorOptions): Promise<OpenAPIV3.Document>;
 export declare const __TEST_EXPORTS: {

package/dist/generator/generateOpenApi.js

@@ -1,6 +1,6 @@
 import z from "zod";
-import { hasValue } from "../server/utils/typeGuards";
-import { isJsonResponseSchema } from "../server/handlers/api/responses/jsonResponse";
+import { hasValue } from "../server/utils/typeGuards.js";
+import { isJsonResponseSchema } from "../server/handlers/api/responses/jsonResponse.js";
 function extractPathAndParameters(path) {
     const parameters = path.match(/:([a-zA-Z0-9_]+)/g)?.map((param) => {
         return {
@@ -155,7 +155,11 @@ export async function generateOpenApiDoc(server, options) {
         info: {
             title: options.title,
             version: options.version,
+            description: options.description,
+            license: options.license,
+            contact: options.contact,
         },
+        servers: options.servers ?? [],
         paths: paths,
         components: {
             securitySchemes,

package/dist/generator/index.d.ts

@@ -1 +1 @@
-export { generateOpenApiDoc } from "./generateOpenApi";
+export { generateOpenApiDoc } from "./generateOpenApi.js";

package/dist/generator/index.js

@@ -1 +1 @@
-export { generateOpenApiDoc } from "./generateOpenApi";
+export { generateOpenApiDoc } from "./generateOpenApi.js";

package/dist/server/handlers/api/ApiEndpoint.d.ts

@@ -1,8 +1,8 @@
 import z from "zod";
-import { HttpMethod } from "../../constants/HttpMethods";
-import { ApiEndpointDefinition } from "./EndpointDefinition";
-import { HandlerForDefinition } from "./HandlerFromDefinition";
-import { GenericResponseSchemaMap } from "./responses";
+import { HttpMethod } from "../../constants/HttpMethods.js";
+import { ApiEndpointDefinition } from "./EndpointDefinition.js";
+import { HandlerForDefinition } from "./HandlerFromDefinition.js";
+import { GenericResponseSchemaMap } from "./responses/index.js";
 export interface ApiEndpoint<Path extends string = string, Method extends HttpMethod = HttpMethod, RequestBody extends z.ZodType | undefined = undefined | z.ZodType, Query extends z.ZodType | undefined = undefined | z.ZodType, ResponseMap extends GenericResponseSchemaMap = GenericResponseSchemaMap, Handler extends HandlerForDefinition<Path, RequestBody, Query, ResponseMap> = HandlerForDefinition<Path, RequestBody, Query, ResponseMap>> {
     definition: ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponseMap>;
     handler: Handler;

package/dist/server/handlers/api/EndpointDefinition.d.ts

@@ -1,7 +1,7 @@
 import z from "zod";
-import { HttpMethod } from "../../constants/HttpMethods";
-import { SecurityScheme } from "../../security/SecuritySchema";
-import { GenericResponseSchemaMap } from "./responses/index";
+import { HttpMethod } from "../../constants/HttpMethods.js";
+import { SecurityScheme } from "../../security/SecuritySchema.js";
+import { GenericResponseSchemaMap } from "./responses/index.js";
 export interface ApiEndpointMeta {
     name: string;
     group: string;

package/dist/server/handlers/api/EndpointHandler.d.ts

@@ -1,6 +1,6 @@
 import { Request, Response } from "express";
-import { HttpStatusCode } from "../../constants/HttpStatusCodes";
-import { HandlerResponse } from "./responses";
+import { HttpStatusCode } from "../../constants/HttpStatusCodes.js";
+import { HandlerResponse } from "./responses/index.js";
 export type ApiEndpointHandler<Responses extends HandlerResponse<HttpStatusCode, unknown>, PathParams extends Record<string, string> = {}, RequestBody = unknown, Query = unknown, Caller = unknown> = (typedRequestData: {
     request: Request<PathParams, unknown, RequestBody, Query, Record<string, unknown>>;
     response: Response<unknown>;

package/dist/server/handlers/api/HandlerFromDefinition.d.ts

@@ -1,10 +1,10 @@
 import z from "zod";
-import { HttpStatusCode } from "../../constants/HttpStatusCodes";
-import { SecurityScheme } from "../../security/SecuritySchema";
-import { Prettify } from "../../utils/types";
-import { ApiEndpointHandler } from "./EndpointHandler";
-import { ExtractPathParams } from "./PathParameters";
-import { GenericResponseSchema, GenericResponseSchemaMap, InferResponseFromSchema } from "./responses/index";
+import { HttpStatusCode } from "../../constants/HttpStatusCodes.js";
+import { SecurityScheme } from "../../security/SecuritySchema.js";
+import { Prettify } from "../../utils/types.js";
+import { ApiEndpointHandler } from "./EndpointHandler.js";
+import { ExtractPathParams } from "./PathParameters.js";
+import { GenericResponseSchema, GenericResponseSchemaMap, InferResponseFromSchema } from "./responses/index.js";
 export type HandlerForDefinition<Path extends string, RequestBody extends z.ZodType | undefined, Query extends z.ZodType | undefined, ResponsesMap extends GenericResponseSchemaMap, SecuritySchemas extends SecurityScheme<unknown>[] = []> = ApiEndpointHandler<Exclude<Prettify<{
     [K in keyof ResponsesMap]: K extends HttpStatusCode ? InferResponseFromSchema<K, ResponsesMap[K] extends GenericResponseSchema ? ResponsesMap[K] : never> : never;
 }[keyof ResponsesMap]>, undefined>, ExtractPathParams<Path>, RequestBody extends undefined ? undefined : z.infer<RequestBody>, Query extends undefined ? undefined : z.infer<Query>, SecuritySchemas extends SecurityScheme<infer Caller>[] ? Caller : unknown>;

package/dist/server/handlers/api/createApiHandler.d.ts

@@ -1,15 +1,15 @@
 import z from "zod";
-import { HttpMethod } from "../../constants/HttpMethods";
-import { HttpStatusCode } from "../../constants/HttpStatusCodes";
-import { SecurityScheme } from "../../security/SecuritySchema";
-import { Prettify } from "../../utils/types";
-import { ApiEndpointDefinition } from "./EndpointDefinition";
-import { ApiEndpointHandler } from "./EndpointHandler";
-import { HandlerForDefinition } from "./HandlerFromDefinition";
-import { GenericResponseSchemaMap, HandlerResponse } from "./responses";
+import { HttpMethod } from "../../constants/HttpMethods.js";
+import { HttpStatusCode } from "../../constants/HttpStatusCodes.js";
+import { SecurityScheme } from "../../security/SecuritySchema.js";
+import { Prettify } from "../../utils/types.js";
+import { ApiEndpointDefinition } from "./EndpointDefinition.js";
+import { ApiEndpointHandler } from "./EndpointHandler.js";
+import { HandlerForDefinition } from "./HandlerFromDefinition.js";
+import { GenericResponseSchemaMap, HandlerResponse } from "./responses/index.js";
 export declare function createApiEndpointHandler<const ResponsesMap extends GenericResponseSchemaMap, const Path extends string, const Method extends HttpMethod, const RequestBody extends z.ZodType | undefined = undefined, const Query extends z.ZodType | undefined = undefined, const SecuritySchemas extends SecurityScheme<unknown>[] = []>(definition: Prettify<ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponsesMap, SecuritySchemas>>, handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap, SecuritySchemas>): {
     definition: {
-        meta: import("./EndpointDefinition").ApiEndpointMeta;
+        meta: import("./EndpointDefinition.js").ApiEndpointMeta;
         path: Path;
         method: Method;
         requestBodySchema?: RequestBody | undefined;

package/dist/server/handlers/api/responses/index.d.ts

@@ -1,6 +1,6 @@
 import z from "zod";
-import { HttpStatusCode } from "../../../constants/HttpStatusCodes";
-import { JsonResponseSchema } from "./jsonResponse";
+import { HttpStatusCode } from "../../../constants/HttpStatusCodes.js";
+import { JsonResponseSchema } from "./jsonResponse.js";
 export type AbstractResponseSchema<Headers extends string[] | undefined = string[] | undefined> = {
     type: string;
     headers?: Headers;

package/dist/server/handlers/api/responses/jsonResponse.d.ts

@@ -1,5 +1,5 @@
 import z from "zod";
-import { AbstractResponseSchema } from ".";
+import { AbstractResponseSchema } from "./index.js";
 export interface JsonResponseSchema<DataSchema extends z.ZodType = z.ZodType, Headers extends string[] | undefined = string[] | undefined> extends AbstractResponseSchema<Headers> {
     type: "json";
     schema: DataSchema;

package/dist/server/index.d.ts

@@ -1,6 +1,8 @@
-export { createApiEndpointHandler } from "./handlers/api/createApiHandler";
-export { createBasicAuthSchema } from "./security/basicAuth";
-export { createBearerAuthSchema } from "./security/bearerAuth";
-export { createServer, type Server, type ServerConfig } from "./server";
+export { HttpStatusCodes, type HttpStatusCode, } from "./constants/HttpStatusCodes.js";
+export { HttpMethods, type HttpMethod } from "./constants/HttpMethods.js";
+export { createApiEndpointHandler } from "./handlers/api/createApiHandler.js";
+export { createBasicAuthSchema } from "./security/basicAuth.js";
+export { createBearerAuthSchema } from "./security/bearerAuth.js";
+export { createServer, type Server, type ServerConfig } from "./server.js";
 declare const _default: {};
 export default _default;

package/dist/server/index.js

@@ -1,5 +1,7 @@
-export { createApiEndpointHandler } from "./handlers/api/createApiHandler";
-export { createBasicAuthSchema } from "./security/basicAuth";
-export { createBearerAuthSchema } from "./security/bearerAuth";
-export { createServer } from "./server";
+export { HttpStatusCodes, } from "./constants/HttpStatusCodes.js";
+export { HttpMethods } from "./constants/HttpMethods.js";
+export { createApiEndpointHandler } from "./handlers/api/createApiHandler.js";
+export { createBasicAuthSchema } from "./security/basicAuth.js";
+export { createBearerAuthSchema } from "./security/bearerAuth.js";
+export { createServer } from "./server.js";
 export default {};

package/dist/server/middleware/auth.d.ts

@@ -1,2 +1,2 @@
-import { SecurityScheme } from "../security/SecuritySchema";
+import { SecurityScheme } from "../security/SecuritySchema.js";
 export declare function buildAuthenticationMiddleware<Caller>(schemes: SecurityScheme<Caller>[]): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;

package/dist/server/middleware/auth.js

@@ -1,6 +1,6 @@
 import expressAsyncHandler from "express-async-handler";
-import { HttpStatusCodes } from "../constants/HttpStatusCodes";
-import { authenticate } from "../security/SecuritySchema";
+import { HttpStatusCodes } from "../constants/HttpStatusCodes.js";
+import { authenticate } from "../security/SecuritySchema.js";
 export function buildAuthenticationMiddleware(schemes) {
     return expressAsyncHandler(async (request, response, next) => {
         const caller = await authenticate(schemes, request);

package/dist/server/middleware/logging.d.ts

@@ -1,4 +1,4 @@
 import { NextFunction, Request, Response } from "express";
-import { Logger } from "../utils/logging";
+import { Logger } from "../utils/logging.js";
 export declare function buildRequestLogger(logger: Logger, isInDevMode: boolean): (req: Request, res: Response, next: NextFunction) => void;
 export declare function buildResponseLogger(logger: Logger, isInDevMode: boolean): (req: Request, res: Response, next: NextFunction) => void;

package/dist/server/middleware/logging.js

@@ -1,4 +1,4 @@
-import colors from "colors/safe";
+import colors from "colors/safe.js";
 export function buildRequestLogger(logger, isInDevMode) {
     return (req, res, next) => {
         logger.info(`[Request] ${colors.cyan(req.method)} - ${colors.cyan(req.path)}`);

package/dist/server/middleware/validation.js

@@ -1,4 +1,4 @@
-import { HttpStatusCodes } from "../constants/HttpStatusCodes";
+import { HttpStatusCodes } from "../constants/HttpStatusCodes.js";
 export function buildBodyValidatorMiddleware(schema) {
     return (request, response, next) => {
         const validationResult = schema.safeParse(request.body);

package/dist/server/security/SecuritySchema.d.ts

@@ -1,5 +1,5 @@
 import { Request } from "express";
-import { BasicAuthScheme } from "./basicAuth";
-import { BearerAuthScheme } from "./bearerAuth";
+import { BasicAuthScheme } from "./basicAuth.js";
+import { BearerAuthScheme } from "./bearerAuth.js";
 export type SecurityScheme<Caller> = BasicAuthScheme<Caller> | BearerAuthScheme<Caller>;
 export declare function authenticate<Caller>(schemes: SecurityScheme<Caller>[], request: Request): Promise<Caller | null>;

package/dist/server/security/SecuritySchema.js

@@ -1,5 +1,5 @@
-import { buildBasicAuthenticator } from "./basicAuth";
-import { buildBearerAuthenticator } from "./bearerAuth";
+import { buildBasicAuthenticator } from "./basicAuth.js";
+import { buildBearerAuthenticator } from "./bearerAuth.js";
 export async function authenticate(schemes, request) {
     const authenticationResults = await Promise.all(schemes.map((scheme) => {
         switch (scheme.scheme) {

package/dist/server/security/basicAuth.js

@@ -1,4 +1,4 @@
-import { hasNoValue } from "../utils/typeGuards";
+import { hasNoValue } from "../utils/typeGuards.js";
 export function createBasicAuthSchema(name, validateCaller) {
     return {
         name,

package/dist/server/server.d.ts

@@ -1,7 +1,7 @@
 import { Application } from "express";
-import { ApiEndpointDefinition } from "./handlers/api/EndpointDefinition";
-import { HandlerForDefinition } from "./handlers/api/HandlerFromDefinition";
-import { Logger } from "./utils/logging";
+import { ApiEndpointDefinition } from "./handlers/api/EndpointDefinition.js";
+import { HandlerForDefinition } from "./handlers/api/HandlerFromDefinition.js";
+import { Logger } from "./utils/logging.js";
 export interface ServerConfig {
     inDevMode: boolean;
     port: number;

package/dist/server/server.js

@@ -1,12 +1,12 @@
 import cookieParser from "cookie-parser";
 import express from "express";
-import { buildApiEndpointHandler } from "./handlers/api/createApiHandler";
-import { buildAuthenticationMiddleware } from "./middleware/auth";
-import { buildRequestLogger, buildResponseLogger } from "./middleware/logging";
-import { buildBodyValidatorMiddleware, buildQueryValidatorMiddleware, } from "./middleware/validation";
-import { isEmpty } from "./utils/funcs";
-import { NoOpLogger } from "./utils/logging";
-import { hasNoValue, hasValue } from "./utils/typeGuards";
+import { buildApiEndpointHandler } from "./handlers/api/createApiHandler.js";
+import { buildAuthenticationMiddleware } from "./middleware/auth.js";
+import { buildRequestLogger, buildResponseLogger, } from "./middleware/logging.js";
+import { buildBodyValidatorMiddleware, buildQueryValidatorMiddleware, } from "./middleware/validation.js";
+import { isEmpty } from "./utils/funcs.js";
+import { NoOpLogger } from "./utils/logging.js";
+import { hasNoValue, hasValue } from "./utils/typeGuards.js";
 function registerApiEndpoint(expressApp, endpoint) {
     const { definition, handler } = endpoint;
     const handlerStack = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transit-kit",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "A declarative TypeScript framework for building type-safe Express.js APIs with automatic OpenAPI generation",
   "keywords": [
     "express",
@@ -41,7 +41,7 @@
   "scripts": {
     "lint": "eslint",
     "test": "vitest",
-    "build": "rm -rf ./dist && tsc"
+    "build": "rm -rf ./dist && tsc -p ./tsconfig.build.json"
   },
   "devDependencies": {
     "@types/cookie-parser": "^1.4.9",

package/dist/generator/generateOpenApi.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/generator/generateOpenApi.spec.js

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import z from "zod";
-import { createApiEndpointHandler } from "../server";
-import { __TEST_EXPORTS } from "./generateOpenApi";
-const { translateToOpenAPIPathItem } = __TEST_EXPORTS;
-describe("translateToOpenAPIPathItem", () => {
-    it("should translate endpoint definitions to OpenAPI path items", () => {
-        const { definition } = createApiEndpointHandler({
-            method: "get",
-            path: "/users/:id",
-            meta: {
-                name: "getUser",
-                description: "Retrieve a user by ID",
-                group: "User",
-            },
-            securitySchemes: [],
-            responseSchemas: {
-                200: {
-                    type: "json",
-                    schema: z.string(),
-                },
-            },
-        }, async ({ request }) => {
-            return {
-                code: 200,
-                data: request.params.id,
-            };
-        });
-        const [path, pathItem] = translateToOpenAPIPathItem(definition);
-        const expectedPath = "/users/{id}";
-        const expectedSchema = {
-            $schema: "https://json-schema.org/draft/2020-12/schema",
-            type: "string",
-        };
-        const expectedPathItem = {
-            get: {
-                operationId: "getUser",
-                summary: "Retrieve a user by ID",
-                tags: ["User"],
-                description: "Retrieve a user by ID",
-                parameters: [
-                    {
-                        description: "Path parameter :id",
-                        name: "id",
-                        in: "path",
-                        required: true,
-                        schema: { type: "string" },
-                    },
-                ],
-                security: [],
-                responses: {
-                    "200": {
-                        description: "Response for status code 200",
-                        content: {
-                            "application/json": {
-                                schema: expectedSchema,
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        expect(path).toBe(expectedPath);
-        expect(pathItem).toEqual(expectedPathItem);
-    });
-});

package/dist/server/handlers/api/HandlerFromDefinition.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/server/handlers/api/HandlerFromDefinition.spec.js

@@ -1,15 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-describe("HandlerFromDefinition", () => {
-    it("can infer handler responses correctly (Json)", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
-    it("can infer handler responses correctly (headers)", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
-    it("can infer caller from auth schema (Basic)", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
-    it("can infer caller from auth schema (Bearer)", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
-});

package/dist/server/handlers/api/PathParameters.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/server/handlers/api/PathParameters.spec.js

@@ -1,12 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-describe("ExtractPathParameters", () => {
-    it("can infer the parameter types of a path", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
-    it("can infer multiple params", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
-    it("can infer correctly if no param is present", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
-});

package/dist/server/handlers/api/createApiHandler.spec.d.ts

@@ -1,17 +0,0 @@
-import z from "zod";
-export declare const testEndpointBase: {
-    meta: {
-        name: string;
-        description: string;
-        group: string;
-    };
-    method: "get";
-    path: string;
-    securitySchemes: never[];
-    responseSchemas: {
-        200: {
-            type: "json";
-            schema: z.ZodString;
-        };
-    };
-};

package/dist/server/handlers/api/createApiHandler.spec.js

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createServer } from "../../server";
-import { createApiEndpointHandler } from "./createApiHandler";
-import testRequest from "supertest";
-import z from "zod";
-import { HttpMethods } from "../../constants/HttpMethods";
-export const testEndpointBase = {
-    meta: {
-        name: "getTest",
-        description: "Gets test element",
-        group: "test",
-    },
-    method: HttpMethods.get,
-    path: "/test",
-    securitySchemes: [],
-    responseSchemas: {
-        200: {
-            type: "json",
-            schema: z.string(),
-        },
-    },
-};
-describe("createApiHandler", () => {
-    it("can create an API handler that responds correctly (json)", async () => {
-        const endpoint = createApiEndpointHandler({
-            ...testEndpointBase,
-        }, async () => {
-            return {
-                code: 200,
-                data: "test",
-            };
-        });
-        const server = createServer({
-            inDevMode: true,
-            port: 3000,
-            logger: false,
-        });
-        server.registerApiEndpoint(endpoint);
-        const response = await testRequest(server.expressApp).get("/test");
-        expect(response.status).toBe(200);
-        expect(response.text).toBe("test");
-    });
-    it("can create an API handler that responds with custom headers", async () => {
-        const endpoint = createApiEndpointHandler({
-            ...testEndpointBase,
-            responseSchemas: {
-                200: {
-                    type: "json",
-                    schema: z.string(),
-                    headers: ["X-Custom-Header"],
-                },
-            },
-        }, async () => {
-            return {
-                code: 200,
-                data: "test",
-                headers: {
-                    "X-Custom-Header": "CustomValue",
-                },
-            };
-        });
-        const server = createServer({
-            inDevMode: true,
-            port: 3000,
-            logger: false,
-        });
-        server.registerApiEndpoint(endpoint);
-        const response = await testRequest(server.expressApp).get("/test");
-        expect(response.status).toBe(200);
-        expect(response.text).toBe("test");
-        expect(response.headers["x-custom-header"]).toBe("CustomValue");
-    });
-});

package/dist/server/security/basicAuth.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/server/security/basicAuth.spec.js

@@ -1,46 +0,0 @@
-import testRequest from "supertest";
-import { describe, expect, it } from "vitest";
-import { HttpStatusCodes } from "../constants/HttpStatusCodes";
-import { createApiEndpointHandler } from "../handlers/api/createApiHandler";
-import { testEndpointBase } from "../handlers/api/createApiHandler.spec";
-import { createServer } from "../server";
-import { createBasicAuthSchema } from "./basicAuth";
-describe("basic auth schema", () => {
-    const testUsername = "Test";
-    const testPassword = "TestPW";
-    const encodedCredentials = Buffer.from(`${testUsername}:${testPassword}`).toString("base64");
-    const authScheme = createBasicAuthSchema("TestAuth", async (name, password) => {
-        if (name === testUsername && password === testPassword) {
-            return {
-                username: name,
-            };
-        }
-        else {
-            return null;
-        }
-    });
-    const endpoint = createApiEndpointHandler({
-        ...testEndpointBase,
-        securitySchemes: [authScheme],
-    }, async () => {
-        return { code: HttpStatusCodes.Ok_200, data: "test" };
-    });
-    const server = createServer({
-        port: 3000,
-        inDevMode: false,
-        logger: false,
-    });
-    server.registerApiEndpoint(endpoint);
-    it("accepts valid credentials", async () => {
-        const response = await testRequest(server.expressApp)
-            .get("/test")
-            .set("Authorization", `Basic ${encodedCredentials}`);
-        expect(response.status).toBe(HttpStatusCodes.Ok_200);
-    });
-    it("rejects invalid credentials", async () => {
-        const response = await testRequest(server.expressApp)
-            .get("/test")
-            .set("Authorization", `Basic INVALID:INVALID`);
-        expect(response.status).toBe(HttpStatusCodes.Unauthorized_401);
-    });
-});