@orpc/openapi 0.0.0-next.af8ac85 → 0.0.0-next.b0f324e

package/dist/shared/openapi.CDsfPHgw.mjs

@@ -0,0 +1,148 @@
+import { fallbackContractConfig } from '@orpc/contract';
+import { OpenAPISerializer } from '@orpc/openapi-client/standard';
+import { isObject } from '@orpc/shared';
+import { eachContractProcedure, convertPathToHttpPath, isProcedure, getLazyRouterPrefix, unlazy, getRouterChild, createContractedProcedure } from '@orpc/server';
+import { createRouter, addRoute, findRoute } from 'rou3';
+import { s as standardizeHTTPPath } from './openapi.BHG_gu5Z.mjs';
+
+class OpenAPICodec {
+  constructor(serializer = new OpenAPISerializer()) {
+    this.serializer = serializer;
+  }
+  async decode(request, params, procedure) {
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    if (inputStructure === "compact") {
+      const data = request.method === "GET" ? this.serializer.deserialize(request.url.searchParams) : this.serializer.deserialize(await request.body());
+      if (data === void 0) {
+        return params;
+      }
+      if (isObject(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    const deserializeSearchParams = () => {
+      return this.serializer.deserialize(request.url.searchParams);
+    };
+    return {
+      params,
+      get query() {
+        const value = deserializeSearchParams();
+        Object.defineProperty(this, "query", { value, writable: true });
+        return value;
+      },
+      set query(value) {
+        Object.defineProperty(this, "query", { value, writable: true });
+      },
+      headers: request.headers,
+      body: this.serializer.deserialize(await request.body())
+    };
+  }
+  encode(output, procedure) {
+    const successStatus = fallbackContractConfig("defaultSuccessStatus", procedure["~orpc"].route.successStatus);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!isObject(output)) {
+      throw new Error(
+        'Invalid output structure for "detailed" output. Expected format: { body: any, headers?: Record<string, string | string[] | undefined> }'
+      );
+    }
+    return {
+      status: successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+}
+
+class OpenAPIMatcher {
+  tree = createRouter();
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = eachContractProcedure({
+      router,
+      path
+    }, ({ path: path2, contract }) => {
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = contract["~orpc"].route.path ? toRou3Pattern(contract["~orpc"].route.path) : convertPathToHttpPath(path2);
+      if (isProcedure(contract)) {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        });
+      } else {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        });
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: convertPathToHttpPath(option.path),
+      laziedPrefix: getLazyRouterPrefix(option.lazied)
+    })));
+  }
+  async match(method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.lazied);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouterChild(match.data.router, ...match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(match.data.contract, maybeProcedure);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+}
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "**:$1").replace(/\{([^}]+)\}/g, ":$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, decodeURIComponent(value)]));
+}
+
+export { OpenAPICodec as O, OpenAPIMatcher as a };

package/dist/shared/openapi.D0VMNR6V.mjs

@@ -0,0 +1,25 @@
+import { StandardHandler } from '@orpc/server/standard';
+import { toStandardRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { a as OpenAPIMatcher, O as OpenAPICodec } from './openapi.CDsfPHgw.mjs';
+
+class OpenAPIHandler {
+  standardHandler;
+  constructor(router, options) {
+    const matcher = options?.matcher ?? new OpenAPIMatcher();
+    const codec = options?.codec ?? new OpenAPICodec();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...[options]) {
+    const standardRequest = toStandardRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, options)
+    };
+  }
+}
+
+export { OpenAPIHandler as O };

package/dist/shared/openapi.Dz_6xooR.d.mts

@@ -0,0 +1,7 @@
+import { Context } from '@orpc/server';
+import { RPCHandlerOptions } from '@orpc/server/standard';
+
+interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T> {
+}
+
+export type { OpenAPIHandlerOptions as O };

package/dist/shared/openapi.Dz_6xooR.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '@orpc/server';
+import { RPCHandlerOptions } from '@orpc/server/standard';
+
+interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T> {
+}
+
+export type { OpenAPIHandlerOptions as O };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.af8ac85",
+  "version": "0.0.0-next.b0f324e",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,44 +15,57 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
+    },
+    "./hono": {
+      "types": "./dist/adapters/hono/index.d.mts",
+      "import": "./dist/adapters/hono/index.mjs",
+      "default": "./dist/adapters/hono/index.mjs"
+    },
+    "./next": {
+      "types": "./dist/adapters/next/index.d.mts",
+      "import": "./dist/adapters/next/index.mjs",
+      "default": "./dist/adapters/next/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./node": {
+      "types": "./dist/adapters/node/index.d.mts",
+      "import": "./dist/adapters/node/index.mjs",
+      "default": "./dist/adapters/node/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0-beta.4",
-    "@types/content-disposition": "^0.5.8",
-    "content-disposition": "^0.5.4",
-    "escape-string-regexp": "^5.0.0",
-    "fast-content-type-parse": "^2.0.0",
-    "hono": "^4.6.12",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.0.0-next.af8ac85",
-    "@orpc/server": "0.0.0-next.af8ac85",
-    "@orpc/shared": "0.0.0-next.af8ac85"
+    "rou3": "^0.5.1",
+    "@orpc/contract": "0.0.0-next.b0f324e",
+    "@orpc/openapi-client": "0.0.0-next.b0f324e",
+    "@orpc/client": "0.0.0-next.b0f324e",
+    "@orpc/server": "0.0.0-next.b0f324e",
+    "@orpc/standard-server-fetch": "0.0.0-next.b0f324e",
+    "@orpc/shared": "0.0.0-next.b0f324e",
+    "@orpc/standard-server-node": "0.0.0-next.b0f324e",
+    "@orpc/standard-server": "0.0.0-next.b0f324e"
   },
   "devDependencies": {
-    "@readme/openapi-parser": "^2.6.0",
     "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-KNYXLM77.js

@@ -1,107 +0,0 @@
-// 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