@temporary-name/server 1.9.3-alpha.e09726e1bf5340c7b7052eeabcb4935b3c85ce93 → 1.9.3-alpha.e098b3d1c5bffbad2fadfda89ba01f6452db46b5

package/dist/openapi/index.mjs

@@ -1,7 +1,7 @@
 import { isProcedure, resolveContractProcedures, ORPCError, createRouterClient } from '@temporary-name/server';
-import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@temporary-name/contract';
+import { standardizeHTTPPath, fallbackContractConfig, getDynamicParams, getEventIteratorSchemaDetails } from '@temporary-name/contract';
 import { isObject, stringifyJSON, findDeepMatches, toArray, clone, value, toHttpPath, isORPCErrorStatus, fallbackORPCErrorStatus, fallbackORPCErrorMessage, resolveMaybeOptionalOptions, createORPCErrorFromJson } from '@temporary-name/shared';
-import { a as standardizeHTTPPath, j as jsonSerialize, g as getDynamicParams, d as deserialize, s as serialize } from '../shared/server.BEHw7Eyx.mjs';
+import { j as jsonSerialize, d as deserialize, s as serialize } from '../shared/server.JtIZ8YG7.mjs';
 import '@temporary-name/standard-server';
 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';
@@ -530,94 +530,77 @@ ${errors.join("\n\n")}`
   }
   async #request(doc, ref, def, baseSchemaConvertOptions) {
     const method = fallbackContractConfig("defaultMethod", def.route.method);
-    const details = getEventIteratorSchemaDetails(def.inputSchema);
-    if (details) {
-      ref.requestBody = {
-        required: true,
-        content: toOpenAPIEventIteratorContent(
-          await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
-          await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
-        )
-      };
-      return;
-    }
     const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
-    const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
-    let [required, schema] = await this.converter.convert(def.inputSchema, {
+    const [_pathRequired, pathSchema] = await this.converter.convert(def.schemas.pathSchema, {
       ...baseSchemaConvertOptions,
       strategy: "input",
-      minStructureDepthForRef: dynamicParams?.length || inputStructure === "detailed" ? 1 : 0
+      minStructureDepthForRef: 1
     });
-    if (isAnySchema(schema) && !dynamicParams?.length) {
-      return;
-    }
-    if (inputStructure === "compact") {
-      if (dynamicParams?.length) {
-        const error2 = new OpenAPIGeneratorError(
-          'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
-        );
-        if (!isObjectSchema(schema)) {
-          throw error2;
-        }
-        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
-        schema = rest;
-        required = rest.required ? rest.required.length !== 0 : false;
-        if (!checkParamsSchema(paramsSchema, dynamicParams)) {
-          throw error2;
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+    if (dynamicParams?.length) {
+      const error = new OpenAPIGeneratorError(
+        // TODO: fix this error
+        'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
+      );
+      if (!isObjectSchema(pathSchema)) {
+        throw error;
       }
-      if (method === "GET") {
-        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, schema);
-        if (!isObjectSchema(resolvedSchema)) {
-          throw new OpenAPIGeneratorError(
-            'When method is "GET", input schema must satisfy: object | any | unknown'
-          );
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
-      } else {
-        ref.requestBody = {
-          required,
-          content: toOpenAPIContent(schema)
-        };
+      if (!checkParamsSchema(pathSchema, dynamicParams)) {
+        throw error;
+      }
+      ref.parameters ??= [];
+      ref.parameters.push(...toOpenAPIParameters(pathSchema, "path"));
+    } else {
+      const error = new OpenAPIGeneratorError("Params set via path do not match those on the route");
+      if (!isObjectSchema(pathSchema)) {
+        console.log("FOO", pathSchema);
+        throw error;
+      }
+      if (!checkParamsSchema(pathSchema, [])) {
+        console.log("BAR", pathSchema);
+        throw error;
       }
-      return;
-    }
-    const error = new OpenAPIGeneratorError(
-      'When input structure is "detailed", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'
-    );
-    if (!isObjectSchema(schema)) {
-      throw error;
     }
-    const resolvedParamSchema = schema.properties?.params !== void 0 ? resolveOpenAPIJsonSchemaRef(doc, schema.properties.params) : void 0;
-    if (dynamicParams?.length && (resolvedParamSchema === void 0 || !isObjectSchema(resolvedParamSchema) || !checkParamsSchema(resolvedParamSchema, dynamicParams))) {
-      throw new OpenAPIGeneratorError(
-        'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
-      );
+    const [_queryRequired, querySchema] = await this.converter.convert(def.schemas.querySchema, {
+      ...baseSchemaConvertOptions,
+      strategy: "input",
+      minStructureDepthForRef: 0
+    });
+    if (!isAnySchema(querySchema)) {
+      const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, querySchema);
+      if (!isObjectSchema(resolvedSchema)) {
+        throw new OpenAPIGeneratorError("Query param schema must satisfy: object | any | unknown");
+      }
+      ref.parameters ??= [];
+      ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
     }
-    for (const from of ["params", "query", "headers"]) {
-      const fromSchema = schema.properties?.[from];
-      if (fromSchema !== void 0) {
-        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, fromSchema);
-        if (!isObjectSchema(resolvedSchema)) {
-          throw error;
+    if (method !== "GET") {
+      const details = getEventIteratorSchemaDetails(def.schemas.bodySchema);
+      if (details) {
+        ref.requestBody = {
+          required: true,
+          content: toOpenAPIEventIteratorContent(
+            await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
+            await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
+          )
+        };
+      } else {
+        const [bodyRequired, bodySchema] = await this.converter.convert(def.schemas.bodySchema, {
+          ...baseSchemaConvertOptions,
+          strategy: "input",
+          minStructureDepthForRef: 0
+        });
+        if (isAnySchema(bodySchema)) {
+          return;
         }
-        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));
+        ref.requestBody = {
+          required: bodyRequired,
+          content: toOpenAPIContent(bodySchema)
+        };
       }
     }
-    if (schema.properties?.body !== void 0) {
-      ref.requestBody = {
-        required: schema.required?.includes("body"),
-        content: toOpenAPIContent(schema.properties.body)
-      };
-    }
   }
   async #successResponse(doc, ref, def, baseSchemaConvertOptions) {
-    const outputSchema = def.outputSchema;
+    const outputSchema = def.schemas.outputSchema;
     const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
     const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
     const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);

package/dist/plugins/index.d.mts

@@ -1,58 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
-import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
-import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.C1fnTLq0.mjs';
-import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.BKSOrA6h.mjs';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.D6Qs_UcF.mjs';
+import { C as Context, G as ProcedureClientInterceptorOptions } from '../shared/server.BL2R5jcp.mjs';
 import { Meta } from '@temporary-name/contract';
 
-interface BatchHandlerOptions<T extends Context> {
-    /**
-     * The max size of the batch allowed.
-     *
-     * @default 10
-     */
-    maxSize?: Value<Promisable<number>, [StandardHandlerInterceptorOptions<T>]>;
-    /**
-     * Map the request before processing it.
-     *
-     * @default merged back batch request headers into the request
-     */
-    mapRequestItem?(request: StandardRequest, batchOptions: StandardHandlerInterceptorOptions<T>): StandardRequest;
-    /**
-     * Success batch response status code.
-     *
-     * @default 207
-     */
-    successStatus?: Value<Promisable<number>, [
-        responses: Promise<BatchResponseBodyItem>[],
-        batchOptions: StandardHandlerInterceptorOptions<T>
-    ]>;
-    /**
-     * success batch response headers.
-     *
-     * @default {}
-     */
-    headers?: Value<Promisable<StandardHeaders>, [
-        responses: Promise<BatchResponseBodyItem>[],
-        batchOptions: StandardHandlerInterceptorOptions<T>
-    ]>;
-}
-/**
- * The Batch Requests Plugin allows you to combine multiple requests and responses into a single batch,
- * reducing the overhead of sending each one separately.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/batch-requests Batch Requests Plugin Docs}
- */
-declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    private readonly maxSize;
-    private readonly mapRequestItem;
-    private readonly successStatus;
-    private readonly headers;
-    order: number;
-    constructor(options?: BatchHandlerOptions<T>);
-    init(options: StandardHandlerOptions<T>): void;
-}
-
 interface CORSOptions<T extends Context> {
     origin?: Value<Promisable<string | readonly string[] | null | undefined>, [
         origin: string,
@@ -156,5 +106,5 @@ declare class SimpleCsrfProtectionHandlerPlugin<T extends Context> implements St
     init(options: StandardHandlerOptions<T>): void;
 }
 
-export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
-export type { BatchHandlerOptions, CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions };
+export { CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export type { CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions };

package/dist/plugins/index.d.ts

@@ -1,58 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
-import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
-import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.CQyYNJ1H.js';
-import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.BKSOrA6h.js';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.DpoO_ER_.js';
+import { C as Context, G as ProcedureClientInterceptorOptions } from '../shared/server.BL2R5jcp.js';
 import { Meta } from '@temporary-name/contract';
 
-interface BatchHandlerOptions<T extends Context> {
-    /**
-     * The max size of the batch allowed.
-     *
-     * @default 10
-     */
-    maxSize?: Value<Promisable<number>, [StandardHandlerInterceptorOptions<T>]>;
-    /**
-     * Map the request before processing it.
-     *
-     * @default merged back batch request headers into the request
-     */
-    mapRequestItem?(request: StandardRequest, batchOptions: StandardHandlerInterceptorOptions<T>): StandardRequest;
-    /**
-     * Success batch response status code.
-     *
-     * @default 207
-     */
-    successStatus?: Value<Promisable<number>, [
-        responses: Promise<BatchResponseBodyItem>[],
-        batchOptions: StandardHandlerInterceptorOptions<T>
-    ]>;
-    /**
-     * success batch response headers.
-     *
-     * @default {}
-     */
-    headers?: Value<Promisable<StandardHeaders>, [
-        responses: Promise<BatchResponseBodyItem>[],
-        batchOptions: StandardHandlerInterceptorOptions<T>
-    ]>;
-}
-/**
- * The Batch Requests Plugin allows you to combine multiple requests and responses into a single batch,
- * reducing the overhead of sending each one separately.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/batch-requests Batch Requests Plugin Docs}
- */
-declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    private readonly maxSize;
-    private readonly mapRequestItem;
-    private readonly successStatus;
-    private readonly headers;
-    order: number;
-    constructor(options?: BatchHandlerOptions<T>);
-    init(options: StandardHandlerOptions<T>): void;
-}
-
 interface CORSOptions<T extends Context> {
     origin?: Value<Promisable<string | readonly string[] | null | undefined>, [
         origin: string,
@@ -156,5 +106,5 @@ declare class SimpleCsrfProtectionHandlerPlugin<T extends Context> implements St
     init(options: StandardHandlerOptions<T>): void;
 }
 
-export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
-export type { BatchHandlerOptions, CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions };
+export { CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export type { CORSOptions, RequestHeadersPluginContext, ResponseHeadersPluginContext, SimpleCsrfProtectionHandlerPluginOptions };

package/dist/plugins/index.mjs

@@ -1,120 +1,7 @@
-import { runWithSpan, value, setSpanError, isAsyncIteratorObject, AsyncIteratorClass, clone, ORPCError } from '@temporary-name/shared';
+import { value, clone, ORPCError } from '@temporary-name/shared';
 import { flattenHeader } from '@temporary-name/standard-server';
-import { parseBatchRequest, toBatchResponse } from '@temporary-name/standard-server/batch';
 import { toFetchHeaders } from '@temporary-name/standard-server-fetch';
 
-class BatchHandlerPlugin {
-  maxSize;
-  mapRequestItem;
-  successStatus;
-  headers;
-  order = 5e6;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 10;
-    this.mapRequestItem = options.mapRequestItem ?? ((request, { request: batchRequest }) => ({
-      ...request,
-      headers: {
-        ...batchRequest.headers,
-        ...request.headers
-      }
-    }));
-    this.successStatus = options.successStatus ?? 207;
-    this.headers = options.headers ?? {};
-  }
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.unshift(async (options2) => {
-      const xHeader = flattenHeader(options2.request.headers["x-orpc-batch"]);
-      if (xHeader === void 0) {
-        return options2.next();
-      }
-      let isParsing = false;
-      try {
-        return await runWithSpan({ name: "handle_batch_request" }, async (span) => {
-          const mode = xHeader === "buffered" ? "buffered" : "streaming";
-          isParsing = true;
-          const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
-          isParsing = false;
-          span?.setAttribute("batch.mode", mode);
-          span?.setAttribute("batch.size", parsed.length);
-          const maxSize = await value(this.maxSize, options2);
-          if (parsed.length > maxSize) {
-            const message = "Batch request size exceeds the maximum allowed size";
-            setSpanError(span, message);
-            return {
-              matched: true,
-              response: {
-                status: 413,
-                headers: {},
-                body: message
-              }
-            };
-          }
-          const responses = parsed.map((request, index) => {
-            const mapped = this.mapRequestItem(request, options2);
-            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
-              span?.addEvent(`response.${index}.${matched ? "success" : "not_matched"}`);
-              if (matched) {
-                if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
-                  return {
-                    index,
-                    status: 500,
-                    headers: {},
-                    body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
-                  };
-                }
-                return { ...response2, index };
-              }
-              return { index, status: 404, headers: {}, body: "No procedure matched" };
-            }).catch((err) => {
-              Promise.reject(err);
-              return { index, status: 500, headers: {}, body: "Internal server error" };
-            });
-          });
-          await Promise.race(responses);
-          const status = await value(this.successStatus, responses, options2);
-          const headers = await value(this.headers, responses, options2);
-          const promises = [...responses];
-          const response = await toBatchResponse({
-            status,
-            headers,
-            mode,
-            body: new AsyncIteratorClass(
-              async () => {
-                const handling = promises.filter((p) => p !== void 0);
-                if (handling.length <= 0) {
-                  return { done: true, value: void 0 };
-                }
-                const value2 = await Promise.race(handling);
-                promises[value2.index] = void 0;
-                return { done: false, value: value2 };
-              },
-              async () => {
-              }
-            )
-          });
-          return {
-            matched: true,
-            response
-          };
-        });
-      } catch (cause) {
-        if (isParsing) {
-          return {
-            matched: true,
-            response: {
-              status: 400,
-              headers: {},
-              body: "Invalid batch request, this could be caused by a malformed request body or a missing header"
-            }
-          };
-        }
-        throw cause;
-      }
-    });
-  }
-}
-
 class CORSPlugin {
   options;
   order = 9e6;
@@ -285,4 +172,4 @@ class SimpleCsrfProtectionHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export { CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };

package/dist/shared/{server.BeuTpcmO.d.mts → server.7aL9gcoU.d.mts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.BKSOrA6h.mjs';
-import { c as StandardHandleOptions } from './server.C1fnTLq0.mjs';
+import { C as Context } from './server.BL2R5jcp.mjs';
+import { c as StandardHandleOptions } from './server.D6Qs_UcF.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;