transit-kit 0.1.0 → 0.2.0

package/src/cli/generateOpenApi.ts

@@ -1,217 +0,0 @@
-import { glob } from "glob";
-import path from "path";
-import z from "zod";
-import { HttpMethod } from "../server/constants/HttpMethods";
-import { ApiEndpointDefinition } from "../server/handlers/api/EndpointDefinition";
-import { GenericResponseSchemaMap } from "../server/handlers/api/responses";
-import { hasNoValue, hasValue } from "../server/utils/typeGuards";
-
-import { ZodType } from "zod";
-
-import { OpenAPIV3 } from "openapi-types";
-import { isJsonResponseSchema } from "../server/handlers/api/responses/jsonResponse";
-
-async function findEndpointDefinitions(targetPath: string) {
-  const files = await glob("**/*.ts", {
-    cwd: path.resolve(process.cwd(), targetPath),
-    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__ as
-            | ApiEndpointDefinition<
-                string,
-                HttpMethod,
-                z.ZodType | undefined,
-                z.ZodType | undefined,
-                GenericResponseSchemaMap
-              >
-            | undefined;
-
-          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: string): {
-  openApiPath: string;
-  parameters: OpenAPIV3.ParameterObject[];
-} {
-  const parameters: OpenAPIV3.ParameterObject[] =
-    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: ZodType,
-): OpenAPIV3.ParameterObject[] {
-  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 as OpenAPIV3.SchemaObject,
-      }),
-    );
-  } else {
-    return [];
-  }
-}
-
-function translateToOpenAPIPathItem(
-  definition: ApiEndpointDefinition<
-    string,
-    HttpMethod,
-    ZodType | undefined,
-    ZodType | undefined,
-    GenericResponseSchemaMap
-  >,
-): [string, OpenAPIV3.PathItemObject] {
-  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,
-              ) as OpenAPIV3.SchemaObject, // Type assertion
-            },
-          },
-        },
-      }
-    : {};
-
-  // 4. Response Schema Translation
-  const responses = Object.entries(responseSchemas)
-    .map(([statusCode, responseDef]) => {
-      if (isJsonResponseSchema(responseDef)) {
-        const zodSchema = responseDef.dataSchema as ZodType;
-        const responseSchema = z.toJSONSchema(zodSchema);
-
-        return {
-          [statusCode]: {
-            description: `Response for status code ${statusCode}`,
-            content: {
-              [responseDef.dataType]: {
-                schema: responseSchema as OpenAPIV3.SchemaObject,
-              },
-            },
-          } as OpenAPIV3.ResponseObject,
-        };
-      } else {
-        return {
-          [statusCode]: {
-            description: `Response for status code ${statusCode}`,
-          } as OpenAPIV3.ResponseObject,
-        };
-      }
-    })
-    .reduce((acc, resp) => {
-      return { ...acc, ...resp };
-    }, {});
-
-  const operation: OpenAPIV3.OperationObject = {
-    operationId: meta.name,
-    summary: meta.description,
-    tags: [meta.group],
-    description: meta.description,
-    parameters: operationParameters,
-    ...requestBody,
-    responses,
-  };
-
-  const pathItem: OpenAPIV3.PathItemObject = {
-    [method.toLowerCase()]: operation,
-  };
-
-  return [openApiPath, pathItem];
-}
-
-export async function generateOpenApiDoc(targetPath: string) {
-  const definitions = await findEndpointDefinitions(targetPath);
-
-  const paths = definitions.reduce<OpenAPIV3.PathsObject>((acc, def) => {
-    const [openApiPath, pathItem] = translateToOpenAPIPathItem(def);
-
-    if (acc[openApiPath]) {
-      acc[openApiPath] = {
-        ...acc[openApiPath],
-        ...pathItem,
-      };
-    } else {
-      acc[openApiPath] = pathItem;
-    }
-
-    return acc;
-  }, {});
-
-  const openApiDocument: OpenAPIV3.Document = {
-    openapi: "3.0.0",
-    info: {
-      title: "Generated API",
-      version: "1.0.0",
-    },
-    paths: paths,
-  };
-
-  return openApiDocument;
-}

package/src/server/constants/HttpMethods.ts

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

package/src/server/constants/HttpStatusCodes.ts

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

package/src/server/handlers/api/EndpointDefinition.ts

@@ -1,24 +0,0 @@
-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/src/server/handlers/api/EndpointHandler.ts

@@ -1,24 +0,0 @@
-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/src/server/handlers/api/HandlerFormDefinition.spec.ts

@@ -1,120 +0,0 @@
-import { Request } from "express";
-import { describe, expectTypeOf, it } from "vitest";
-import z from "zod";
-import { HandlerForDefinition } from "./HandlerFromDefinition";
-
-describe("HandlerFromDefinition", () => {
-  it("can infer handler responses correctly (Empty)", () => {
-    type Handler = HandlerForDefinition<
-      "/test",
-      undefined,
-      undefined,
-      {
-        200: {};
-      }
-    >;
-
-    type Expected = (
-      request: Request<
-        undefined,
-        unknown,
-        undefined,
-        undefined,
-        Record<string, unknown>
-      >,
-    ) => Promise<
-      | {
-          code: 200;
-        }
-      | {
-          code: 500;
-        }
-    >;
-
-    expectTypeOf<Handler>().toEqualTypeOf<Expected>();
-  });
-
-  it("can infer handler responses correctly (Json)", () => {
-    const _data = z.object({
-      a: z.number(),
-    });
-
-    type Handler = HandlerForDefinition<
-      "/test",
-      undefined,
-      undefined,
-      {
-        200: {
-          dataType: "application/json";
-          dataSchema: typeof _data;
-        };
-      }
-    >;
-
-    type Expected = (
-      request: Request<
-        undefined,
-        unknown,
-        undefined,
-        undefined,
-        Record<string, unknown>
-      >,
-    ) => Promise<
-      | {
-          code: 200;
-          dataType: "application/json";
-          json: {
-            a: number;
-          };
-        }
-      | {
-          code: 500;
-        }
-    >;
-
-    expectTypeOf<Handler>().toEqualTypeOf<Expected>();
-  });
-
-  it("can infer handler responses correctly (Multiple)", () => {
-    const _data = z.object({
-      a: z.number(),
-    });
-
-    type Handler = HandlerForDefinition<
-      "/test",
-      undefined,
-      undefined,
-      {
-        200: {
-          dataType: "application/json";
-          dataSchema: typeof _data;
-        };
-        400: {};
-      }
-    >;
-
-    type Expected = (
-      request: Request<
-        undefined,
-        unknown,
-        undefined,
-        undefined,
-        Record<string, unknown>
-      >,
-    ) => Promise<
-      | {
-          code: 200;
-          dataType: "application/json";
-          json: {
-            a: number;
-          };
-        }
-      | { code: 400 }
-      | {
-          code: 500;
-        }
-    >;
-
-    expectTypeOf<Handler>().toEqualTypeOf<Expected>();
-  });
-});

package/src/server/handlers/api/HandlerFromDefinition.ts

@@ -1,33 +0,0 @@
-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/src/server/handlers/api/PathParameters.spec.ts

@@ -1,28 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-import { ExtractPathParams } from "./PathParameters";
-
-describe("ExtractPathParameters", () => {
-  it("can infer the parameter types of a path", () => {
-    type Path = "/test/path/with/:testId";
-    type ParamObject = ExtractPathParams<Path>;
-
-    expectTypeOf<ParamObject>().toEqualTypeOf<{ testId: string }>();
-  });
-
-  it("can infer multiple params", () => {
-    type Path = "/test/path/with/:testId/and/:otherId";
-    type ParamObject = ExtractPathParams<Path>;
-
-    expectTypeOf<ParamObject>().toEqualTypeOf<{
-      testId: string;
-      otherId: string;
-    }>();
-  });
-
-  it("can infer correctly if no param is present", () => {
-    type Path = "/test/path/without";
-    type ParamObject = ExtractPathParams<Path>;
-
-    expectTypeOf<ParamObject>().toEqualTypeOf<undefined>();
-  });
-});

package/src/server/handlers/api/PathParameters.ts

@@ -1,10 +0,0 @@
-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/src/server/handlers/api/createApiHandler.ts

@@ -1,44 +0,0 @@
-import { Request, Response } from "express";
-import expressAsyncHandler from "express-async-handler";
-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";
-import { isJsonResponse } from "./responses/jsonResponse";
-
-export 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>,
-) {
-  return {
-    __API_ENDPOINT_DEFINITION__: definition,
-    definition,
-    handler,
-  };
-}
-
-export function buildApiEndpointHandler(handler: ApiEndpointHandler) {
-  return expressAsyncHandler(async (request: Request, response: Response) => {
-    const result = await handler(request);
-
-    if (isJsonResponse(result)) {
-      response.status(result.code).json(result.json);
-    } else {
-      response.status(result.code).send();
-    }
-  });
-}

package/src/server/handlers/api/responses/emptyResponse.ts

@@ -1,12 +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/src/server/handlers/api/responses/index.ts

@@ -1,15 +0,0 @@
-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/src/server/handlers/api/responses/jsonResponse.ts

@@ -1,44 +0,0 @@
-import z from "zod";
-import { HttpStatusCode } from "../../../constants/HttpStatusCodes";
-import { hasValue } from "../../../utils/typeGuards";
-
-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 function isJsonResponseSchema(
-  value: unknown,
-): value is JsonResponseSchema {
-  return (
-    typeof value === "object" &&
-    hasValue(value) &&
-    "dataType" in value &&
-    value.dataType === "application/json"
-  );
-}
-export function isJsonResponse(value: unknown): value is JsonResponse {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "dataType" in value &&
-    value.dataType === "application/json"
-  );
-}

package/src/server/index.ts

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

package/src/server/middleware/logging.ts

@@ -1,41 +0,0 @@
-import colors from "colors/safe";
-import { NextFunction, Request, Response } from "express";
-import { Logger } from "../utils/logging";
-
-export function buildRequestLogger(logger: Logger, isInDevMode: boolean) {
-  return (req: Request, res: Response, next: NextFunction) => {
-    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: Logger, isInDevMode: boolean) {
-  return (req: Request, res: Response, next: NextFunction) => {
-    const originalSend = res.send;
-
-    res.json = function (body: unknown): Response {
-      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();
-  };
-}