@dokploy/trpc-openapi 0.0.2 → 0.0.3

package/src/generator/schema.ts

@@ -1,238 +0,0 @@
-// @ts-nocheck
-import { TRPCError } from "@trpc/server";
-import { OpenAPIV3 } from "openapi-types";
-import { z } from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
-
-import { OpenApiContentType } from "../types";
-import {
-	instanceofZodType,
-	instanceofZodTypeCoercible,
-	instanceofZodTypeLikeString,
-	instanceofZodTypeLikeVoid,
-	instanceofZodTypeObject,
-	instanceofZodTypeOptional,
-	unwrapZodType,
-	zodSupportsCoerce,
-} from "../utils/zod";
-
-const zodSchemaToOpenApiSchemaObject = (
-	zodSchema: z.ZodType,
-): OpenAPIV3.SchemaObject => {
-	// FIXME: https://github.com/StefanTerdell/zod-to-json-schema/issues/35
-	return zodToJsonSchema(zodSchema, {
-		target: "openApi3",
-		$refStrategy: "none",
-	}) as any;
-};
-
-export const getParameterObjects = (
-	currentSchema: unknown,
-	pathParameters: string[],
-	inType: "all" | "path" | "query",
-	example: Record<string, any> | undefined,
-): OpenAPIV3.ParameterObject[] | undefined => {
-	const schema = currentSchema ?? z.void();
-	const isRequired = !schema.isOptional();
-	const unwrappedSchema = unwrapZodType(schema, true);
-
-	if (
-		pathParameters.length === 0 &&
-		instanceofZodTypeLikeVoid(unwrappedSchema)
-	) {
-		return undefined;
-	}
-
-	if (!instanceofZodTypeObject(unwrappedSchema)) {
-		throw new TRPCError({
-			message: "Input parser must be a ZodObject",
-			code: "INTERNAL_SERVER_ERROR",
-		});
-	}
-
-	const shape = unwrappedSchema.shape;
-	const shapeKeys = Object.keys(shape);
-
-	for (const pathParameter of pathParameters) {
-		if (!shapeKeys.includes(pathParameter)) {
-			throw new TRPCError({
-				message: `Input parser expects key from path: "${pathParameter}"`,
-				code: "INTERNAL_SERVER_ERROR",
-			});
-		}
-	}
-
-	return shapeKeys
-		.filter((shapeKey) => {
-			const isPathParameter = pathParameters.includes(shapeKey);
-			if (inType === "path") {
-				return isPathParameter;
-			} else if (inType === "query") {
-				return !isPathParameter;
-			}
-			return true;
-		})
-		.map((shapeKey) => {
-			let shapeSchema = shape[shapeKey]!;
-			const isShapeRequired = !shapeSchema.isOptional();
-			const isPathParameter = pathParameters.includes(shapeKey);
-
-			if (!instanceofZodTypeLikeString(shapeSchema)) {
-				if (zodSupportsCoerce) {
-					if (!instanceofZodTypeCoercible(shapeSchema)) {
-						throw new TRPCError({
-							message: `Input parser key: "${shapeKey}" must be ZodString, ZodNumber, ZodBoolean, ZodBigInt or ZodDate`,
-							code: "INTERNAL_SERVER_ERROR",
-						});
-					}
-				} else {
-					throw new TRPCError({
-						message: `Input parser key: "${shapeKey}" must be ZodString`,
-						code: "INTERNAL_SERVER_ERROR",
-					});
-				}
-			}
-
-			if (instanceofZodTypeOptional(shapeSchema)) {
-				if (isPathParameter) {
-					throw new TRPCError({
-						message: `Path parameter: "${shapeKey}" must not be optional`,
-						code: "INTERNAL_SERVER_ERROR",
-					});
-				}
-				shapeSchema = shapeSchema.unwrap();
-			}
-
-			const { description, ...openApiSchemaObject } =
-				zodSchemaToOpenApiSchemaObject(shapeSchema);
-
-			return {
-				name: shapeKey,
-				in: isPathParameter ? "path" : "query",
-				required: isPathParameter || (isRequired && isShapeRequired),
-				schema: openApiSchemaObject,
-				description: description,
-				example: example?.[shapeKey],
-			};
-		});
-};
-
-export const getRequestBodyObject = (
-	currentSchema: unknown,
-	pathParameters: string[],
-	contentTypes: OpenApiContentType[],
-	example: Record<string, any> | undefined,
-): OpenAPIV3.RequestBodyObject | undefined => {
-	// if (!instanceofZodType(schema)) {
-	// 	throw new TRPCError({
-	// 		message: "Input parser expects a Zod validator",
-	// 		code: "INTERNAL_SERVER_ERROR",
-	// 	});
-	// }
-
-	const schema = currentSchema ?? z.void();
-
-	const isRequired = !schema.isOptional();
-	const unwrappedSchema = unwrapZodType(schema, true);
-
-	if (
-		pathParameters.length === 0 &&
-		instanceofZodTypeLikeVoid(unwrappedSchema)
-	) {
-		return undefined;
-	}
-
-	if (!instanceofZodTypeObject(unwrappedSchema)) {
-		throw new TRPCError({
-			message: "Input parser must be a ZodObject",
-			code: "INTERNAL_SERVER_ERROR",
-		});
-	}
-
-	// remove path parameters
-	const mask: Record<string, true> = {};
-	const dedupedExample = example && { ...example };
-	pathParameters.forEach((pathParameter) => {
-		mask[pathParameter] = true;
-		if (dedupedExample) {
-			delete dedupedExample[pathParameter];
-		}
-	});
-	const dedupedSchema = unwrappedSchema.omit(mask);
-
-	// if all keys are path parameters
-	if (
-		pathParameters.length > 0 &&
-		Object.keys(dedupedSchema.shape).length === 0
-	) {
-		return undefined;
-	}
-
-	const openApiSchemaObject = zodSchemaToOpenApiSchemaObject(dedupedSchema);
-	const content: OpenAPIV3.RequestBodyObject["content"] = {};
-	for (const contentType of contentTypes) {
-		content[contentType] = {
-			schema: openApiSchemaObject,
-			example: dedupedExample,
-		};
-	}
-
-	return {
-		required: isRequired,
-		content,
-	};
-};
-export const errorResponseObject: OpenAPIV3.ResponseObject = {
-	description: "Error response",
-	content: {
-		"application/json": {
-			schema: zodSchemaToOpenApiSchemaObject(
-				z.object({
-					message: z.string(),
-					code: z.string(),
-					issues: z.array(z.object({ message: z.string() })).optional(),
-				}),
-			),
-		},
-	},
-};
-
-export const getResponsesObject = (
-	schema: unknown,
-	example: Record<string, any> | undefined,
-	headers:
-		| Record<string, OpenAPIV3.HeaderObject | OpenAPIV3.ReferenceObject>
-		| undefined,
-): OpenAPIV3.ResponsesObject => {
-	// if (!instanceofZodType(schema)) {
-	//   throw new TRPCError({
-	//     message: 'Output parser expects a Zod validator',
-	//     code: 'INTERNAL_SERVER_ERROR',
-	//   });
-	// }
-
-	console.log(schema);
-
-	const successResponseObject: OpenAPIV3.ResponseObject = {
-		description: "Successful response",
-		headers: headers,
-		content: {
-			"application/json": {
-				...(schema && {
-					schema: zodSchemaToOpenApiSchemaObject(schema),
-				}),
-				// schema: zodSchemaToOpenApiSchemaObject(schema),
-				example,
-			},
-		},
-	};
-
-	// console.log(zodSchemaToOpenApiSchemaObject(schema));
-
-	return {
-		200: successResponseObject,
-		default: {
-			$ref: "#/components/responses/error",
-		},
-	};
-};

package/src/index.ts

@@ -1,42 +0,0 @@
-import {
-	CreateOpenApiExpressMiddlewareOptions,
-	CreateOpenApiHttpHandlerOptions,
-	CreateOpenApiNextHandlerOptions,
-	createOpenApiExpressMiddleware,
-	createOpenApiHttpHandler,
-	createOpenApiNextHandler,
-} from "./adapters";
-import {
-	GenerateOpenApiDocumentOptions,
-	generateOpenApiDocument,
-	openApiVersion,
-} from "./generator";
-import {
-	OpenApiErrorResponse,
-	OpenApiMeta,
-	OpenApiMethod,
-	OpenApiResponse,
-	OpenApiRouter,
-	OpenApiSuccessResponse,
-} from "./types";
-import { ZodTypeLikeString, ZodTypeLikeVoid } from "./utils/zod";
-
-export {
-	CreateOpenApiExpressMiddlewareOptions,
-	CreateOpenApiHttpHandlerOptions,
-	CreateOpenApiNextHandlerOptions,
-	createOpenApiExpressMiddleware,
-	createOpenApiHttpHandler,
-	createOpenApiNextHandler,
-	openApiVersion,
-	generateOpenApiDocument,
-	GenerateOpenApiDocumentOptions,
-	OpenApiRouter,
-	OpenApiMeta,
-	OpenApiMethod,
-	OpenApiResponse,
-	OpenApiSuccessResponse,
-	OpenApiErrorResponse,
-	ZodTypeLikeString,
-	ZodTypeLikeVoid,
-};

package/src/types.ts

@@ -1,79 +0,0 @@
-import { Procedure, ProcedureParams, Router } from '@trpc/server';
-import type { RootConfig } from '@trpc/server/dist/core/internals/config';
-import { TRPC_ERROR_CODE_KEY } from '@trpc/server/rpc';
-import type { RouterDef } from '@trpc/server/src/core/router';
-import { OpenAPIV3 } from 'openapi-types';
-import { ZodIssue } from 'zod';
-
-export type OpenApiMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
-
-type TRPCMeta = Record<string, unknown>;
-
-export type OpenApiContentType =
-  | 'application/json'
-  | 'application/x-www-form-urlencoded'
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  | (string & {});
-
-export type OpenApiMeta<TMeta = TRPCMeta> = TMeta & {
-  openapi?: {
-    enabled?: boolean;
-    method: OpenApiMethod;
-    path: `/${string}`;
-    summary?: string;
-    description?: string;
-    protect?: boolean;
-    tags?: string[];
-    headers?: (OpenAPIV3.ParameterBaseObject & { name: string; in?: 'header' })[];
-    contentTypes?: OpenApiContentType[];
-    deprecated?: boolean;
-    example?: {
-      request?: Record<string, any>;
-      response?: Record<string, any>;
-    };
-    responseHeaders?: Record<string, OpenAPIV3.HeaderObject | OpenAPIV3.ReferenceObject>;
-  };
-};
-
-export type OpenApiProcedure<TMeta = TRPCMeta> = Procedure<
-  'query' | 'mutation',
-  ProcedureParams<
-    RootConfig<{
-      transformer: any;
-      errorShape: any;
-      ctx: any;
-      meta: OpenApiMeta<TMeta>;
-    }>,
-    any,
-    any,
-    any,
-    any,
-    any,
-    OpenApiMeta<TMeta>
-  >
->;
-
-export type OpenApiProcedureRecord<TMeta = TRPCMeta> = Record<string, OpenApiProcedure<TMeta>>;
-
-export type OpenApiRouter<TMeta = TRPCMeta> = Router<
-  RouterDef<
-    RootConfig<{
-      transformer: any;
-      errorShape: any;
-      ctx: any;
-      meta: OpenApiMeta<TMeta>;
-    }>,
-    any,
-    any
-  >
->;
-
-export type OpenApiSuccessResponse<D = any> = D;
-
-export type OpenApiErrorResponse = {
-  message: string;
-  code: TRPC_ERROR_CODE_KEY;
-  issues?: ZodIssue[];
-};
-
-export type OpenApiResponse<D = any> = OpenApiSuccessResponse<D> | OpenApiErrorResponse;

package/src/utils/method.ts

@@ -1,8 +0,0 @@
-import { OpenApiMethod } from '../types';
-
-export const acceptsRequestBody = (method: OpenApiMethod) => {
-  if (method === 'GET' || method === 'DELETE') {
-    return false;
-  }
-  return true;
-};

package/src/utils/path.ts

@@ -1,12 +0,0 @@
-export const normalizePath = (path: string) => {
-  return `/${path.replace(/^\/|\/$/g, '')}`;
-};
-
-export const getPathParameters = (path: string) => {
-  return Array.from(path.matchAll(/\{(.+?)\}/g)).map(([_, key]) => key!);
-};
-
-export const getPathRegExp = (path: string) => {
-  const groupedExp = path.replace(/\{(.+?)\}/g, (_, key: string) => `(?<${key}>[^/]+)`);
-  return new RegExp(`^${groupedExp}$`, 'i');
-};

package/src/utils/procedure.ts

@@ -1,45 +0,0 @@
-// eslint-disable-next-line import/no-unresolved
-import { ProcedureType } from '@trpc/server';
-import { AnyZodObject, z } from 'zod';
-
-import { OpenApiMeta, OpenApiProcedure, OpenApiProcedureRecord } from '../types';
-
-const mergeInputs = (inputParsers: AnyZodObject[]): AnyZodObject => {
-  return inputParsers.reduce((acc, inputParser) => {
-    return acc.merge(inputParser);
-  }, z.object({}));
-};
-
-// `inputParser` & `outputParser` are private so this is a hack to access it
-export const getInputOutputParsers = (procedure: OpenApiProcedure) => {
-  const { inputs, output } = procedure._def;
-  return {
-    inputParser: inputs.length >= 2 ? mergeInputs(inputs as AnyZodObject[]) : inputs[0],
-    outputParser: output,
-  };
-};
-
-const getProcedureType = (procedure: OpenApiProcedure): ProcedureType => {
-  if (procedure._def.query) return 'query';
-  if (procedure._def.mutation) return 'mutation';
-  if (procedure._def.subscription) return 'subscription';
-  throw new Error('Unknown procedure type');
-};
-
-export const forEachOpenApiProcedure = (
-  procedureRecord: OpenApiProcedureRecord,
-  callback: (values: {
-    path: string;
-    type: ProcedureType;
-    procedure: OpenApiProcedure;
-    openapi: NonNullable<OpenApiMeta['openapi']>;
-  }) => void,
-) => {
-  for (const [path, procedure] of Object.entries(procedureRecord)) {
-    const { openapi } = procedure._def.meta ?? {};
-    if (openapi && openapi.enabled !== false) {
-      const type = getProcedureType(procedure);
-      callback({ path, type, procedure, openapi });
-    }
-  }
-};

package/src/utils/zod.ts

@@ -1,115 +0,0 @@
-import { z } from 'zod';
-
-export const instanceofZodType = (type: any): type is z.ZodTypeAny => {
-  return !!type?._def?.typeName;
-};
-
-export const instanceofZodTypeKind = <Z extends z.ZodFirstPartyTypeKind>(
-  type: z.ZodTypeAny,
-  zodTypeKind: Z,
-): type is InstanceType<typeof z[Z]> => {
-  return type?._def?.typeName === zodTypeKind;
-};
-
-export const instanceofZodTypeOptional = (
-  type: z.ZodTypeAny,
-): type is z.ZodOptional<z.ZodTypeAny> => {
-  return instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodOptional);
-};
-
-export const instanceofZodTypeObject = (type: z.ZodTypeAny): type is z.ZodObject<z.ZodRawShape> => {
-  return instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodObject);
-};
-
-export type ZodTypeLikeVoid = z.ZodVoid | z.ZodUndefined | z.ZodNever;
-
-export const instanceofZodTypeLikeVoid = (type: z.ZodTypeAny): type is ZodTypeLikeVoid => {
-  return (
-    instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodVoid) ||
-    instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodUndefined) ||
-    instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodNever)
-  );
-};
-
-export const unwrapZodType = (type: z.ZodTypeAny, unwrapPreprocess: boolean): z.ZodTypeAny => {
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodOptional)) {
-    return unwrapZodType(type.unwrap(), unwrapPreprocess);
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodDefault)) {
-    return unwrapZodType(type.removeDefault(), unwrapPreprocess);
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodLazy)) {
-    return unwrapZodType(type._def.getter(), unwrapPreprocess);
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodEffects)) {
-    if (type._def.effect.type === 'refinement') {
-      return unwrapZodType(type._def.schema, unwrapPreprocess);
-    }
-    if (type._def.effect.type === 'transform') {
-      return unwrapZodType(type._def.schema, unwrapPreprocess);
-    }
-    if (unwrapPreprocess && type._def.effect.type === 'preprocess') {
-      return unwrapZodType(type._def.schema, unwrapPreprocess);
-    }
-  }
-  return type;
-};
-
-type NativeEnumType = {
-  [k: string]: string | number;
-  [nu: number]: string;
-};
-
-export type ZodTypeLikeString =
-  | z.ZodString
-  | z.ZodOptional<ZodTypeLikeString>
-  | z.ZodDefault<ZodTypeLikeString>
-  | z.ZodEffects<ZodTypeLikeString, unknown, unknown>
-  | z.ZodUnion<[ZodTypeLikeString, ...ZodTypeLikeString[]]>
-  | z.ZodIntersection<ZodTypeLikeString, ZodTypeLikeString>
-  | z.ZodLazy<ZodTypeLikeString>
-  | z.ZodLiteral<string>
-  | z.ZodEnum<[string, ...string[]]>
-  | z.ZodNativeEnum<NativeEnumType>;
-
-export const instanceofZodTypeLikeString = (_type: z.ZodTypeAny): _type is ZodTypeLikeString => {
-  const type = unwrapZodType(_type, false);
-
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodEffects)) {
-    if (type._def.effect.type === 'preprocess') {
-      return true;
-    }
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodUnion)) {
-    return !type._def.options.some((option) => !instanceofZodTypeLikeString(option));
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodIntersection)) {
-    return (
-      instanceofZodTypeLikeString(type._def.left) && instanceofZodTypeLikeString(type._def.right)
-    );
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodLiteral)) {
-    return typeof type._def.value === 'string';
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodEnum)) {
-    return true;
-  }
-  if (instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodNativeEnum)) {
-    return !Object.values(type._def.values).some((value) => typeof value === 'number');
-  }
-  return instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodString);
-};
-
-export const zodSupportsCoerce = 'coerce' in z;
-
-export type ZodTypeCoercible = z.ZodNumber | z.ZodBoolean | z.ZodBigInt | z.ZodDate;
-
-export const instanceofZodTypeCoercible = (_type: z.ZodTypeAny): _type is ZodTypeCoercible => {
-  const type = unwrapZodType(_type, false);
-  return (
-    instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodNumber) ||
-    instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodBoolean) ||
-    instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodBigInt) ||
-    instanceofZodTypeKind(type, z.ZodFirstPartyTypeKind.ZodDate)
-  );
-};

package/test/adapters/express.test.ts

@@ -1,150 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { initTRPC } from '@trpc/server';
-import express from 'express';
-import fetch from 'node-fetch';
-import { z } from 'zod';
-
-import {
-  CreateOpenApiExpressMiddlewareOptions,
-  OpenApiMeta,
-  OpenApiRouter,
-  createOpenApiExpressMiddleware,
-} from '../../src';
-
-const createContextMock = jest.fn();
-const responseMetaMock = jest.fn();
-const onErrorMock = jest.fn();
-
-const clearMocks = () => {
-  createContextMock.mockClear();
-  responseMetaMock.mockClear();
-  onErrorMock.mockClear();
-};
-
-const createExpressServerWithRouter = <TRouter extends OpenApiRouter>(
-  handlerOpts: CreateOpenApiExpressMiddlewareOptions<TRouter>,
-  serverOpts?: { basePath?: `/${string}` },
-) => {
-  const openApiExpressMiddleware = createOpenApiExpressMiddleware({
-    router: handlerOpts.router,
-    createContext: handlerOpts.createContext ?? createContextMock,
-    responseMeta: handlerOpts.responseMeta ?? responseMetaMock,
-    onError: handlerOpts.onError ?? onErrorMock,
-    maxBodySize: handlerOpts.maxBodySize,
-  } as any);
-
-  const app = express();
-
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  app.use(serverOpts?.basePath ?? '/', openApiExpressMiddleware);
-
-  const server = app.listen(0);
-  const port = (server.address() as any).port as number;
-  const url = `http://localhost:${port}`;
-
-  return {
-    url,
-    close: () => server.close(),
-  };
-};
-
-const t = initTRPC.meta<OpenApiMeta>().context<any>().create();
-
-describe('express adapter', () => {
-  afterEach(() => {
-    clearMocks();
-  });
-
-  test('with valid routes', async () => {
-    const appRouter = t.router({
-      sayHelloQuery: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/say-hello' } })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ greeting: z.string() }))
-        .query(({ input }) => ({ greeting: `Hello ${input.name}!` })),
-      sayHelloMutation: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/say-hello' } })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ greeting: z.string() }))
-        .mutation(({ input }) => ({ greeting: `Hello ${input.name}!` })),
-      sayHelloSlash: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/say/hello' } })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ greeting: z.string() }))
-        .query(({ input }) => ({ greeting: `Hello ${input.name}!` })),
-    });
-
-    const { url, close } = createExpressServerWithRouter({
-      router: appRouter,
-    });
-
-    {
-      const res = await fetch(`${url}/say-hello?name=James`, { method: 'GET' });
-      const body = await res.json();
-
-      expect(res.status).toBe(200);
-      expect(body).toEqual({ greeting: 'Hello James!' });
-      expect(createContextMock).toHaveBeenCalledTimes(1);
-      expect(responseMetaMock).toHaveBeenCalledTimes(1);
-      expect(onErrorMock).toHaveBeenCalledTimes(0);
-
-      clearMocks();
-    }
-    {
-      const res = await fetch(`${url}/say-hello`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: 'James' }),
-      });
-      const body = await res.json();
-
-      expect(res.status).toBe(200);
-      expect(body).toEqual({ greeting: 'Hello James!' });
-      expect(createContextMock).toHaveBeenCalledTimes(1);
-      expect(responseMetaMock).toHaveBeenCalledTimes(1);
-      expect(onErrorMock).toHaveBeenCalledTimes(0);
-
-      clearMocks();
-    }
-    {
-      const res = await fetch(`${url}/say/hello?name=James`, { method: 'GET' });
-      const body = await res.json();
-
-      expect(res.status).toBe(200);
-      expect(body).toEqual({ greeting: 'Hello James!' });
-      expect(createContextMock).toHaveBeenCalledTimes(1);
-      expect(responseMetaMock).toHaveBeenCalledTimes(1);
-      expect(onErrorMock).toHaveBeenCalledTimes(0);
-    }
-
-    close();
-  });
-
-  test('with basePath', async () => {
-    const appRouter = t.router({
-      echo: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/echo' } })
-        .input(z.object({ payload: z.string() }))
-        .output(z.object({ payload: z.string(), context: z.undefined() }))
-        .query(({ input }) => ({ payload: input.payload })),
-    });
-
-    const { url, close } = createExpressServerWithRouter(
-      { router: appRouter },
-      { basePath: '/open-api' },
-    );
-
-    const res = await fetch(`${url}/open-api/echo?payload=jlalmes`, { method: 'GET' });
-    const body = await res.json();
-
-    expect(res.status).toBe(200);
-    expect(body).toEqual({
-      payload: 'jlalmes',
-    });
-    expect(createContextMock).toHaveBeenCalledTimes(1);
-    expect(responseMetaMock).toHaveBeenCalledTimes(1);
-    expect(onErrorMock).toHaveBeenCalledTimes(0);
-
-    close();
-  });
-});