@temporary-name/server 1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d → 1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d

package/dist/index.mjs

@@ -1,14 +1,35 @@
-import { isContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, enhanceRoute, mergeTags, getContractRouter } from '@temporary-name/contract';
-export { ValidationError, eventIterator, type, 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 { g as gatingContext } from './shared/server.D6K9uoPI.mjs';
-import { c as createProcedureClient, i as isLazy, g as getLazyMeta, l as lazy, u as unlazy } from './shared/server.BEQrAa3A.mjs';
-export { L as LAZY_SYMBOL, a as createORPCErrorConstructorMap, m as mergeCurrentContext, b as middlewareOutputFn } from './shared/server.BEQrAa3A.mjs';
+import { isContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, enhanceRoute, mergeTags, ContractProcedure, prefixRoute, getContractRouter } from '@temporary-name/contract';
+export { ValidationError, eventIterator, validateORPCError } from '@temporary-name/contract';
+import { SchemaClass, gatingContext } from '@temporary-name/zod';
+import { c as createProcedureClient, i as isLazy, g as getLazyMeta, l as lazy, u as unlazy } from './shared/server.DcfsPloY.mjs';
+export { L as LAZY_SYMBOL, a as createORPCErrorConstructorMap, m as mergeCurrentContext, b as middlewareOutputFn } from './shared/server.DcfsPloY.mjs';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
-import 'node:async_hooks';
-import 'zod';
-import 'zod/v4/core';
+
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
+}
 
 function decorateMiddleware(middleware) {
   const decorated = ((...args) => middleware(...args));
@@ -46,30 +67,6 @@ function decorateMiddleware(middleware) {
   return decorated;
 }
 
-function isStartWithMiddlewares(middlewares, compare) {
-  if (compare.length > middlewares.length) {
-    return false;
-  }
-  for (let i = 0; i < middlewares.length; i++) {
-    if (compare[i] === void 0) {
-      return true;
-    }
-    if (middlewares[i] !== compare[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-function mergeMiddlewares(first, second, options) {
-  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
-    return second;
-  }
-  return [...first, ...second];
-}
-function addMiddleware(middlewares, addition) {
-  return [...middlewares, addition];
-}
-
 class Procedure {
   /**
    * This property holds the defined options.
@@ -296,87 +293,49 @@ async function unlazyRouter(router) {
   return unlazied;
 }
 
-class Builder {
-  /**
-   * This property holds the defined options.
-   */
-  "~orpc";
+class ProcedureBuilder extends ContractProcedure {
+  z;
   constructor(def) {
-    this["~orpc"] = def;
+    super(def);
+    this.z = new SchemaClass();
   }
   /**
-   * Set or override the initial context.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
-   */
-  $context() {
-    return this;
-  }
-  /**
-   * Creates a middleware.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-   */
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  /**
-   * Adds type-safe custom errors.
-   * The provided errors are spared-merged with any existing errors.
+   * 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 Builder({
+    return new ProcedureBuilder({
       ...this["~orpc"],
       errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   /**
-   * Uses a middleware to modify the context or improve the pipeline.
-   *
-   * @info Supports both normal middleware and inline middleware implementations.
-   * @note The current context must be satisfy middleware dependent-context
-   * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
-   */
-  use(middleware) {
-    return new Builder({
-      ...this["~orpc"],
-      middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
-    });
-  }
-  useGating(gates, isGateEnabled) {
-    return this.use(({ next, context }) => {
-      return gatingContext.run(
-        (gate) => isGateEnabled(gate, context),
-        () => next({ context: { isGateEnabled } })
-      );
-    });
-  }
-  /**
-   * Sets or updates the metadata.
-   * The provided metadata is spared-merged with any existing metadata.
+   * Sets or updates the metadata for the contract.
+   * The provided metadata is spared-merged with any existing metadata in the contract.
    *
    * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
    */
   meta(meta) {
-    return new Builder({
+    return new ProcedureBuilder({
       ...this["~orpc"],
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   /**
-   * Sets or updates the route definition.
-   * The provided route is spared-merged with any existing route.
+   * Sets or updates the route definition for the contract.
+   * The provided route is spared-merged with any existing route in the contract.
    * This option is typically relevant when integrating with OpenAPI.
    *
    * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
    * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
    */
   route(route) {
-    return new Builder({
+    const { prefix } = this["~orpc"];
+    return new ProcedureBuilder({
       ...this["~orpc"],
-      route: mergeRoute(this["~orpc"].route, route)
+      route: mergeRoute(this["~orpc"].route, prefix ? prefixRoute(route, prefix) : route)
     });
   }
   /**
@@ -385,7 +344,7 @@ class Builder {
    * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Input Validation Docs}
    */
   input(schema) {
-    return new Builder({
+    return new ProcedureBuilder({
       ...this["~orpc"],
       inputSchema: schema,
       inputValidationIndex: this["~orpc"].middlewares.length
@@ -397,12 +356,33 @@ class Builder {
    * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Output Validation Docs}
    */
   output(schema) {
-    return new Builder({
+    return new ProcedureBuilder({
       ...this["~orpc"],
       outputSchema: schema,
       outputValidationIndex: this["~orpc"].middlewares.length
     });
   }
+  /**
+   * Uses a middleware to modify the context or improve the pipeline.
+   *
+   * @info Supports both normal middleware and inline middleware implementations.
+   * @note The current context must be satisfy middleware dependent-context
+   * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+   */
+  use(middleware) {
+    return new this.constructor({
+      ...this["~orpc"],
+      middlewares: addMiddleware(this["~orpc"].middlewares, middleware)
+    });
+  }
+  useGating(gates, isGateEnabled) {
+    return this.use(({ next, context }) => {
+      return gatingContext.run(
+        (gate) => isGateEnabled(gate, context),
+        () => next({ context: { isGateEnabled } })
+      );
+    });
+  }
   /**
    * Defines the handler of the procedure.
    *
@@ -414,6 +394,8 @@ class Builder {
       handler
     });
   }
+}
+class BuilderWithMiddlewares extends ProcedureBuilder {
   /**
    * Prefixes all procedures in the router.
    * The provided prefix is post-appended to any existing router prefix.
@@ -423,7 +405,7 @@ class Builder {
    * @see {@link https://orpc.unnoq.com/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
    */
   prefix(prefix) {
-    return new Builder({
+    return new this.constructor({
       ...this["~orpc"],
       prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
@@ -435,7 +417,7 @@ class Builder {
    * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
    */
   tag(...tags) {
-    return new Builder({
+    return new this.constructor({
       ...this["~orpc"],
       tags: mergeTags(this["~orpc"].tags, tags)
     });
@@ -458,15 +440,34 @@ class Builder {
     return enhanceRouter(lazy(loader), this["~orpc"]);
   }
 }
+
+class Builder extends BuilderWithMiddlewares {
+  /**
+   * Set or override the initial context.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/context Context Docs}
+   */
+  $context() {
+    return this;
+  }
+  /**
+   * Creates a middleware.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+   */
+  middleware(middleware) {
+    return decorateMiddleware(middleware);
+  }
+}
 function createApiBuilder(opts = {}) {
-  const base = new Builder({
+  return new Builder({
     route: {},
     meta: opts.meta ?? {},
     errorMap: {},
     inputValidationIndex: 0,
     outputValidationIndex: 0,
     middlewares: [
-      onError((error, options) => {
+      onError((error, _options) => {
         console.dir(error, { depth: null });
       })
     ],
@@ -474,7 +475,6 @@ function createApiBuilder(opts = {}) {
     // the best solution). For now I've removed the interface to configure it externally.
     dedupeLeadingMiddlewares: true
   });
-  return base;
 }
 const os = createApiBuilder();
 
@@ -615,4 +615,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, DecoratedProcedure, Procedure, addMiddleware, call, createAccessibleLazyRouter, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getHiddenRouterContract, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, isStartWithMiddlewares, lazy, mergeMiddlewares, os, resolveContractProcedures, setHiddenRouterContract, traverseContractProcedures, unlazy, unlazyRouter };
+export { Builder, BuilderWithMiddlewares, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createAccessibleLazyRouter, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getHiddenRouterContract, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, isStartWithMiddlewares, lazy, mergeMiddlewares, os, resolveContractProcedures, setHiddenRouterContract, traverseContractProcedures, unlazy, unlazyRouter };

package/dist/openapi/index.d.mts

@@ -0,0 +1,220 @@
+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 { 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';
+
+type OverrideOperationValue = Partial<OpenAPI.OperationObject> | ((current: OpenAPI.OperationObject, procedure: AnyContractProcedure) => OpenAPI.OperationObject);
+/**
+ * Customize The Operation Object by proxy an error map item or a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#customizing-operation-objects Customizing Operation Objects Docs}
+ */
+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;
+
+/**
+ * @internal
+ */
+type ObjectSchema = JSONSchema & {
+    type: 'object';
+} & object;
+/**
+ * @internal
+ */
+type FileSchema = JSONSchema & {
+    type: 'string';
+    contentMediaType: string;
+} & object;
+/**
+ * @internal
+ */
+declare const LOGIC_KEYWORDS: string[];
+
+interface SchemaConverterComponent {
+    allowedStrategies: readonly SchemaConvertOptions['strategy'][];
+    schema: AnySchema;
+    required: boolean;
+    ref: string;
+}
+interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+    /**
+     * Common components should use `$ref` to represent themselves if matched.
+     */
+    components?: readonly SchemaConverterComponent[];
+    /**
+     * Minimum schema structure depth required before using `$ref` for components.
+     *
+     * For example, if set to 2, `$ref` will only be used for schemas nested at depth 2 or greater.
+     *
+     * @default 0 - No depth limit;
+     */
+    minStructureDepthForRef?: number;
+}
+interface SchemaConverter {
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: JSONSchema]>;
+}
+interface ConditionalSchemaConverter extends SchemaConverter {
+    condition(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<boolean>;
+}
+declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: readonly ConditionalSchemaConverter[]);
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promise<[required: boolean, jsonSchema: JSONSchema]>;
+}
+
+interface OpenAPIGeneratorOptions {
+    schemaConverters?: ConditionalSchemaConverter[];
+}
+interface OpenAPIGeneratorGenerateOptions extends Partial<Omit<OpenAPI.Document, 'openapi'>> {
+    /**
+     * Exclude procedures from the OpenAPI specification.
+     *
+     * @deprecated Use `filter` option instead.
+     * @default () => false
+     */
+    exclude?: (procedure: AnyProcedure | AnyContractProcedure, path: readonly string[]) => boolean;
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from the OpenAPI specification.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+    /**
+     * Common schemas to be used for $ref resolution.
+     */
+    commonSchemas?: Record<string, {
+        /**
+         * Determines which schema definition to use when input and output schemas differ.
+         * This is needed because some schemas transform data differently between input and output,
+         * making it impossible to use a single $ref for both cases.
+         *
+         * @example
+         * ```ts
+         * // This schema transforms a string input into a number output
+         * const Schema = z.string()
+         *   .transform(v => Number(v))
+         *   .pipe(z.number())
+         *
+         * // Input schema:  { type: 'string' }
+         * // Output schema: { type: 'number' }
+         * ```
+         *
+         * When schemas differ between input and output, you must explicitly choose
+         * which version to use for the OpenAPI specification.
+         *
+         * @default 'input' - Uses the input schema definition by default
+         */
+        strategy?: SchemaConvertOptions['strategy'];
+        schema: AnySchema;
+    } | {
+        error: 'UndefinedError';
+        schema?: never;
+    }>;
+}
+/**
+ * The generator that converts oRPC routers/contracts to OpenAPI specifications.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
+ */
+declare class OpenAPIGenerator {
+    #private;
+    private readonly converter;
+    constructor(options?: OpenAPIGeneratorOptions);
+    /**
+     * Generates OpenAPI specifications from oRPC routers/contracts.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
+     */
+    generate(router: AnyContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
+}
+
+/**
+ * @internal
+ */
+declare function toOpenAPIPath(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function toOpenAPIMethod(method: HTTPMethod): Lowercase<HTTPMethod>;
+/**
+ * @internal
+ */
+declare function toOpenAPIContent(schema: JSONSchema): Record<string, OpenAPI.MediaTypeObject>;
+/**
+ * @internal
+ */
+declare function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema]: [boolean, JSONSchema], [returnsRequired, returnsSchema]: [boolean, JSONSchema]): Record<string, OpenAPI.MediaTypeObject>;
+/**
+ * @internal
+ */
+declare function toOpenAPIParameters(schema: ObjectSchema, parameterIn: 'path' | 'query' | 'header' | 'cookie'): OpenAPI.ParameterObject[];
+/**
+ * @internal
+ */
+declare function checkParamsSchema(schema: ObjectSchema, params: string[]): boolean;
+/**
+ * @internal
+ */
+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
+ */
+declare function isFileSchema(schema: JSONSchema): schema is FileSchema;
+/**
+ * @internal
+ */
+declare function isObjectSchema(schema: JSONSchema): schema is ObjectSchema;
+/**
+ * @internal
+ */
+declare function isAnySchema(schema: JSONSchema): boolean;
+/**
+ * @internal
+ */
+declare function separateObjectSchema(schema: ObjectSchema, separatedProperties: string[]): [matched: ObjectSchema, rest: ObjectSchema];
+/**
+ * @internal
+ */
+declare function filterSchemaBranches(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): [matches: JSONSchema[], rest: JSONSchema | undefined];
+declare function applySchemaOptionality(required: boolean, schema: JSONSchema): JSONSchema;
+/**
+ * Takes a JSON schema and, if it's primarily a union type (anyOf, oneOf),
+ * recursively expands it into an array of its constituent, non-union base schemas.
+ * If the schema is not a simple union or is a base type, it's returned as a single-element array.
+ */
+declare function expandUnionSchema(schema: JSONSchema): JSONSchema[];
+declare function expandArrayableSchema(schema: JSONSchema): undefined | [items: JSONSchema, array: JSONSchema & {
+    type: 'array';
+    items?: JSONSchema;
+}];
+declare function isPrimitiveSchema(schema: JSONSchema): boolean;
+
+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 };