@mionjs/router 0.8.10 → 0.13.0

package/.dist/esm/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/esm/src/callContext.js

@@ -1,125 +1,77 @@
-import { WORKFLOW_PATH } from "./constants.js";
-import { getRouteExecutionChain } from "./router.js";
-import { StatusCodes, SerializerModes, getRoutePath, MION_ROUTES, RpcError } from "@mionjs/core";
-import { getRoutesFlowExecutionChain } from "./routesFlow.js";
-let contextPool = [];
-function getContextPoolStats() {
-  return {
-    poolSize: contextPool.length
-  };
+import { JSON_CONTENT_TYPE } from "./constants.js";
+import { getBatchExecutionChain } from "./batches.js";
+import { getNotFoundExecutionChain, getRouteExecutionChain, getRouterOptions } from "./router.js";
+import { FatalError, MION_BATCH_PATH, MION_ROUTES, SerializerModes, StatusCodes } from "@mionjs/core";
+//#region src/callContext.ts
+/** Resolves a request to the REGISTERED chain that answers it, allocating NOTHING, so a streaming adapter
+*  calls it BEFORE the body to read against `chain.maxBodySize` and `createContextFromChain` after.
+*  Nothing of the request's own may survive the read: such an object is promoted to the old heap and the
+*  parsed body attached to it is promoted with it, which on a 4 MB body costs garbage-collector throughput.
+*  The chain is SHARED and long-lived: mutating what this returns damages the route for the whole process.
+*  An unknown path or batch id resolves to a not-found chain that never reads the body (`readsBody` false)
+*  and runs only the global middlewares that declare `alwaysRun`. */
+function resolveExecutionChain(path, urlQuery, rawRequest) {
+	const opts = getRouterOptions();
+	return getExecutionChain(path, opts.pathTransform?.(rawRequest, path) || path, urlQuery, rawRequest, opts);
 }
-function clearContextPool() {
-  contextPool = [];
+/** `path` and `urlQuery` are the request's; a route chain's own path wins, not-found and batch chains use the request's. */
+function createContextFromChain(chain, path, urlQuery, reqHeaders, respHeaders, reqRawBody, reqBodyType) {
+	const request = {
+		headers: reqHeaders,
+		rawBody: reqRawBody,
+		bodyType: reqBodyType ?? getRequestBodyType(reqRawBody),
+		body: EMPTY_BODY,
+		thrownErrors: void 0
+	};
+	const response = {
+		statusCode: StatusCodes.OK,
+		contentType: JSON_CONTENT_TYPE,
+		hasErrors: false,
+		fatalError: void 0,
+		headers: respHeaders,
+		body: {}
+	};
+	const contextDataFactory = getRouterOptions().contextDataFactory;
+	return {
+		path: chain.path ?? path,
+		request,
+		response,
+		executionChain: chain,
+		maxBodySize: chain.maxBodySize,
+		readsBody: chain.readsBody,
+		shared: contextDataFactory ? contextDataFactory() : {},
+		urlQuery,
+		batchId: chain.batchId,
+		batchRouteIds: chain.batchRouteIds
+	};
 }
-function createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery) {
-  const transformedPath = opts.pathTransform?.(rawRequest, path) || path;
-  const { executionChain, routesFlowRouteIds } = getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);
-  return {
-    path: transformedPath,
-    request: {
-      headers: reqHeaders,
-      rawBody: reqRawBody,
-      bodyType: reqBodyType ?? getRequestBodyType(reqRawBody),
-      body: {},
-      thrownErrors: void 0
-    },
-    response: {
-      statusCode: StatusCodes.OK,
-      hasErrors: false,
-      headers: respHeaders,
-      body: {},
-      rawBody: "",
-      serializer: SerializerModes.json,
-      binSerializer: void 0
-    },
-    executionChain,
-    shared: opts.contextDataFactory ? opts.contextDataFactory() : {},
-    urlQuery,
-    routesFlowRouteIds
-  };
-}
-function acquireCallContext(usePooling, path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery) {
-  if (!usePooling) return createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery);
-  const pooledContext = contextPool.pop();
-  const transformedPath = opts.pathTransform?.(rawRequest, path) || path;
-  if (pooledContext) {
-    const ctx = pooledContext;
-    ctx.path = transformedPath;
-    const req = ctx.request;
-    req.headers = reqHeaders;
-    req.rawBody = reqRawBody;
-    req.bodyType = reqBodyType ?? getRequestBodyType(reqRawBody);
-    req.body = {};
-    req.thrownErrors = void 0;
-    const resp = ctx.response;
-    resp.statusCode = StatusCodes.OK;
-    resp.hasErrors = false;
-    resp.headers = respHeaders;
-    resp.body = {};
-    resp.rawBody = "";
-    resp.serializer = SerializerModes.json;
-    resp.binSerializer = void 0;
-    const { executionChain, routesFlowRouteIds } = getExecutionChain(path, transformedPath, urlQuery, rawRequest, opts);
-    ctx.executionChain = executionChain;
-    ctx.routesFlowRouteIds = routesFlowRouteIds;
-    ctx.shared = opts.contextDataFactory ? opts.contextDataFactory() : {};
-    ctx.urlQuery = urlQuery;
-    return ctx;
-  }
-  return createCallContext(path, opts, reqRawBody, rawRequest, reqHeaders, respHeaders, reqBodyType, urlQuery);
-}
-function releaseCallContext(ctx, maxPoolSize) {
-  if (contextPool.length < maxPoolSize) {
-    const mutableCtx = ctx;
-    const req = mutableCtx.request;
-    req.rawBody = "";
-    req.body = null;
-    req.thrownErrors = void 0;
-    mutableCtx.response = {
-      statusCode: StatusCodes.OK,
-      hasErrors: false,
-      headers: null,
-      // Will be set when context is acquired
-      body: null,
-      // Will be set when context is acquired
-      rawBody: "",
-      serializer: SerializerModes.json,
-      binSerializer: void 0
-    };
-    mutableCtx.shared = null;
-    mutableCtx.executionChain = null;
-    mutableCtx.routesFlowRouteIds = void 0;
-    contextPool.push(ctx);
-  }
+var EMPTY_BODY = Object.freeze({});
+/** The one-call form, for a caller that already has the body (a host that parsed it, `dispatchRoute`, a test). */
+function createCallContext(path, urlQuery, rawRequest, reqHeaders, respHeaders, reqRawBody, reqBodyType) {
+	return createContextFromChain(resolveExecutionChain(path, urlQuery, rawRequest), path, urlQuery, reqHeaders, respHeaders, reqRawBody, reqBodyType);
 }
+/** The wire form of a body: a string is stringified JSON, anything else a parsed object. A body
+*  not yet read (a context built before it) reads as an object until the body arrives. */
 function getRequestBodyType(rawBody) {
-  if (typeof rawBody === "string") return SerializerModes.stringifyJson;
-  if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array) return SerializerModes.binary;
-  return SerializerModes.json;
+	if (typeof rawBody === "string") return SerializerModes.stringifyJson;
+	if (rawBody instanceof ArrayBuffer || rawBody instanceof Uint8Array) throw new Error("mion: a byte request body has no encoder; send the body as a JSON string or a parsed object.");
+	return SerializerModes.json;
 }
 function getExecutionChain(originalPath, transformedPath, urlQuery, rawRequest, opts) {
-  const hasPrefix = !!opts.basePath;
-  const isRoutesFlowPath = hasPrefix ? originalPath.endsWith(WORKFLOW_PATH) : originalPath === WORKFLOW_PATH;
-  if (isRoutesFlowPath) return getRoutesFlowExecutionChain(rawRequest, opts, urlQuery);
-  let executionChain = getRouteExecutionChain(transformedPath);
-  if (!executionChain) {
-    const notFoundPath = getRoutePath([MION_ROUTES.notFound], opts);
-    executionChain = getRouteExecutionChain(notFoundPath);
-    if (!executionChain) {
-      throw new RpcError({
-        statusCode: StatusCodes.UNEXPECTED_ERROR,
-        type: "not-found",
-        publicMessage: "Not-found route is not registered. This should never happen."
-      });
-    }
-  }
-  return { executionChain };
+	if (!!opts.basePath ? originalPath.endsWith(MION_BATCH_PATH) : originalPath === MION_BATCH_PATH) return getBatchExecutionChain(rawRequest, opts, urlQuery) ?? notFoundChain(MION_ROUTES.batchNotFound);
+	return getRouteExecutionChain(transformedPath) ?? notFoundChain(MION_ROUTES.notFound);
+}
+/** mion's own not-found chains are built by initRouter, so an absent one is a bug, not a request error. */
+function notFoundChain(chainId) {
+	const executionChain = getNotFoundExecutionChain(chainId);
+	if (!executionChain) throw new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "not-found",
+		publicMessage: "Not-found chain is not registered. This should never happen."
+	});
+	return executionChain;
 }
-export {
-  acquireCallContext,
-  clearContextPool,
-  createCallContext,
-  getContextPoolStats,
-  releaseCallContext
-};
-//# sourceMappingURL=callContext.js.map
+//#endregion
+export { createCallContext, createContextFromChain, getRequestBodyType, resolveExecutionChain };
+
+//# sourceMappingURL=callContext.js.map

package/.dist/esm/src/callContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"callContext.js","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":[],"mappings":"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"}
+{"version":3,"file":"callContext.js","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,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,YAAY;EACxB,aAAa;EACb,WAAW;EACX,YAAY,KAAA;EACZ,SAAS;EACT,MAAM,CAAC;CACT;CACA,MAAM,qBAAqB,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,gBAAgB;CACxD,IAAI,mBAAmB,eAAe,mBAAmB,YACvD,MAAM,IAAI,MAAM,8FAA8F;CAChH,OAAO,gBAAgB;AACzB;AAEA,SAAS,kBACP,cACA,iBACA,UACA,YACA,MACuB;CAIvB,IADoB,CAFD,CAAC,KAAK,WAEO,aAAa,SAAS,eAAe,IAAI,iBAAiB,iBAExF,OAAO,uBAAuB,YAAY,MAAM,QAAQ,KAAK,cAAc,YAAY,aAAa;CAGtG,OAAO,uBAAuB,eAAe,KAAK,cAAc,YAAY,QAAQ;AACtF;;AAGA,SAAS,cAAc,SAAwC;CAC7D,MAAM,iBAAiB,0BAA0B,OAAO;CACxD,IAAI,CAAC,gBACH,MAAM,IAAI,WAAW;EACnB,YAAY,YAAY;EACxB,MAAM;EACN,eAAe;CACjB,CAAC;CAEH,OAAO;AACT"}

package/.dist/esm/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/esm/src/constants.js

@@ -1,45 +1,23 @@
-import { getENV, PATH_SEPARATOR, MION_ROUTES } from "@mionjs/core";
-const IS_TEST_ENV = getENV("JEST_WORKER_ID") !== void 0 || 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 = `${PATH_SEPARATOR}${MION_ROUTES.notFound}`;
-const WORKFLOW_KEY = `mion-routes-flow`;
-const WORKFLOW_PATH = `${PATH_SEPARATOR}${WORKFLOW_KEY}`;
-export {
-  DEFAULT_ROUTE_OPTIONS,
-  HEADER_HOOK_DEFAULT_PARAMS,
-  IS_TEST_ENV,
-  MAX_ROUTE_NESTING,
-  NOT_FOUND_HOOK_NAME,
-  NOT_FOUND_PATH,
-  ROUTE_DEFAULT_PARAMS,
-  WORKFLOW_KEY,
-  WORKFLOW_PATH
-};
-//# sourceMappingURL=constants.js.map
+var MAX_ROUTE_NESTING = 10;
+var JSON_CONTENT_TYPE = "application/json; charset=utf-8";
+//#endregion
+export { DEFAULT_ROUTE_OPTIONS, JSON_CONTENT_TYPE, MAX_ROUTE_NESTING };
+
+//# sourceMappingURL=constants.js.map

package/.dist/esm/src/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","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":[],"mappings":";AAUO,MAAM,cAAc,OAAO,gBAAgB,MAAM,UAAa,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,GAAG,cAAc,GAAG,YAAY,QAAQ;AAC/D,MAAM,eAAe;AACrB,MAAM,gBAAgB,GAAG,cAAc,GAAG,YAAY;"}
+{"version":3,"file":"constants.js","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/esm/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