@temporary-name/server 1.9.3-alpha.62445d8d52a6787e7750865cd468fca8cccd3e28 → 1.9.3-alpha.62d88f5cf3908d4411b5278f1824b69334da8072

package/dist/shared/server.BnAF9pfn.mjs

@@ -0,0 +1,339 @@
+import { isObject, NullProtoObj, fallbackContractConfig, stringifyJSON, isAsyncIteratorObject, tryDecodeURIComponent, toHttpPath, runWithSpan, ORPC_NAME, asyncIteratorWithSpan, setSpanError } from '@temporary-name/shared';
+import { e as encodeError, i as isAPIErrorStatus, s as standardizeHTTPPath, A as APIError, B as BadRequestError, t as toAPIError$1 } from './server.MJ43MXYj.mjs';
+import { c as createProcedureClient } from './server.CCWAen7P.mjs';
+import { toAPIError, traverseContractProcedures, getLazyMeta, unlazy } from '@temporary-name/server';
+import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
+import { createRouter, addRoute, findRoute } from 'rou3';
+
+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 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;
+}
+
+async function decode(request, pathParams) {
+  return {
+    path: pathParams ?? {},
+    query: bracketNotationDeserialize(Array.from(request.url.searchParams.entries())),
+    headers: request.headers,
+    body: await request.body() ?? {}
+  };
+}
+function asyncSafeSerialize(data) {
+  if (isAsyncIteratorObject(data)) {
+    return mapEventIterator(data, {
+      value: async (value) => value,
+      error: async (e) => {
+        return new ErrorEvent({
+          data: encodeError(toAPIError(e))["body"],
+          cause: e
+        });
+      }
+    });
+  }
+  return data;
+}
+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: asyncSafeSerialize(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: asyncSafeSerialize(output.body)
+  };
+}
+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) || isAPIErrorStatus(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));
+      addRoute(this.tree, method, httpPath, {
+        path: path2,
+        // cast is safe because router is typed as Router (not ContractRouter)
+        procedure: contract,
+        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;
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+}
+
+function throwOrLog(error) {
+  if (process.env.NODE_ENV !== "production") {
+    throw error;
+  } else {
+    console.error(error);
+  }
+}
+class StandardHandler {
+  matcher;
+  constructor(router) {
+    this.matcher = new StandardOpenAPIMatcher();
+    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 runWithSpan({ name: `${request.method} ${request.url.pathname}` }, async (span) => {
+      let step;
+      let errorMap;
+      try {
+        const context = options.context;
+        const method = request.method;
+        const url = request.url;
+        const pathname = prefix ? url.pathname.replace(prefix, "") : url.pathname;
+        const match = await runWithSpan(
+          { name: "find_procedure" },
+          () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
+        );
+        if (!match) {
+          return { matched: false, response: void 0 };
+        }
+        errorMap = match.procedure["~orpc"].errorMap;
+        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(request, match.params));
+        step = void 0;
+        if (isAsyncIteratorObject(input.body)) {
+          input.body = asyncIteratorWithSpan(
+            { name: "consume_event_iterator_input", signal: request.signal },
+            input.body
+          );
+        }
+        const client = createProcedureClient(match.procedure, {
+          context,
+          path: match.path
+        });
+        step = "call_procedure";
+        const output = await client(input, {
+          request,
+          signal: request.signal,
+          lastEventId: request.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 isAPIError = e instanceof APIError;
+        if (isAPIError) {
+          if (!errorMap) {
+            throwOrLog(
+              new Error(`Got APIError but errorMap is undefined. APIError="{${e.message}"`, { cause: e })
+            );
+          } else if (!errorMap[e.constructor.name]) {
+            throwOrLog(
+              new Error(
+                `APIError "${e.constructor.name}" (type "${e.constructor.type}") is not registered. Add it to your API with: baseApi.useErrors({ ${e.constructor.name} })`,
+                { cause: e }
+              )
+            );
+          }
+        }
+        const error = step === "decode_input" && !(e instanceof APIError) ? new BadRequestError({
+          code: "malformed_request",
+          message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+          cause: e
+        }) : toAPIError$1(e);
+        const response = encodeError(error);
+        return {
+          matched: true,
+          response
+        };
+      }
+    });
+  }
+}
+
+export { StandardHandler as S, StandardOpenAPIMatcher as a, decodeParams as b, decode as d, encode as e, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };

package/dist/shared/server.C1RJffw4.mjs

@@ -0,0 +1,30 @@
+import { parse, serialize } from 'cookie';
+
+function setCookie(headers, name, value, options = {}) {
+  if (headers === void 0) {
+    return;
+  }
+  const cookieString = serialize(name, value, {
+    path: "/",
+    ...options
+  });
+  headers.append("Set-Cookie", cookieString);
+}
+function getCookie(headers, name, options = {}) {
+  if (headers === void 0) {
+    return void 0;
+  }
+  const cookieHeader = headers.get("cookie");
+  if (cookieHeader === null) {
+    return void 0;
+  }
+  return parse(cookieHeader, options)[name];
+}
+function deleteCookie(headers, name, options = {}) {
+  return setCookie(headers, name, "", {
+    ...options,
+    maxAge: 0
+  });
+}
+
+export { deleteCookie as d, getCookie as g, setCookie as s };

package/dist/shared/server.CCWAen7P.mjs

@@ -0,0 +1,156 @@
+import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
+import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
+import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
+import { u as unlazy, B as BadRequestError, V as ValidationError, I as InternalServerError } from './server.MJ43MXYj.mjs';
+
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
+function createProcedureClient(lazyableProcedure, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  return async (...[input, callerOptions]) => {
+    const path = toArray(options.path);
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options.context ?? {}, clientContext);
+    const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
+      span?.setAttribute("procedure.path", [...path]);
+      return executeProcedureInternal(procedure, input, {
+        context,
+        path,
+        procedure,
+        request: callerOptions?.request,
+        signal: callerOptions?.signal,
+        lastEventId: callerOptions?.lastEventId
+      });
+    });
+    if (isAsyncIteratorObject(output)) {
+      if (output instanceof HibernationEventIterator) {
+        return output;
+      }
+      return overlayProxy(
+        output,
+        mapEventIterator(
+          asyncIteratorWithSpan(
+            { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+            output
+          ),
+          {
+            value: (v) => v,
+            error: async (e) => e
+          }
+        )
+      );
+    }
+    return output;
+  };
+}
+async function validateInput(procedure, input) {
+  const schemas = procedure["~orpc"].schemas;
+  return runWithSpan({ name: "validate_input" }, async () => {
+    const resultBody = await safeDecodeAsync(schemas.bodySchema, input.body, { parseType: "body" });
+    const resultPath = await safeDecodeAsync(schemas.pathSchema, input.path, { parseType: "path" });
+    const resultQuery = await safeDecodeAsync(schemas.querySchema, input.query, { parseType: "query" });
+    const issues = [];
+    if (!resultBody.success) {
+      issues.push(...resultBody.error.issues.map((i) => ({ ...i, path: ["body", ...i.path] })));
+    }
+    if (!resultPath.success) {
+      issues.push(...resultPath.error.issues.map((i) => ({ ...i, path: ["path", ...i.path] })));
+    }
+    if (!resultQuery.success) {
+      issues.push(...resultQuery.error.issues.map((i) => ({ ...i, path: ["query", ...i.path] })));
+    }
+    if (issues.length > 0) {
+      throw new BadRequestError({
+        code: "input_validation_failed",
+        message: "Input validation failed",
+        cause: new ValidationError({
+          issues,
+          data: input
+        })
+      });
+    }
+    const results = {
+      body: resultBody.data,
+      path: resultPath.data,
+      query: resultQuery.data
+    };
+    return results;
+  });
+}
+async function validateOutput(procedure, output) {
+  const schema = procedure["~orpc"].schemas.outputSchema;
+  if (!schema) {
+    return output;
+  }
+  return runWithSpan({ name: "validate_output" }, async () => {
+    const result = await safeEncodeAsync(schema, output, { parseType: "output" });
+    if (!result.success) {
+      throw new InternalServerError({
+        message: "Output validation failed",
+        cause: new ValidationError({
+          issues: result.error.issues,
+          data: output
+        })
+      });
+    }
+    return result.data;
+  });
+}
+async function executeProcedureInternal(procedure, input, options) {
+  const middlewares = procedure["~orpc"].middlewares;
+  const inputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].inputValidationIndex),
+    middlewares.length
+  );
+  const outputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].outputValidationIndex),
+    middlewares.length
+  );
+  const next = async (index, context, input2) => {
+    let currentInput = input2;
+    if (index === inputValidationIndex) {
+      currentInput = await validateInput(procedure, currentInput);
+    }
+    const mid = middlewares[index];
+    const output = mid ? await runWithSpan({ name: `middleware.${mid.name}`, signal: options.signal }, async (span) => {
+      span?.setAttribute("middleware.index", index);
+      span?.setAttribute("middleware.name", mid.name);
+      const result = await mid(
+        {
+          ...options,
+          context,
+          next: async (nextOptions) => {
+            const nextContext = nextOptions?.context ?? {};
+            return {
+              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              // NB: Pretty sure this isn't used (or meant to be used) at runtime, it's just there
+              // to get type inference in the builder (via the caller returning the output of next() in
+              // the middleware function)
+              context: nextContext
+            };
+          }
+        },
+        currentInput,
+        middlewareOutputFn
+      );
+      return result.output;
+    }) : await runWithSpan(
+      { name: "handler", signal: options.signal },
+      () => procedure["~orpc"].handler(currentInput, { ...options, context })
+    );
+    if (index === outputValidationIndex) {
+      return await validateOutput(procedure, output);
+    }
+    return output;
+  };
+  return next(0, options.context, input);
+}
+
+export { middlewareOutputFn as a, createProcedureClient as c, mergeCurrentContext as m };

package/dist/shared/server.CjPiuQYH.d.mts

@@ -0,0 +1,51 @@
+import { JSONSchema, SchemaConverter } from '@temporary-name/server/openapi';
+
+interface ZodToJsonSchemaConverterOptions {
+    /**
+     * Max depth of lazy type.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
+    /**
+     * The schema to be used to represent the any | unknown type.
+     *
+     * @default { }
+     */
+    anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+}
+declare class ZodToJsonSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    constructor(options?: ZodToJsonSchemaConverterOptions);
+    convert: SchemaConverter;
+}
+
+export { ZodToJsonSchemaConverter as a };
+export type { ZodToJsonSchemaConverterOptions as Z };

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

@@ -0,0 +1,51 @@
+import { JSONSchema, SchemaConverter } from '@temporary-name/server/openapi';
+
+interface ZodToJsonSchemaConverterOptions {
+    /**
+     * Max depth of lazy type.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
+    /**
+     * The schema to be used to represent the any | unknown type.
+     *
+     * @default { }
+     */
+    anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+}
+declare class ZodToJsonSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    constructor(options?: ZodToJsonSchemaConverterOptions);
+    convert: SchemaConverter;
+}
+
+export { ZodToJsonSchemaConverter as a };
+export type { ZodToJsonSchemaConverterOptions as Z };

package/dist/shared/server.DLyn62VH.d.mts

@@ -0,0 +1,39 @@
+import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
+import { C as Context, m as Router } from './server.DpIhEnBO.mjs';
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    constructor(router: Router<T>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (object 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 { StandardHandler as b, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F, StandardHandleOptions as S, StandardHandleResult as a };