@temporary-name/server 1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d → 1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6

package/dist/shared/server.DwbIdsnK.mjs

@@ -0,0 +1,254 @@
+import { stringifyJSON, isObject, isORPCErrorStatus, tryDecodeURIComponent, toHttpPath, toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, ORPCError, toORPCError } from '@temporary-name/shared';
+import { c as createProcedureClient } from './server.C61o1Zch.mjs';
+import { fallbackContractConfig, standardizeHTTPPath } from '@temporary-name/contract';
+import { d as deserialize, b as bracketNotationDeserialize, s as serialize } from './server.JtIZ8YG7.mjs';
+import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@temporary-name/server';
+import { createRouter, addRoute, findRoute } from 'rou3';
+
+async function decode(request, pathParams) {
+  return {
+    path: pathParams ?? {},
+    query: bracketNotationDeserialize(Array.from(request.url.searchParams.entries())),
+    headers: request.headers,
+    body: deserialize(await request.body()) ?? {}
+  };
+}
+function 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: new Headers(),
+      body: serialize(output)
+    };
+  }
+  if (!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 ?? new Headers(),
+    body: serialize(output.body)
+  };
+}
+function encodeError(error) {
+  return {
+    status: error.status,
+    headers: new Headers(),
+    body: serialize(error.toJSON(), { outputFormat: "plain" })
+  };
+}
+function 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) => {
+      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;
+  constructor(router, options) {
+    this.matcher = new StandardOpenAPIMatcher();
+    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";
+              const input = await runWithSpan({ name: "decode_input" }, () => decode(request2, match.params));
+              step = void 0;
+              if (isAsyncIteratorObject(input.body)) {
+                input.body = asyncIteratorWithSpan(
+                  { name: "consume_event_iterator_input", signal: request2.signal },
+                  input.body
+                );
+              }
+              const client = createProcedureClient(match.procedure, {
+                context,
+                path: match.path,
+                interceptors: this.clientInterceptors
+              });
+              step = "call_procedure";
+              const output = await client(input, {
+                request: request2,
+                signal: request2.signal,
+                lastEventId: request2.headers.get("last-event-id") ?? void 0
+              });
+              step = void 0;
+              const response = 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 = encodeError(error);
+          return {
+            matched: true,
+            response
+          };
+        }
+      });
+    });
+  }
+}
+
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, encodeError as a, StandardOpenAPIMatcher as b, decodeParams as c, decode as d, encode as e, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };

package/dist/shared/server.JtIZ8YG7.mjs

@@ -0,0 +1,237 @@
+import { isObject, NullProtoObj, isAsyncIteratorObject, isORPCErrorJson, createORPCErrorFromJson, toORPCError } from '@temporary-name/shared';
+import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
+
+function bracketNotationSerialize(data, segments = [], result = []) {
+  if (Array.isArray(data)) {
+    data.forEach((item, i) => {
+      bracketNotationSerialize(item, [...segments, i], result);
+    });
+  } else if (isObject(data)) {
+    for (const key in data) {
+      bracketNotationSerialize(data[key], [...segments, key], result);
+    }
+  } else {
+    result.push([stringifyPath(segments), data]);
+  }
+  return result;
+}
+function bracketNotationDeserialize(serialized, { maxArrayIndex = 9999 } = {}) {
+  if (serialized.length === 0) {
+    return {};
+  }
+  const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+  const ref = { value: [] };
+  for (const [path, value] of serialized) {
+    const segments = parsePath(path);
+    let currentRef = ref;
+    let nextSegment = "value";
+    segments.forEach((segment, i) => {
+      if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+        currentRef[nextSegment] = [];
+      }
+      if (i !== segments.length - 1) {
+        if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, maxArrayIndex)) {
+          if (arrayPushStyles.has(currentRef[nextSegment])) {
+            arrayPushStyles.delete(currentRef[nextSegment]);
+            currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+          } else {
+            currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+          }
+        }
+      } else {
+        if (Array.isArray(currentRef[nextSegment])) {
+          if (segment === "") {
+            if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          } else {
+            if (arrayPushStyles.has(currentRef[nextSegment])) {
+              arrayPushStyles.delete(currentRef[nextSegment]);
+              currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+            } else if (!isValidArrayIndex(segment, maxArrayIndex)) {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          }
+        }
+      }
+      currentRef = currentRef[nextSegment];
+      nextSegment = segment;
+    });
+    if (Array.isArray(currentRef) && nextSegment === "") {
+      arrayPushStyles.add(currentRef);
+      currentRef.push(value);
+    } else if (nextSegment in currentRef) {
+      if (Array.isArray(currentRef[nextSegment])) {
+        currentRef[nextSegment].push(value);
+      } else {
+        currentRef[nextSegment] = [currentRef[nextSegment], value];
+      }
+    } else {
+      currentRef[nextSegment] = value;
+    }
+  }
+  return ref.value;
+}
+function stringifyPath(segments) {
+  return segments.map((segment) => {
+    return segment.toString().replace(/[\\[\]]/g, (match) => {
+      switch (match) {
+        case "\\":
+          return "\\\\";
+        case "[":
+          return "\\[";
+        case "]":
+          return "\\]";
+        /* v8 ignore next 2 */
+        default:
+          return match;
+      }
+    });
+  }).reduce((result, segment, i) => {
+    if (i === 0) {
+      return segment;
+    }
+    return `${result}[${segment}]`;
+  }, "");
+}
+function parsePath(path) {
+  const segments = [];
+  let inBrackets = false;
+  let currentSegment = "";
+  let backslashCount = 0;
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    const nextChar = path[i + 1];
+    if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+      if (nextChar === void 0) {
+        inBrackets = false;
+      }
+      segments.push(currentSegment);
+      currentSegment = "";
+      i++;
+    } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+      inBrackets = true;
+      segments.push(currentSegment);
+      currentSegment = "";
+    } else if (char === "\\") {
+      backslashCount++;
+    } else {
+      currentSegment += "\\".repeat(backslashCount / 2) + char;
+      backslashCount = 0;
+    }
+  }
+  return inBrackets || segments.length === 0 ? [path] : segments;
+}
+function isValidArrayIndex(value, maxIndex) {
+  return /^0$|^[1-9]\d*$/.test(value) && Number(value) <= maxIndex;
+}
+function arrayToObject(array) {
+  const obj = new NullProtoObj();
+  array.forEach((item, i) => {
+    obj[i] = item;
+  });
+  return obj;
+}
+function pushStyleArrayToObject(array) {
+  const obj = new NullProtoObj();
+  obj[""] = array.length === 1 ? array[0] : array;
+  return obj;
+}
+
+function jsonSerialize(data, hasBlobRef = { value: false }) {
+  if (data instanceof Blob) {
+    hasBlobRef.value = true;
+    return [data, hasBlobRef.value];
+  }
+  if (data instanceof Set) {
+    return jsonSerialize(Array.from(data), hasBlobRef);
+  }
+  if (data instanceof Map) {
+    return jsonSerialize(Array.from(data.entries()), hasBlobRef);
+  }
+  if (Array.isArray(data)) {
+    const json = data.map((v) => v === void 0 ? null : jsonSerialize(v, hasBlobRef)[0]);
+    return [json, hasBlobRef.value];
+  }
+  if (isObject(data)) {
+    const json = {};
+    for (const k in data) {
+      if (k === "toJSON" && typeof data[k] === "function") {
+        continue;
+      }
+      json[k] = jsonSerialize(data[k], hasBlobRef)[0];
+    }
+    return [json, hasBlobRef.value];
+  }
+  if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+    return [data.toString(), hasBlobRef.value];
+  }
+  if (data instanceof Date) {
+    return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+  }
+  if (Number.isNaN(data)) {
+    return [null, hasBlobRef.value];
+  }
+  return [data, hasBlobRef.value];
+}
+
+function serialize(data, options = {}) {
+  if (isAsyncIteratorObject(data) && !options.outputFormat) {
+    return mapEventIterator(data, {
+      value: async (value) => _serialize(value, { outputFormat: "plain" }),
+      error: async (e) => {
+        return new ErrorEvent({
+          data: _serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+          cause: e
+        });
+      }
+    });
+  }
+  return _serialize(data, options);
+}
+function _serialize(data, options) {
+  const [json, hasBlob] = jsonSerialize(data);
+  if (options.outputFormat === "plain") {
+    return json;
+  }
+  if (options.outputFormat === "URLSearchParams") {
+    const params = new URLSearchParams();
+    for (const [path, value] of bracketNotationSerialize(json)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        params.append(path, value.toString());
+      }
+    }
+    return params;
+  }
+  if (json instanceof Blob || json === void 0 || !hasBlob) {
+    return json;
+  }
+  const form = new FormData();
+  for (const [path, value] of bracketNotationSerialize(json)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      form.append(path, value.toString());
+    } else if (value instanceof Blob) {
+      form.append(path, value);
+    }
+  }
+  return form;
+}
+function deserialize(data) {
+  if (data instanceof URLSearchParams || data instanceof FormData) {
+    return bracketNotationDeserialize(Array.from(data.entries()));
+  }
+  if (isAsyncIteratorObject(data)) {
+    return mapEventIterator(data, {
+      value: async (value) => value,
+      error: async (e) => {
+        if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
+          return createORPCErrorFromJson(e.data, { cause: e });
+        }
+        return e;
+      }
+    });
+  }
+  return data;
+}
+
+export { bracketNotationDeserialize as b, deserialize as d, jsonSerialize as j, serialize as s };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@temporary-name/server",
   "type": "module",
-  "version": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
+  "version": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
   "license": "MIT",
   "homepage": "https://www.stainless.com/",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/unnoq/krusty.git",
+    "url": "git+https://github.com/stainless-api/krusty.git",
     "directory": "packages/server"
   },
   "keywords": [
@@ -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": [
@@ -66,21 +71,22 @@
   },
   "dependencies": {
     "cookie": "^1.0.2",
-    "@standard-schema/spec": "^1.0.0",
+    "rou3": "^0.7.7",
     "zod": "^4.1.12",
-    "@temporary-name/contract": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
-    "@temporary-name/interop": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
-    "@temporary-name/openapi": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
-    "@temporary-name/standard-server": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
-    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
-    "@temporary-name/shared": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
-    "@temporary-name/standard-server-fetch": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d",
-    "@temporary-name/standard-server-node": "1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d"
+    "@temporary-name/contract": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/interop": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/json-schema": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/standard-server": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/standard-server-node": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/zod": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6",
+    "@temporary-name/shared": "1.9.3-alpha.47c8371db8c45c361b1db0b785980cc77971e6e6"
   },
   "devDependencies": {
+    "@types/supertest": "^6.0.3",
     "@types/ws": "^8.18.1",
-    "supertest": "^7.1.4",
-    "type-fest": "^5.0.1"
+    "supertest": "^7.1.4"
   },
   "scripts": {
     "build": "unbuild",