@orpc/openapi 0.0.0-next.9588d75 → 0.0.0-next.9914009

package/dist/chunk-EVWWILO6.js

@@ -0,0 +1,25 @@
+import {
+  OpenAPIHandler
+} from "./chunk-X2HG5K4J.js";
+
+// src/adapters/fetch/openapi-handler-server.ts
+import { TrieRouter } from "hono/router/trie-router";
+var OpenAPIServerHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new TrieRouter(), router, options);
+  }
+};
+
+// src/adapters/fetch/openapi-handler-serverless.ts
+import { LinearRouter } from "hono/router/linear-router";
+var OpenAPIServerlessHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new LinearRouter(), router, options);
+  }
+};
+
+export {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+};
+//# sourceMappingURL=chunk-EVWWILO6.js.map

package/dist/chunk-KNYXLM77.js

@@ -0,0 +1,107 @@
+// src/json-serializer.ts
+import { isPlainObject } from "@orpc/shared";
+var JSONSerializer = class {
+  serialize(payload) {
+    if (payload instanceof Set)
+      return this.serialize([...payload]);
+    if (payload instanceof Map)
+      return this.serialize([...payload.entries()]);
+    if (Array.isArray(payload)) {
+      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
+    }
+    if (Number.isNaN(payload))
+      return "NaN";
+    if (typeof payload === "bigint")
+      return payload.toString();
+    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
+      return "Invalid Date";
+    }
+    if (payload instanceof RegExp)
+      return payload.toString();
+    if (payload instanceof URL)
+      return payload.toString();
+    if (!isPlainObject(payload))
+      return payload;
+    return Object.keys(payload).reduce(
+      (carry, key) => {
+        const val = payload[key];
+        carry[key] = this.serialize(val);
+        return carry;
+      },
+      {}
+    );
+  }
+};
+
+// src/utils.ts
+import { isContractProcedure } from "@orpc/contract";
+import { getRouterContract, isLazy, isProcedure, unlazy } from "@orpc/server";
+function forEachContractProcedure(options, callback, result = [], isCurrentRouterContract = false) {
+  const hiddenContract = getRouterContract(options.router);
+  if (!isCurrentRouterContract && hiddenContract) {
+    return forEachContractProcedure(
+      {
+        path: options.path,
+        router: hiddenContract
+      },
+      callback,
+      result,
+      true
+    );
+  }
+  if (isLazy(options.router)) {
+    result.push({
+      router: options.router,
+      path: options.path
+    });
+  } else if (isProcedure(options.router)) {
+    callback({
+      contract: options.router["~orpc"].contract,
+      path: options.path
+    });
+  } else if (isContractProcedure(options.router)) {
+    callback({
+      contract: options.router,
+      path: options.path
+    });
+  } else {
+    for (const key in options.router) {
+      forEachContractProcedure(
+        {
+          router: options.router[key],
+          path: [...options.path, key]
+        },
+        callback,
+        result
+      );
+    }
+  }
+  return result;
+}
+async function forEachAllContractProcedure(router, callback) {
+  const pending = [{
+    path: [],
+    router
+  }];
+  for (const item of pending) {
+    const lazies = forEachContractProcedure(item, callback);
+    for (const lazy of lazies) {
+      const { default: router2 } = await unlazy(lazy.router);
+      pending.push({
+        path: lazy.path,
+        router: router2
+      });
+    }
+  }
+}
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+
+export {
+  JSONSerializer,
+  forEachContractProcedure,
+  forEachAllContractProcedure,
+  standardizeHTTPPath
+};
+//# sourceMappingURL=chunk-KNYXLM77.js.map

package/dist/{chunk-UPDKQRQG.js → chunk-X2HG5K4J.js}

@@ -1,4 +1,10 @@
-// src/fetch/bracket-notation.ts
+import {
+  JSONSerializer,
+  forEachContractProcedure,
+  standardizeHTTPPath
+} from "./chunk-KNYXLM77.js";
+
+// src/adapters/fetch/bracket-notation.ts
 import { isPlainObject } from "@orpc/shared";
 function serialize(payload, parentKey = "") {
   if (!Array.isArray(payload) && !isPlainObject(payload))
@@ -207,21 +213,9 @@ function parsePath(path) {
   return result;
 }
 
-// src/fetch/input-builder-full.ts
-var InputBuilderFull = class {
-  build(params, query, headers, body) {
-    return {
-      params,
-      query,
-      headers,
-      body
-    };
-  }
-};
-
-// src/fetch/input-builder-simple.ts
+// src/adapters/fetch/input-structure-compact.ts
 import { isPlainObject as isPlainObject2 } from "@orpc/shared";
-var InputBuilderSimple = class {
+var InputStructureCompact = class {
   build(params, payload) {
     if (Object.keys(params).length === 0) {
       return payload;
@@ -236,17 +230,28 @@ var InputBuilderSimple = class {
   }
 };
 
-// src/fetch/openapi-handler.ts
-import { createProcedureClient, ORPCError as ORPCError2 } from "@orpc/server";
-import { executeWithHooks, ORPC_HANDLER_HEADER, trim } from "@orpc/shared";
+// src/adapters/fetch/input-structure-detailed.ts
+var InputStructureDetailed = class {
+  build(params, query, headers, body) {
+    return {
+      params,
+      query,
+      headers,
+      body
+    };
+  }
+};
 
-// src/fetch/openapi-payload-codec.ts
+// src/adapters/fetch/openapi-payload-codec.ts
 import { ORPCError } from "@orpc/server";
-import { findDeepMatches, isPlainObject as isPlainObject3 } from "@orpc/shared";
+import { findDeepMatches } from "@orpc/shared";
 import cd from "content-disposition";
 import { safeParse } from "fast-content-type-parse";
 import wcmatch from "wildcard-match";
 var OpenAPIPayloadCodec = class {
+  constructor(jsonSerializer) {
+    this.jsonSerializer = jsonSerializer;
+  }
   encode(payload, accept) {
     const typeMatchers = (accept?.split(",").map(safeParse) ?? [{ type: "*/*" }]).map(({ type }) => wcmatch(type));
     if (payload instanceof Blob) {
@@ -264,7 +269,7 @@ var OpenAPIPayloadCodec = class {
         };
       }
     }
-    const handledPayload = this.serialize(payload);
+    const handledPayload = this.jsonSerializer.serialize(payload);
     const hasBlobs = findDeepMatches((v) => v instanceof Blob, handledPayload).values.length > 0;
     const isExpectedMultipartFormData = typeMatchers.some(
       (isMatch) => isMatch("multipart/form-data")
@@ -345,129 +350,60 @@ var OpenAPIPayloadCodec = class {
       })
     };
   }
-  serialize(payload) {
-    if (payload instanceof Set)
-      return this.serialize([...payload]);
-    if (payload instanceof Map)
-      return this.serialize([...payload.entries()]);
-    if (Array.isArray(payload)) {
-      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
-    }
-    if (Number.isNaN(payload))
-      return "NaN";
-    if (typeof payload === "bigint")
-      return payload.toString();
-    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
-      return "Invalid Date";
-    }
-    if (payload instanceof RegExp)
-      return payload.toString();
-    if (payload instanceof URL)
-      return payload.toString();
-    if (!isPlainObject3(payload))
-      return payload;
-    return Object.keys(payload).reduce(
-      (carry, key) => {
-        const val = payload[key];
-        carry[key] = this.serialize(val);
-        return carry;
-      },
-      {}
-    );
-  }
   async decode(re) {
-    if (re instanceof Headers || re instanceof URLSearchParams || re instanceof FormData) {
-      return deserialize([...re.entries()]);
-    }
-    const contentType = re.headers.get("content-type");
-    const contentDisposition = re.headers.get("content-disposition");
-    const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
-    if (fileName) {
-      const blob2 = await re.blob();
-      const file = new File([blob2], fileName, {
-        type: blob2.type
-      });
-      return file;
-    }
-    if (!contentType || contentType.startsWith("application/json")) {
-      if (!re.body) {
-        return void 0;
+    try {
+      if (re instanceof Headers || re instanceof URLSearchParams || re instanceof FormData) {
+        return deserialize([...re.entries()]);
       }
-      return await re.json();
-    }
-    if (contentType.startsWith("application/x-www-form-urlencoded")) {
-      const params = new URLSearchParams(await re.text());
-      return this.decode(params);
-    }
-    if (contentType.startsWith("text/")) {
-      const text = await re.text();
-      return text;
-    }
-    if (contentType.startsWith("multipart/form-data")) {
-      const form = await re.formData();
-      return this.decode(form);
+      const contentType = re.headers.get("content-type");
+      const contentDisposition = re.headers.get("content-disposition");
+      const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+      if (fileName) {
+        const blob2 = await re.blob();
+        const file = new File([blob2], fileName, {
+          type: blob2.type
+        });
+        return file;
+      }
+      if (!contentType || contentType.startsWith("application/json")) {
+        if (!re.body) {
+          return void 0;
+        }
+        const text = await re.text();
+        if (!text) {
+          return void 0;
+        }
+        return JSON.parse(text);
+      }
+      if (contentType.startsWith("application/x-www-form-urlencoded")) {
+        const params = new URLSearchParams(await re.text());
+        return this.decode(params);
+      }
+      if (contentType.startsWith("text/")) {
+        const text = await re.text();
+        return text;
+      }
+      if (contentType.startsWith("multipart/form-data")) {
+        const form = await re.formData();
+        return this.decode(form);
+      }
+      const blob = await re.blob();
+      return new File([blob], "blob", {
+        type: blob.type
+      });
+    } catch (e) {
+      throw new ORPCError({
+        code: "BAD_REQUEST",
+        message: "Cannot parse request/response. Please check the request/response body and Content-Type header.",
+        cause: e
+      });
     }
-    const blob = await re.blob();
-    return new File([blob], "blob", {
-      type: blob.type
-    });
   }
 };
 
-// src/fetch/openapi-procedure-matcher.ts
-import { getLazyRouterPrefix, getRouterChild, isProcedure as isProcedure2, unlazy } from "@orpc/server";
+// src/adapters/fetch/openapi-procedure-matcher.ts
+import { fallbackToGlobalConfig, getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
 import { mapValues } from "@orpc/shared";
-
-// src/utils.ts
-import { isContractProcedure } from "@orpc/contract";
-import { getRouterContract, isLazy, isProcedure } from "@orpc/server";
-function forEachContractProcedure(options, callback, result = [], isCurrentRouterContract = false) {
-  const hiddenContract = getRouterContract(options.router);
-  if (!isCurrentRouterContract && hiddenContract) {
-    return forEachContractProcedure(
-      {
-        path: options.path,
-        router: hiddenContract
-      },
-      callback,
-      result,
-      true
-    );
-  }
-  if (isLazy(options.router)) {
-    result.push({
-      router: options.router,
-      path: options.path
-    });
-  } else if (isProcedure(options.router)) {
-    callback({
-      contract: options.router["~orpc"].contract,
-      path: options.path
-    });
-  } else if (isContractProcedure(options.router)) {
-    callback({
-      contract: options.router,
-      path: options.path
-    });
-  } else {
-    for (const key in options.router) {
-      forEachContractProcedure(
-        {
-          router: options.router[key],
-          path: [...options.path, key]
-        },
-        callback,
-        result
-      );
-    }
-  }
-  return result;
-}
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-
-// src/fetch/openapi-procedure-matcher.ts
 var OpenAPIProcedureMatcher = class {
   constructor(hono, router) {
     this.hono = hono;
@@ -498,7 +434,7 @@ var OpenAPIProcedureMatcher = class {
       (v) => paramStash[v]
     ) : match[1];
     const { default: maybeProcedure } = await unlazy(getRouterChild(this.router, ...path));
-    if (!isProcedure2(maybeProcedure)) {
+    if (!isProcedure(maybeProcedure)) {
       return void 0;
     }
     return {
@@ -510,7 +446,7 @@ var OpenAPIProcedureMatcher = class {
   }
   add(path, router) {
     const lazies = forEachContractProcedure({ path, router }, ({ path: path2, contract }) => {
-      const method = contract["~orpc"].route?.method ?? "POST";
+      const method = fallbackToGlobalConfig("defaultMethod", contract["~orpc"].route?.method);
       const httpPath = contract["~orpc"].route?.path ? this.convertOpenAPIPathToRouterPath(contract["~orpc"].route?.path) : `/${path2.map(encodeURIComponent).join("/")}`;
       this.hono.add(method, httpPath, [httpPath, path2]);
     });
@@ -534,7 +470,7 @@ var OpenAPIProcedureMatcher = class {
   }
 };
 
-// src/fetch/schema-coercer.ts
+// src/adapters/fetch/schema-coercer.ts
 var CompositeSchemaCoercer = class {
   constructor(coercers) {
     this.coercers = coercers;
@@ -548,49 +484,52 @@ var CompositeSchemaCoercer = class {
   }
 };
 
-// src/fetch/openapi-handler.ts
+// src/adapters/fetch/openapi-handler.ts
+import { createProcedureClient, fallbackToGlobalConfig as fallbackToGlobalConfig2, ORPCError as ORPCError2 } from "@orpc/server";
+import { executeWithHooks, isPlainObject as isPlainObject3, trim } from "@orpc/shared";
 var OpenAPIHandler = class {
   constructor(hono, router, options) {
     this.options = options;
+    const jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
     this.procedureMatcher = options?.procedureMatcher ?? new OpenAPIProcedureMatcher(hono, router);
-    this.payloadCodec = options?.payloadCodec ?? new OpenAPIPayloadCodec();
-    this.inputBuilderSimple = options?.inputBuilderSimple ?? new InputBuilderSimple();
-    this.inputBuilderFull = options?.inputBuilderFull ?? new InputBuilderFull();
+    this.payloadCodec = options?.payloadCodec ?? new OpenAPIPayloadCodec(jsonSerializer);
+    this.inputStructureCompact = options?.inputBuilderSimple ?? new InputStructureCompact();
+    this.inputStructureDetailed = options?.inputBuilderFull ?? new InputStructureDetailed();
     this.compositeSchemaCoercer = new CompositeSchemaCoercer(options?.schemaCoercers ?? []);
   }
   procedureMatcher;
   payloadCodec;
-  inputBuilderSimple;
-  inputBuilderFull;
+  inputStructureCompact;
+  inputStructureDetailed;
   compositeSchemaCoercer;
-  condition(request) {
-    return request.headers.get(ORPC_HANDLER_HEADER) === null;
-  }
-  async fetch(request, ...[options]) {
+  async handle(request, ...[options]) {
     const context = options?.context;
     const headers = request.headers;
-    const accept = headers.get("Accept") || void 0;
+    const accept = headers.get("accept") || void 0;
     const execute = async () => {
       const url = new URL(request.url);
       const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
       const query = url.searchParams;
       const customMethod = request.method === "POST" ? query.get("method")?.toUpperCase() : void 0;
-      const method = customMethod || request.method;
-      const match = await this.procedureMatcher.match(method, pathname);
-      if (!match) {
-        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
+      const matchedMethod = customMethod || request.method;
+      const matched = await this.procedureMatcher.match(matchedMethod, pathname);
+      if (!matched) {
+        return { matched: false, response: void 0 };
       }
-      const decodedPayload = request.method === "GET" ? await this.payloadCodec.decode(query) : await this.payloadCodec.decode(request);
-      const input = this.inputBuilderSimple.build(match.params, decodedPayload);
-      const coercedInput = this.compositeSchemaCoercer.coerce(match.procedure["~orpc"].contract["~orpc"].InputSchema, input);
-      const client = createProcedureClient({
+      const contractDef = matched.procedure["~orpc"].contract["~orpc"];
+      const input = await this.decodeInput(matched.procedure, matched.params, request);
+      const coercedInput = this.compositeSchemaCoercer.coerce(contractDef.InputSchema, input);
+      const client = createProcedureClient(matched.procedure, {
         context,
-        procedure: match.procedure,
-        path: match.path
+        path: matched.path
+      });
+      const output = await client(coercedInput, { signal: request.signal });
+      const { body, headers: resHeaders } = this.encodeOutput(matched.procedure, output, accept);
+      const response = new Response(body, {
+        headers: resHeaders,
+        status: fallbackToGlobalConfig2("defaultSuccessStatus", contractDef.route?.successStatus)
       });
-      const output = await client(coercedInput, { signal: options?.signal });
-      const { body, headers: headers2 } = this.payloadCodec.encode(output);
-      return new Response(body, { headers: headers2 });
+      return { matched: true, response };
     };
     try {
       return await executeWithHooks({
@@ -599,27 +538,94 @@ var OpenAPIHandler = class {
         input: request,
         hooks: this.options,
         meta: {
-          signal: options?.signal
+          signal: request.signal
         }
       });
     } catch (e) {
       const error = this.convertToORPCError(e);
       try {
         const { body, headers: headers2 } = this.payloadCodec.encode(error.toJSON(), accept);
-        return new Response(body, {
+        const response = new Response(body, {
           status: error.status,
           headers: headers2
         });
+        return { matched: true, response };
       } catch (e2) {
         const error2 = this.convertToORPCError(e2);
-        const { body, headers: headers2 } = this.payloadCodec.encode(error2.toJSON());
-        return new Response(body, {
+        const { body, headers: headers2 } = this.payloadCodec.encode(error2.toJSON(), void 0);
+        const response = new Response(body, {
           status: error2.status,
           headers: headers2
         });
+        return { matched: true, response };
       }
     }
   }
+  async decodeInput(procedure, params, request) {
+    const inputStructure = fallbackToGlobalConfig2("defaultInputStructure", procedure["~orpc"].contract["~orpc"].route?.inputStructure);
+    const url = new URL(request.url);
+    const query = url.searchParams;
+    const headers = request.headers;
+    if (inputStructure === "compact") {
+      return this.inputStructureCompact.build(
+        params,
+        request.method === "GET" ? await this.payloadCodec.decode(query) : await this.payloadCodec.decode(request)
+      );
+    }
+    const decodedQuery = await this.payloadCodec.decode(query);
+    const decodedHeaders = await this.payloadCodec.decode(headers);
+    const decodedBody = await this.payloadCodec.decode(request);
+    return this.inputStructureDetailed.build(params, decodedQuery, decodedHeaders, decodedBody);
+  }
+  encodeOutput(procedure, output, accept) {
+    const outputStructure = fallbackToGlobalConfig2("defaultOutputStructure", procedure["~orpc"].contract["~orpc"].route?.outputStructure);
+    if (outputStructure === "compact") {
+      return this.payloadCodec.encode(output, accept);
+    }
+    this.assertDetailedOutput(output);
+    const headers = new Headers();
+    if (output.headers) {
+      for (const [key, value] of Object.entries(output.headers)) {
+        headers.append(key, value);
+      }
+    }
+    const { body, headers: encodedHeaders } = this.payloadCodec.encode(output.body, accept);
+    if (encodedHeaders) {
+      for (const [key, value] of encodedHeaders.entries()) {
+        headers.append(key, value);
+      }
+    }
+    return { body, headers };
+  }
+  assertDetailedOutput(output) {
+    const error = new Error(`
+      Invalid output structure for 'detailed' output. 
+      Expected format:
+      {
+        body?: unknown;       // The main response content (optional)
+        headers?: {           // Additional headers (optional)
+          [key: string]: string;
+        };
+      }
+
+      Example:
+      {
+        body: { message: "Success" },
+        headers: { "X-Custom-Header": "Custom-Value" },
+      }
+
+      Fix: Ensure your output matches the expected structure.
+    `);
+    if (!isPlainObject3(output) || Object.keys(output).some((key) => key !== "body" && key !== "headers")) {
+      throw error;
+    }
+    if (output.headers !== void 0 && !isPlainObject3(output.headers)) {
+      throw error;
+    }
+    if (output.headers && Object.entries(output.headers).some(([key, value]) => typeof key !== "string" || typeof value !== "string")) {
+      throw error;
+    }
+  }
   convertToORPCError(e) {
     return e instanceof ORPCError2 ? e : new ORPCError2({
       code: "INTERNAL_SERVER_ERROR",
@@ -629,37 +635,17 @@ var OpenAPIHandler = class {
   }
 };
 
-// src/fetch/openapi-handler-server.ts
-import { TrieRouter } from "hono/router/trie-router";
-var OpenAPIServerHandler = class extends OpenAPIHandler {
-  constructor(router, options) {
-    super(new TrieRouter(), router, options);
-  }
-};
-
-// src/fetch/openapi-handler-serverless.ts
-import { LinearRouter } from "hono/router/linear-router";
-var OpenAPIServerlessHandler = class extends OpenAPIHandler {
-  constructor(router, options) {
-    super(new LinearRouter(), router, options);
-  }
-};
-
 export {
   serialize,
   deserialize,
   escapeSegment,
   stringifyPath,
   parsePath,
-  InputBuilderFull,
-  InputBuilderSimple,
+  InputStructureCompact,
+  InputStructureDetailed,
   OpenAPIPayloadCodec,
-  forEachContractProcedure,
-  standardizeHTTPPath,
   OpenAPIProcedureMatcher,
   CompositeSchemaCoercer,
-  OpenAPIHandler,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler
+  OpenAPIHandler
 };
-//# sourceMappingURL=chunk-UPDKQRQG.js.map
+//# sourceMappingURL=chunk-X2HG5K4J.js.map

package/dist/fetch.js

@@ -1,22 +1,25 @@
+import {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-EVWWILO6.js";
 import {
   CompositeSchemaCoercer,
-  InputBuilderFull,
-  InputBuilderSimple,
+  InputStructureCompact,
+  InputStructureDetailed,
   OpenAPIHandler,
   OpenAPIPayloadCodec,
   OpenAPIProcedureMatcher,
-  OpenAPIServerHandler,
-  OpenAPIServerlessHandler,
   deserialize,
   escapeSegment,
   parsePath,
   serialize,
   stringifyPath
-} from "./chunk-UPDKQRQG.js";
+} from "./chunk-X2HG5K4J.js";
+import "./chunk-KNYXLM77.js";
 export {
   CompositeSchemaCoercer,
-  InputBuilderFull,
-  InputBuilderSimple,
+  InputStructureCompact,
+  InputStructureDetailed,
   OpenAPIHandler,
   OpenAPIPayloadCodec,
   OpenAPIProcedureMatcher,