@temporary-name/server 1.9.3-alpha.6a70825f6d8c3dc99b87e4e5b778aea0fa007417 → 1.9.3-alpha.6d3c10e7b535aec2de4b812161c8001a916134b9

package/dist/index.mjs

@@ -1,12 +1,70 @@
-import { mergePrefix, mergeTags, ContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, prefixRoute, initialSchemas, isContractProcedure, getContractRouter } from '@temporary-name/contract';
-export { ValidationError, eventIterator, validateORPCError } from '@temporary-name/contract';
-import { onError, resolveMaybeOptionalOptions } from '@temporary-name/shared';
-export { AsyncIteratorClass, EventPublisher, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, safe, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
-import { SchemaClass, core, object, gatingContext } from '@temporary-name/zod';
+import { assertNever, splitFirst, ORPCError, onError, resolveMaybeOptionalOptions, isTypescriptObject, isPropertyKey } from '@temporary-name/shared';
+export { AsyncIteratorClass, EventPublisher, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+import { SchemaClass, object, core, gatingContext } from '@temporary-name/zod';
+import { g as getCookie } from './shared/server.C1RJffw4.mjs';
+import { P as Procedure, m as mergePrefix, a as mergeTags, e as enhanceRouter, C as Contract, p as parseEndpointDefinition, b as mergeRoute, c as prefixRoute, d as addMiddleware, l as lazyInternal, f as getLazyMeta, u as unlazy, i as isProcedure, h as isLazy, j as getRouter } from './shared/server.ChOv1yG3.mjs';
+export { L as LAZY_SYMBOL, V as ValidationError, q as createAccessibleLazyRouter, w as endpointRegex, g as getDynamicParams, n as isStartWithMiddlewares, k as lazy, o as mergeMiddlewares, r as resolveContractProcedures, s as standardizeHTTPPath, t as traverseContractProcedures, v as unlazyRouter } from './shared/server.ChOv1yG3.mjs';
+import { c as createProcedureClient } from './shared/server.DgzAlPjF.mjs';
+export { m as mergeCurrentContext, a as middlewareOutputFn } from './shared/server.DgzAlPjF.mjs';
+export { e as eventIterator, g as getEventIteratorSchemaDetails } from './shared/server.YUvuxHty.mjs';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
-import { g as getDynamicParams } from './shared/server.DN9mVGfv.mjs';
-import { P as Procedure, c as createProcedureClient, e as enhanceRouter, a as addMiddleware, s as setHiddenRouterContract, l as lazyInternal, g as getLazyMeta, u as unlazy, i as isProcedure, b as isLazy, d as getRouter } from './shared/server.CHV9AQHl.mjs';
-export { L as LAZY_SYMBOL, p as createAccessibleLazyRouter, f as createORPCErrorConstructorMap, o as getHiddenRouterContract, k as isStartWithMiddlewares, h as lazy, m as mergeCurrentContext, n as mergeMiddlewares, j as middlewareOutputFn, r as resolveContractProcedures, t as traverseContractProcedures, q as unlazyRouter } from './shared/server.CHV9AQHl.mjs';
+import 'cookie';
+
+function validateTokenPrefix(prefix, token) {
+  if (prefix && !token.startsWith(prefix)) {
+    throw new ORPCError("UNAUTHORIZED", { message: `Invalid auth token. It must start with "${prefix}"` });
+  }
+}
+function validateTokenAuth(config, token, options) {
+  const { tokenPrefix, validate } = config;
+  validateTokenPrefix(tokenPrefix, token);
+  return validate(token, options);
+}
+function authByQuery(config, options) {
+  const { name, tokenPrefix, validate } = config;
+  const query = options.request.url.searchParams;
+  const token = query.get(name);
+  if (!token) return void 0;
+  validateTokenPrefix(tokenPrefix, token);
+  return validate(token, options);
+}
+function authByHeader(config, options) {
+  const authHeader = options.request.headers.get(config.name);
+  return authHeader ? validateTokenAuth(config, authHeader, options) : void 0;
+}
+function authByCookie(config, options) {
+  const cookie = getCookie(options.request.headers, config.name);
+  return cookie ? validateTokenAuth(config, cookie, options) : void 0;
+}
+function authByBearer(config, options) {
+  const authHeader = options.request.headers.get("Authorization");
+  if (!authHeader) return void 0;
+  const [authType, bearer] = splitFirst(authHeader, " ");
+  return authType === "Bearer" ? validateTokenAuth(config, bearer, options) : void 0;
+}
+function authByBasic(config, options) {
+  const authHeader = options.request.headers.get("Authorization");
+  if (!authHeader) return void 0;
+  const [authType, encoded] = splitFirst(authHeader, " ");
+  if (authType !== "Basic") return void 0;
+  const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+  const [username, password] = splitFirst(decoded, ":");
+  validateTokenPrefix(config.tokenPrefix, password);
+  return config.validate(username, password, options);
+}
+function authByType(config, options) {
+  const { type } = config;
+  return type === "header" ? authByHeader(config, options) : type === "query" ? authByQuery(config, options) : type === "cookie" ? authByCookie(config, options) : type === "bearer" ? authByBearer(config, options) : type === "basic" ? authByBasic(config, options) : type === "none" ? false : assertNever(type);
+}
+function authDescription(config) {
+  const { type } = config;
+  return type === "basic" ? "a Basic Authentication header" : type === "bearer" ? "a Bearer Authentication header" : type === "header" ? `a header named "${config.name}"` : type === "query" ? `a query parameter named "${config.name}"` : type === "cookie" ? `a cookie named "${config.name}"` : type === "none" ? "no authentication" : assertNever(type);
+}
+
+function mergeMeta(meta1, meta2) {
+  return { ...meta1, ...meta2 };
+}
 
 class DecoratedProcedure extends Procedure {
   /**
@@ -27,24 +85,19 @@ class DecoratedProcedure extends Procedure {
   }
 }
 
-class ProcedureBuilder extends ContractProcedure {
+const initialSchemas = {
+  pathSchema: z.strictObject({}),
+  querySchema: z.strictObject({}),
+  bodySchema: z.strictObject({}),
+  outputSchema: z.unknown()
+};
+
+class ProcedureBuilder extends Contract {
   z;
   constructor(def) {
     super(def);
     this.z = new SchemaClass();
   }
-  /**
-   * Adds type-safe custom errors to the contract.
-   * The provided errors are spared-merged with any existing errors in the contract.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
-   */
-  errors(errors) {
-    return new ProcedureBuilder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-  }
   /**
    * Sets or updates the metadata for the contract.
    * The provided metadata is spared-merged with any existing metadata in the contract.
@@ -57,16 +110,8 @@ class ProcedureBuilder extends ContractProcedure {
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
-  endpoint(endpoint, schema) {
-    const [method, path] = endpoint.split(" ", 2);
-    const pathParamNames = getDynamicParams(path)?.map((p) => p.name) ?? [];
-    if (schema && !(schema instanceof core.$ZodObject)) {
-      throw new Error(`Path schema for endpoint "${endpoint}" must be a ZodObject schema.`);
-    }
-    const schemaKeys = schema ? Object.keys(schema._zod.def.shape) : [];
-    if (pathParamNames.length !== schemaKeys.length || !pathParamNames.every((name) => schemaKeys.includes(name))) {
-      throw new Error(`Path schema keys do not match dynamic parameters in endpoint "${endpoint}".`);
-    }
+  endpoint(stringsOrEndpoint, ...values) {
+    const { method, path, pathSchema } = parseEndpointDefinition(stringsOrEndpoint, values);
     const { prefix } = this["~orpc"];
     const route = { method, path };
     return new ProcedureBuilder({
@@ -74,7 +119,7 @@ class ProcedureBuilder extends ContractProcedure {
       route: mergeRoute(this["~orpc"].route, prefix ? prefixRoute(route, prefix) : route),
       schemas: {
         ...this["~orpc"].schemas,
-        pathSchema: schema instanceof core.$ZodType ? schema : object(schema ?? {})
+        pathSchema
       }
     });
   }
@@ -141,6 +186,36 @@ class ProcedureBuilder extends ContractProcedure {
       middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
     });
   }
+  // `& {}` is so AuthType will be expanded in parameter info tooltips.
+  // The default of false for ValidatedAuthContext is used when you pass in the type 'none'. We use false
+  // because we can't use null or undefined (see ValidatedAuthContext) but we still want it to be falsy.
+  useAuth(type, ...rest) {
+    const config = { type, ...rest[0] };
+    const middleware = os.$context().middleware(async (options) => {
+      const { next, context } = options;
+      if (context.auth) return next();
+      const auth = await authByType(config, options);
+      if (auth === void 0) {
+        const { authConfigs } = options.procedure["~orpc"];
+        if (context.auth !== false && config === authConfigs.at(-1)) {
+          let authDescriptions = authConfigs.map(authDescription).join(", ");
+          if (authConfigs.length > 1) {
+            authDescriptions = `one of: ${authDescriptions}`;
+          }
+          throw new ORPCError("UNAUTHORIZED", {
+            message: `Authentication required. You must provide ${authDescriptions}`
+          });
+        }
+        return next();
+      }
+      return next({ context: { auth } });
+    });
+    return new this.constructor({
+      ...this["~orpc"],
+      authConfigs: [...this["~orpc"].authConfigs, config],
+      middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
+    });
+  }
   useGating(gates, isGateEnabled) {
     return this.use(({ next, context }) => {
       return gatingContext.run(
@@ -155,6 +230,9 @@ class ProcedureBuilder extends ContractProcedure {
    * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
    */
   handler(handler) {
+    if (this["~orpc"].schemas.outputSchema === initialSchemas.outputSchema) {
+      throw new Error("You must call .output() before calling .handler()");
+    }
     return new DecoratedProcedure({
       ...this["~orpc"],
       handler
@@ -256,7 +334,6 @@ function createApiBuilder(opts = {}) {
   return new Builder({
     route: {},
     meta: opts.meta ?? {},
-    errorMap: {},
     inputValidationIndex: 0,
     outputValidationIndex: 0,
     middlewares: [
@@ -267,85 +344,12 @@ function createApiBuilder(opts = {}) {
     schemas: initialSchemas,
     // NB: this is a relic from orpc -- I'm not convinced there's a need for this (or if there is, that it's
     // the best solution). For now I've removed the interface to configure it externally.
-    dedupeLeadingMiddlewares: true
+    dedupeLeadingMiddlewares: true,
+    authConfigs: []
   });
 }
 const os = createApiBuilder();
 
-function implementerInternal(contract, middlewares) {
-  if (isContractProcedure(contract)) {
-    const impl2 = new Builder({
-      ...contract["~orpc"],
-      middlewares,
-      inputValidationIndex: middlewares.length,
-      outputValidationIndex: middlewares.length,
-      dedupeLeadingMiddlewares: true
-    });
-    return impl2;
-  }
-  const impl = new Proxy(contract, {
-    get: (target, key) => {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      let method;
-      if (key === "middleware") {
-        method = (mid) => decorateMiddleware(mid);
-      } else if (key === "use") {
-        method = (mid) => {
-          return implementerInternal(contract, addMiddleware(middlewares, mid));
-        };
-      } else if (key === "router") {
-        method = (router) => {
-          const adapted = enhanceRouter(router, {
-            middlewares,
-            errorMap: {},
-            prefix: void 0,
-            tags: void 0,
-            dedupeLeadingMiddlewares: true
-          });
-          return setHiddenRouterContract(adapted, contract);
-        };
-      }
-      const next = getContractRouter(target, [key]);
-      if (!next) {
-        return method ?? next;
-      }
-      const nextImpl = implementerInternal(next, middlewares);
-      if (method) {
-        return new Proxy(method, {
-          get(_, key2) {
-            return Reflect.get(nextImpl, key2);
-          }
-        });
-      }
-      return nextImpl;
-    }
-  });
-  return impl;
-}
-function implement(contract) {
-  const implInternal = implementerInternal(contract, []);
-  const impl = new Proxy(implInternal, {
-    get: (target, key) => {
-      let method;
-      if (key === "$context") {
-        method = () => impl;
-      }
-      const next = Reflect.get(target, key);
-      if (!method || !next || typeof next !== "function" && typeof next !== "object") {
-        return method || next;
-      }
-      return new Proxy(method, {
-        get(_, key2) {
-          return Reflect.get(next, key2);
-        }
-      });
-    }
-  });
-  return impl;
-}
-
 function createAssertedLazyProcedure(lazied) {
   const lazyProcedure = lazyInternal(async () => {
     const { default: maybeProcedure } = await unlazy(lazied);
@@ -360,14 +364,6 @@ function createAssertedLazyProcedure(lazied) {
   }, getLazyMeta(lazied));
   return lazyProcedure;
 }
-function createContractedProcedure(procedure, contract) {
-  return new Procedure({
-    ...procedure["~orpc"],
-    errorMap: contract["~orpc"].errorMap,
-    route: contract["~orpc"].route,
-    meta: contract["~orpc"].meta
-  });
-}
 function call(procedure, input, ...rest) {
   const options = resolveMaybeOptionalOptions(rest);
   return createProcedureClient(procedure, options)(input, options);
@@ -398,4 +394,21 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, BuilderWithMiddlewares, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, lazyInternal, os, setHiddenRouterContract, unlazy };
+function isSchemaIssue(issue) {
+  if (!isTypescriptObject(issue) || typeof issue.message !== "string") {
+    return false;
+  }
+  if (issue.path !== void 0) {
+    if (!Array.isArray(issue.path)) {
+      return false;
+    }
+    if (!issue.path.every(
+      (segment) => isPropertyKey(segment) || isTypescriptObject(segment) && isPropertyKey(segment.key)
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { Builder, BuilderWithMiddlewares, Contract, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createApiBuilder, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getLazyMeta, getRouter, initialSchemas, isLazy, isProcedure, isSchemaIssue, lazyInternal, mergeMeta, os, parseEndpointDefinition, unlazy };

package/dist/openapi/index.d.mts

@@ -1,11 +1,12 @@
-import { OpenAPI, AnyContractProcedure, AnySchema, AnyContractRouter } from '@temporary-name/contract';
-export { OpenAPI } from '@temporary-name/contract';
-import { AnyProcedure, TraverseContractProcedureCallbackOptions, AnyRouter, ORPCError, ClientContext, Lazyable, CreateProcedureClientOptions, InferRouterInitialContext, Schema, ErrorMap, Meta, RouterClient } from '@temporary-name/server';
-import { Promisable, Value, HTTPPath, HTTPMethod, NestedClient, Client, MaybeOptionalOptions } from '@temporary-name/shared';
+import { Contract } from '@temporary-name/server';
+import { OpenAPI, Promisable, Value, HTTPPath, HTTPMethod } from '@temporary-name/shared';
+export { OpenAPI } from '@temporary-name/shared';
+import { d as AnySchema, b as Contract$1, ac as TraverseContractProcedureCallbackOptions, a2 as ContractRouter, w as AnyRouter } from '../shared/server.DimTvmOQ.mjs';
 import { JSONSchema } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { JSONSchema, ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+import '@temporary-name/zod';
 
-type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: AnyContractProcedure) => OpenAPI.OperationObject);
+type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: Contract) => OpenAPI.OperationObject);
 /**
  * Customize The Operation Object by proxy an error map item or a middleware.
  *
@@ -13,7 +14,7 @@ type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: Open
  */
 declare function customOpenAPIOperation<T extends object>(o: T, extend: OverrideOperationValue): T;
 declare function getCustomOpenAPIOperation(o: object): OverrideOperationValue | undefined;
-declare function applyCustomOpenAPIOperation(operation: OpenAPI.OperationObject, contract: AnyContractProcedure): OpenAPI.OperationObject;
+declare function applyCustomOpenAPIOperation(operation: OpenAPI.OperationObject, contract: Contract): OpenAPI.OperationObject;
 
 /**
  * @internal
@@ -76,7 +77,7 @@ interface OpenAPIGeneratorGenerateOptions extends Partial<Omit<OpenAPI.Document,
      * @deprecated Use `filter` option instead.
      * @default () => false
      */
-    exclude?: (procedure: AnyProcedure | AnyContractProcedure, path: readonly string[]) => boolean;
+    exclude?: (procedure: Contract$1, path: readonly string[]) => boolean;
     /**
      * Filter procedures. Return `false` to exclude a procedure from the OpenAPI specification.
      *
@@ -129,7 +130,7 @@ declare class OpenAPIGenerator {
      *
      * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
      */
-    generate(router: AnyContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
+    generate(router: ContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
 }
 
 /**
@@ -162,23 +163,6 @@ declare function checkParamsSchema(schema: ObjectSchema, params: string[]): bool
 declare function toOpenAPISchema(schema: JSONSchema): OpenAPI.SchemaObject & object;
 declare function resolveOpenAPIJsonSchemaRef(doc: OpenAPI.Document, schema: JSONSchema): JSONSchema;
 
-type JsonifiedValue<T> = T extends string ? T : T extends number ? T : T extends boolean ? T : T extends null ? T : T extends undefined ? T : T extends Array<unknown> ? JsonifiedArray<T> : T extends Record<string, unknown> ? {
-    [K in keyof T]: JsonifiedValue<T[K]>;
-} : T extends Date ? string : T extends bigint ? string : T extends File ? File : T extends Blob ? Blob : T extends RegExp ? string : T extends URL ? string : T extends Map<infer K, infer V> ? JsonifiedArray<[K, V][]> : T extends Set<infer U> ? JsonifiedArray<U[]> : T extends AsyncIteratorObject<infer U, infer V> ? AsyncIteratorObject<JsonifiedValue<U>, JsonifiedValue<V>> : unknown;
-type JsonifiedArray<T extends Array<unknown>> = T extends readonly [] ? [] : T extends readonly [infer U, ...infer V] ? [
-    U extends undefined ? null : JsonifiedValue<U>,
-    ...JsonifiedArray<V>
-] : T extends Array<infer U> ? Array<JsonifiedValue<U>> : unknown;
-/**
- * Convert types that JSON not support to corresponding json types
- *
- * @see {@link https://orpc.unnoq.com/docs/openapi/client/openapi-link OpenAPI Link Docs}
- */
-type JsonifiedClient<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? Client<UClientContext, UInput, JsonifiedValue<UOutput>, UError extends ORPCError<infer UCode, infer UData> ? ORPCError<UCode, JsonifiedValue<UData>> : UError> : {
-    [K in keyof T]: T[K] extends NestedClient<any> ? JsonifiedClient<T[K]> : T[K];
-};
-declare function createJsonifiedRouterClient<T extends AnyRouter, TClientContext extends ClientContext>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown, unknown>, ErrorMap, Meta, TClientContext>>): JsonifiedClient<RouterClient<T, TClientContext>>;
-
 /**
  *@internal
  */
@@ -216,5 +200,5 @@ declare const oo: {
     spec: typeof customOpenAPIOperation;
 };
 
-export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, createJsonifiedRouterClient, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
-export type { ConditionalSchemaConverter, FileSchema, JsonifiedArray, JsonifiedClient, JsonifiedValue, ObjectSchema, OpenAPIGeneratorGenerateOptions, OpenAPIGeneratorOptions, OverrideOperationValue, SchemaConvertOptions, SchemaConverter, SchemaConverterComponent };
+export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export type { ConditionalSchemaConverter, FileSchema, ObjectSchema, OpenAPIGeneratorGenerateOptions, OpenAPIGeneratorOptions, OverrideOperationValue, SchemaConvertOptions, SchemaConverter, SchemaConverterComponent };

package/dist/openapi/index.d.ts

@@ -1,11 +1,12 @@
-import { OpenAPI, AnyContractProcedure, AnySchema, AnyContractRouter } from '@temporary-name/contract';
-export { OpenAPI } from '@temporary-name/contract';
-import { AnyProcedure, TraverseContractProcedureCallbackOptions, AnyRouter, ORPCError, ClientContext, Lazyable, CreateProcedureClientOptions, InferRouterInitialContext, Schema, ErrorMap, Meta, RouterClient } from '@temporary-name/server';
-import { Promisable, Value, HTTPPath, HTTPMethod, NestedClient, Client, MaybeOptionalOptions } from '@temporary-name/shared';
+import { Contract } from '@temporary-name/server';
+import { OpenAPI, Promisable, Value, HTTPPath, HTTPMethod } from '@temporary-name/shared';
+export { OpenAPI } from '@temporary-name/shared';
+import { d as AnySchema, b as Contract$1, ac as TraverseContractProcedureCallbackOptions, a2 as ContractRouter, w as AnyRouter } from '../shared/server.DimTvmOQ.js';
 import { JSONSchema } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { JSONSchema, ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+import '@temporary-name/zod';
 
-type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: AnyContractProcedure) => OpenAPI.OperationObject);
+type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: Contract) => OpenAPI.OperationObject);
 /**
  * Customize The Operation Object by proxy an error map item or a middleware.
  *
@@ -13,7 +14,7 @@ type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: Open
  */
 declare function customOpenAPIOperation<T extends object>(o: T, extend: OverrideOperationValue): T;
 declare function getCustomOpenAPIOperation(o: object): OverrideOperationValue | undefined;
-declare function applyCustomOpenAPIOperation(operation: OpenAPI.OperationObject, contract: AnyContractProcedure): OpenAPI.OperationObject;
+declare function applyCustomOpenAPIOperation(operation: OpenAPI.OperationObject, contract: Contract): OpenAPI.OperationObject;
 
 /**
  * @internal
@@ -76,7 +77,7 @@ interface OpenAPIGeneratorGenerateOptions extends Partial<Omit<OpenAPI.Document,
      * @deprecated Use `filter` option instead.
      * @default () => false
      */
-    exclude?: (procedure: AnyProcedure | AnyContractProcedure, path: readonly string[]) => boolean;
+    exclude?: (procedure: Contract$1, path: readonly string[]) => boolean;
     /**
      * Filter procedures. Return `false` to exclude a procedure from the OpenAPI specification.
      *
@@ -129,7 +130,7 @@ declare class OpenAPIGenerator {
      *
      * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
      */
-    generate(router: AnyContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
+    generate(router: ContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
 }
 
 /**
@@ -162,23 +163,6 @@ declare function checkParamsSchema(schema: ObjectSchema, params: string[]): bool
 declare function toOpenAPISchema(schema: JSONSchema): OpenAPI.SchemaObject & object;
 declare function resolveOpenAPIJsonSchemaRef(doc: OpenAPI.Document, schema: JSONSchema): JSONSchema;
 
-type JsonifiedValue<T> = T extends string ? T : T extends number ? T : T extends boolean ? T : T extends null ? T : T extends undefined ? T : T extends Array<unknown> ? JsonifiedArray<T> : T extends Record<string, unknown> ? {
-    [K in keyof T]: JsonifiedValue<T[K]>;
-} : T extends Date ? string : T extends bigint ? string : T extends File ? File : T extends Blob ? Blob : T extends RegExp ? string : T extends URL ? string : T extends Map<infer K, infer V> ? JsonifiedArray<[K, V][]> : T extends Set<infer U> ? JsonifiedArray<U[]> : T extends AsyncIteratorObject<infer U, infer V> ? AsyncIteratorObject<JsonifiedValue<U>, JsonifiedValue<V>> : unknown;
-type JsonifiedArray<T extends Array<unknown>> = T extends readonly [] ? [] : T extends readonly [infer U, ...infer V] ? [
-    U extends undefined ? null : JsonifiedValue<U>,
-    ...JsonifiedArray<V>
-] : T extends Array<infer U> ? Array<JsonifiedValue<U>> : unknown;
-/**
- * Convert types that JSON not support to corresponding json types
- *
- * @see {@link https://orpc.unnoq.com/docs/openapi/client/openapi-link OpenAPI Link Docs}
- */
-type JsonifiedClient<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? Client<UClientContext, UInput, JsonifiedValue<UOutput>, UError extends ORPCError<infer UCode, infer UData> ? ORPCError<UCode, JsonifiedValue<UData>> : UError> : {
-    [K in keyof T]: T[K] extends NestedClient<any> ? JsonifiedClient<T[K]> : T[K];
-};
-declare function createJsonifiedRouterClient<T extends AnyRouter, TClientContext extends ClientContext>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown, unknown>, ErrorMap, Meta, TClientContext>>): JsonifiedClient<RouterClient<T, TClientContext>>;
-
 /**
  *@internal
  */
@@ -216,5 +200,5 @@ declare const oo: {
     spec: typeof customOpenAPIOperation;
 };
 
-export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, createJsonifiedRouterClient, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
-export type { ConditionalSchemaConverter, FileSchema, JsonifiedArray, JsonifiedClient, JsonifiedValue, ObjectSchema, OpenAPIGeneratorGenerateOptions, OpenAPIGeneratorOptions, OverrideOperationValue, SchemaConvertOptions, SchemaConverter, SchemaConverterComponent };
+export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export type { ConditionalSchemaConverter, FileSchema, ObjectSchema, OpenAPIGeneratorGenerateOptions, OpenAPIGeneratorOptions, OverrideOperationValue, SchemaConvertOptions, SchemaConverter, SchemaConverterComponent };

package/dist/openapi/index.mjs

@@ -1,11 +1,11 @@
-import { isProcedure, resolveContractProcedures, ORPCError, createRouterClient } from '@temporary-name/server';
-import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@temporary-name/contract';
-import { isObject, stringifyJSON, findDeepMatches, toArray, clone, value, toHttpPath, isORPCErrorStatus, fallbackORPCErrorStatus, fallbackORPCErrorMessage, resolveMaybeOptionalOptions, createORPCErrorFromJson } from '@temporary-name/shared';
-import { j as jsonSerialize, d as deserialize, s as serialize } from '../shared/server.JtIZ8YG7.mjs';
+import { isObject, stringifyJSON, findDeepMatches, toArray, clone, value, fallbackContractConfig, toHttpPath, isORPCErrorStatus } from '@temporary-name/shared';
+import { j as jsonSerialize } from '../shared/server.CQIFwyhc.mjs';
 import '@temporary-name/standard-server';
-import { s as standardizeHTTPPath, g as getDynamicParams } from '../shared/server.DN9mVGfv.mjs';
+import { g as getEventIteratorSchemaDetails } from '../shared/server.YUvuxHty.mjs';
+import { s as standardizeHTTPPath, r as resolveContractProcedures, g as getDynamicParams } from '../shared/server.ChOv1yG3.mjs';
 import { TypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+import '@temporary-name/zod';
 
 const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
 function customOpenAPIOperation(o, extend) {
@@ -23,20 +23,12 @@ function getCustomOpenAPIOperation(o) {
 }
 function applyCustomOpenAPIOperation(operation, contract) {
   const operationCustoms = [];
-  for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
-    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
+  for (const middleware of contract["~orpc"].middlewares) {
+    const maybeExtender = getCustomOpenAPIOperation(middleware);
     if (maybeExtender) {
       operationCustoms.push(maybeExtender);
     }
   }
-  if (isProcedure(contract)) {
-    for (const middleware of contract["~orpc"].middlewares) {
-      const maybeExtender = getCustomOpenAPIOperation(middleware);
-      if (maybeExtender) {
-        operationCustoms.push(maybeExtender);
-      }
-    }
-  }
   let currentOperation = operation;
   for (const custom of operationCustoms) {
     if (typeof custom === "function") {
@@ -433,12 +425,6 @@ class OpenAPIGenerator {
           };
           await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);
           await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);
-          await this.#errorResponse(
-            operationObjectRef,
-            def,
-            baseSchemaConvertOptions,
-            undefinedErrorJsonSchema
-          );
         }
         if (typeof def.route.spec === "function") {
           operationObjectRef = def.route.spec(operationObjectRef);
@@ -697,64 +683,10 @@ ${errors.join("\n\n")}`
       }
     }
   }
-  async #errorResponse(ref, def, baseSchemaConvertOptions, undefinedErrorSchema) {
-    const errorMap = def.errorMap;
-    const errors = {};
-    for (const code in errorMap) {
-      const config = errorMap[code];
-      if (!config) {
-        continue;
-      }
-      const status = fallbackORPCErrorStatus(code, config.status);
-      const message = fallbackORPCErrorMessage(code, config.message);
-      const [dataRequired, dataSchema] = await this.converter.convert(config.data, {
-        ...baseSchemaConvertOptions,
-        strategy: "output"
-      });
-      errors[status] ??= [];
-      errors[status].push({
-        type: "object",
-        properties: {
-          defined: { const: true },
-          code: { const: code },
-          status: { const: status },
-          message: { type: "string", default: message },
-          data: dataSchema
-        },
-        required: dataRequired ? ["defined", "code", "status", "message", "data"] : ["defined", "code", "status", "message"]
-      });
-    }
-    ref.responses ??= {};
-    for (const status in errors) {
-      const schemas = errors[status];
-      ref.responses[status] = {
-        description: status,
-        content: toOpenAPIContent({
-          oneOf: [...schemas, undefinedErrorSchema]
-        })
-      };
-    }
-  }
-}
-
-function createJsonifiedRouterClient(router, ...rest) {
-  const options = resolveMaybeOptionalOptions(rest);
-  options.interceptors ??= [];
-  options.interceptors.unshift(async (options2) => {
-    try {
-      return deserialize(serialize(await options2.next()));
-    } catch (e) {
-      if (e instanceof ORPCError) {
-        throw createORPCErrorFromJson(deserialize(serialize(e.toJSON(), { outputFormat: "plain" })));
-      }
-      throw e;
-    }
-  });
-  return createRouterClient(router, options);
 }
 
 const oo = {
   spec: customOpenAPIOperation
 };
 
-export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, createJsonifiedRouterClient, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, customOpenAPIOperation, expandArrayableSchema, expandUnionSchema, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, isPrimitiveSchema, oo, resolveOpenAPIJsonSchemaRef, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };

package/dist/shared/server.BYV-qTJt.d.ts

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