transit-kit 0.1.0

package/.github/workflows/ci.yml

@@ -0,0 +1,73 @@
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  lint:
+    name: 🔍 Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: 📦 Install dependencies
+        run: npm ci
+
+      - name: ✨ Run linter
+        run: npm run lint
+
+  test:
+    name: 🧪 Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: 📥 Checkout code
+        uses: actions/checkout@v4
+
+      - name: ⚙️ Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "npm"
+
+      - name: 📦 Install dependencies
+        run: npm ci
+
+      - name: 🧪 Run tests
+        run: npm run test -- --run
+
+  build:
+    name: 🏗️ Build
+    runs-on: ubuntu-latest
+    needs: [lint, test]
+    steps:
+      - name: 📥 Checkout code
+        uses: actions/checkout@v4
+
+      - name: ⚙️ Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: 📦 Install dependencies
+        run: npm ci
+
+      - name: 🔨 Build package
+        run: npm run build
+
+      - name: 📤 Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          retention-days: 7

package/.github/workflows/release.yml

@@ -0,0 +1,37 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: 🚀 Publish to npm
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - name: 📥 Checkout code
+        uses: actions/checkout@v4
+
+      - name: ⚙️ Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          registry-url: "https://registry.npmjs.org"
+          cache: "npm"
+
+      - name: 📦 Install dependencies
+        run: npm ci
+
+      - name: 🧪 Run tests
+        run: npm run test -- --run
+
+      - name: 🔨 Build package
+        run: npm run build
+
+      - name: 🚀 Publish to npm
+        run: npm publish --provenance
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1 @@
+# declarative-server

package/dist/cli/cli.d.ts

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

package/dist/cli/cli.js

@@ -0,0 +1,20 @@
+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")
+    .action(async (options) => {
+    const { output } = options;
+    const generatedDoc = await generateOpenApiDoc();
+    fs.writeFileSync(output, JSON.stringify(generatedDoc, null, 2), {
+        encoding: "utf-8",
+    });
+    console.log(`OpenAPI document generated at: ${output}`);
+});
+program.parse();

package/dist/cli/generateOpenApi.d.ts

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

package/dist/cli/generateOpenApi.js

@@ -0,0 +1,152 @@
+import { glob } from "glob";
+import path from "path";
+import z from "zod";
+import { hasNoValue, hasValue } from "../server/utils/typeGuards";
+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 {
+            name: param.substring(1),
+            in: "path",
+            required: true,
+            schema: { type: "string" },
+            description: `Path parameter ${param}`,
+        };
+    }) ?? [];
+    const openApiPath = path.replace(/:([a-zA-Z0-9_]+)/g, (_, paramName) => {
+        return `{${paramName}}`;
+    });
+    return { openApiPath, parameters };
+}
+function extractQueryParameters(querySchema) {
+    const querySchemaObject = z.toJSONSchema(querySchema);
+    if (querySchemaObject.properties) {
+        return Object.entries(querySchemaObject.properties).map(([name, schema]) => ({
+            name: name,
+            in: "query",
+            required: querySchemaObject.required?.includes(name) || false,
+            schema: schema,
+        }));
+    }
+    else {
+        return [];
+    }
+}
+function translateToOpenAPIPathItem(definition) {
+    const { meta, path, method, requestBodySchema, querySchema, responseSchemas, } = definition;
+    // 1. Path and Parameter extraction
+    const { openApiPath, parameters: pathParameters } = extractPathAndParameters(path);
+    const queryParameters = hasValue(querySchema)
+        ? extractQueryParameters(querySchema)
+        : [];
+    const operationParameters = [...pathParameters, ...queryParameters];
+    const requestBody = hasValue(requestBodySchema)
+        ? {
+            requestBody: {
+                description: `${meta.name} Request Body`,
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: z.toJSONSchema(requestBodySchema), // Type assertion
+                    },
+                },
+            },
+        }
+        : {};
+    // 4. Response Schema Translation
+    const responses = Object.entries(responseSchemas)
+        .map(([statusCode, responseDef]) => {
+        if (isJsonResponseSchema(responseDef)) {
+            const zodSchema = responseDef.dataSchema;
+            const responseSchema = z.toJSONSchema(zodSchema);
+            return {
+                [statusCode]: {
+                    description: `Response for status code ${statusCode}`,
+                    content: {
+                        [responseDef.dataType]: {
+                            schema: responseSchema,
+                        },
+                    },
+                },
+            };
+        }
+        else {
+            return {
+                [statusCode]: {
+                    description: `Response for status code ${statusCode}`,
+                },
+            };
+        }
+    })
+        .reduce((acc, resp) => {
+        return { ...acc, ...resp };
+    }, {});
+    const operation = {
+        operationId: meta.name,
+        summary: meta.description,
+        tags: [meta.group],
+        description: meta.description,
+        parameters: operationParameters,
+        ...requestBody,
+        responses,
+    };
+    const pathItem = {
+        [method.toLowerCase()]: operation,
+    };
+    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;
+}

package/dist/server/constants/HttpMethods.d.ts

@@ -0,0 +1,10 @@
+export declare const HttpMethods: {
+    readonly get: "get";
+    readonly post: "post";
+    readonly put: "put";
+    readonly delete: "delete";
+    readonly patch: "patch";
+    readonly head: "head";
+    readonly options: "options";
+};
+export type HttpMethod = (typeof HttpMethods)[keyof typeof HttpMethods];

package/dist/server/constants/HttpMethods.js

@@ -0,0 +1,9 @@
+export const HttpMethods = {
+    get: "get",
+    post: "post",
+    put: "put",
+    delete: "delete",
+    patch: "patch",
+    head: "head",
+    options: "options",
+};

package/dist/server/constants/HttpStatusCodes.d.ts

@@ -0,0 +1,48 @@
+export declare const SuccessStatusCodes: {
+    readonly Ok_200: 200;
+    readonly Created_201: 201;
+    readonly NoContent_204: 204;
+};
+export type SuccessStatusCode = (typeof SuccessStatusCodes)[keyof typeof SuccessStatusCodes];
+export declare const ClientErrorStatusCodes: {
+    readonly BadRequest_400: 400;
+    readonly Unauthorized_401: 401;
+    readonly Forbidden_403: 403;
+    readonly NotFound_404: 404;
+    readonly Conflict_409: 409;
+};
+export type ClientErrorStatusCode = (typeof ClientErrorStatusCodes)[keyof typeof ClientErrorStatusCodes];
+export declare const ServerErrorStatusCodes: {
+    readonly InternalServerError_500: 500;
+    readonly NotImplemented_501: 501;
+    readonly BadGateway_502: 502;
+    readonly ServiceUnavailable_503: 503;
+};
+export declare const ErrorStatusCodes: {
+    readonly InternalServerError_500: 500;
+    readonly NotImplemented_501: 501;
+    readonly BadGateway_502: 502;
+    readonly ServiceUnavailable_503: 503;
+    readonly BadRequest_400: 400;
+    readonly Unauthorized_401: 401;
+    readonly Forbidden_403: 403;
+    readonly NotFound_404: 404;
+    readonly Conflict_409: 409;
+};
+export type ErrorStatusCode = (typeof ErrorStatusCodes)[keyof typeof ErrorStatusCodes];
+export type ServerErrorStatusCode = (typeof ServerErrorStatusCodes)[keyof typeof ServerErrorStatusCodes];
+export declare const HttpStatusCodes: {
+    readonly InternalServerError_500: 500;
+    readonly NotImplemented_501: 501;
+    readonly BadGateway_502: 502;
+    readonly ServiceUnavailable_503: 503;
+    readonly BadRequest_400: 400;
+    readonly Unauthorized_401: 401;
+    readonly Forbidden_403: 403;
+    readonly NotFound_404: 404;
+    readonly Conflict_409: 409;
+    readonly Ok_200: 200;
+    readonly Created_201: 201;
+    readonly NoContent_204: 204;
+};
+export type HttpStatusCode = (typeof HttpStatusCodes)[keyof typeof HttpStatusCodes];

package/dist/server/constants/HttpStatusCodes.js

@@ -0,0 +1,27 @@
+export const SuccessStatusCodes = {
+    Ok_200: 200,
+    Created_201: 201,
+    NoContent_204: 204,
+};
+export const ClientErrorStatusCodes = {
+    BadRequest_400: 400,
+    Unauthorized_401: 401,
+    Forbidden_403: 403,
+    NotFound_404: 404,
+    Conflict_409: 409,
+};
+export const ServerErrorStatusCodes = {
+    InternalServerError_500: 500,
+    NotImplemented_501: 501,
+    BadGateway_502: 502,
+    ServiceUnavailable_503: 503,
+};
+export const ErrorStatusCodes = {
+    ...ClientErrorStatusCodes,
+    ...ServerErrorStatusCodes,
+};
+export const HttpStatusCodes = {
+    ...SuccessStatusCodes,
+    ...ClientErrorStatusCodes,
+    ...ServerErrorStatusCodes,
+};

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

@@ -0,0 +1,16 @@
+import z from "zod";
+import { HttpMethod } from "../../constants/HttpMethods";
+import { GenericResponseSchemaMap } from "./responses/index";
+export interface ApiEndpointMeta {
+    name: string;
+    group: string;
+    description: string;
+}
+export type ApiEndpointDefinition<Path extends string, Method extends HttpMethod, RequestBody extends z.ZodType | undefined, Query extends z.ZodType | undefined, ResponseMap extends GenericResponseSchemaMap> = {
+    meta: ApiEndpointMeta;
+    path: Path;
+    method: Method;
+    requestBodySchema?: RequestBody;
+    querySchema?: Query;
+    responseSchemas: ResponseMap;
+};

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

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

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

@@ -0,0 +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 | {
+    code: (typeof HttpStatusCodes)["InternalServerError_500"];
+}>;

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

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

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

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

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

@@ -0,0 +1,19 @@
+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(),
+        });
+        expectTypeOf().toEqualTypeOf();
+    });
+});

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

@@ -0,0 +1,11 @@
+import z from "zod";
+import { HttpStatusCode } from "../../constants/HttpStatusCodes";
+import { Prettify } from "../../utils/types";
+import { ApiEndpointHandler } from "./EndpointHandler";
+import { ExtractPathParams } from "./PathParameters";
+import { EmptyResponse, EmptyResponseSchema } from "./responses/emptyResponse";
+import { 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> = ApiEndpointHandler<ExtractPathParams<Path>, RequestBody extends undefined ? undefined : z.infer<RequestBody>, Query extends undefined ? undefined : z.infer<Query>, Prettify<{
+    [K in keyof ResponsesMap]: K extends HttpStatusCode ? ResponsesMap[K] extends JsonResponseSchema ? JsonResponseSchemaToResponseType<K, ResponsesMap[K]> : ResponsesMap[K] extends EmptyResponseSchema ? EmptyResponse<K> : never : never;
+}[keyof ResponsesMap]>>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+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.d.ts

@@ -0,0 +1,12 @@
+import z from "zod";
+import { HttpMethod } from "../../constants/HttpMethods";
+import { ApiEndpointDefinition } from "./EndpointDefinition";
+import { ApiEndpointHandler } from "./EndpointHandler";
+import { HandlerForDefinition } from "./HandlerFromDefinition";
+import { 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>>;

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

@@ -0,0 +1,20 @@
+import expressAsyncHandler from "express-async-handler";
+import { isJsonResponse } from "./responses/jsonResponse";
+export function createApiEndpointHandler(definition, handler) {
+    return {
+        __API_ENDPOINT_DEFINITION__: definition,
+        definition,
+        handler,
+    };
+}
+export function buildApiEndpointHandler(handler) {
+    return expressAsyncHandler(async (request, response) => {
+        const result = await handler(request);
+        if (isJsonResponse(result)) {
+            response.status(result.code).json(result.json);
+        }
+        else {
+            response.status(result.code).send();
+        }
+    });
+}

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

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

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

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

@@ -0,0 +1,7 @@
+import { ClientErrorStatusCode, SuccessStatusCode } from "../../../constants/HttpStatusCodes";
+import { EmptyResponse, EmptyResponseSchema } from "./emptyResponse";
+import { JsonResponse, JsonResponseSchema } from "./jsonResponse";
+export type GenericResponseSchemaMap = {
+    [K in SuccessStatusCode | ClientErrorStatusCode]?: EmptyResponseSchema | JsonResponseSchema | undefined;
+};
+export type GenericResponse = EmptyResponse | JsonResponse;

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

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

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

@@ -0,0 +1,14 @@
+import z from "zod";
+import { HttpStatusCode } from "../../../constants/HttpStatusCodes";
+export interface JsonResponseSchema<DataSchema extends z.ZodType = z.ZodType> {
+    dataType: "application/json";
+    dataSchema: 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;

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

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

package/dist/server/index.d.ts

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

package/dist/server/index.js

@@ -0,0 +1,3 @@
+export { createApiEndpointHandler } from "./handlers/api/createApiHandler";
+export { createServer } from "./server";
+export default {};

package/dist/server/middleware/logging.d.ts

@@ -0,0 +1,4 @@
+import { NextFunction, Request, Response } from "express";
+import { Logger } from "../utils/logging";
+export declare function buildRequestLogger(logger: Logger, isInDevMode: boolean): (req: Request, res: Response, next: NextFunction) => void;
+export declare function buildResponseLogger(logger: Logger, isInDevMode: boolean): (req: Request, res: Response, next: NextFunction) => void;

package/dist/server/middleware/logging.js

@@ -0,0 +1,25 @@
+import colors from "colors/safe";
+export function buildRequestLogger(logger, isInDevMode) {
+    return (req, res, next) => {
+        logger.info(`[Request] ${colors.cyan(req.method)} - ${colors.cyan(req.path)}`);
+        if (isInDevMode) {
+            logger.info(`[Request - Dev] Headers: ${JSON.stringify(req.headers)}`);
+            logger.info(`[Request - Dev] Query: ${JSON.stringify(req.query)}`);
+            logger.info(`[Request - Dev] Body: ${JSON.stringify(req.body)}`);
+        }
+        next();
+    };
+}
+export function buildResponseLogger(logger, isInDevMode) {
+    return (req, res, next) => {
+        const originalSend = res.send;
+        res.json = 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)}`);
+            }
+            return originalSend.call(this, body);
+        };
+        next();
+    };
+}

package/dist/server/middleware/validation.d.ts

@@ -0,0 +1,4 @@
+import { NextFunction, Request, Response } from "express";
+import { ZodType } from "zod";
+export declare function buildBodyValidatorMiddleware<Schema extends ZodType>(schema: Schema): (request: Request, response: Response, next: NextFunction) => void;
+export declare function buildQueryValidatorMiddleware<Schema extends ZodType>(schema: Schema): (request: Request, response: Response, next: NextFunction) => void;

package/dist/server/middleware/validation.js

@@ -0,0 +1,27 @@
+import { HttpStatusCodes } from "../constants/HttpStatusCodes";
+export function buildBodyValidatorMiddleware(schema) {
+    return (request, response, next) => {
+        const validationResult = schema.safeParse(request.body);
+        if (!validationResult.success) {
+            response.status(HttpStatusCodes.BadRequest_400).json({
+                message: `Body invalid`,
+                error: validationResult.error,
+            });
+            return;
+        }
+        next();
+    };
+}
+export function buildQueryValidatorMiddleware(schema) {
+    return (request, response, next) => {
+        const validationResult = schema.safeParse(request.query);
+        if (!validationResult.success) {
+            response.status(HttpStatusCodes.BadRequest_400).json({
+                message: `Query parameters invalid`,
+                error: validationResult.error,
+            });
+            return;
+        }
+        next();
+    };
+}