transit-kit 0.4.3 → 0.5.0

package/dist/cli/generateOpenApi.spec.js

@@ -13,17 +13,18 @@ describe("translateToOpenAPIPathItem", () => {
                 description: "Retrieve a user by ID",
                 group: "User",
             },
+            securitySchemes: [],
             responseSchemas: {
                 200: {
                     dataType: "application/json",
                     dataSchema: z.string(),
                 },
             },
-        }, async (req) => {
+        }, async ({ request }) => {
             return {
                 code: 200,
                 dataType: "application/json",
-                json: req.params.id,
+                json: request.params.id,
             };
         });
         const [path, pathItem] = translateToOpenAPIPathItem(definition);

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/EndpointHandler.d.ts

@@ -1,7 +1,9 @@
-import { Request } from "express";
+import { Request, Response } from "express";
 import { HttpStatusCodes } from "../../constants/HttpStatusCodes";
 import { GenericResponse } from "./responses";
-export type ApiEndpointHandler<PathParams extends Record<string, string> = {}, RequestBody = unknown, Query = unknown, Responses extends GenericResponse = never, Caller = unknown> = (request: Request<PathParams, unknown, RequestBody, Query, Record<string, unknown>>, extractedRequestData: {
+export type ApiEndpointHandler<PathParams extends Record<string, string> = {}, RequestBody = unknown, Query = unknown, Responses extends GenericResponse = never, Caller = unknown> = (typedRequestData: {
+    request: Request<PathParams, unknown, RequestBody, Query, Record<string, unknown>>;
+    response: Response<unknown>;
     parameters: PathParams;
     query: Query;
     body: RequestBody;

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.js

@@ -8,14 +8,14 @@ export function createApiEndpointHandler(definition, handler) {
 }
 export function buildApiEndpointHandler(handler) {
     return expressAsyncHandler(async (request, response) => {
-        const caller = response.locals.caller;
-        const extractedRequestData = {
+        const result = await handler({
+            request,
+            response,
             parameters: request.params,
             query: request.query,
             body: request.body,
-            caller,
-        };
-        const result = await handler(request, extractedRequestData);
+            caller: response.locals.caller,
+        });
         if (isJsonResponse(result)) {
             response.status(result.code).json(result.json);
         }

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/handlers/api/responses/emptyResponse.spec.d.ts

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

package/dist/server/handlers/api/responses/emptyResponse.spec.js

@@ -0,0 +1,9 @@
+import { describe, expectTypeOf, it } from "vitest";
+describe("empty response", () => {
+    it("can correctly infer the response type from schema", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it("can correctly identify a literal with the type", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});

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

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

package/dist/server/handlers/api/responses/jsonResponse.spec.js

@@ -0,0 +1,39 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import z from "zod";
+import { isJsonResponse, isJsonResponseSchema, } from "./jsonResponse";
+describe("empty response", () => {
+    it("can correctly infer the response type from schema", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it("can correctly identify a literal with the type", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it("can correctly validate if a response is of type", () => {
+        const res = {
+            dataType: "application/json",
+            json: "string",
+        };
+        expect(isJsonResponse(res)).toBe(true);
+    });
+    it("can correctly validate if a response is not of type", () => {
+        const res = {
+            dataType: "application/data", //<=== Wrong
+            json: "string",
+        };
+        expect(isJsonResponse(res)).toBe(false);
+    });
+    it("can correctly validate if a response schema is of type", () => {
+        const res = {
+            dataType: "application/json",
+            dataSchema: z.string(),
+        };
+        expect(isJsonResponseSchema(res)).toBe(true);
+    });
+    it("can correctly validate if a response schema is not of type", () => {
+        const res = {
+            dataType: "application/data", // <=== Wrong
+            dataSchema: z.string(),
+        };
+        expect(isJsonResponseSchema(res)).toBe(false);
+    });
+});

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.5.0",
   "description": "A declarative TypeScript framework for building type-safe Express.js APIs with automatic OpenAPI generation",
   "keywords": [
     "express",