transit-kit 0.4.4 → 0.6.0

package/dist/{cli → generator}/generateOpenApi.d.ts

@@ -3,8 +3,13 @@ import { ApiEndpointDefinition } from "../server/handlers/api/EndpointDefinition
 import { GenericResponseSchemaMap } from "../server/handlers/api/responses";
 import { ZodType } from "zod";
 import { OpenAPIV3 } from "openapi-types";
+import { Server } from "../server";
 declare function translateToOpenAPIPathItem(definition: ApiEndpointDefinition<string, HttpMethod, ZodType | undefined, ZodType | undefined, GenericResponseSchemaMap>): [string, OpenAPIV3.PathItemObject];
-export declare function generateOpenApiDoc(targetPath: string): Promise<OpenAPIV3.Document<{}>>;
+interface GeneratorOptions {
+    title: string;
+    version: string;
+}
+export declare function generateOpenApiDoc(server: Server, options: GeneratorOptions): Promise<OpenAPIV3.Document>;
 export declare const __TEST_EXPORTS: {
     translateToOpenAPIPathItem: typeof translateToOpenAPIPathItem;
 };

package/dist/{cli → generator}/generateOpenApi.js

@@ -1,6 +1,5 @@
 import z from "zod";
 import { hasValue } from "../server/utils/typeGuards";
-import path from "path";
 import { isJsonResponseSchema } from "../server/handlers/api/responses/jsonResponse";
 function extractPathAndParameters(path) {
     const parameters = path.match(/:([a-zA-Z0-9_]+)/g)?.map((param) => {
@@ -137,43 +136,34 @@ function extractSecuritySchemes(endpointDefinitions) {
         return { ...acc, ...scheme };
     }, {});
 }
-export async function generateOpenApiDoc(targetPath) {
-    const serverModule = await import(path.resolve(process.cwd(), targetPath));
-    const server = serverModule.default;
-    if (hasValue(server) &&
-        hasValue(server.endpointDefinitions) &&
-        Array.isArray(server.endpointDefinitions)) {
-        const endpointDefinitions = server.endpointDefinitions;
-        const paths = endpointDefinitions.reduce((acc, def) => {
-            const [openApiPath, pathItem] = translateToOpenAPIPathItem(def);
-            if (acc[openApiPath]) {
-                acc[openApiPath] = {
-                    ...acc[openApiPath],
-                    ...pathItem,
-                };
-            }
-            else {
-                acc[openApiPath] = pathItem;
-            }
-            return acc;
-        }, {});
-        const securitySchemes = extractSecuritySchemes(endpointDefinitions);
-        const openApiDocument = {
-            openapi: "3.0.0",
-            info: {
-                title: "Generated API",
-                version: "1.0.0",
-            },
-            paths: paths,
-            components: {
-                securitySchemes,
-            },
-        };
-        return openApiDocument;
-    }
-    else {
-        throw new Error("The specified module does not export a valid server instance.");
-    }
+export async function generateOpenApiDoc(server, options) {
+    const endpointDefinitions = server.endpointDefinitions;
+    const paths = endpointDefinitions.reduce((acc, def) => {
+        const [openApiPath, pathItem] = translateToOpenAPIPathItem(def);
+        if (acc[openApiPath]) {
+            acc[openApiPath] = {
+                ...acc[openApiPath],
+                ...pathItem,
+            };
+        }
+        else {
+            acc[openApiPath] = pathItem;
+        }
+        return acc;
+    }, {});
+    const securitySchemes = extractSecuritySchemes(endpointDefinitions);
+    const openApiDocument = {
+        openapi: "3.0.0",
+        info: {
+            title: options.title,
+            version: options.version,
+        },
+        paths: paths,
+        components: {
+            securitySchemes,
+        },
+    };
+    return openApiDocument;
 }
 export const __TEST_EXPORTS = {
     translateToOpenAPIPathItem,

package/dist/{cli → generator}/generateOpenApi.spec.js

@@ -20,11 +20,11 @@ describe("translateToOpenAPIPathItem", () => {
                     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/generator/index.d.ts

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

package/dist/generator/index.js

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

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transit-kit",
-  "version": "0.4.4",
+  "version": "0.6.0",
   "description": "A declarative TypeScript framework for building type-safe Express.js APIs with automatic OpenAPI generation",
   "keywords": [
     "express",
@@ -31,9 +31,13 @@
       "types": "./dist/server/index.d.ts",
       "import": "./dist/server/index.js",
       "require": "./dist/server/index.js"
+    },
+    "./generator": {
+      "types": "./dist/generator/index.d.ts",
+      "import": "./dist/generator/index.js",
+      "require": "./dist/generator/index.js"
     }
   },
-  "bin": "./dist/cli/cli.js",
   "scripts": {
     "lint": "eslint",
     "test": "vitest",
@@ -59,7 +63,6 @@
   },
   "dependencies": {
     "colors": "^1.4.0",
-    "commander": "^14.0.2",
     "cookie-parser": "^1.4.7",
     "express": "^4.21.1",
     "express-async-handler": "^1.2.0",

package/dist/cli/cli.js

@@ -1,21 +0,0 @@
-import { Command } from "commander";
-import fs from "fs";
-import { generateOpenApiDoc } from "./generateOpenApi";
-const program = new Command();
-program
-    .name("transit-kit")
-    .description("CLI of the transitKit backend framework")
-    .version("1.0.0");
-program
-    .command("generate-openapi")
-    .option("-o, --output <path>", "Output path for the generated OpenAPI document", "openapi.json")
-    .option("-t, --target <path>", "Target path to search for endpoint definitions", ".")
-    .action(async (options) => {
-    const { output, target } = options;
-    const generatedDoc = await generateOpenApiDoc(target);
-    fs.writeFileSync(output, JSON.stringify(generatedDoc, null, 2), {
-        encoding: "utf-8",
-    });
-    console.log(`OpenAPI document generated at: ${output}`);
-});
-program.parse();