add isArray to response-definition

Author: omermecitoglu

src/core/content.ts

@@ -1,16 +1,24 @@
 import zodToJsonSchema from "zod-to-json-schema";
 import type { RequestBodyObject } from "@omer-x/openapi-types/request-body";
+import type { SchemaObject } from "@omer-x/openapi-types/schema";
 import type { ZodType } from "zod";
 
-export function resolveContent(source?: ZodType<unknown> | string) {
+function resolveSchema(source: ZodType<unknown> | string, isArray: boolean = false): SchemaObject {
+  if (typeof source === "string") {
+    const refObject = { $ref: `#/components/schemas/${source}` } as SchemaObject;
+    if (isArray) {
+      return { type: "array", items: refObject } as SchemaObject;
+    }
+    return refObject;
+  }
+  return zodToJsonSchema(isArray ? source.array() : source, { target: "openApi3" }) as SchemaObject;
+}
+
+export function resolveContent(source?: ZodType<unknown> | string, isArray: boolean = false) {
   if (!source) return undefined;
   return {
     "application/json": {
-      schema: typeof source === "string" ? {
-        $ref: `#/components/schemas/${source}`,
-      } : zodToJsonSchema(source, {
-        target: "openApi3",
-      }),
+      schema: resolveSchema(source, isArray),
     },
   } as RequestBodyObject["content"];
 }

src/core/responses.ts

@@ -11,12 +11,13 @@ export function addBadRequest(queryParams?: unknown, requestBody?: unknown) {
 
 export function bundleResponses(collection: Record<string, ResponseDefinition>) {
   return Object.keys(collection).reduce((result, key) => {
+    const response = collection[key];
     return {
       ...result,
-      [key]: {
-        ...collection[key],
-        content: resolveContent(collection[key]?.content),
-      },
+      [key]: !response ? undefined : {
+        description: response.description,
+        content: resolveContent(response.content, response.isArray),
+      } satisfies ResponseObject,
     };
   }, {}) as ResponsesObject;
 }

src/index.ts

@@ -36,7 +36,7 @@ type RouteOptions<Method, PathParams, QueryParams, RequestBody> = {
 } & (RouteWithBody<RequestBody> | RouteWithoutBody);
 
 export default function createRoute<M extends HttpMethod, PP, QP, RB>(input: RouteOptions<M, PP, QP, RB>) {
-  const handler: RouteMethodHandler<RB, PP> = async (request, props) => {
+  const handler: RouteMethodHandler<PP> = async (request, props) => {
     try {
       const { searchParams } = new URL(request.url);
       const queryParams = parseSearchParams(searchParams, input.queryParams);
@@ -75,5 +75,5 @@ export default function createRoute<M extends HttpMethod, PP, QP, RB>(input: Rou
     responses: responses,
   };
 
-  return { [input.method]: handler } as RouteHandler<M, RB, PP>;
+  return { [input.method]: handler } as RouteHandler<M, PP>;
 }

src/types/next.ts

@@ -1,18 +1,17 @@
 import type { HttpMethod } from "./http";
-import type { FixedRequest } from "./request";
 import type { OperationObject } from "@omer-x/openapi-types/operation";
 
 type RouteHandlerProps<PathParams> = {
   params?: PathParams,
 };
 
-export type RouteMethodHandler<RequestBody, PathParams> = ((
-  request: FixedRequest<RequestBody>,
+export type RouteMethodHandler<PathParams> = ((
+  request: Request,
   props: RouteHandlerProps<PathParams>
 ) => Promise<Response>) & {
   apiData?: OperationObject,
 };
 
-export type RouteHandler<HM extends HttpMethod, RequestBody, PathParams> = {
-  [key in HM]: RouteMethodHandler<RequestBody, PathParams>;
+export type RouteHandler<HM extends HttpMethod, PathParams> = {
+  [key in HM]: RouteMethodHandler<PathParams>;
 };

src/types/response.ts

@@ -3,4 +3,5 @@ import type { ZodType } from "zod";
 export type ResponseDefinition = {
   description: string,
   content?: ZodType | string,
+  isArray?: boolean,
 };