transit-kit 0.6.2 → 0.7.0

package/dist/generator/generateOpenApi.js

@@ -1,38 +1,6 @@
 import z from "zod";
 import { hasValue } from "../server/utils/typeGuards";
 import { isJsonResponseSchema } from "../server/handlers/api/responses/jsonResponse";
-function prepareForJsonSchema(schema) {
-    // 1. Handle Dates (The Core Issue)
-    if (schema instanceof z.ZodDate) {
-        return z.string().datetime().describe("ISO 8601 date-time string");
-    }
-    // 2. Handle Objects
-    if (schema instanceof z.ZodObject) {
-        const newShape = {};
-        for (const key in schema.shape) {
-            newShape[key] = prepareForJsonSchema(schema.shape[key]);
-        }
-        return z.object(newShape);
-    }
-    // 3. Handle Arrays
-    if (schema instanceof z.ZodArray) {
-        return z.array(prepareForJsonSchema(schema.element));
-    }
-    // 4. Handle Optionals
-    if (schema instanceof z.ZodOptional) {
-        return prepareForJsonSchema(schema.unwrap()).optional();
-    }
-    // 5. Handle Nullables
-    if (schema instanceof z.ZodNullable) {
-        return prepareForJsonSchema(schema.unwrap()).nullable();
-    }
-    // 7. Handle Unions
-    if (schema instanceof z.ZodUnion) {
-        return z.union(schema.options.map((option) => prepareForJsonSchema(option)));
-    }
-    // Return as-is if no transformation is needed
-    return schema;
-}
 function extractPathAndParameters(path) {
     const parameters = path.match(/:([a-zA-Z0-9_]+)/g)?.map((param) => {
         return {
@@ -49,7 +17,7 @@ function extractPathAndParameters(path) {
     return { openApiPath, parameters };
 }
 function extractQueryParameters(querySchema) {
-    const querySchemaObject = z.toJSONSchema(prepareForJsonSchema(querySchema));
+    const querySchemaObject = z.toJSONSchema(querySchema, { io: "input" });
     if (querySchemaObject.properties) {
         return Object.entries(querySchemaObject.properties).map(([name, schema]) => ({
             name: name,
@@ -95,7 +63,9 @@ function translateToOpenAPIPathItem(definition) {
                 required: true,
                 content: {
                     "application/json": {
-                        schema: z.toJSONSchema(prepareForJsonSchema(requestBodySchema)), // Type assertion
+                        schema: z.toJSONSchema(requestBodySchema, {
+                            io: "input",
+                        }), // Type assertion
                     },
                 },
             },
@@ -105,13 +75,13 @@ function translateToOpenAPIPathItem(definition) {
     const responses = Object.entries(responseSchemas)
         .map(([statusCode, responseDef]) => {
         if (isJsonResponseSchema(responseDef)) {
-            const zodSchema = responseDef.dataSchema;
-            const responseSchema = z.toJSONSchema(prepareForJsonSchema(zodSchema));
+            const zodSchema = responseDef.schema;
+            const responseSchema = z.toJSONSchema(zodSchema, { io: "input" });
             return {
                 [statusCode]: {
                     description: `Response for status code ${statusCode}`,
                     content: {
-                        [responseDef.dataType]: {
+                        ["application/json"]: {
                             schema: responseSchema,
                         },
                     },
@@ -119,11 +89,7 @@ function translateToOpenAPIPathItem(definition) {
             };
         }
         else {
-            return {
-                [statusCode]: {
-                    description: `Response for status code ${statusCode}`,
-                },
-            };
+            throw new Error(`Unsupported response schema type: ${responseDef}`);
         }
     })
         .reduce((acc, resp) => {

package/dist/generator/generateOpenApi.spec.js

@@ -16,15 +16,14 @@ describe("translateToOpenAPIPathItem", () => {
             securitySchemes: [],
             responseSchemas: {
                 200: {
-                    dataType: "application/json",
-                    dataSchema: z.string(),
+                    type: "json",
+                    schema: z.string(),
                 },
             },
         }, async ({ request }) => {
             return {
                 code: 200,
-                dataType: "application/json",
-                json: request.params.id,
+                data: request.params.id,
             };
         });
         const [path, pathItem] = translateToOpenAPIPathItem(definition);

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

@@ -1,13 +1,11 @@
 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> = (typedRequestData: {
+import { HttpStatusCode } from "../../constants/HttpStatusCodes";
+import { HandlerResponse } from "./responses";
+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>;
     parameters: PathParams;
     query: Query;
     body: RequestBody;
     caller: Caller;
-}) => Promise<Responses | {
-    code: (typeof HttpStatusCodes)["InternalServerError_500"];
-}>;
+}) => Promise<Responses>;

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

@@ -4,9 +4,7 @@ import { SecurityScheme } from "../../security/SecuritySchema";
 import { Prettify } from "../../utils/types";
 import { ApiEndpointHandler } from "./EndpointHandler";
 import { ExtractPathParams } from "./PathParameters";
-import { EmptyResponse, EmptyResponseSchema } from "./responses/emptyResponse";
-import { GenericResponse, GenericResponseSchemaMap } from "./responses/index";
-import { JsonResponseSchema, JsonResponseSchemaToResponseType } from "./responses/jsonResponse";
-export type HandlerForDefinition<Path extends string, RequestBody extends z.ZodType | undefined, Query extends z.ZodType | undefined, ResponsesMap extends GenericResponseSchemaMap, SecuritySchemas extends SecurityScheme<unknown>[] = []> = ApiEndpointHandler<ExtractPathParams<Path>, RequestBody extends undefined ? undefined : z.infer<RequestBody>, Query extends undefined ? undefined : z.infer<Query>, Exclude<Prettify<{
-    [K in keyof ResponsesMap]: K extends HttpStatusCode ? ResponsesMap[K] extends JsonResponseSchema ? JsonResponseSchemaToResponseType<K, ResponsesMap[K]> : ResponsesMap[K] extends EmptyResponseSchema ? EmptyResponse<K> : ResponsesMap[K] extends undefined ? never : GenericResponse : never;
-}[keyof ResponsesMap]>, undefined>, SecuritySchemas extends SecurityScheme<infer Caller>[] ? Caller : unknown>;
+import { GenericResponseSchema, GenericResponseSchemaMap, InferResponseFromSchema } from "./responses/index";
+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/HandlerFromDefinition.spec.js

@@ -1,19 +1,9 @@
 import { describe, expectTypeOf, it } from "vitest";
-import z from "zod";
 describe("HandlerFromDefinition", () => {
-    it("can infer handler responses correctly (Empty)", () => {
-        expectTypeOf().toEqualTypeOf();
-    });
     it("can infer handler responses correctly (Json)", () => {
-        const _data = z.object({
-            a: z.number(),
-        });
         expectTypeOf().toEqualTypeOf();
     });
-    it("can infer handler responses correctly (Multiple)", () => {
-        const _data = z.object({
-            a: z.number(),
-        });
+    it("can infer handler responses correctly (headers)", () => {
         expectTypeOf().toEqualTypeOf();
     });
     it("can infer caller from auth schema (Basic)", () => {

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

@@ -1,11 +1,12 @@
 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 { GenericResponse, GenericResponseSchemaMap } from "./responses";
+import { GenericResponseSchemaMap, HandlerResponse } 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, SecuritySchemas>): {
     definition: {
         meta: import("./EndpointDefinition").ApiEndpointMeta;
@@ -18,4 +19,8 @@ export declare function createApiEndpointHandler<const ResponsesMap extends Gene
     };
     handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap, SecuritySchemas>;
 };
-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>>;
+export declare function buildApiEndpointHandler<Handler extends ApiEndpointHandler<HandlerResponse<HttpStatusCode, unknown> & {
+    headers?: {
+        [key: string]: string;
+    };
+}, Record<string, string>, unknown, unknown, 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

@@ -1,5 +1,4 @@
 import expressAsyncHandler from "express-async-handler";
-import { isJsonResponse } from "./responses/jsonResponse";
 export function createApiEndpointHandler(definition, handler) {
     return {
         definition,
@@ -16,11 +15,9 @@ export function buildApiEndpointHandler(handler) {
             body: request.body,
             caller: response.locals.caller,
         });
-        if (isJsonResponse(result)) {
-            response.status(result.code).json(result.json);
-        }
-        else {
-            response.status(result.code).send();
-        }
+        response
+            .status(result.code)
+            .set(result.headers ?? {})
+            .send(result.data);
     });
 }

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

@@ -6,12 +6,12 @@ export declare const testEndpointBase: {
         group: string;
     };
     method: "get";
-    requestBodySchema: z.ZodObject<{
-        name: z.ZodString;
-    }, z.core.$strip>;
     path: string;
     securitySchemes: never[];
     responseSchemas: {
-        200: {};
+        200: {
+            type: "json";
+            schema: z.ZodString;
+        };
     };
 };

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

@@ -1,4 +1,4 @@
-import { describe, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import { createServer } from "../../server";
 import { createApiEndpointHandler } from "./createApiHandler";
 import testRequest from "supertest";
@@ -11,22 +11,23 @@ export const testEndpointBase = {
         group: "test",
     },
     method: HttpMethods.get,
-    requestBodySchema: z.object({
-        name: z.string(),
-    }),
     path: "/test",
     securitySchemes: [],
     responseSchemas: {
-        200: {},
+        200: {
+            type: "json",
+            schema: z.string(),
+        },
     },
 };
 describe("createApiHandler", () => {
-    it("can create an API handler", () => {
+    it("can create an API handler that responds correctly (json)", async () => {
         const endpoint = createApiEndpointHandler({
             ...testEndpointBase,
         }, async () => {
             return {
                 code: 200,
+                data: "test",
             };
         });
         const server = createServer({
@@ -35,6 +36,38 @@ describe("createApiHandler", () => {
             logger: false,
         });
         server.registerApiEndpoint(endpoint);
-        testRequest(server.expressApp).get("/test").expect(200);
+        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/handlers/api/responses/index.d.ts

@@ -1,7 +1,23 @@
-import { ClientErrorStatusCode, SuccessStatusCode } from "../../../constants/HttpStatusCodes";
-import { EmptyResponse, EmptyResponseSchema } from "./emptyResponse";
-import { JsonResponse, JsonResponseSchema } from "./jsonResponse";
+import z from "zod";
+import { HttpStatusCode } from "../../../constants/HttpStatusCodes";
+import { JsonResponseSchema } from "./jsonResponse";
+export type AbstractResponseSchema<Headers extends string[] | undefined = string[] | undefined> = {
+    type: string;
+    headers?: Headers;
+};
+export type HandlerResponse<Code extends HttpStatusCode, Data> = {
+    code: Code;
+    data: Data;
+};
+export type GenericResponseSchema = JsonResponseSchema;
 export type GenericResponseSchemaMap = {
-    [K in SuccessStatusCode | ClientErrorStatusCode]?: EmptyResponseSchema | JsonResponseSchema | undefined;
+    [key in HttpStatusCode]?: GenericResponseSchema;
 };
-export type GenericResponse = EmptyResponse | JsonResponse;
+export type InferHeadersFromSchema<Schema extends AbstractResponseSchema> = Schema extends {
+    headers: infer Headers;
+} ? Headers extends string[] ? {
+    headers: {
+        [K in Headers[number]]: string;
+    };
+} : {} : {};
+export type InferResponseFromSchema<Code extends HttpStatusCode, Schema extends GenericResponseSchema> = Schema extends JsonResponseSchema<infer DataSchema> ? HandlerResponse<Code, z.infer<DataSchema>> & InferHeadersFromSchema<Schema> : never;

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

@@ -1,14 +1,7 @@
 import z from "zod";
-import { HttpStatusCode } from "../../../constants/HttpStatusCodes";
-export interface JsonResponseSchema<DataSchema extends z.ZodType = z.ZodType> {
-    dataType: "application/json";
-    dataSchema: DataSchema;
+import { AbstractResponseSchema } from ".";
+export interface JsonResponseSchema<DataSchema extends z.ZodType = z.ZodType, Headers extends string[] | undefined = string[] | undefined> extends AbstractResponseSchema<Headers> {
+    type: "json";
+    schema: DataSchema;
 }
-export interface JsonResponse<Code extends HttpStatusCode = HttpStatusCode, Data = unknown> {
-    code: Code;
-    dataType: "application/json";
-    json: Data;
-}
-export type JsonResponseSchemaToResponseType<Code extends HttpStatusCode, Schema extends JsonResponseSchema> = Schema extends JsonResponseSchema<infer DataSchema> ? JsonResponse<Code, z.infer<DataSchema>> : never;
-export declare function isJsonResponseSchema(value: unknown): value is JsonResponseSchema;
-export declare function isJsonResponse(value: unknown): value is JsonResponse;
+export declare function isJsonResponseSchema(value: AbstractResponseSchema): value is JsonResponseSchema;

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

@@ -1,13 +1,3 @@
-import { hasValue } from "../../../utils/typeGuards";
 export function isJsonResponseSchema(value) {
-    return (typeof value === "object" &&
-        hasValue(value) &&
-        "dataType" in value &&
-        value.dataType === "application/json");
-}
-export function isJsonResponse(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "dataType" in value &&
-        value.dataType === "application/json");
+    return value.type === "json";
 }

package/dist/server/middleware/logging.js

@@ -13,7 +13,7 @@ export function buildRequestLogger(logger, isInDevMode) {
 export function buildResponseLogger(logger, isInDevMode) {
     return (req, res, next) => {
         const originalSend = res.send;
-        res.json = function (body) {
+        res.send = function (body) {
             logger.info(`[Response] ${colors.cyan(req.method)} - ${colors.cyan(req.path)} - Status: ${res.statusCode > 299 && res.statusCode < 599 ? colors.red(res.statusCode.toString()) : colors.green(res.statusCode.toString())}`);
             if (isInDevMode) {
                 logger.info(`[Response - Dev] Body: ${JSON.stringify(body)}`);

package/dist/server/security/basicAuth.js

@@ -16,6 +16,7 @@ export function buildBasicAuthenticator(scheme) {
         const base64Credentials = authHeader.slice("Basic ".length);
         const credentials = Buffer.from(base64Credentials, "base64").toString("utf-8");
         const [username, password] = credentials.split(":", 2);
+        console.log("Decoded credentials:", { username, password });
         return scheme.validateCaller(username, password);
     };
 }

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

@@ -1,5 +1,5 @@
 import testRequest from "supertest";
-import { describe, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import { HttpStatusCodes } from "../constants/HttpStatusCodes";
 import { createApiEndpointHandler } from "../handlers/api/createApiHandler";
 import { testEndpointBase } from "../handlers/api/createApiHandler.spec";
@@ -8,6 +8,7 @@ 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 {
@@ -22,7 +23,7 @@ describe("basic auth schema", () => {
         ...testEndpointBase,
         securitySchemes: [authScheme],
     }, async () => {
-        return { code: HttpStatusCodes.Ok_200 };
+        return { code: HttpStatusCodes.Ok_200, data: "test" };
     });
     const server = createServer({
         port: 3000,
@@ -30,16 +31,16 @@ describe("basic auth schema", () => {
         logger: false,
     });
     server.registerApiEndpoint(endpoint);
-    it("accepts valid credentials", () => {
-        testRequest(server.expressApp)
+    it("accepts valid credentials", async () => {
+        const response = await testRequest(server.expressApp)
             .get("/test")
-            .set("Authorization", `Basic ${testUsername}:${testPassword}`)
-            .expect(HttpStatusCodes.Ok_200);
+            .set("Authorization", `Basic ${encodedCredentials}`);
+        expect(response.status).toBe(HttpStatusCodes.Ok_200);
     });
-    it("rejectes invalid credentials", () => {
-        testRequest(server.expressApp)
+    it("rejects invalid credentials", async () => {
+        const response = await testRequest(server.expressApp)
             .get("/test")
-            .set("Authorization", `Basic invalid:invalid`)
-            .expect(HttpStatusCodes.Unauthorized_401);
+            .set("Authorization", `Basic INVALID:INVALID`);
+        expect(response.status).toBe(HttpStatusCodes.Unauthorized_401);
     });
 });

package/package.json

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

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

@@ -1,7 +0,0 @@
-import { HttpStatusCode } from "../../../constants/HttpStatusCodes";
-export interface EmptyResponseSchema {
-}
-export interface EmptyResponse<Code extends HttpStatusCode = HttpStatusCode> {
-    code: Code;
-}
-export type EmptyResponseSchemaToResponseType<Code extends HttpStatusCode, _ extends EmptyResponseSchema> = EmptyResponse<Code>;

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

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

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

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

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

@@ -1,9 +0,0 @@
-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

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

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

@@ -1,39 +0,0 @@
-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);
-    });
-});