@temporary-name/server 1.9.3-alpha.50b729ba628b987e14f5bd1004e5a04590fd4b4e → 1.9.3-alpha.52ad782be6ff2aac22845e524cd6454f857fb89b

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 { 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 { a as standardizeHTTPPath, j as jsonSerialize, g as getDynamicParams, d as deserialize, s as serialize } from '../shared/server.Kxw442A9.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,7 +530,7 @@ ${errors.join("\n\n")}`
   }
   async #request(doc, ref, def, baseSchemaConvertOptions) {
     const method = fallbackContractConfig("defaultMethod", def.route.method);
-    const details = getEventIteratorSchemaDetails(def.inputSchema);
+    const details = getEventIteratorSchemaDetails(def.schemas.inputSchema);
     if (details) {
       ref.requestBody = {
         required: true,
@@ -542,82 +542,48 @@ ${errors.join("\n\n")}`
       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, {
+    let [required, schema] = await this.converter.convert(def.schemas.inputSchema, {
       ...baseSchemaConvertOptions,
       strategy: "input",
-      minStructureDepthForRef: dynamicParams?.length || inputStructure === "detailed" ? 1 : 0
+      minStructureDepthForRef: dynamicParams?.length ? 1 : 0
     });
     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(
+        '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 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)
-        };
+      const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
+      schema = rest;
+      required = rest.required ? rest.required.length !== 0 : false;
+      if (!checkParamsSchema(paramsSchema, dynamicParams)) {
+        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.'
-      );
-    }
-    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;
-        }
-        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));
+      ref.parameters ??= [];
+      ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+    }
+    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'
+        );
       }
-    }
-    if (schema.properties?.body !== void 0) {
+      ref.parameters ??= [];
+      ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
+    } else {
       ref.requestBody = {
-        required: schema.required?.includes("body"),
-        content: toOpenAPIContent(schema.properties.body)
+        required,
+        content: toOpenAPIContent(schema)
       };
     }
   }
   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,8 +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.CbLTWfgn.mjs';
-import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.CZNLCQBm.mjs';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.KIlJQ8K_.mjs';
+import { C as Context, H as ProcedureClientInterceptorOptions } from '../shared/server.Do2Whl-h.mjs';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

package/dist/plugins/index.d.ts

@@ -1,8 +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.Bk5r0-2R.js';
-import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.CZNLCQBm.js';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.DAzElr6Q.js';
+import { C as Context, H as ProcedureClientInterceptorOptions } from '../shared/server.Do2Whl-h.js';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

package/dist/shared/{server.Bs6ka_UE.d.mts → server.B-pKBQ0r.d.mts}

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

package/dist/shared/{server.D2UFMrxf.d.ts → server.BQV-lt_s.d.ts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.CZNLCQBm.js';
-import { c as StandardHandleOptions } from './server.Bk5r0-2R.js';
+import { C as Context } from './server.Do2Whl-h.js';
+import { c as StandardHandleOptions } from './server.DAzElr6Q.js';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.DcfsPloY.mjs → server.BdGbIyq8.mjs}

@@ -1,25 +1,46 @@
-import { validateORPCError, ValidationError } from '@temporary-name/contract';
+import { isContractProcedure, mergePrefix, mergeErrorMap, enhanceRoute, validateORPCError, ValidationError } from '@temporary-name/contract';
 import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
 import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
 import { safeParseAsync } from '@temporary-name/zod';
 
-const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
-function lazy(loader, meta = {}) {
-  return {
-    [LAZY_SYMBOL]: {
-      loader,
-      meta
+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 isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
 }
-function getLazyMeta(lazied) {
-  return lazied[LAZY_SYMBOL].meta;
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
 }
-function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+
+class Procedure {
+  /**
+   * This property holds the defined options.
+   */
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+function isProcedure(item) {
+  if (item instanceof Procedure) {
+    return true;
+  }
+  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
 function mergeCurrentContext(context, other) {
@@ -49,6 +70,179 @@ function createORPCErrorConstructorMap(errors) {
   return proxy;
 }
 
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
+function setHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
+    get(target, key) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+        return contract;
+      }
+      return Reflect.get(target, key);
+    }
+  });
+}
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}
+
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
+    }
+    if (isProcedure(current)) {
+      return void 0;
+    }
+    if (!isLazy(current)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return lazyInternal(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
+}
+function createAccessibleLazyRouter(lazied) {
+  const recursive = new Proxy(lazied, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(lazied, [key]);
+      return createAccessibleLazyRouter(next);
+    }
+  });
+  return recursive;
+}
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazyInternal(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = enhanceRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
+      dedupeLeading: options.dedupeLeadingMiddlewares
+    });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  let currentRouter = options.router;
+  const hiddenContract = getHiddenRouterContract(options.router);
+  if (hiddenContract !== void 0) {
+    currentRouter = hiddenContract;
+  }
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
+      path: options.path
+    });
+  } else if (isContractProcedure(currentRouter)) {
+    callback({
+      contract: currentRouter,
+      path: options.path
+    });
+  } else {
+    for (const key in currentRouter) {
+      traverseContractProcedures(
+        {
+          router: currentRouter[key],
+          path: [...options.path, key]
+        },
+        callback,
+        lazyOptions
+      );
+    }
+  }
+  return lazyOptions;
+}
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (isProcedure(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazyInternal(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function lazy(prefix, loader) {
+  return enhanceRouter(lazyInternal(loader), {
+    middlewares: [],
+    errorMap: {},
+    dedupeLeadingMiddlewares: true,
+    prefix
+  });
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
 function middlewareOutputFn(output) {
   return { output, context: {} };
 }
@@ -110,7 +304,7 @@ function createProcedureClient(lazyableProcedure, ...rest) {
   };
 }
 async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].inputSchema;
+  const schema = procedure["~orpc"].schemas.inputSchema;
   if (!schema) {
     return input;
   }
@@ -133,7 +327,7 @@ async function validateInput(procedure, input) {
   });
 }
 async function validateOutput(procedure, output) {
-  const schema = procedure["~orpc"].outputSchema;
+  const schema = procedure["~orpc"].schemas.outputSchema;
   if (!schema) {
     return output;
   }
@@ -199,4 +393,4 @@ async function executeProcedureInternal(procedure, options) {
   return next(0, options.context, options.input);
 }
 
-export { LAZY_SYMBOL as L, createORPCErrorConstructorMap as a, middlewareOutputFn as b, createProcedureClient as c, getLazyMeta as g, isLazy as i, lazy as l, mergeCurrentContext as m, unlazy as u };
+export { LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, createORPCErrorConstructorMap as f, getLazyMeta as g, lazy as h, isProcedure as i, middlewareOutputFn as j, isStartWithMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, mergeMiddlewares as n, getHiddenRouterContract as o, createAccessibleLazyRouter as p, unlazyRouter as q, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };

package/dist/shared/{server.Bk5r0-2R.d.ts → server.DAzElr6Q.d.ts}

@@ -1,7 +1,7 @@
 import { Meta } from '@temporary-name/contract';
 import { HTTPPath, Interceptor } from '@temporary-name/shared';
 import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
-import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.CZNLCQBm.js';
+import { C as Context, R as Router, H as ProcedureClientInterceptorOptions } from './server.Do2Whl-h.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;