@temporary-name/server 1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e → 1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e

package/dist/shared/server.CMTfy2UB.mjs

@@ -0,0 +1,293 @@
+import { isObject, stringifyJSON, isORPCErrorStatus, tryDecodeURIComponent, value, toHttpPath, toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, ORPCError, toORPCError } from '@temporary-name/shared';
+import { flattenHeader } from '@temporary-name/standard-server';
+import { c as createProcedureClient } from './server.BZtKt8i8.mjs';
+import { fallbackContractConfig } from '@temporary-name/contract';
+import { d as deserialize, s as serialize, a as standardizeHTTPPath } from './server.BEHw7Eyx.mjs';
+import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@temporary-name/server';
+import { createRouter, addRoute, findRoute } from 'rou3';
+
+class StandardOpenAPICodec {
+  constructor() {
+  }
+  async decode(request, params, procedure) {
+    const inputStructure = fallbackContractConfig(
+      "defaultInputStructure",
+      procedure["~orpc"].route.inputStructure
+    );
+    if (inputStructure === "compact") {
+      const data = request.method === "GET" ? deserialize(request.url.searchParams) : deserialize(await request.body());
+      if (data === void 0) {
+        return params;
+      }
+      if (isObject(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    const deserializeSearchParams = () => {
+      return 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: 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: serialize(output)
+      };
+    }
+    if (!this.#isDetailedOutput(output)) {
+      throw new Error(`
+        Invalid "detailed" output structure:
+        \u2022 Expected an object with optional properties:
+          - status (number 200-399)
+          - headers (Record<string, string | string[]>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output)}
+      `);
+    }
+    return {
+      status: output.status ?? successStatus,
+      headers: output.headers ?? {},
+      body: serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: serialize(error.toJSON(), { outputFormat: "plain" })
+    };
+  }
+  #isDetailedOutput(output) {
+    if (!isObject(output)) {
+      return false;
+    }
+    if (output.headers && !isObject(output.headers)) {
+      return false;
+    }
+    if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) {
+      return false;
+    }
+    return true;
+  }
+}
+
+function resolveFriendlyStandardHandleOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+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, tryDecodeURIComponent(value)])
+  );
+}
+
+class StandardOpenAPIMatcher {
+  tree = createRouter();
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
+      if (!value(true, traverseOptions)) {
+        return;
+      }
+      const { path: path2, contract } = traverseOptions;
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(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: toHttpPath(option.path),
+        laziedPrefix: getLazyMeta(option.router).prefix
+      }))
+    );
+  }
+  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.router);
+          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(getRouter(match.data.router, match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+}
+
+class CompositeStandardHandlerPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options, router) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options, router);
+    }
+  }
+}
+
+class StandardHandler {
+  interceptors;
+  clientInterceptors;
+  rootInterceptors;
+  matcher;
+  codec;
+  constructor(router, options) {
+    this.matcher = new StandardOpenAPIMatcher();
+    this.codec = new StandardOpenAPICodec();
+    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
+    plugins.init(options, router);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
+    this.rootInterceptors = toArray(options.rootInterceptors);
+    this.matcher.init(router);
+  }
+  async handle(request, options) {
+    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
+    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
+      return { matched: false, response: void 0 };
+    }
+    return intercept(this.rootInterceptors, { ...options, request, prefix }, async (interceptorOptions) => {
+      return runWithSpan({ name: `${request.method} ${request.url.pathname}` }, async (span) => {
+        let step;
+        try {
+          return await intercept(
+            this.interceptors,
+            interceptorOptions,
+            async ({ request: request2, context, prefix: prefix2 }) => {
+              const method = request2.method;
+              const url = request2.url;
+              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
+              const match = await runWithSpan(
+                { name: "find_procedure" },
+                () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
+              );
+              if (!match) {
+                return { matched: false, response: void 0 };
+              }
+              span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
+              span?.setAttribute("rpc.system", ORPC_NAME);
+              span?.setAttribute("rpc.method", match.path.join("."));
+              step = "decode_input";
+              let input = await runWithSpan(
+                { name: "decode_input" },
+                () => this.codec.decode(request2, match.params, match.procedure)
+              );
+              step = void 0;
+              if (isAsyncIteratorObject(input)) {
+                input = asyncIteratorWithSpan(
+                  { name: "consume_event_iterator_input", signal: request2.signal },
+                  input
+                );
+              }
+              const client = createProcedureClient(match.procedure, {
+                context,
+                path: match.path,
+                interceptors: this.clientInterceptors
+              });
+              step = "call_procedure";
+              const output = await client(input, {
+                signal: request2.signal,
+                lastEventId: flattenHeader(request2.headers["last-event-id"])
+              });
+              step = void 0;
+              const response = this.codec.encode(output, match.procedure);
+              return {
+                matched: true,
+                response
+              };
+            }
+          );
+        } catch (e) {
+          if (step !== "call_procedure") {
+            setSpanError(span, e);
+          }
+          const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
+            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+            cause: e
+          }) : toORPCError(e);
+          const response = this.codec.encodeError(error);
+          return {
+            matched: true,
+            response
+          };
+        }
+      });
+    });
+  }
+}
+
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, StandardOpenAPICodec as a, StandardOpenAPIMatcher as b, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };

package/dist/shared/{server.Bo94xDTv.d.mts → server.CQyYNJ1H.d.ts}

@@ -1,7 +1,7 @@
 import { Meta } from '@temporary-name/contract';
-import { HTTPPath, ORPCError, Interceptor } from '@temporary-name/shared';
-import { StandardResponse, StandardLazyRequest } from '@temporary-name/standard-server';
-import { C as Context, R as Router, A as AnyRouter, a as AnyProcedure, P as ProcedureClientInterceptorOptions } from './server.C1YnHvvf.mjs';
+import { HTTPPath, Interceptor } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.BKSOrA6h.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
@@ -13,22 +13,6 @@ declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends
     init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
 }
 
-type StandardParams = Record<string, string>;
-type StandardMatchResult = {
-    path: readonly string[];
-    procedure: AnyProcedure;
-    params?: StandardParams;
-} | undefined;
-interface StandardMatcher {
-    init(router: AnyRouter): void;
-    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
-}
-interface StandardCodec {
-    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
-    encodeError(error: ORPCError<any, any>): StandardResponse;
-    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
-}
-
 interface StandardHandleOptions<T extends Context> {
     prefix?: HTTPPath;
     context: T;
@@ -60,14 +44,14 @@ interface StandardHandlerOptions<TContext extends Context> {
     clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
 }
 declare class StandardHandler<T extends Context> {
-    private readonly matcher;
-    private readonly codec;
     private readonly interceptors;
     private readonly clientInterceptors;
     private readonly rootInterceptors;
-    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    private readonly matcher;
+    private readonly codec;
+    constructor(router: Router<any, T>, options: NoInfer<StandardHandlerOptions<T>>);
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S };
-export type { StandardHandlerPlugin as a, StandardHandleOptions as b, StandardHandlerInterceptorOptions as c, StandardHandlerOptions as d, StandardHandleResult as e, StandardParams as f, StandardMatchResult as g, StandardMatcher as h, StandardCodec as i };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as e };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };

package/dist/shared/server.SLLuK6_v.d.ts

@@ -0,0 +1,23 @@
+import { HTTPPath } from '@temporary-name/shared';
+import { C as Context } from './server.BKSOrA6h.js';
+import { c as StandardHandleOptions } from './server.CQyYNJ1H.js';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+/**
+ * {@link https://github.com/unjs/rou3}
+ *
+ * @internal
+ */
+declare function toRou3Pattern(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function decodeParams(params: Record<string, string>): Record<string, string>;
+
+export { decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@temporary-name/server",
   "type": "module",
-  "version": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
+  "version": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e",
   "license": "MIT",
   "homepage": "https://www.stainless.com/",
   "repository": {
@@ -47,6 +47,11 @@
       "types": "./dist/adapters/aws-lambda/index.d.mts",
       "import": "./dist/adapters/aws-lambda/index.mjs",
       "default": "./dist/adapters/aws-lambda/index.mjs"
+    },
+    "./openapi": {
+      "types": "./dist/openapi/index.d.mts",
+      "import": "./dist/openapi/index.mjs",
+      "default": "./dist/openapi/index.mjs"
     }
   },
   "files": [
@@ -67,17 +72,18 @@
   "dependencies": {
     "cookie": "^1.0.2",
     "@standard-schema/spec": "^1.0.0",
+    "rou3": "^0.7.7",
     "zod": "^4.1.12",
-    "@temporary-name/interop": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
-    "@temporary-name/contract": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
-    "@temporary-name/openapi": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
-    "@temporary-name/shared": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
-    "@temporary-name/standard-server-fetch": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
-    "@temporary-name/standard-server-node": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
-    "@temporary-name/standard-server": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e",
-    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e"
+    "@temporary-name/contract": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e",
+    "@temporary-name/interop": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e",
+    "@temporary-name/standard-server": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e",
+    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e",
+    "@temporary-name/shared": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e",
+    "@temporary-name/standard-server-node": "1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e"
   },
   "devDependencies": {
+    "@types/supertest": "^6.0.3",
     "@types/ws": "^8.18.1",
     "supertest": "^7.1.4"
   },

package/dist/shared/server.D6K9uoPI.mjs

@@ -1,35 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import 'zod';
-import * as z4 from 'zod/v4/core';
-
-const gatingContext = new AsyncLocalStorage();
-function withoutGatedFields(data, schema, isGateEnabled) {
-  const filtered = { ...data };
-  const gatedFields = getGatedFields(schema);
-  for (const [fieldName, gate] of gatedFields) {
-    if (!isGateEnabled(gate)) {
-      delete filtered[fieldName];
-    }
-  }
-  return filtered;
-}
-function getGatedFields(schema) {
-  if (!schema || schema["~standard"].vendor !== "zod") {
-    return [];
-  }
-  const gatedFields = [];
-  const zodDef = schema._zod.def;
-  if (zodDef.type === "object") {
-    const shape = zodDef.shape;
-    for (const fieldName in shape) {
-      const fieldSchema = shape[fieldName];
-      const gate = z4.globalRegistry.get(fieldSchema)?.gate;
-      if (gate) {
-        gatedFields.push([fieldName, gate]);
-      }
-    }
-  }
-  return gatedFields;
-}
-
-export { gatingContext as g, withoutGatedFields as w };

package/dist/shared/server.DZ5BIITo.mjs

@@ -1,9 +0,0 @@
-function resolveFriendlyStandardHandleOptions(options) {
-  return {
-    ...options,
-    context: options.context ?? {}
-    // Context only optional if all fields are optional
-  };
-}
-
-export { resolveFriendlyStandardHandleOptions as r };

package/dist/shared/server.X0YaZxSJ.mjs

@@ -1,13 +0,0 @@
-class CompositeStandardHandlerPlugin {
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-  }
-  init(options, router) {
-    for (const plugin of this.plugins) {
-      plugin.init?.(options, router);
-    }
-  }
-}
-
-export { CompositeStandardHandlerPlugin as C };