@mionjs/router 0.8.8 → 0.13.0

package/.dist/cjs/src/callContext.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"callContext.cjs","sources":["../../../src/callContext.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {WORKFLOW_PATH} from './constants.ts';\nimport {getRouteExecutionChain} from './router.ts';\nimport type {\n    CallContext,\n    MionResponse,\n    MionRequest,\n    MionHeaders,\n    RawRequestBody,\n    RoutesFlowExecutionResult,\n} from './types/context.ts';\nimport type {RouterOptions} from './types/general.ts';\nimport {Mutable, StatusCodes, SerializerModes, SerializerCode, RpcError, MION_ROUTES, getRoutePath} from '@mionjs/core';\nimport {getRoutesFlowExecutionChain} from './routesFlow.ts';\n\n// ############# POOL STATE #############\n\nlet contextPool: CallContext[] = [];\n\n/** Get current pool statistics for monitoring */\nexport function getContextPoolStats(): {poolSize: number} {\n    return {\n        poolSize: contextPool.length,\n    };\n}\n\n/** Clear the context pool - useful for testing */\nexport function clearContextPool(): void {\n    contextPool = [];\n}\n\n// ############# CONTEXT CREATION #############\n\n/** Creates a new CallContext without pooling (original behavior) */\nexport function createCallContext(\n    path: string,\n    opts: RouterOptions,\n    reqRawBody: RawRequestBody,\n    rawRequest: unknown,\n    reqHeaders: MionHeaders,\n    respHeaders: MionHeaders,\n    reqBodyType?: SerializerCode,\n    urlQuery?: string\n): CallContext {\n    const transformedPath = opts.pathTransform?.(rawRequest, path) || path;\n    const {executionChain, routesFlowRouteIds} = getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);\n    return {\n        path: transformedPath,\n        request: {\n            headers: reqHeaders,\n            rawBody: reqRawBody,\n            bodyType: reqBodyType ?? getRequestBodyType(reqRawBody),\n            body: {},\n            thrownErrors: undefined,\n        },\n        response: {\n            statusCode: StatusCodes.OK,\n            hasErrors: false,\n            headers: respHeaders,\n            body: {},\n            rawBody: '',\n            serializer: SerializerModes.json,\n            binSerializer: undefined,\n        },\n        executionChain,\n        shared: opts.contextDataFactory ? opts.contextDataFactory() : {},\n        urlQuery,\n        routesFlowRouteIds,\n    } as CallContext;\n}\n\n/** Acquires a CallContext from the pool or creates a new one */\nexport function acquireCallContext(\n    usePooling: boolean,\n    path: string,\n    opts: RouterOptions,\n    reqRawBody: RawRequestBody,\n    rawRequest: unknown,\n    reqHeaders: MionHeaders,\n    respHeaders: MionHeaders,\n    reqBodyType?: SerializerCode,\n    urlQuery?: string\n): CallContext {\n    if (!usePooling) return createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery);\n    const pooledContext = contextPool.pop();\n    const transformedPath = opts.pathTransform?.(rawRequest, path) || path;\n\n    if (pooledContext) {\n        // Reuse the pooled context shell, but create fresh body objects\n        const ctx = pooledContext as Mutable<CallContext>;\n        ctx.path = transformedPath;\n        // Reset request - reuse the request object shell\n        const req = ctx.request as Mutable<MionRequest>;\n        req.headers = reqHeaders;\n        req.rawBody = reqRawBody;\n        req.bodyType = reqBodyType ?? getRequestBodyType(reqRawBody);\n        req.body = {}; // Must be fresh - handlers write to this\n        req.thrownErrors = undefined;\n        // Reset response - reuse the response object shell\n        const resp = ctx.response as Mutable<MionResponse>;\n        resp.statusCode = StatusCodes.OK;\n        resp.hasErrors = false;\n        resp.headers = respHeaders;\n        resp.body = {}; // Must be fresh - handlers write to this\n        resp.rawBody = '';\n        resp.serializer = SerializerModes.json;\n        resp.binSerializer = undefined;\n        // Reset execution chain and routesFlow route IDs\n        const {executionChain, routesFlowRouteIds} = getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);\n        ctx.executionChain = executionChain;\n        ctx.routesFlowRouteIds = routesFlowRouteIds;\n        // Reset shared data\n        ctx.shared = opts.contextDataFactory ? opts.contextDataFactory() : {};\n        // Reset urlQuery\n        ctx.urlQuery = urlQuery;\n        return ctx;\n    }\n    // No pooled context available, create new one\n    return createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery);\n}\n\n/** Releases a CallContext back to the pool for reuse */\nexport function releaseCallContext(ctx: CallContext, maxPoolSize: number): void {\n    if (contextPool.length < maxPoolSize) {\n        const mutableCtx = ctx as Mutable<CallContext>;\n        const req = mutableCtx.request as Mutable<MionRequest>;\n        // Clear request data - safe to mutate since request is not returned to caller\n        req.rawBody = '';\n        req.body = null as any; // Will be set when context is acquired\n        req.thrownErrors = undefined;\n        // Create fresh response object - the old one may still be referenced by the caller\n        // IMPORTANT: We must NOT mutate the existing response object because it's returned\n        // to the platform wrapper (e.g., HTTP handler) which may still be using it\n        mutableCtx.response = {\n            statusCode: StatusCodes.OK,\n            hasErrors: false,\n            headers: null as any, // Will be set when context is acquired\n            body: null as any, // Will be set when context is acquired\n            rawBody: '',\n            serializer: SerializerModes.json,\n            binSerializer: undefined,\n        };\n        mutableCtx.shared = null as any;\n        mutableCtx.executionChain = null as any;\n        mutableCtx.routesFlowRouteIds = undefined;\n        contextPool.push(ctx);\n    }\n    // If pool is full, let the context be garbage collected\n}\n\n// ############# HELPER FUNCTIONS #############\n\nfunction getRequestBodyType(rawBody: RawRequestBody): SerializerCode {\n    if (typeof rawBody === 'string') return SerializerModes.stringifyJson;\n    if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array) return SerializerModes.binary;\n    return SerializerModes.json;\n}\n\n/** Gets the execution chain for a path, handling routesFlow paths specially */\nfunction getExecutionChain(\n    originalPath: string,\n    transformedPath: string,\n    urlQuery: string | undefined,\n    rawRequest: unknown,\n    opts: RouterOptions\n): RoutesFlowExecutionResult {\n    const hasPrefix = !!opts.basePath;\n    // Handle routesFlow path - check if the original path ends with the workflow key\n    // This works with any prefix (e.g., /mion-routes-flow, /api/v1/mion-routes-flow)\n    const isRoutesFlowPath = hasPrefix ? originalPath.endsWith(WORKFLOW_PATH) : originalPath === WORKFLOW_PATH;\n    if (isRoutesFlowPath) return getRoutesFlowExecutionChain(rawRequest, opts, urlQuery);\n\n    // Normal path - get execution chain from router using transformed path\n    let executionChain = getRouteExecutionChain(transformedPath);\n    if (!executionChain) {\n        const notFoundPath = getRoutePath([MION_ROUTES.notFound], opts);\n        executionChain = getRouteExecutionChain(notFoundPath);\n        if (!executionChain) {\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'not-found',\n                publicMessage: 'Not-found route is not registered. This should never happen.',\n            });\n        }\n    }\n    return {executionChain};\n}\n"],"names":["StatusCodes","SerializerModes","WORKFLOW_PATH","getRoutesFlowExecutionChain","getRouteExecutionChain","getRoutePath","MION_ROUTES","RpcError"],"mappings":";;;;;;AAuBA,IAAI,cAA6B,CAAA;AAG1B,SAAS,sBAA0C;AACtD,SAAO;AAAA,IACH,UAAU,YAAY;AAAA,EAAA;AAE9B;AAGO,SAAS,mBAAyB;AACrC,gBAAc,CAAA;AAClB;AAKO,SAAS,kBACZ,MACA,MACA,YACA,YACA,YACA,aACA,aACA,UACW;AACX,QAAM,kBAAkB,KAAK,gBAAgB,YAAY,IAAI,KAAK;AAClE,QAAM,EAAC,gBAAgB,mBAAA,IAAsB,kBAAkB,MAAM,iBAAiB,UAAU,YAAY,IAAI;AAChH,SAAO;AAAA,IACH,MAAM;AAAA,IACN,SAAS;AAAA,MACL,SAAS;AAAA,MACT,SAAS;AAAA,MACT,UAAU,eAAe,mBAAmB,UAAU;AAAA,MACtD,MAAM,CAAA;AAAA,MACN,cAAc;AAAA,IAAA;AAAA,IAElB,UAAU;AAAA,MACN,YAAYA,KAAAA,YAAY;AAAA,MACxB,WAAW;AAAA,MACX,SAAS;AAAA,MACT,MAAM,CAAA;AAAA,MACN,SAAS;AAAA,MACT,YAAYC,KAAAA,gBAAgB;AAAA,MAC5B,eAAe;AAAA,IAAA;AAAA,IAEnB;AAAA,IACA,QAAQ,KAAK,qBAAqB,KAAK,mBAAA,IAAuB,CAAA;AAAA,IAC9D;AAAA,IACA;AAAA,EAAA;AAER;AAGO,SAAS,mBACZ,YACA,MACA,MACA,YACA,YACA,YACA,aACA,aACA,UACW;AACX,MAAI,CAAC,WAAY,QAAO,kBAAkB,MAAM,MAAM,YAAY,YAAY,YAAY,aAAa,aAAa,QAAQ;AAC5H,QAAM,gBAAgB,YAAY,IAAA;AAClC,QAAM,kBAAkB,KAAK,gBAAgB,YAAY,IAAI,KAAK;AAElE,MAAI,eAAe;AAEf,UAAM,MAAM;AACZ,QAAI,OAAO;AAEX,UAAM,MAAM,IAAI;AAChB,QAAI,UAAU;AACd,QAAI,UAAU;AACd,QAAI,WAAW,eAAe,mBAAmB,UAAU;AAC3D,QAAI,OAAO,CAAA;AACX,QAAI,eAAe;AAEnB,UAAM,OAAO,IAAI;AACjB,SAAK,aAAaD,KAAAA,YAAY;AAC9B,SAAK,YAAY;AACjB,SAAK,UAAU;AACf,SAAK,OAAO,CAAA;AACZ,SAAK,UAAU;AACf,SAAK,aAAaC,KAAAA,gBAAgB;AAClC,SAAK,gBAAgB;AAErB,UAAM,EAAC,gBAAgB,mBAAA,IAAsB,kBAAkB,MAAM,iBAAiB,UAAU,YAAY,IAAI;AAChH,QAAI,iBAAiB;AACrB,QAAI,qBAAqB;AAEzB,QAAI,SAAS,KAAK,qBAAqB,KAAK,mBAAA,IAAuB,CAAA;AAEnE,QAAI,WAAW;AACf,WAAO;AAAA,EACX;AAEA,SAAO,kBAAkB,MAAM,MAAM,YAAY,YAAY,YAAY,aAAa,aAAa,QAAQ;AAC/G;AAGO,SAAS,mBAAmB,KAAkB,aAA2B;AAC5E,MAAI,YAAY,SAAS,aAAa;AAClC,UAAM,aAAa;AACnB,UAAM,MAAM,WAAW;AAEvB,QAAI,UAAU;AACd,QAAI,OAAO;AACX,QAAI,eAAe;AAInB,eAAW,WAAW;AAAA,MAClB,YAAYD,KAAAA,YAAY;AAAA,MACxB,WAAW;AAAA,MACX,SAAS;AAAA;AAAA,MACT,MAAM;AAAA;AAAA,MACN,SAAS;AAAA,MACT,YAAYC,KAAAA,gBAAgB;AAAA,MAC5B,eAAe;AAAA,IAAA;AAEnB,eAAW,SAAS;AACpB,eAAW,iBAAiB;AAC5B,eAAW,qBAAqB;AAChC,gBAAY,KAAK,GAAG;AAAA,EACxB;AAEJ;AAIA,SAAS,mBAAmB,SAAyC;AACjE,MAAI,OAAO,YAAY,SAAU,QAAOA,KAAAA,gBAAgB;AACxD,MAAI,mBAAmB,eAAe,mBAAmB,mBAAmBA,KAAAA,gBAAgB;AAC5F,SAAOA,KAAAA,gBAAgB;AAC3B;AAGA,SAAS,kBACL,cACA,iBACA,UACA,YACA,MACyB;AACzB,QAAM,YAAY,CAAC,CAAC,KAAK;AAGzB,QAAM,mBAAmB,YAAY,aAAa,SAASC,cAAAA,aAAa,IAAI,iBAAiBA,cAAAA;AAC7F,MAAI,iBAAkB,QAAOC,eAAAA,4BAA4B,YAAY,MAAM,QAAQ;AAGnF,MAAI,iBAAiBC,WAAAA,uBAAuB,eAAe;AAC3D,MAAI,CAAC,gBAAgB;AACjB,UAAM,eAAeC,KAAAA,aAAa,CAACC,KAAAA,YAAY,QAAQ,GAAG,IAAI;AAC9D,qBAAiBF,WAAAA,uBAAuB,YAAY;AACpD,QAAI,CAAC,gBAAgB;AACjB,YAAM,IAAIG,KAAAA,SAAS;AAAA,QACf,YAAYP,KAAAA,YAAY;AAAA,QACxB,MAAM;AAAA,QACN,eAAe;AAAA,MAAA,CAClB;AAAA,IACL;AAAA,EACJ;AACA,SAAO,EAAC,eAAA;AACZ;;;;;;"}
+{"version":3,"file":"callContext.cjs","names":[],"sources":["../../../src/callContext.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {getRouteExecutionChain, getNotFoundExecutionChain, getRouterOptions} from './router.ts';\nimport type {CallContext, MionHeaders, MionRequest, MionResponse, RawRequestBody} from './types/context.ts';\nimport type {RouterOptions} from './types/general.ts';\nimport type {MethodsExecutionChain} from './types/remoteMethods.ts';\nimport {StatusCodes, SerializerModes, SerializerCode, FatalError, MION_ROUTES, MION_BATCH_PATH} from '@mionjs/core';\nimport type {AnyObject} from '@mionjs/core';\nimport {getBatchExecutionChain} from './batches.ts';\nimport {JSON_CONTENT_TYPE} from './constants.ts';\n\n// ############# CONTEXT CREATION #############\n\n/** Resolves a request to the REGISTERED chain that answers it, allocating NOTHING, so a streaming adapter\n *  calls it BEFORE the body to read against `chain.maxBodySize` and `createContextFromChain` after.\n *  Nothing of the request's own may survive the read: such an object is promoted to the old heap and the\n *  parsed body attached to it is promoted with it, which on a 4 MB body costs garbage-collector throughput.\n *  The chain is SHARED and long-lived: mutating what this returns damages the route for the whole process.\n *  An unknown path or batch id resolves to a not-found chain that never reads the body (`readsBody` false)\n *  and runs only the global middlewares that declare `alwaysRun`. */\nexport function resolveExecutionChain(path: string, urlQuery: string | undefined, rawRequest: unknown): MethodsExecutionChain {\n  const opts = getRouterOptions();\n  const transformedPath = opts.pathTransform?.(rawRequest, path) || path;\n  return getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);\n}\n\n/** `path` and `urlQuery` are the request's; a route chain's own path wins, not-found and batch chains use the request's. */\nexport function createContextFromChain(\n  chain: MethodsExecutionChain,\n  path: string,\n  urlQuery: string | undefined,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  reqRawBody?: RawRequestBody,\n  reqBodyType?: SerializerCode\n): CallContext {\n  const request: MionRequest = {\n    headers: reqHeaders,\n    rawBody: reqRawBody,\n    bodyType: reqBodyType ?? getRequestBodyType(reqRawBody),\n    // Shared and FROZEN: the parse replaces it, and a write before the parse would leak across requests\n    body: EMPTY_BODY,\n    thrownErrors: undefined,\n  } as MionRequest;\n  const response: MionResponse = {\n    statusCode: StatusCodes.OK,\n    contentType: JSON_CONTENT_TYPE,\n    hasErrors: false,\n    fatalError: undefined,\n    headers: respHeaders,\n    body: {},\n  } as MionResponse;\n  const contextDataFactory = getRouterOptions().contextDataFactory;\n\n  return {\n    path: chain.path ?? path,\n    request,\n    response,\n    executionChain: chain,\n    maxBodySize: chain.maxBodySize,\n    readsBody: chain.readsBody,\n    // Eager: a lazy defineProperty puts contexts in V8 dictionary mode (2x heap, 6% less throughput at 1 KB)\n    shared: contextDataFactory ? contextDataFactory() : {},\n    urlQuery,\n    batchId: chain.batchId,\n    batchRouteIds: chain.batchRouteIds,\n  } as CallContext;\n}\n\nconst EMPTY_BODY: Readonly<AnyObject> = Object.freeze({});\n\n/** The one-call form, for a caller that already has the body (a host that parsed it, `dispatchRoute`, a test). */\nexport function createCallContext(\n  path: string,\n  urlQuery: string | undefined,\n  rawRequest: unknown,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  reqRawBody?: RawRequestBody,\n  reqBodyType?: SerializerCode\n): CallContext {\n  const chain = resolveExecutionChain(path, urlQuery, rawRequest);\n  return createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders, reqRawBody, reqBodyType);\n}\n\n// ############# HELPER FUNCTIONS #############\n\n/** The wire form of a body: a string is stringified JSON, anything else a parsed object. A body\n *  not yet read (a context built before it) reads as an object until the body arrives. */\nexport function getRequestBodyType(rawBody: RawRequestBody | undefined): SerializerCode {\n  if (typeof rawBody === 'string') return SerializerModes.stringifyJson;\n  if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array)\n    throw new Error('mion: a byte request body has no encoder; send the body as a JSON string or a parsed object.');\n  return SerializerModes.json;\n}\n\nfunction getExecutionChain(\n  originalPath: string,\n  transformedPath: string,\n  urlQuery: string | undefined,\n  rawRequest: unknown,\n  opts: RouterOptions\n): MethodsExecutionChain {\n  const hasPrefix = !!opts.basePath;\n  // the batch key ends the path under any prefix (/mion-batch, /api/v1/mion-batch); the query id picks the chain\n  const isBatchPath = hasPrefix ? originalPath.endsWith(MION_BATCH_PATH) : originalPath === MION_BATCH_PATH;\n  if (isBatchPath) {\n    return getBatchExecutionChain(rawRequest, opts, urlQuery) ?? notFoundChain(MION_ROUTES.batchNotFound);\n  }\n\n  return getRouteExecutionChain(transformedPath) ?? notFoundChain(MION_ROUTES.notFound);\n}\n\n/** mion's own not-found chains are built by initRouter, so an absent one is a bug, not a request error. */\nfunction notFoundChain(chainId: string): MethodsExecutionChain {\n  const executionChain = getNotFoundExecutionChain(chainId);\n  if (!executionChain) {\n    throw new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'not-found',\n      publicMessage: 'Not-found chain is not registered. This should never happen.',\n    });\n  }\n  return executionChain;\n}\n"],"mappings":";;;;;;;;;;;;;AAyBA,SAAgB,sBAAsB,MAAc,UAA8B,YAA4C;CAC5H,MAAM,OAAO,mBAAA,iBAAiB;CAE9B,OAAO,kBAAkB,MADD,KAAK,gBAAgB,YAAY,IAAI,KAAK,MAClB,UAAU,YAAY,IAAI;AAC5E;;AAGA,SAAgB,uBACd,OACA,MACA,UACA,YACA,aACA,YACA,aACa;CACb,MAAM,UAAuB;EAC3B,SAAS;EACT,SAAS;EACT,UAAU,eAAe,mBAAmB,UAAU;EAEtD,MAAM;EACN,cAAc,KAAA;CAChB;CACA,MAAM,WAAyB;EAC7B,YAAY,aAAA,YAAY;EACxB,aAAa,sBAAA;EACb,WAAW;EACX,YAAY,KAAA;EACZ,SAAS;EACT,MAAM,CAAC;CACT;CACA,MAAM,qBAAqB,mBAAA,iBAAiB,EAAE;CAE9C,OAAO;EACL,MAAM,MAAM,QAAQ;EACpB;EACA;EACA,gBAAgB;EAChB,aAAa,MAAM;EACnB,WAAW,MAAM;EAEjB,QAAQ,qBAAqB,mBAAmB,IAAI,CAAC;EACrD;EACA,SAAS,MAAM;EACf,eAAe,MAAM;CACvB;AACF;AAEA,IAAM,aAAkC,OAAO,OAAO,CAAC,CAAC;;AAGxD,SAAgB,kBACd,MACA,UACA,YACA,YACA,aACA,YACA,aACa;CAEb,OAAO,uBADO,sBAAsB,MAAM,UAAU,UACtB,GAAO,MAAM,UAAU,YAAY,aAAa,YAAY,WAAW;AACvG;;;AAMA,SAAgB,mBAAmB,SAAqD;CACtF,IAAI,OAAO,YAAY,UAAU,OAAO,aAAA,gBAAgB;CACxD,IAAI,mBAAmB,eAAe,mBAAmB,YACvD,MAAM,IAAI,MAAM,8FAA8F;CAChH,OAAO,aAAA,gBAAgB;AACzB;AAEA,SAAS,kBACP,cACA,iBACA,UACA,YACA,MACuB;CAIvB,IADoB,CAFD,CAAC,KAAK,WAEO,aAAa,SAAS,aAAA,eAAe,IAAI,iBAAiB,aAAA,iBAExF,OAAO,oBAAA,uBAAuB,YAAY,MAAM,QAAQ,KAAK,cAAc,aAAA,YAAY,aAAa;CAGtG,OAAO,mBAAA,uBAAuB,eAAe,KAAK,cAAc,aAAA,YAAY,QAAQ;AACtF;;AAGA,SAAS,cAAc,SAAwC;CAC7D,MAAM,iBAAiB,mBAAA,0BAA0B,OAAO;CACxD,IAAI,CAAC,gBACH,MAAM,IAAI,aAAA,WAAW;EACnB,YAAY,aAAA,YAAY;EACxB,MAAM;EACN,eAAe;CACjB,CAAC;CAEH,OAAO;AACT"}

package/.dist/cjs/src/callContext.d.ts

@@ -1,11 +1,8 @@
 import { CallContext, MionHeaders, RawRequestBody } from './types/context.ts';
-import { RouterOptions } from './types/general.ts';
+import { MethodsExecutionChain } from './types/remoteMethods.ts';
 import { SerializerCode } from '@mionjs/core';
-export declare function getContextPoolStats(): {
-    poolSize: number;
-};
-export declare function clearContextPool(): void;
-export declare function createCallContext(path: string, opts: RouterOptions, reqRawBody: RawRequestBody, rawRequest: unknown, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqBodyType?: SerializerCode, urlQuery?: string): CallContext;
-export declare function acquireCallContext(usePooling: boolean, path: string, opts: RouterOptions, reqRawBody: RawRequestBody, rawRequest: unknown, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqBodyType?: SerializerCode, urlQuery?: string): CallContext;
-export declare function releaseCallContext(ctx: CallContext, maxPoolSize: number): void;
+export declare function resolveExecutionChain(path: string, urlQuery: string | undefined, rawRequest: unknown): MethodsExecutionChain;
+export declare function createContextFromChain(chain: MethodsExecutionChain, path: string, urlQuery: string | undefined, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqRawBody?: RawRequestBody, reqBodyType?: SerializerCode): CallContext;
+export declare function createCallContext(path: string, urlQuery: string | undefined, rawRequest: unknown, reqHeaders: MionHeaders, respHeaders: MionHeaders, reqRawBody?: RawRequestBody, reqBodyType?: SerializerCode): CallContext;
+export declare function getRequestBodyType(rawBody: RawRequestBody | undefined): SerializerCode;
 //# sourceMappingURL=callContext.d.ts.map

package/.dist/cjs/src/constants.cjs

@@ -1,45 +1,26 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const core = require("@mionjs/core");
-const IS_TEST_ENV = core.getENV("JEST_WORKER_ID") !== void 0 || core.getENV("NODE_ENV") === "test";
-const ROUTE_DEFAULT_PARAMS = ["context"];
-const HEADER_HOOK_DEFAULT_PARAMS = ["context", "headers"];
-const DEFAULT_ROUTE_OPTIONS = {
-  /** Prefix for all routes, i.e: api/v1. Path separator is added between the prefix and the route */
-  basePath: "",
-  /** Suffix for all routes, i.e: .json. No path separator is added between the route and the suffix */
-  suffix: "",
-  /** Function that transforms the path before finding a route */
-  pathTransform: void 0,
-  /** Default serializer mode - json as default native serializer, and minimum overhead to transform just required fields */
-  serializer: "json",
-  /** Default run type compiling options for routes and middleFns, can't be configured by the user as would break functionality  */
-  runTypeOptions: {},
-  /** set to true to generate router spec for clients.  */
-  getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === "true",
-  /** Set true to automatically generate and id for every error.  */
-  autoGenerateErrorId: false,
-  /** client routes are initialized by default */
-  skipClientRoutes: IS_TEST_ENV,
-  /** AOT mode is disabled by default */
-  aot: false,
-  /** Context pooling size == 100 by default */
-  maxContextPoolSize: 100,
-  /** RoutesFlow cache size == 100 by default */
-  maxRoutesFlowsCacheSize: 100
+//#region src/constants.ts
+var DEFAULT_ROUTE_OPTIONS = {
+	basePath: "",
+	suffix: "",
+	pathTransform: void 0,
+	/** set to true to generate router spec for clients.  */
+	getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === "true",
+	autoGenerateErrorId: false,
+	/** Every chain step is awaited by default, so the chain keeps yielding between steps */
+	alwaysAwait: true,
+	/** A type-derived request limit is the JSON maximum times this factor */
+	maxBodySizeFactor: 2,
+	releaseRawBody: true,
+	responseHeaders: {},
+	apiVersionCheck: true,
+	getAllRemoteMethodsMaxNumber: 100
 };
-const MAX_ROUTE_NESTING = 10;
-const NOT_FOUND_HOOK_NAME = "_miΦn404NΦtfΦundHΦΦk_";
-const NOT_FOUND_PATH = `${core.PATH_SEPARATOR}${core.MION_ROUTES.notFound}`;
-const WORKFLOW_KEY = `mion-routes-flow`;
-const WORKFLOW_PATH = `${core.PATH_SEPARATOR}${WORKFLOW_KEY}`;
+var MAX_ROUTE_NESTING = 10;
+var JSON_CONTENT_TYPE = "application/json; charset=utf-8";
+//#endregion
 exports.DEFAULT_ROUTE_OPTIONS = DEFAULT_ROUTE_OPTIONS;
-exports.HEADER_HOOK_DEFAULT_PARAMS = HEADER_HOOK_DEFAULT_PARAMS;
-exports.IS_TEST_ENV = IS_TEST_ENV;
+exports.JSON_CONTENT_TYPE = JSON_CONTENT_TYPE;
 exports.MAX_ROUTE_NESTING = MAX_ROUTE_NESTING;
-exports.NOT_FOUND_HOOK_NAME = NOT_FOUND_HOOK_NAME;
-exports.NOT_FOUND_PATH = NOT_FOUND_PATH;
-exports.ROUTE_DEFAULT_PARAMS = ROUTE_DEFAULT_PARAMS;
-exports.WORKFLOW_KEY = WORKFLOW_KEY;
-exports.WORKFLOW_PATH = WORKFLOW_PATH;
-//# sourceMappingURL=constants.cjs.map
+
+//# sourceMappingURL=constants.cjs.map

package/.dist/cjs/src/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.cjs","sources":["../../../src/constants.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {RouterOptions} from './types/general.ts';\nimport {getENV, MION_ROUTES, PATH_SEPARATOR} from '@mionjs/core';\n\nexport const IS_TEST_ENV = getENV('JEST_WORKER_ID') !== undefined || getENV('NODE_ENV') === 'test';\n\nexport const ROUTE_DEFAULT_PARAMS = ['context'];\nexport const HEADER_HOOK_DEFAULT_PARAMS = ['context', 'headers'];\n\nexport const DEFAULT_ROUTE_OPTIONS = {\n    /** Prefix for all routes, i.e: api/v1. Path separator is added between the prefix and the route */\n    basePath: '',\n    /** Suffix for all routes, i.e: .json. No path separator is added between the route and the suffix */\n    suffix: '',\n    /** Function that transforms the path before finding a route */\n    pathTransform: undefined,\n    /** Default serializer mode - json as default native serializer, and minimum overhead to transform just required fields */\n    serializer: 'json',\n    /** Default run type compiling options for routes and middleFns, can't be configured by the user as would break functionality  */\n    runTypeOptions: {},\n    /** set to true to generate router spec for clients.  */\n    getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === 'true',\n    /** Set true to automatically generate and id for every error.  */\n    autoGenerateErrorId: false,\n    /** client routes are initialized by default */\n    skipClientRoutes: IS_TEST_ENV,\n    /** AOT mode is disabled by default */\n    aot: false,\n    /** Context pooling size == 100 by default */\n    maxContextPoolSize: 100,\n    /** RoutesFlow cache size == 100 by default */\n    maxRoutesFlowsCacheSize: 100,\n} as Readonly<RouterOptions>;\n\nexport const MAX_ROUTE_NESTING = 10;\nexport const NOT_FOUND_HOOK_NAME = '_miΦn404NΦtfΦundHΦΦk_';\nexport const NOT_FOUND_PATH = `${PATH_SEPARATOR}${MION_ROUTES.notFound}`;\nexport const WORKFLOW_KEY = `mion-routes-flow`;\nexport const WORKFLOW_PATH = `${PATH_SEPARATOR}${WORKFLOW_KEY}`;\n"],"names":["getENV","PATH_SEPARATOR","MION_ROUTES"],"mappings":";;;AAUO,MAAM,cAAcA,KAAAA,OAAO,gBAAgB,MAAM,UAAaA,KAAAA,OAAO,UAAU,MAAM;AAErF,MAAM,uBAAuB,CAAC,SAAS;AACvC,MAAM,6BAA6B,CAAC,WAAW,SAAS;AAExD,MAAM,wBAAwB;AAAA;AAAA,EAEjC,UAAU;AAAA;AAAA,EAEV,QAAQ;AAAA;AAAA,EAER,eAAe;AAAA;AAAA,EAEf,YAAY;AAAA;AAAA,EAEZ,gBAAgB,CAAA;AAAA;AAAA,EAEhB,qBAAqB,QAAQ,IAAI,yBAAyB;AAAA;AAAA,EAE1D,qBAAqB;AAAA;AAAA,EAErB,kBAAkB;AAAA;AAAA,EAElB,KAAK;AAAA;AAAA,EAEL,oBAAoB;AAAA;AAAA,EAEpB,yBAAyB;;AAGtB,MAAM,oBAAoB;AAC1B,MAAM,sBAAsB;AAC5B,MAAM,iBAAiB,GAAGC,KAAAA,cAAc,GAAGC,KAAAA,YAAY,QAAQ;AAC/D,MAAM,eAAe;AACrB,MAAM,gBAAgB,GAAGD,mBAAc,GAAG,YAAY;;;;;;;;;;"}
+{"version":3,"file":"constants.cjs","names":[],"sources":["../../../src/constants.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {RouterOptions} from './types/general.ts';\n\nexport const DEFAULT_ROUTE_OPTIONS = {\n  basePath: '',\n  suffix: '',\n  pathTransform: undefined,\n  /** set to true to generate router spec for clients.  */\n  getPublicRoutesData: process.env.GENERATE_ROUTER_SPEC === 'true',\n  autoGenerateErrorId: false,\n  /** Every chain step is awaited by default, so the chain keeps yielding between steps */\n  alwaysAwait: true,\n  /** A type-derived request limit is the JSON maximum times this factor */\n  maxBodySizeFactor: 2,\n  releaseRawBody: true,\n  responseHeaders: {},\n  apiVersionCheck: true,\n  getAllRemoteMethodsMaxNumber: 100,\n} as Readonly<RouterOptions>;\n\nexport const MAX_ROUTE_NESTING = 10;\n\nexport const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';\n"],"mappings":";;AASA,IAAa,wBAAwB;CACnC,UAAU;CACV,QAAQ;CACR,eAAe,KAAA;;CAEf,qBAAqB,QAAQ,IAAI,yBAAyB;CAC1D,qBAAqB;;CAErB,aAAa;;CAEb,mBAAmB;CACnB,gBAAgB;CAChB,iBAAiB,CAAC;CAClB,iBAAiB;CACjB,8BAA8B;AAChC;AAEA,IAAa,oBAAoB;AAEjC,IAAa,oBAAoB"}

package/.dist/cjs/src/constants.d.ts

@@ -1,11 +1,5 @@
 import { RouterOptions } from './types/general.ts';
-export declare const IS_TEST_ENV: boolean;
-export declare const ROUTE_DEFAULT_PARAMS: string[];
-export declare const HEADER_HOOK_DEFAULT_PARAMS: string[];
 export declare const DEFAULT_ROUTE_OPTIONS: Readonly<RouterOptions>;
 export declare const MAX_ROUTE_NESTING = 10;
-export declare const NOT_FOUND_HOOK_NAME = "_mi\u03A6n404N\u03A6tf\u03A6undH\u03A6\u03A6k_";
-export declare const NOT_FOUND_PATH: string;
-export declare const WORKFLOW_KEY = "mion-routes-flow";
-export declare const WORKFLOW_PATH = "/mion-routes-flow";
+export declare const JSON_CONTENT_TYPE = "application/json; charset=utf-8";
 //# sourceMappingURL=constants.d.ts.map

package/.dist/cjs/src/dispatch.cjs

@@ -1,141 +1,239 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const src_router = require("./router.cjs");
-const core = require("@mionjs/core");
-const src_lib_dispatchError = require("./lib/dispatchError.cjs");
-const src_callContext = require("./callContext.cjs");
+const require_src_lib_dispatchError = require("./lib/dispatchError.cjs");
+const require_src_callContext = require("./callContext.cjs");
+const require_src_router = require("./router.cjs");
+let _mionjs_core = require("@mionjs/core");
+let _mionjs_run_types = require("@mionjs/run-types");
+//#region src/dispatch.ts
+/** The one-call form for a caller that already has the body (tests, a host that parsed it). */
 async function dispatchRoute(path, reqRawBody, reqHeaders, respHeaders, rawRequest, rawResponse, reqBodyType, urlQuery) {
-  const opts = src_router.getRouterOptions();
-  const usePooling = opts.maxContextPoolSize > 0;
-  const context = src_callContext.acquireCallContext(
-    usePooling,
-    path,
-    opts,
-    reqRawBody,
-    rawRequest,
-    reqHeaders,
-    respHeaders,
-    reqBodyType,
-    urlQuery
-  );
-  try {
-    await runExecutionChain(context, rawRequest, rawResponse, opts);
-    return context.response;
-  } catch (err) {
-    return Promise.reject(err);
-  } finally {
-    if (usePooling) {
-      src_callContext.releaseCallContext(context, opts.maxContextPoolSize);
-    }
-  }
-}
-async function runExecutionChain(context, rawRequest, rawResponse, opts) {
-  const { response, request } = context;
-  const executionList = context.executionChain.methods;
-  response.serializer = context.executionChain.serializer;
-  for (let i = 0; i < executionList.length; i++) {
-    const executable = executionList[i];
-    if (response.hasErrors && !executable.options.runOnError) continue;
-    try {
-      const methodCaller = executable.methodCaller || getMethodCaller(executable);
-      const result = await methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
-      if (result === void 0 || !executable.hasReturnData) continue;
-      if (executable.headersReturn && result instanceof core.HeadersSubset) {
-        const headersMap = result.headers;
-        for (const name in headersMap) {
-          const value = headersMap[name];
-          if (value !== void 0 && value !== null) {
-            response.headers.set(name, value);
-          }
-        }
-        continue;
-      }
-      response.body[executable.id] = result;
-    } catch (err) {
-      src_lib_dispatchError.onExecutableError(context, executable, err);
-    }
-  }
-  return context.response;
-}
-async function runRawMiddleFn(context, executable, req, resp, opts, rawRequest, rawResponse) {
-  const result = await executable.handler(context, rawRequest, rawResponse, opts);
-  return result;
-}
-async function runHeadersMiddleFn(context, executable, request) {
-  const headerNames = executable.headersParam.headerNames;
-  const params = deserializeBodyParamsOrThrow(request, executable);
-  const headersMap = {};
-  headerNames.forEach((name) => {
-    const value = request.headers.get(name);
-    if (value) headersMap[name] = value;
-  });
-  const headersSubset = new core.HeadersSubset(headersMap);
-  validateHeaderParamsOrThrow(headersSubset, executable);
-  if (executable.options.validateParams) validateParametersOrThrow(params, executable);
-  const result = await executable.handler(context, headersSubset, ...params);
-  return result;
-}
-async function runRouteOrMiddleFn(context, executable, request) {
-  const params = deserializeBodyParamsOrThrow(request, executable);
-  if (executable.options.validateParams) validateParametersOrThrow(params, executable);
-  const result = await executable.handler(context, ...params);
-  return result;
+	return dispatchWithContext(require_src_callContext.createCallContext(path, urlQuery, rawRequest, reqHeaders, respHeaders, reqRawBody, reqBodyType), rawRequest, rawResponse);
 }
+/** A streaming adapter builds the context before reading the body, to check `context.maxBodySize`, then passes it. */
+async function dispatchWithContext(context, rawRequest, rawResponse, reqRawBody, reqBodyType) {
+	if (reqRawBody !== void 0) {
+		const request = context.request;
+		request.rawBody = reqRawBody;
+		request.bodyType = reqBodyType ?? require_src_callContext.getRequestBodyType(reqRawBody);
+	}
+	return dispatchMaybeSync(context, rawRequest, rawResponse);
+}
+/** `dispatchWithContext` for a context built with its body, minus the promise when no step needs one. */
+function dispatchMaybeSync(context, rawRequest, rawResponse) {
+	const opts = require_src_router.getRouterOptions();
+	if (opts.alwaysAwait) return runExecutionChain(context, rawRequest, rawResponse, opts, 0);
+	return runSyncExecutionChain(context, rawRequest, rawResponse, opts);
+}
+/** Dispatches a request the platform adapter refused after its route resolved: a body past the limit.
+*  The error is recorded exactly as a thrown one is, so the chain runs only the members that declare
+*  `alwaysRun` (a rate limiter, an access log) and answers with the same envelope. The adapter stopped
+*  the read, so the context is built without a body.
+*  `path` and `urlQuery` travel with the chain rather than on it: mion's not-found chains and a merged
+*  batch chain each answer for many paths, so they carry none of their own, and a refusal does reach one
+*  of those (an adapter checks a declared content-length before asking whether the chain reads a body). */
+function dispatchPlatformError(chain, path, urlQuery, platformError, reqHeaders, respHeaders, rawRequest, rawResponse) {
+	const context = require_src_callContext.createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders);
+	require_src_lib_dispatchError.recordUndeclaredError(context, _mionjs_core.MION_ROUTES.platformError, platformError);
+	return dispatchWithContext(context, rawRequest, rawResponse);
+}
+async function runExecutionChain(context, rawRequest, rawResponse, opts, startIndex) {
+	const { response, request, executionChain } = context;
+	const alwaysAwait = opts.alwaysAwait;
+	const executionList = executionChain.methods;
+	const executionCount = executionList.length;
+	for (let i = startIndex; i < executionCount; i++) {
+		const executable = executionList[i];
+		if (response.hasErrors && !executable.alwaysRun) continue;
+		try {
+			let result;
+			if (alwaysAwait || executable.isAsync) result = await executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+			else {
+				result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+				if (isUncheckedPromise(executable, result)) result = await result;
+			}
+			applyResult(context, executable, result);
+		} catch (err) {
+			require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, err);
+		}
+	}
+	return context.response;
+}
+/** `runExecutionChain` without awaits: from the first async step on it hands over, so both give the same result. */
+function runSyncExecutionChain(context, rawRequest, rawResponse, opts) {
+	const { response, request, executionChain } = context;
+	const executionList = executionChain.methods;
+	const executionCount = executionList.length;
+	for (let i = 0; i < executionCount; i++) {
+		const executable = executionList[i];
+		if (response.hasErrors && !executable.alwaysRun) continue;
+		if (executable.isAsync) return runExecutionChain(context, rawRequest, rawResponse, opts, i);
+		try {
+			const result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);
+			if (isUncheckedPromise(executable, result)) return Promise.resolve(result).then((resolved) => applyResult(context, executable, resolved)).catch((err) => require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, err)).then(() => runExecutionChain(context, rawRequest, rawResponse, opts, i + 1));
+			applyResult(context, executable, result);
+		} catch (err) {
+			require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, err);
+		}
+	}
+	return response;
+}
+/** Backstop for a wrong or missing declared type, else the promise is serialized as the answer. */
+function isUncheckedPromise(executable, result) {
+	if (executable.asyncChecked === true) return false;
+	executable.asyncChecked = true;
+	if (result === null || typeof result !== "object" || typeof result.then !== "function") return false;
+	executable.isAsync = true;
+	return true;
+}
+/** A throw here is the caller's to record, like the step's own. */
+function applyResult(context, executable, result) {
+	if (result === void 0) return;
+	const response = context.response;
+	const isMionError = result !== null && result["mion@isΣrrθr"] === true;
+	if (!executable.hasReturnData) {
+		if (isMionError || (0, _mionjs_core.isNativeError)(result)) require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, result);
+		return;
+	}
+	if (isMionError) {
+		if (result.isFatal === true) require_src_lib_dispatchError.markResponseFailed(context, result, _mionjs_core.StatusCodes.APPLICATION_ERROR);
+	} else if ((0, _mionjs_core.isNativeError)(result)) {
+		require_src_lib_dispatchError.recordUndeclaredError(context, executable.id, result);
+		return;
+	}
+	if (executable.headersReturn && result instanceof _mionjs_core.HeadersSubset) {
+		const headersMap = result.headers;
+		for (const name of Object.keys(headersMap)) {
+			const value = headersMap[name];
+			if (value !== void 0 && value !== null) response.headers.set(name, value);
+		}
+		return;
+	}
+	response.body[executable.id] = result;
+}
+function runRawMiddleware(context, executable, req, resp, opts, rawRequest, rawResponse) {
+	return executable.handler(context, rawRequest, rawResponse, opts);
+}
+function runHeadersMiddleware(context, executable, request) {
+	const headerNames = executable.headersParam.headerNames;
+	const params = sanitizeParams(deserializeBodyParamsOrThrow(request, executable), request, executable);
+	const headersMap = {};
+	headerNames.forEach((name) => {
+		const value = request.headers.get(name);
+		if (value) headersMap[name] = value;
+	});
+	const headersSubset = (0, _mionjs_core.trustedHeadersSubset)(headersMap);
+	validateHeaderParamsOrThrow(headersSubset, executable);
+	validateParametersOrThrow(params, executable);
+	return executable.handler(context, headersSubset, ...params);
+}
+function runRouteOrMiddleware(context, executable, request) {
+	const params = sanitizeParams(deserializeBodyParamsOrThrow(request, executable), request, executable);
+	validateParametersOrThrow(params, executable);
+	return executable.handler(context, ...params);
+}
+/** Applies the rewrites the params types declare under a format's `transform` key (trim / case /
+*  replace / stripSeparators) in place, after decode and BEFORE validation. Params only: headers and
+*  return values are never sanitized. A transform over wrong-shaped input can throw (`.trim()` on a
+*  number): the raw params fall through so validation reports the real error instead of a 500. */
+function sanitizeParams(params, request, executable) {
+	if (!executable.options.sanitizeParams) return params;
+	const formatTransform = executable.paramsJitFns.formatTransform;
+	if (!formatTransform || formatTransform.isNoop) return params;
+	try {
+		const sanitized = formatTransform.fn(params);
+		request.body[executable.id] = sanitized;
+		return sanitized;
+	} catch {
+		return params;
+	}
+}
+/** The caller for a method kind. Read ONCE, when the method is registered, so the dispatch loop
+*  reads a field instead of branching on the method type on every request. */
+function callerForType(type) {
+	if (type === _mionjs_core.HandlerType.rawMiddleware) return runRawMiddleware;
+	if (type === _mionjs_core.HandlerType.headersMiddleware) return runHeadersMiddleware;
+	return runRouteOrMiddleware;
+}
+/** The caller already stored on a registered method. */
 function getMethodCaller(executable) {
-  if (executable.type === core.HandlerType.rawMiddleFn) {
-    executable.methodCaller = runRawMiddleFn;
-  } else if (executable.type === core.HandlerType.headersMiddleFn) {
-    executable.methodCaller = runHeadersMiddleFn;
-  } else {
-    executable.methodCaller = runRouteOrMiddleFn;
-  }
-  return executable.methodCaller;
+	return executable.methodCaller;
 }
+/** Shared, for the members whose id is absent from the body: a fresh empty array per member per request
+*  bought nothing. Frozen, so a handler that tried to mutate its params fails loudly instead of corrupting
+*  the next request; nothing can reach it anyway, an empty tuple is spread into the call. */
+var EMPTY_PARAMS = [];
+Object.freeze(EMPTY_PARAMS);
 function deserializeBodyParamsOrThrow(request, executable) {
-  const params = request.body[executable.id] || [];
-  if (request.bodyType === core.SerializerModes.binary) return params;
-  if (executable.paramsJitFns.restoreFromJson.isNoop) return params;
-  try {
-    request.body[executable.id] = executable.paramsJitFns.restoreFromJson.fn(params);
-    return request.body[executable.id];
-  } catch (e) {
-    throw new core.RpcError({
-      statusCode: core.StatusCodes.UNEXPECTED_ERROR,
-      type: "serialization-error",
-      publicMessage: `Invalid params '${executable.id}', can not deserialize. Parameters might be of the wrong type.`,
-      originalError: e,
-      errorData: {
-        deserializeError: e?.message || "Unknown error"
-      }
-    });
-  }
+	const body = request.body;
+	const params = Object.hasOwn(body, executable.id) ? body[executable.id] : void 0;
+	if (!params) return EMPTY_PARAMS;
+	if (!Array.isArray(params)) throw new _mionjs_core.FatalError({
+		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+		type: "serialization-error",
+		publicMessage: `Invalid params '${executable.id}', params must be an array.`,
+		errorData: { deserializeError: "params must be an array" }
+	});
+	const { decode } = executable.paramsJitFns.json;
+	if (decode.isNoop) return params;
+	try {
+		const decoded = decode.fn(params);
+		body[executable.id] = decoded;
+		return decoded;
+	} catch (e) {
+		if (isStackOverflow(e)) throw nestingTooDeep(executable, e);
+		const detail = typeof e?.message === "string" && e.message.startsWith(_mionjs_run_types.UNSAFE_PROPERTY_NAME_MESSAGE) ? e.message : "Parameters might be of the wrong type.";
+		throw new _mionjs_core.FatalError({
+			statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+			type: "serialization-error",
+			publicMessage: `Invalid params '${executable.id}', can not deserialize. ${detail}`,
+			originalError: e,
+			errorData: { deserializeError: detail }
+		});
+	}
+}
+/** A RangeError out of a compiled function is the engine's stack limit: the request nested deeper
+*  than a recursive type can be walked. Reported as its own typed 4xx, never as an unknown error. */
+function isStackOverflow(err) {
+	return err instanceof RangeError;
+}
+function nestingTooDeep(executable, originalError) {
+	return new _mionjs_core.FatalError({
+		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+		type: "request-nesting-too-deep",
+		publicMessage: `Invalid params in '${executable.id}', the request is nested too deep.`,
+		originalError
+	});
 }
 function validateParametersOrThrow(params, executable) {
-  if (executable.paramsJitFns.isType.isNoop) return;
-  if (!executable.paramsJitFns.isType.fn(params)) {
-    const validationError = new core.RpcError({
-      statusCode: core.StatusCodes.UNEXPECTED_ERROR,
-      type: "validation-error",
-      publicMessage: `Invalid params in '${executable.id}', validation failed.`,
-      errorData: {
-        typeErrors: executable.paramsJitFns.typeErrors.fn(params)
-      }
-    });
-    throw validationError;
-  }
+	if (executable.paramsJitFns.isType.isNoop) return;
+	let isValid;
+	try {
+		isValid = executable.paramsJitFns.isType.fn(params);
+	} catch (e) {
+		if (isStackOverflow(e)) throw nestingTooDeep(executable, e);
+		throw e;
+	}
+	if (!isValid) throw new _mionjs_core.FatalError({
+		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+		type: "validation-error",
+		publicMessage: `Invalid params in '${executable.id}', validation failed.`,
+		errorData: { typeErrors: executable.paramsJitFns.typeErrors.fn(params) }
+	});
 }
 function validateHeaderParamsOrThrow(headers, executable) {
-  if (!executable.headersParam.jitFns.isType.fn(headers)) {
-    const validationError = new core.RpcError({
-      statusCode: core.StatusCodes.UNEXPECTED_ERROR,
-      type: "validation-error",
-      publicMessage: `Invalid params in '${executable.id}', validation failed.`,
-      errorData: {
-        typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers)
-      }
-    });
-    throw validationError;
-  }
+	if (!executable.headersParam.jitFns.isType.fn(headers)) throw new _mionjs_core.FatalError({
+		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
+		type: "validation-error",
+		publicMessage: `Invalid params in '${executable.id}', validation failed.`,
+		errorData: { typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers) }
+	});
 }
+//#endregion
+exports.callerForType = callerForType;
+exports.dispatchMaybeSync = dispatchMaybeSync;
+exports.dispatchPlatformError = dispatchPlatformError;
 exports.dispatchRoute = dispatchRoute;
-//# sourceMappingURL=dispatch.cjs.map
+exports.dispatchWithContext = dispatchWithContext;
+exports.getMethodCaller = getMethodCaller;
+
+//# sourceMappingURL=dispatch.cjs.map

package/.dist/cjs/src/dispatch.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.cjs","sources":["../../../src/dispatch.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {CallContext, MionResponse, MionRequest, MionHeaders, RawRequestBody} from './types/context.ts';\nimport {type RouterOptions} from './types/general.ts';\nimport {HeadersMethod, RemoteMethod, RawMethod} from './types/remoteMethods.ts';\nimport {getRouterOptions} from './router.ts';\nimport {Mutable, AnyObject, StatusCodes, HeadersSubset, SerializerModes, SerializerCode} from '@mionjs/core';\nimport {RpcError, HandlerType, ValidationError} from '@mionjs/core';\nimport {onExecutableError} from './lib/dispatchError.ts';\nimport {acquireCallContext, releaseCallContext} from './callContext.ts';\n\n/*\n * PERFORMANCE PROFILING NOTE:\n * different options has been tested to improve performance but were discarded due to worst or no noticeable improvements\n * - using promisify(setImmediate): worst or no improvement\n * - using queueMicrotask instead of setImmediate: definitely worst\n * - using callback instead promises: seems to be more slow but use less memory in some scenarios.\n */\n\n// ############# PUBLIC METHODS #############\n\nexport async function dispatchRoute<Req, Resp>(\n    path: string,\n    reqRawBody: RawRequestBody,\n    reqHeaders: MionHeaders,\n    respHeaders: MionHeaders,\n    rawRequest: Req,\n    rawResponse?: Resp,\n    reqBodyType?: SerializerCode,\n    urlQuery?: string\n): Promise<MionResponse> {\n    const opts = getRouterOptions();\n    const usePooling = opts.maxContextPoolSize > 0;\n    const context = acquireCallContext(\n        usePooling,\n        path,\n        opts,\n        reqRawBody,\n        rawRequest,\n        reqHeaders,\n        respHeaders,\n        reqBodyType,\n        urlQuery\n    );\n\n    try {\n        await runExecutionChain(context, rawRequest, rawResponse, opts);\n        return context.response;\n    } catch (err: any | RpcError<string> | Error) {\n        // this should never happen, exceptions should be handled inside runExecutionChain\n        return Promise.reject(err);\n    } finally {\n        // Release context back to pool if pooling is enabled\n        if (usePooling) {\n            releaseCallContext(context, opts.maxContextPoolSize);\n        }\n    }\n}\n\n// ############# PRIVATE METHODS #############\n\n// runs the ExecutionChain of a route\nasync function runExecutionChain(\n    context: CallContext,\n    rawRequest: unknown,\n    rawResponse: unknown,\n    opts: RouterOptions\n): Promise<MionResponse> {\n    const {response, request} = context;\n    const executionList = context.executionChain.methods;\n    (response as Mutable<MionResponse>).serializer = context.executionChain.serializer;\n    for (let i = 0; i < executionList.length; i++) {\n        const executable = executionList[i];\n        if (response.hasErrors && !executable.options.runOnError) continue;\n\n        try {\n            const methodCaller = executable.methodCaller || getMethodCaller(executable);\n            // runRawMiddleFn , runHeadersMiddleFn & runRouteOrMiddleFn must always accept the same parameters in the same order\n            const result = await methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n\n            if (result === undefined || !executable.hasReturnData) continue;\n            if (executable.headersReturn && result instanceof HeadersSubset) {\n                const headersMap = result.headers;\n                for (const name in headersMap) {\n                    const value = headersMap[name];\n                    if (value !== undefined && value !== null) {\n                        response.headers.set(name, value);\n                    }\n                }\n                continue;\n            }\n            (response.body as Mutable<AnyObject>)[executable.id] = result;\n        } catch (err: any | RpcError<string> | Error) {\n            // All thrown errors are unexpected\n            onExecutableError(context, executable, err);\n        }\n    }\n    return context.response;\n}\n\nasync function runRawMiddleFn(\n    context: CallContext,\n    executable: RawMethod,\n    req,\n    resp,\n    opts: RouterOptions,\n    rawRequest: unknown,\n    rawResponse: unknown\n) {\n    const result = await executable.handler(context, rawRequest, rawResponse, opts);\n    return result;\n}\n\nasync function runHeadersMiddleFn(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n    const headerNames = executable.headersParam.headerNames;\n    const params = deserializeBodyParamsOrThrow(request, executable as RemoteMethod);\n    const headersMap: Record<string, string> = {};\n    headerNames.forEach((name) => {\n        const value = request.headers.get(name);\n        if (value) headersMap[name] = value;\n    });\n    const headersSubset = new HeadersSubset(headersMap);\n    validateHeaderParamsOrThrow(headersSubset, executable as HeadersMethod);\n    if (executable.options.validateParams) validateParametersOrThrow(params, executable as HeadersMethod);\n\n    const result = await executable.handler(context, headersSubset, ...params);\n    return result;\n}\n\nasync function runRouteOrMiddleFn(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n    const params = deserializeBodyParamsOrThrow(request, executable as RemoteMethod);\n    if (executable.options.validateParams) validateParametersOrThrow(params, executable as RemoteMethod);\n    const result = await executable.handler(context, ...params);\n    return result;\n}\n\nfunction getMethodCaller(executable: RemoteMethod) {\n    if (executable.type === HandlerType.rawMiddleFn) {\n        executable.methodCaller = runRawMiddleFn;\n    } else if (executable.type === HandlerType.headersMiddleFn) {\n        executable.methodCaller = runHeadersMiddleFn;\n    } else {\n        executable.methodCaller = runRouteOrMiddleFn;\n    }\n    return executable.methodCaller;\n}\n\nfunction deserializeBodyParamsOrThrow(request: MionRequest, executable: RemoteMethod): any[] {\n    const params: any[] = (request.body[executable.id] as any[]) || [];\n    // For binary requests, params are already deserialized in the serializer middleFn\n    // (deserializeBinaryRequestBody in serializer.routes.ts)\n    if (request.bodyType === SerializerModes.binary) return params;\n\n    // For JSON requests, use restoreFromJson to deserialize\n    if (executable.paramsJitFns.restoreFromJson.isNoop) return params;\n    try {\n        (request.body as Mutable<MionRequest['body']>)[executable.id] = executable.paramsJitFns.restoreFromJson.fn(params);\n        return request.body[executable.id] as any[];\n    } catch (e: any) {\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'serialization-error',\n            publicMessage: `Invalid params '${executable.id}', can not deserialize. Parameters might be of the wrong type.`,\n            originalError: e,\n            errorData: {\n                deserializeError: e?.message || 'Unknown error',\n            },\n        });\n    }\n}\n\nfunction validateParametersOrThrow(params: any[], executable: RemoteMethod): void {\n    if (executable.paramsJitFns.isType.isNoop) return;\n    if (!executable.paramsJitFns.isType.fn(params)) {\n        const validationError: ValidationError = new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'validation-error',\n            publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n            errorData: {\n                typeErrors: executable.paramsJitFns.typeErrors.fn(params),\n            },\n        });\n        throw validationError;\n    }\n}\n\nfunction validateHeaderParamsOrThrow(headers: HeadersSubset<string, string>, executable: HeadersMethod): void {\n    if (!executable.headersParam.jitFns.isType.fn(headers)) {\n        const validationError: ValidationError = new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'validation-error',\n            publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n            errorData: {\n                typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers),\n            },\n        });\n        throw validationError;\n    }\n}\n"],"names":["getRouterOptions","acquireCallContext","releaseCallContext","HeadersSubset","onExecutableError","HandlerType","SerializerModes","RpcError","StatusCodes"],"mappings":"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"}
+{"version":3,"file":"dispatch.cjs","names":[],"sources":["../../../src/dispatch.ts"],"sourcesContent":["/* ########\n * 2022 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {CallContext, MionResponse, MionRequest, MionHeaders, RawRequestBody} from './types/context.ts';\nimport {type RouterOptions} from './types/general.ts';\nimport {HeadersMethod, RemoteMethod, RawMethod} from './types/remoteMethods.ts';\nimport type {MethodsExecutionChain} from './types/remoteMethods.ts';\nimport {getRouterOptions} from './router.ts';\nimport {Mutable, AnyObject, StatusCodes, HeadersSubset, SerializerCode, MION_ROUTES, trustedHeadersSubset} from '@mionjs/core';\nimport {RpcError, FatalError, HandlerType, ValidationError, isNativeError} from '@mionjs/core';\nimport {UNSAFE_PROPERTY_NAME_MESSAGE} from '@mionjs/run-types';\nimport {markResponseFailed, recordUndeclaredError} from './lib/dispatchError.ts';\nimport {createCallContext, createContextFromChain, getRequestBodyType} from './callContext.ts';\n\n// Profiled and discarded: promisify(setImmediate) (worse or no gain), queueMicrotask instead of\n// setImmediate (definitely worse), callbacks instead of promises (slower, less memory in some scenarios).\n\n// ############# PUBLIC METHODS #############\n\n/** The one-call form for a caller that already has the body (tests, a host that parsed it). */\nexport async function dispatchRoute<Req, Resp>(\n  path: string,\n  reqRawBody: RawRequestBody,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  rawRequest: Req,\n  rawResponse?: Resp,\n  reqBodyType?: SerializerCode,\n  urlQuery?: string\n): Promise<MionResponse> {\n  const context = createCallContext(path, urlQuery, rawRequest, reqHeaders, respHeaders, reqRawBody, reqBodyType);\n  return dispatchWithContext(context, rawRequest, rawResponse);\n}\n\n/** A streaming adapter builds the context before reading the body, to check `context.maxBodySize`, then passes it. */\nexport async function dispatchWithContext<Req, Resp>(\n  context: CallContext,\n  rawRequest: Req,\n  rawResponse?: Resp,\n  reqRawBody?: RawRequestBody,\n  reqBodyType?: SerializerCode\n): Promise<MionResponse> {\n  if (reqRawBody !== undefined) {\n    const request = context.request as Mutable<MionRequest>;\n    request.rawBody = reqRawBody;\n    request.bodyType = reqBodyType ?? getRequestBodyType(reqRawBody);\n  }\n  // No catch: the chain runners handle every exception themselves, so one that only re-rejects changes nothing.\n  return dispatchMaybeSync(context, rawRequest, rawResponse);\n}\n\n/** `dispatchWithContext` for a context built with its body, minus the promise when no step needs one. */\nexport function dispatchMaybeSync<Req, Resp>(\n  context: CallContext,\n  rawRequest: Req,\n  rawResponse?: Resp\n): MionResponse | Promise<MionResponse> {\n  const opts = getRouterOptions();\n  if (opts.alwaysAwait) return runExecutionChain(context, rawRequest, rawResponse, opts, 0);\n  return runSyncExecutionChain(context, rawRequest, rawResponse, opts);\n}\n\n/** Dispatches a request the platform adapter refused after its route resolved: a body past the limit.\n *  The error is recorded exactly as a thrown one is, so the chain runs only the members that declare\n *  `alwaysRun` (a rate limiter, an access log) and answers with the same envelope. The adapter stopped\n *  the read, so the context is built without a body.\n *  `path` and `urlQuery` travel with the chain rather than on it: mion's not-found chains and a merged\n *  batch chain each answer for many paths, so they carry none of their own, and a refusal does reach one\n *  of those (an adapter checks a declared content-length before asking whether the chain reads a body). */\nexport function dispatchPlatformError<Req, Resp>(\n  chain: MethodsExecutionChain,\n  path: string,\n  urlQuery: string | undefined,\n  platformError: RpcError<string>,\n  reqHeaders: MionHeaders,\n  respHeaders: MionHeaders,\n  rawRequest: Req,\n  rawResponse?: Resp\n): Promise<MionResponse> {\n  const context = createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders);\n  recordUndeclaredError(context, MION_ROUTES.platformError, platformError);\n  return dispatchWithContext(context, rawRequest, rawResponse);\n}\n\n// ############# PRIVATE METHODS #############\n\nasync function runExecutionChain(\n  context: CallContext,\n  rawRequest: unknown,\n  rawResponse: unknown,\n  opts: RouterOptions,\n  startIndex: number\n): Promise<MionResponse> {\n  const {response, request, executionChain} = context;\n  // `alwaysAwait: false` skips the await on sync steps: awaiting one only costs a promise frame\n  const alwaysAwait = opts.alwaysAwait;\n  const executionList = executionChain.methods;\n  const executionCount = executionList.length;\n  for (let i = startIndex; i < executionCount; i++) {\n    const executable = executionList[i];\n    if (response.hasErrors && !executable.alwaysRun) continue;\n\n    try {\n      // runRawMiddleware, runHeadersMiddleware & runRouteOrMiddleware must take the same params in the same order\n      // methodCaller is resolved at registration, so the loop never picks one\n      // `isAsync` comes from the type checker, so a plain function returning a promise still awaits\n      let result;\n      if (alwaysAwait || executable.isAsync) {\n        result = await executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n      } else {\n        result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n        if (isUncheckedPromise(executable, result)) result = await result;\n      }\n      applyResult(context, executable, result);\n    } catch (err: any) {\n      // All thrown errors are undeclared and fatal\n      recordUndeclaredError(context, executable.id, err);\n    }\n  }\n  return context.response;\n}\n\n/** `runExecutionChain` without awaits: from the first async step on it hands over, so both give the same result. */\nfunction runSyncExecutionChain(\n  context: CallContext,\n  rawRequest: unknown,\n  rawResponse: unknown,\n  opts: RouterOptions\n): MionResponse | Promise<MionResponse> {\n  const {response, request, executionChain} = context;\n  const executionList = executionChain.methods;\n  const executionCount = executionList.length;\n  for (let i = 0; i < executionCount; i++) {\n    const executable = executionList[i];\n    if (response.hasErrors && !executable.alwaysRun) continue;\n    if (executable.isAsync) return runExecutionChain(context, rawRequest, rawResponse, opts, i);\n\n    try {\n      const result = executable.methodCaller(context, executable, request, response, opts, rawRequest, rawResponse);\n      if (isUncheckedPromise(executable, result)) {\n        return Promise.resolve(result)\n          .then((resolved) => applyResult(context, executable, resolved))\n          .catch((err) => recordUndeclaredError(context, executable.id, err))\n          .then(() => runExecutionChain(context, rawRequest, rawResponse, opts, i + 1));\n      }\n      applyResult(context, executable, result);\n    } catch (err: any) {\n      // All thrown errors are undeclared and fatal\n      recordUndeclaredError(context, executable.id, err);\n    }\n  }\n  return response;\n}\n\n/** Backstop for a wrong or missing declared type, else the promise is serialized as the answer. */\nfunction isUncheckedPromise(executable: RemoteMethod, result: any): result is PromiseLike<unknown> {\n  if (executable.asyncChecked === true) return false;\n  executable.asyncChecked = true;\n  if (result === null || typeof result !== 'object' || typeof result.then !== 'function') return false;\n  (executable as Mutable<RemoteMethod>).isAsync = true;\n  return true;\n}\n\n/** A throw here is the caller's to record, like the step's own. */\nfunction applyResult(context: CallContext, executable: RemoteMethod, result: any): void {\n  if (result === undefined) return;\n  const response = context.response;\n  // One brand read serves every branch below: it is an own property on every mion error, wire copies too\n  // `null` is a valid answer and reading a property off it throws, so it is excluded first\n  const isMionError = result !== null && result['mion@isΣrrθr'] === true;\n  if (!executable.hasReturnData) {\n    // a raw middleware declares no return, so a returned error is undeclared and halts like a thrown one\n    if (isMionError || isNativeError(result)) recordUndeclaredError(context, executable.id, result);\n    return;\n  }\n  if (isMionError) {\n    // a returned FatalError is declared: it ends the chain but keeps its slot; a plain RpcError lets the chain run on\n    if (result.isFatal === true) markResponseFailed(context, result, StatusCodes.APPLICATION_ERROR);\n  }\n  // A brandless Error is a bug with no typed slot; in the body it would be served as a SUCCESSFUL answer\n  else if (isNativeError(result)) {\n    recordUndeclaredError(context, executable.id, result);\n    return; // like a thrown one: it belongs in @thrownErrors, never in the body\n  }\n  if (executable.headersReturn && result instanceof HeadersSubset) {\n    // own keys only: a HeadersSubset built over a parsed body must not turn inherited keys into headers\n    const headersMap = result.headers;\n    for (const name of Object.keys(headersMap)) {\n      const value = headersMap[name];\n      if (value !== undefined && value !== null) {\n        response.headers.set(name, value);\n      }\n    }\n    return;\n  }\n  (response.body as Mutable<AnyObject>)[executable.id] = result;\n}\n\n// The three callers below are NOT async: awaiting the handler only to return its value adds a promise\n// frame per chain member, and the loop's own await and try/catch cover the value and the promise alike.\nfunction runRawMiddleware(\n  context: CallContext,\n  executable: RawMethod,\n  req,\n  resp,\n  opts: RouterOptions,\n  rawRequest: unknown,\n  rawResponse: unknown\n) {\n  return executable.handler(context, rawRequest, rawResponse, opts);\n}\n\nfunction runHeadersMiddleware(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n  const headerNames = executable.headersParam.headerNames;\n  const params = sanitizeParams(\n    deserializeBodyParamsOrThrow(request, executable as RemoteMethod),\n    request,\n    executable as RemoteMethod\n  );\n  const headersMap: Record<string, string> = {};\n  headerNames.forEach((name) => {\n    const value = request.headers.get(name);\n    if (value) headersMap[name] = value;\n  });\n  const headersSubset = trustedHeadersSubset(headersMap);\n  validateHeaderParamsOrThrow(headersSubset, executable as HeadersMethod);\n  validateParametersOrThrow(params, executable as HeadersMethod);\n\n  return executable.handler(context, headersSubset, ...params);\n}\n\nfunction runRouteOrMiddleware(context: CallContext, executable: HeadersMethod, request: MionRequest) {\n  const params = sanitizeParams(\n    deserializeBodyParamsOrThrow(request, executable as RemoteMethod),\n    request,\n    executable as RemoteMethod\n  );\n  validateParametersOrThrow(params, executable as RemoteMethod);\n  return executable.handler(context, ...params);\n}\n\n/** Applies the rewrites the params types declare under a format's `transform` key (trim / case /\n *  replace / stripSeparators) in place, after decode and BEFORE validation. Params only: headers and\n *  return values are never sanitized. A transform over wrong-shaped input can throw (`.trim()` on a\n *  number): the raw params fall through so validation reports the real error instead of a 500. */\nfunction sanitizeParams(params: any[], request: MionRequest, executable: RemoteMethod): any[] {\n  if (!executable.options.sanitizeParams) return params;\n  const formatTransform = executable.paramsJitFns.formatTransform;\n  if (!formatTransform || formatTransform.isNoop) return params;\n  try {\n    const sanitized = formatTransform.fn(params) as any[];\n    (request.body as Mutable<MionRequest['body']>)[executable.id] = sanitized;\n    return sanitized;\n  } catch {\n    return params;\n  }\n}\n\n/** The caller for a method kind. Read ONCE, when the method is registered, so the dispatch loop\n *  reads a field instead of branching on the method type on every request. */\nexport function callerForType(type: RemoteMethod['type']): (...args: any[]) => any {\n  if (type === HandlerType.rawMiddleware) return runRawMiddleware;\n  if (type === HandlerType.headersMiddleware) return runHeadersMiddleware;\n  return runRouteOrMiddleware;\n}\n\n/** The caller already stored on a registered method. */\nexport function getMethodCaller(executable: RemoteMethod) {\n  return executable.methodCaller;\n}\n\n/** Shared, for the members whose id is absent from the body: a fresh empty array per member per request\n *  bought nothing. Frozen, so a handler that tried to mutate its params fails loudly instead of corrupting\n *  the next request; nothing can reach it anyway, an empty tuple is spread into the call. */\nconst EMPTY_PARAMS: any[] = [];\nObject.freeze(EMPTY_PARAMS);\n\nfunction deserializeBodyParamsOrThrow(request: MionRequest, executable: RemoteMethod): any[] {\n  // own key only: an id like `toString` would otherwise read Object.prototype off the parsed body\n  const body = request.body;\n  const params = (Object.hasOwn(body, executable.id) ? body[executable.id] : undefined) as any[] | undefined;\n  // EMPTY_PARAMS is frozen and the decoders mutate what they are handed, so decoding the sentinel would\n  // report a raw serialization error where validation should refuse the missing body.\n  if (!params) return EMPTY_PARAMS;\n  // a route without params has no validator, so a spread string would reach the handler as its characters\n  if (!Array.isArray(params))\n    throw new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'serialization-error',\n      publicMessage: `Invalid params '${executable.id}', params must be an array.`,\n      errorData: {deserializeError: 'params must be an array'},\n    });\n\n  const {decode} = executable.paramsJitFns.json;\n  if (decode.isNoop) return params;\n  try {\n    const decoded = decode.fn(params);\n    (body as Mutable<MionRequest['body']>)[executable.id] = decoded;\n    return decoded;\n  } catch (e: any) {\n    if (isStackOverflow(e)) throw nestingTooDeep(executable, e);\n    // Fixed wire text: the decoder's message quotes internal detail; the original stays on `originalError`.\n    // A refused-key message is safe to pass on: mion's own constant, naming a key the caller sent.\n    const refusedKey = typeof e?.message === 'string' && e.message.startsWith(UNSAFE_PROPERTY_NAME_MESSAGE);\n    const detail = refusedKey ? (e.message as string) : 'Parameters might be of the wrong type.';\n    throw new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'serialization-error',\n      publicMessage: `Invalid params '${executable.id}', can not deserialize. ${detail}`,\n      originalError: e,\n      errorData: {\n        deserializeError: detail,\n      },\n    });\n  }\n}\n\n/** A RangeError out of a compiled function is the engine's stack limit: the request nested deeper\n *  than a recursive type can be walked. Reported as its own typed 4xx, never as an unknown error. */\nfunction isStackOverflow(err: unknown): boolean {\n  return err instanceof RangeError;\n}\n\nfunction nestingTooDeep(executable: RemoteMethod, originalError: Error): RpcError<'request-nesting-too-deep'> {\n  return new FatalError({\n    statusCode: StatusCodes.UNEXPECTED_ERROR,\n    type: 'request-nesting-too-deep',\n    publicMessage: `Invalid params in '${executable.id}', the request is nested too deep.`,\n    originalError,\n  });\n}\n\nfunction validateParametersOrThrow(params: any[], executable: RemoteMethod): void {\n  if (executable.paramsJitFns.isType.isNoop) return;\n  let isValid: boolean;\n  try {\n    isValid = executable.paramsJitFns.isType.fn(params);\n  } catch (e: any) {\n    if (isStackOverflow(e)) throw nestingTooDeep(executable, e);\n    throw e;\n  }\n  if (!isValid) {\n    const validationError: ValidationError = new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'validation-error',\n      publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n      errorData: {\n        typeErrors: executable.paramsJitFns.typeErrors.fn(params),\n      },\n    });\n    throw validationError;\n  }\n}\n\nfunction validateHeaderParamsOrThrow(headers: HeadersSubset<string, string>, executable: HeadersMethod): void {\n  if (!executable.headersParam.jitFns.isType.fn(headers)) {\n    const validationError: ValidationError = new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'validation-error',\n      publicMessage: `Invalid params in '${executable.id}', validation failed.`,\n      errorData: {\n        typeErrors: executable.headersParam.jitFns.typeErrors.fn(headers),\n      },\n    });\n    throw validationError;\n  }\n}\n"],"mappings":"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"}

package/.dist/cjs/src/dispatch.d.ts

@@ -1,4 +1,10 @@
-import { MionResponse, MionHeaders, RawRequestBody } from './types/context.ts';
-import { SerializerCode } from '@mionjs/core';
+import { CallContext, MionResponse, MionHeaders, RawRequestBody } from './types/context.ts';
+import { RemoteMethod, MethodsExecutionChain } from './types/remoteMethods.ts';
+import { SerializerCode, RpcError } from '@mionjs/core';
 export declare function dispatchRoute<Req, Resp>(path: string, reqRawBody: RawRequestBody, reqHeaders: MionHeaders, respHeaders: MionHeaders, rawRequest: Req, rawResponse?: Resp, reqBodyType?: SerializerCode, urlQuery?: string): Promise<MionResponse>;
+export declare function dispatchWithContext<Req, Resp>(context: CallContext, rawRequest: Req, rawResponse?: Resp, reqRawBody?: RawRequestBody, reqBodyType?: SerializerCode): Promise<MionResponse>;
+export declare function dispatchMaybeSync<Req, Resp>(context: CallContext, rawRequest: Req, rawResponse?: Resp): MionResponse | Promise<MionResponse>;
+export declare function dispatchPlatformError<Req, Resp>(chain: MethodsExecutionChain, path: string, urlQuery: string | undefined, platformError: RpcError<string>, reqHeaders: MionHeaders, respHeaders: MionHeaders, rawRequest: Req, rawResponse?: Resp): Promise<MionResponse>;
+export declare function callerForType(type: RemoteMethod['type']): (...args: any[]) => any;
+export declare function getMethodCaller(executable: RemoteMethod): (...args: any[]) => any;
 //# sourceMappingURL=dispatch.d.ts.map