@temporary-name/server 1.9.3-alpha.f9f5ce625d5edee78250b87b3a64f1d9760c2244 → 1.9.3-alpha.fb7e3a67f82deaeffad5063e136b2f3c03c4b5b3

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.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.D2NXNHIf.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.DvgWQUGK.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.Deg5phAY.d.ts

@@ -0,0 +1,39 @@
+import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
+import { C as Context, m as Router } from './server.BwcJq6aP.js';
+
+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 };