transit-kit 0.1.1 → 0.2.1

package/dist/cli/cli.js

@@ -9,9 +9,10 @@ program
 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 } = options;
-    const generatedDoc = await generateOpenApiDoc();
+    const { output, target } = options;
+    const generatedDoc = await generateOpenApiDoc(target);
     fs.writeFileSync(output, JSON.stringify(generatedDoc, null, 2), {
         encoding: "utf-8",
     });

package/dist/cli/generateOpenApi.d.ts

@@ -1,2 +1,2 @@
 import { OpenAPIV3 } from "openapi-types";
-export declare function generateOpenApiDoc(): Promise<OpenAPIV3.Document<{}>>;
+export declare function generateOpenApiDoc(targetPath: string): Promise<OpenAPIV3.Document<{}>>;

package/dist/cli/generateOpenApi.js

@@ -1,38 +1,7 @@
-import { glob } from "glob";
-import path from "path";
 import z from "zod";
-import { hasNoValue, hasValue } from "../server/utils/typeGuards";
+import { hasValue } from "../server/utils/typeGuards";
+import path from "path";
 import { isJsonResponseSchema } from "../server/handlers/api/responses/jsonResponse";
-async function findEndpointDefinitions() {
-    const files = await glob("**/*.ts", {
-        cwd: process.cwd(),
-        ignore: ["**/node_modules/**", "**/*.spec.ts"],
-    });
-    const definitions = await Promise.all(files.map(async (file) => {
-        const absolutePath = path.resolve(file);
-        const fileUrl = path.toNamespacedPath(absolutePath).startsWith("/")
-            ? `file://${absolutePath}`
-            : `file:///${absolutePath}`;
-        try {
-            const module = await import(fileUrl);
-            if (module.default) {
-                const def = module.default.__API_ENDPOINT_DEFINITION__;
-                if (hasNoValue(def)) {
-                    return null;
-                }
-                return def;
-            }
-            else {
-                return null;
-            }
-        }
-        catch (error) {
-            console.error(`Error importing ${file}:`, error);
-            return null;
-        }
-    }));
-    return definitions.filter(hasValue);
-}
 function extractPathAndParameters(path) {
     const parameters = path.match(/:([a-zA-Z0-9_]+)/g)?.map((param) => {
         return {
@@ -125,28 +94,37 @@ function translateToOpenAPIPathItem(definition) {
     };
     return [openApiPath, pathItem];
 }
-export async function generateOpenApiDoc() {
-    const definitions = await findEndpointDefinitions();
-    const paths = definitions.reduce((acc, def) => {
-        const [openApiPath, pathItem] = translateToOpenAPIPathItem(def);
-        if (acc[openApiPath]) {
-            acc[openApiPath] = {
-                ...acc[openApiPath],
-                ...pathItem,
-            };
-        }
-        else {
-            acc[openApiPath] = pathItem;
-        }
-        return acc;
-    }, {});
-    const openApiDocument = {
-        openapi: "3.0.0",
-        info: {
-            title: "Generated API",
-            version: "1.0.0",
-        },
-        paths: paths,
-    };
-    return openApiDocument;
+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 openApiDocument = {
+            openapi: "3.0.0",
+            info: {
+                title: "Generated API",
+                version: "1.0.0",
+            },
+            paths: paths,
+        };
+        return openApiDocument;
+    }
+    else {
+        throw new Error("The specified module does not export a valid server instance.");
+    }
 }

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

@@ -1,6 +1,6 @@
 import { Request } from "express";
 import { HttpStatusCodes } from "../../constants/HttpStatusCodes";
 import { GenericResponse } from "./responses";
-export type ApiEndpointHandler<PathParams extends Record<string, string> | undefined = {}, RequestBody = unknown, Query = unknown, Responses extends GenericResponse = never> = (request: Request<PathParams, unknown, RequestBody, Query, Record<string, unknown>>) => Promise<Responses | {
+export type ApiEndpointHandler<PathParams extends Record<string, string> = {}, RequestBody = unknown, Query = unknown, Responses extends GenericResponse = never> = (request: Request<PathParams, unknown, RequestBody, Query, Record<string, unknown>>) => Promise<Responses | {
     code: (typeof HttpStatusCodes)["InternalServerError_500"];
 }>;

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

@@ -2,4 +2,4 @@ export type ExtractPathParams<Path extends string> = Path extends `${string}:${i
     [K in Param | keyof ExtractPathParams<Rest>]: string;
 } : Path extends `${string}:${infer Param}` ? {
     [K in Param]: string;
-} : undefined;
+} : {};

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

@@ -3,10 +3,9 @@ import { HttpMethod } from "../../constants/HttpMethods";
 import { ApiEndpointDefinition } from "./EndpointDefinition";
 import { ApiEndpointHandler } from "./EndpointHandler";
 import { HandlerForDefinition } from "./HandlerFromDefinition";
-import { GenericResponseSchemaMap } from "./responses";
+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>(definition: ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponsesMap>, handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap>): {
-    __API_ENDPOINT_DEFINITION__: ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponsesMap>;
     definition: ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponsesMap>;
     handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap>;
 };
-export declare function buildApiEndpointHandler(handler: ApiEndpointHandler): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+export declare function buildApiEndpointHandler(handler: ApiEndpointHandler<Record<string, string>, unknown, unknown, GenericResponse>): import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;

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

@@ -2,7 +2,6 @@ import expressAsyncHandler from "express-async-handler";
 import { isJsonResponse } from "./responses/jsonResponse";
 export function createApiEndpointHandler(definition, handler) {
     return {
-        __API_ENDPOINT_DEFINITION__: definition,
         definition,
         handler,
     };

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

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

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

@@ -0,0 +1,31 @@
+import { describe, it } from "vitest";
+import { createServer } from "../../server";
+import { createApiEndpointHandler } from "./createApiHandler";
+import testRequest from "supertest";
+describe("createApiHandler", () => {
+    it("can create an API handler", () => {
+        const endpoint = createApiEndpointHandler({
+            meta: {
+                name: "",
+                description: "",
+                group: "",
+            },
+            method: "get",
+            path: "/test",
+            responseSchemas: {
+                200: {},
+            },
+        }, async () => {
+            return {
+                code: 200,
+            };
+        });
+        const server = createServer({
+            inDevMode: true,
+            port: 3000,
+            logger: false,
+            endpoints: [endpoint],
+        });
+        testRequest(server.expressApp).get("/test").expect(200);
+    });
+});

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
 export { createApiEndpointHandler } from "./handlers/api/createApiHandler";
-export { createServer, type Server, type ServerOptions } from "./server";
+export { createServer, type Server, type ServerConfig } from "./server";
 declare const _default: {};
 export default _default;

package/dist/server/server.d.ts

@@ -3,19 +3,21 @@ import z from "zod";
 import { HttpMethod } from "./constants/HttpMethods";
 import { ApiEndpointDefinition } from "./handlers/api/EndpointDefinition";
 import { ApiEndpointHandler } from "./handlers/api/EndpointHandler";
+import { GenericResponse, GenericResponseSchemaMap } from "./handlers/api/responses";
 import { Logger } from "./utils/logging";
-export interface ServerOptions {
-    inDevMode?: boolean;
-    port?: number;
-    logger?: Logger | boolean;
+export interface ServerConfig {
+    inDevMode: boolean;
+    port: number;
+    logger: Logger | boolean;
+    endpoints: Array<{
+        handler: ApiEndpointHandler<Record<string, string>, any, any, GenericResponse>;
+        definition: ApiEndpointDefinition<string, HttpMethod, z.ZodType | undefined, z.ZodType | undefined, GenericResponseSchemaMap>;
+    }>;
 }
 export interface Server {
-    _expressApp: Application;
-    _logger: Logger | boolean;
+    expressApp: Application;
+    logger: Logger | boolean;
+    endpointDefinitions: ApiEndpointDefinition<string, HttpMethod, z.ZodType | undefined, z.ZodType | undefined, GenericResponseSchemaMap>[];
     start: () => void;
-    registerApiEndpoint: (endpoint: {
-        endpointHandler: ApiEndpointHandler;
-        endpointDefinition: ApiEndpointDefinition<string, HttpMethod, z.ZodType, z.ZodType, {}>;
-    }) => void;
 }
-export declare function createServer(options: ServerOptions): Server;
+export declare function createServer(config: ServerConfig): Server;

package/dist/server/server.js

@@ -5,39 +5,40 @@ import { buildRequestLogger, buildResponseLogger } from "./middleware/logging";
 import { buildBodyValidatorMiddleware, buildQueryValidatorMiddleware, } from "./middleware/validation";
 import { NoOpLogger } from "./utils/logging";
 import { hasNoValue, hasValue } from "./utils/typeGuards";
-export function createServer(options) {
-    const { port = 3000, inDevMode = false } = options;
-    const logger = options.logger === true
+function registerApiEndpoint(expressApp, endpointDefinition, endpointHandler) {
+    const handlerStack = [
+        hasValue(endpointDefinition.querySchema)
+            ? buildQueryValidatorMiddleware(endpointDefinition.querySchema)
+            : null,
+        hasValue(endpointDefinition.requestBodySchema)
+            ? buildBodyValidatorMiddleware(endpointDefinition.requestBodySchema)
+            : null,
+        buildApiEndpointHandler(endpointHandler),
+    ].filter(hasValue);
+    expressApp[endpointDefinition.method](endpointDefinition.path, handlerStack);
+}
+export function createServer(config) {
+    const { port, inDevMode, endpoints } = config;
+    const logger = config.logger === true
         ? console
-        : options.logger === false || hasNoValue(options.logger)
+        : config.logger === false || hasNoValue(config.logger)
             ? NoOpLogger
-            : options.logger;
+            : config.logger;
     const app = express();
     app.use(express.json());
     app.use(express.urlencoded({ extended: true }));
     app.use(cookieParser());
     app.use(buildRequestLogger(logger, inDevMode));
     app.use(buildResponseLogger(logger, inDevMode));
+    endpoints.forEach(({ definition, handler }) => {
+        registerApiEndpoint(app, definition, handler);
+    });
     return {
-        _expressApp: app,
-        _logger: logger,
+        expressApp: app,
+        logger: logger,
+        endpointDefinitions: endpoints.map((e) => e.definition),
         start: () => {
             app.listen(port);
         },
-        registerApiEndpoint: ({ endpointDefinition, endpointHandler }) => {
-            registerApiEndpoint(app, endpointDefinition, endpointHandler);
-        },
     };
 }
-function registerApiEndpoint(expressApp, endpointDefinition, endpointHandler) {
-    const handlerStack = [
-        hasValue(endpointDefinition.querySchema)
-            ? buildQueryValidatorMiddleware(endpointDefinition.querySchema)
-            : null,
-        hasValue(endpointDefinition.requestBodySchema)
-            ? buildBodyValidatorMiddleware(endpointDefinition.requestBodySchema)
-            : null,
-        buildApiEndpointHandler(endpointHandler),
-    ].filter(hasValue);
-    expressApp[endpointDefinition.method](endpointDefinition.path, handlerStack);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transit-kit",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "A declarative TypeScript framework for building type-safe Express.js APIs with automatic OpenAPI generation",
   "keywords": [
     "express",
@@ -17,11 +17,11 @@
   "author": "D4rkr34lm",
   "repository": {
     "type": "git",
-    "url": "https://github.com/D4rkr34lm/declarative-server.git"
+    "url": "https://github.com/D4rkr34lm/transit-kit.git"
   },
-  "homepage": "https://github.com/D4rkr34lm/declarative-server#readme",
+  "homepage": "https://github.com/D4rkr34lm/transit-kit#readme",
   "bugs": {
-    "url": "https://github.com/D4rkr34lm/declarative-server/issues"
+    "url": "https://github.com/D4rkr34lm/transit-kit/issues"
   },
   "files": [
     "dist"
@@ -42,6 +42,7 @@
   "devDependencies": {
     "@types/cookie-parser": "^1.4.9",
     "@types/express": "^5.0.0",
+    "@types/supertest": "^6.0.3",
     "@vitest/coverage-v8": "^4.0.15",
     "@vitest/eslint-plugin": "^1.5.2",
     "eslint": "^9.39.1",
@@ -49,6 +50,7 @@
     "eslint-plugin-prettier": "^5.5.4",
     "jiti": "^2.6.1",
     "prettier": "^3.7.4",
+    "supertest": "^7.1.4",
     "tslib": "2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.49.0",
@@ -61,7 +63,6 @@
     "cookie-parser": "^1.4.7",
     "express": "^4.21.1",
     "express-async-handler": "^1.2.0",
-    "glob": "^13.0.0",
     "openapi-types": "^12.1.3",
     "zod": "^4.1.13"
   }