@orpc/openapi 0.34.0 → 0.35.0

package/dist/chunk-SOVQ5ARD.js

@@ -1,650 +0,0 @@
-import {
-  JSONSerializer,
-  forEachContractProcedure,
-  standardizeHTTPPath
-} from "./chunk-Q2LSK6YZ.js";
-
-// src/adapters/fetch/bracket-notation.ts
-import { isPlainObject } from "@orpc/shared";
-function serialize(payload, parentKey = "") {
-  if (!Array.isArray(payload) && !isPlainObject(payload))
-    return [["", payload]];
-  const result = [];
-  function helper(value, path) {
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        helper(item, [...path, String(index)]);
-      });
-    } else if (isPlainObject(value)) {
-      for (const [key, val] of Object.entries(value)) {
-        helper(val, [...path, key]);
-      }
-    } else {
-      result.push([stringifyPath(path), value]);
-    }
-  }
-  helper(payload, parentKey ? [parentKey] : []);
-  return result;
-}
-function deserialize(entities) {
-  if (entities.length === 0) {
-    return void 0;
-  }
-  const isRootArray = entities.every(([path]) => path === "");
-  const result = isRootArray ? [] : {};
-  const arrayPushPaths = /* @__PURE__ */ new Set();
-  for (const [path, _] of entities) {
-    const segments = parsePath(path);
-    const base = segments.slice(0, -1).join(".");
-    const last = segments[segments.length - 1];
-    if (last === "") {
-      arrayPushPaths.add(base);
-    } else {
-      arrayPushPaths.delete(base);
-    }
-  }
-  function setValue(obj, segments, value, fullPath) {
-    const [first, ...rest_] = segments;
-    if (Array.isArray(obj) && first === "") {
-      ;
-      obj.push(value);
-      return;
-    }
-    const objAsRecord = obj;
-    if (rest_.length === 0) {
-      objAsRecord[first] = value;
-      return;
-    }
-    const rest = rest_;
-    if (rest[0] === "") {
-      const pathToCheck = segments.slice(0, -1).join(".");
-      if (rest.length === 1 && arrayPushPaths.has(pathToCheck)) {
-        if (!(first in objAsRecord)) {
-          objAsRecord[first] = [];
-        }
-        if (Array.isArray(objAsRecord[first])) {
-          ;
-          objAsRecord[first].push(value);
-          return;
-        }
-      }
-      if (!(first in objAsRecord)) {
-        objAsRecord[first] = {};
-      }
-      const target = objAsRecord[first];
-      target[""] = value;
-      return;
-    }
-    if (!(first in objAsRecord)) {
-      objAsRecord[first] = {};
-    }
-    setValue(
-      objAsRecord[first],
-      rest,
-      value,
-      fullPath
-    );
-  }
-  for (const [path, value] of entities) {
-    const segments = parsePath(path);
-    setValue(result, segments, value, path);
-  }
-  return result;
-}
-function escapeSegment(segment) {
-  return segment.replace(/[\\[\]]/g, (match) => {
-    switch (match) {
-      case "\\":
-        return "\\\\";
-      case "[":
-        return "\\[";
-      case "]":
-        return "\\]";
-      default:
-        return match;
-    }
-  });
-}
-function stringifyPath(path) {
-  const [first, ...rest] = path;
-  const firstSegment = escapeSegment(first);
-  const base = first === "" ? "" : firstSegment;
-  return rest.reduce(
-    (result, segment) => `${result}[${escapeSegment(segment)}]`,
-    base
-  );
-}
-function parsePath(path) {
-  if (path === "")
-    return [""];
-  const result = [];
-  let currentSegment = "";
-  let inBracket = false;
-  let bracketContent = "";
-  let backslashCount = 0;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    if (char === "\\") {
-      backslashCount++;
-      continue;
-    }
-    if (backslashCount > 0) {
-      const literalBackslashes = "\\".repeat(Math.floor(backslashCount / 2));
-      if (char === "[" || char === "]") {
-        if (backslashCount % 2 === 1) {
-          if (inBracket) {
-            bracketContent += literalBackslashes + char;
-          } else {
-            currentSegment += literalBackslashes + char;
-          }
-        } else {
-          if (inBracket) {
-            bracketContent += literalBackslashes;
-          } else {
-            currentSegment += literalBackslashes;
-          }
-          if (char === "[" && !inBracket) {
-            if (currentSegment !== "" || result.length === 0) {
-              result.push(currentSegment);
-            }
-            inBracket = true;
-            bracketContent = "";
-            currentSegment = "";
-          } else if (char === "]" && inBracket) {
-            result.push(bracketContent);
-            inBracket = false;
-            bracketContent = "";
-          } else {
-            if (inBracket) {
-              bracketContent += char;
-            } else {
-              currentSegment += char;
-            }
-          }
-        }
-      } else {
-        const allBackslashes = "\\".repeat(backslashCount);
-        if (inBracket) {
-          bracketContent += allBackslashes + char;
-        } else {
-          currentSegment += allBackslashes + char;
-        }
-      }
-      backslashCount = 0;
-      continue;
-    }
-    if (char === "[" && !inBracket) {
-      if (currentSegment !== "" || result.length === 0) {
-        result.push(currentSegment);
-      }
-      inBracket = true;
-      bracketContent = "";
-      currentSegment = "";
-      continue;
-    }
-    if (char === "]" && inBracket) {
-      result.push(bracketContent);
-      inBracket = false;
-      bracketContent = "";
-      continue;
-    }
-    if (inBracket) {
-      bracketContent += char;
-    } else {
-      currentSegment += char;
-    }
-  }
-  if (backslashCount > 0) {
-    const remainingBackslashes = "\\".repeat(backslashCount);
-    if (inBracket) {
-      bracketContent += remainingBackslashes;
-    } else {
-      currentSegment += remainingBackslashes;
-    }
-  }
-  if (inBracket) {
-    if (currentSegment !== "" || result.length === 0) {
-      result.push(currentSegment);
-    }
-    result.push(`[${bracketContent}`);
-  } else if (currentSegment !== "" || result.length === 0) {
-    result.push(currentSegment);
-  }
-  return result;
-}
-
-// src/adapters/fetch/input-structure-compact.ts
-import { isPlainObject as isPlainObject2 } from "@orpc/shared";
-var InputStructureCompact = class {
-  build(params, payload) {
-    if (Object.keys(params).length === 0) {
-      return payload;
-    }
-    if (!isPlainObject2(payload)) {
-      return params;
-    }
-    return {
-      ...params,
-      ...payload
-    };
-  }
-};
-
-// src/adapters/fetch/input-structure-detailed.ts
-var InputStructureDetailed = class {
-  build(params, query, headers, body) {
-    return {
-      params,
-      query,
-      headers,
-      body
-    };
-  }
-};
-
-// src/adapters/fetch/openapi-payload-codec.ts
-import { ORPCError } from "@orpc/server";
-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) {
-      const contentType = payload.type || "application/octet-stream";
-      if (typeMatchers.some((isMatch) => isMatch(contentType))) {
-        const headers = new Headers({
-          "Content-Type": contentType
-        });
-        if (payload instanceof File && payload.name) {
-          headers.append("Content-Disposition", cd(payload.name));
-        }
-        return {
-          body: payload,
-          headers
-        };
-      }
-    }
-    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")
-    );
-    if (hasBlobs && isExpectedMultipartFormData) {
-      return this.encodeAsFormData(handledPayload);
-    }
-    if (typeMatchers.some((isMatch) => isMatch("application/json"))) {
-      return this.encodeAsJSON(handledPayload);
-    }
-    if (typeMatchers.some(
-      (isMatch) => isMatch("application/x-www-form-urlencoded")
-    )) {
-      return this.encodeAsURLSearchParams(handledPayload);
-    }
-    if (isExpectedMultipartFormData) {
-      return this.encodeAsFormData(handledPayload);
-    }
-    throw new ORPCError("NOT_ACCEPTABLE", {
-      message: `Unsupported content-type: ${accept}`
-    });
-  }
-  encodeAsJSON(payload) {
-    if (payload === void 0) {
-      return {
-        body: void 0,
-        headers: new Headers({
-          "content-type": "application/json"
-        })
-      };
-    }
-    return {
-      body: JSON.stringify(payload),
-      headers: new Headers({
-        "content-type": "application/json"
-      })
-    };
-  }
-  encodeAsFormData(payload) {
-    const form = new FormData();
-    for (const [path, value] of serialize(payload)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        form.append(path, value.toString());
-      } else if (value === null) {
-        form.append(path, "null");
-      } else if (value instanceof Date) {
-        form.append(
-          path,
-          Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()
-        );
-      } else if (value instanceof Blob) {
-        form.append(path, value);
-      }
-    }
-    return {
-      body: form
-    };
-  }
-  encodeAsURLSearchParams(payload) {
-    const params = new URLSearchParams();
-    for (const [path, value] of serialize(payload)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        params.append(path, value.toString());
-      } else if (value === null) {
-        params.append(path, "null");
-      } else if (value instanceof Date) {
-        params.append(
-          path,
-          Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()
-        );
-      }
-    }
-    return {
-      body: params.toString(),
-      headers: new Headers({
-        "content-type": "application/x-www-form-urlencoded"
-      })
-    };
-  }
-  async decode(re) {
-    try {
-      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;
-        }
-        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("BAD_REQUEST", {
-        message: "Cannot parse request/response. Please check the request/response body and Content-Type header.",
-        cause: e
-      });
-    }
-  }
-};
-
-// src/adapters/fetch/openapi-procedure-matcher.ts
-import { fallbackContractConfig } from "@orpc/contract";
-import { getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
-import { mapValues } from "@orpc/shared";
-var OpenAPIProcedureMatcher = class {
-  constructor(hono, router) {
-    this.hono = hono;
-    this.router = router;
-    this.pendingRouters = [{ path: [], router }];
-  }
-  pendingRouters;
-  async match(method, pathname) {
-    await this.handlePendingRouters(pathname);
-    const [matches, paramStash] = this.hono.match(method, pathname);
-    const [match] = matches.sort((a, b) => {
-      const slashCountA = a[0][0].split("/").length;
-      const slashCountB = b[0][0].split("/").length;
-      if (slashCountA !== slashCountB) {
-        return slashCountB - slashCountA;
-      }
-      const paramsCountA = Object.keys(a[1]).length;
-      const paramsCountB = Object.keys(b[1]).length;
-      return paramsCountA - paramsCountB;
-    });
-    if (!match) {
-      return void 0;
-    }
-    const path = match[0][1];
-    const params = paramStash ? mapValues(
-      match[1],
-      // if paramStash is defined, then match[1] is ParamIndexMap
-      (v) => paramStash[v]
-    ) : match[1];
-    const { default: maybeProcedure } = await unlazy(getRouterChild(this.router, ...path));
-    if (!isProcedure(maybeProcedure)) {
-      return void 0;
-    }
-    return {
-      path,
-      procedure: maybeProcedure,
-      params: { ...params }
-      // normalize params from hono
-    };
-  }
-  add(path, router) {
-    const lazies = forEachContractProcedure({ path, router }, ({ path: path2, contract }) => {
-      const method = fallbackContractConfig("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]);
-    });
-    this.pendingRouters.push(...lazies);
-  }
-  async handlePendingRouters(pathname) {
-    const newPendingLazyRouters = [];
-    for (const item of this.pendingRouters) {
-      const lazyPrefix = getLazyRouterPrefix(item.router);
-      if (lazyPrefix && !pathname.startsWith(lazyPrefix) && !pathname.startsWith(`/${item.path.map(encodeURIComponent).join("/")}`)) {
-        newPendingLazyRouters.push(item);
-        continue;
-      }
-      const { default: router } = await unlazy(item.router);
-      this.add(item.path, router);
-    }
-    this.pendingRouters = newPendingLazyRouters;
-  }
-  convertOpenAPIPathToRouterPath(path) {
-    return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
-  }
-};
-
-// src/adapters/fetch/schema-coercer.ts
-var CompositeSchemaCoercer = class {
-  constructor(coercers) {
-    this.coercers = coercers;
-  }
-  coerce(schema, value) {
-    let current = value;
-    for (const coercer of this.coercers) {
-      current = coercer.coerce(schema, current);
-    }
-    return current;
-  }
-};
-
-// src/adapters/fetch/openapi-handler.ts
-import { fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
-import { createProcedureClient, 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(jsonSerializer);
-    this.inputStructureCompact = options?.inputBuilderSimple ?? new InputStructureCompact();
-    this.inputStructureDetailed = options?.inputBuilderFull ?? new InputStructureDetailed();
-    this.compositeSchemaCoercer = new CompositeSchemaCoercer(options?.schemaCoercers ?? []);
-  }
-  procedureMatcher;
-  payloadCodec;
-  inputStructureCompact;
-  inputStructureDetailed;
-  compositeSchemaCoercer;
-  async handle(request, ...[options]) {
-    const context = options?.context ?? {};
-    const headers = request.headers;
-    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 matchedMethod = customMethod || request.method;
-      const matched = await this.procedureMatcher.match(matchedMethod, pathname);
-      if (!matched) {
-        return { matched: false, response: void 0 };
-      }
-      const def = matched.procedure["~orpc"];
-      const input = await this.decodeInput(matched.procedure, matched.params, request);
-      const coercedInput = this.compositeSchemaCoercer.coerce(def.inputSchema, input);
-      const client = createProcedureClient(matched.procedure, {
-        context,
-        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: fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)
-      });
-      return { matched: true, response };
-    };
-    try {
-      return await executeWithHooks({
-        context,
-        execute,
-        input: request,
-        hooks: this.options,
-        meta: {
-          signal: request.signal
-        }
-      });
-    } catch (e) {
-      const error = this.convertToORPCError(e);
-      try {
-        const { body, headers: headers2 } = this.payloadCodec.encode(error.toJSON(), accept);
-        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(), void 0);
-        const response = new Response(body, {
-          status: error2.status,
-          headers: headers2
-        });
-        return { matched: true, response };
-      }
-    }
-  }
-  async decodeInput(procedure, params, request) {
-    const inputStructure = fallbackContractConfig2("defaultInputStructure", procedure["~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 = fallbackContractConfig2("defaultOutputStructure", procedure["~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("INTERNAL_SERVER_ERROR", {
-      message: "Internal server error",
-      cause: e
-    });
-  }
-};
-
-export {
-  serialize,
-  deserialize,
-  escapeSegment,
-  stringifyPath,
-  parsePath,
-  InputStructureCompact,
-  InputStructureDetailed,
-  OpenAPIPayloadCodec,
-  OpenAPIProcedureMatcher,
-  CompositeSchemaCoercer,
-  OpenAPIHandler
-};
-//# sourceMappingURL=chunk-SOVQ5ARD.js.map

package/dist/chunk-VFGNQS5W.js

@@ -1,25 +0,0 @@
-import {
-  OpenAPIHandler
-} from "./chunk-SOVQ5ARD.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-VFGNQS5W.js.map

package/dist/src/adapters/fetch/input-structure-compact.d.ts

@@ -1,6 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputStructureCompact {
-    build(params: Params, payload: unknown): unknown;
-}
-export type PublicInputStructureCompact = Pick<InputStructureCompact, keyof InputStructureCompact>;
-//# sourceMappingURL=input-structure-compact.d.ts.map

package/dist/src/adapters/fetch/input-structure-detailed.d.ts

@@ -1,11 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputStructureDetailed {
-    build(params: Params, query: unknown, headers: unknown, body: unknown): {
-        params: Params;
-        query: unknown;
-        headers: unknown;
-        body: unknown;
-    };
-}
-export type PublicInputStructureDetailed = Pick<InputStructureDetailed, keyof InputStructureDetailed>;
-//# sourceMappingURL=input-structure-detailed.d.ts.map

package/dist/src/adapters/fetch/openapi-handler-server.d.ts

@@ -1,7 +0,0 @@
-import type { Context, Router } from '@orpc/server';
-import type { OpenAPIHandlerOptions } from './openapi-handler';
-import { OpenAPIHandler } from './openapi-handler';
-export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-}
-//# sourceMappingURL=openapi-handler-server.d.ts.map