transit-kit 0.4.3 → 0.4.4

package/dist/cli/generateOpenApi.spec.js

@@ -13,6 +13,7 @@ describe("translateToOpenAPIPathItem", () => {
                 description: "Retrieve a user by ID",
                 group: "User",
             },
+            securitySchemes: [],
             responseSchemas: {
                 200: {
                     dataType: "application/json",

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

@@ -14,5 +14,5 @@ export type ApiEndpointDefinition<Path extends string = string, Method extends H
     requestBodySchema?: RequestBody;
     querySchema?: Query;
     responseSchemas: ResponseMap;
-    securitySchemes?: SecuritySchemes;
+    securitySchemes: SecuritySchemes;
 };

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

@@ -16,4 +16,10 @@ describe("HandlerFromDefinition", () => {
         });
         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/createApiHandler.d.ts

@@ -6,7 +6,7 @@ import { ApiEndpointDefinition } from "./EndpointDefinition";
 import { ApiEndpointHandler } from "./EndpointHandler";
 import { HandlerForDefinition } from "./HandlerFromDefinition";
 import { GenericResponse, GenericResponseSchemaMap } from "./responses";
-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>): {
+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;
         path: Path;
@@ -14,8 +14,8 @@ export declare function createApiEndpointHandler<const ResponsesMap extends Gene
         requestBodySchema?: RequestBody | undefined;
         querySchema?: Query | undefined;
         responseSchemas: ResponsesMap;
-        securitySchemes?: SecuritySchemas | undefined;
+        securitySchemes: SecuritySchemas;
     };
-    handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap>;
+    handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap, SecuritySchemas>;
 };
-export declare function buildApiEndpointHandler<Handler extends ApiEndpointHandler<Record<string, string>, unknown, unknown, GenericResponse>>(handler: Handler): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+export declare function buildApiEndpointHandler<Handler extends ApiEndpointHandler<Record<string, string>, unknown, unknown, GenericResponse, unknown>>(handler: Handler): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;

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

@@ -1 +1,17 @@
-export {};
+import z from "zod";
+export declare const testEndpointBase: {
+    meta: {
+        name: string;
+        description: string;
+        group: string;
+    };
+    method: "get";
+    requestBodySchema: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+    path: string;
+    securitySchemes: never[];
+    responseSchemas: {
+        200: {};
+    };
+};

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

@@ -3,20 +3,27 @@ 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,
+    requestBodySchema: z.object({
+        name: z.string(),
+    }),
+    path: "/test",
+    securitySchemes: [],
+    responseSchemas: {
+        200: {},
+    },
+};
 describe("createApiHandler", () => {
     it("can create an API handler", () => {
         const endpoint = createApiEndpointHandler({
-            meta: {
-                name: "",
-                description: "",
-                group: "",
-            },
-            method: "get",
-            path: "/test",
-            requestBodySchema: z.string(),
-            responseSchemas: {
-                200: {},
-            },
+            ...testEndpointBase,
         }, async () => {
             return {
                 code: 200,

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

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

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

@@ -0,0 +1,45 @@
+import testRequest from "supertest";
+import { describe, 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 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 };
+    });
+    const server = createServer({
+        port: 3000,
+        inDevMode: false,
+        logger: false,
+    });
+    server.registerApiEndpoint(endpoint);
+    it("accepts valid credentials", () => {
+        testRequest(server.expressApp)
+            .get("/test")
+            .set("Authorization", `Basic ${testUsername}:${testPassword}`)
+            .expect(HttpStatusCodes.Ok_200);
+    });
+    it("rejectes invalid credentials", () => {
+        testRequest(server.expressApp)
+            .get("/test")
+            .set("Authorization", `Basic invalid:invalid`)
+            .expect(HttpStatusCodes.Unauthorized_401);
+    });
+});

package/dist/server/server.d.ts

@@ -13,7 +13,7 @@ export interface Server {
     endpointDefinitions: ApiEndpointDefinition[];
     registerApiEndpoint<Definition extends ApiEndpointDefinition>({ definition, handler, }: {
         definition: Definition;
-        handler: HandlerForDefinition<Definition["path"], Definition["requestBodySchema"], Definition["querySchema"], Definition["responseSchemas"]>;
+        handler: HandlerForDefinition<Definition["path"], Definition["requestBodySchema"], Definition["querySchema"], Definition["responseSchemas"], Definition["securitySchemes"]>;
     }): void;
     start: () => void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transit-kit",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "A declarative TypeScript framework for building type-safe Express.js APIs with automatic OpenAPI generation",
   "keywords": [
     "express",