transit-kit 0.7.1 → 0.8.0

package/dist/generator/generateOpenApi.d.ts

@@ -8,6 +8,10 @@ declare function translateToOpenAPIPathItem(definition: ApiEndpointDefinition<st
 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

@@ -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/server/index.d.ts

@@ -1,3 +1,5 @@
+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";

package/dist/server/index.js

@@ -1,3 +1,5 @@
+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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transit-kit",
-  "version": "0.7.1",
+  "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/handlers/api/createApiHandler.js";
-import { __TEST_EXPORTS } from "./generateOpenApi.js";
-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.js";
-import { createApiEndpointHandler } from "./createApiHandler.js";
-import testRequest from "supertest";
-import z from "zod";
-import { HttpMethods } from "../../constants/HttpMethods.js";
-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.js";
-import { createApiEndpointHandler } from "../handlers/api/createApiHandler.js";
-import { testEndpointBase } from "../handlers/api/createApiHandler.spec.js";
-import { createServer } from "../server.js";
-import { createBasicAuthSchema } from "./basicAuth.js";
-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);
-    });
-});