@mionjs/router 0.8.0-alpha.0

package/.dist/cjs/src/routes/errors.routes.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const src_lib_handlers = require("../lib/handlers.cjs");
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const mionErrorsRoutes = {
+  /**
+   * !IMPORTANT!
+   * This is declared as route mostly to reuse existing router serialization/deserialization functionality.
+   * But "@thrownErrors" is expected to be a field in response body that contain all thrown errors from other executables.
+   * thrown Errors are not strongly typed and are all serialized/deserialized as RpcError<string>.
+   * this also prevents users to register a route with the same name.
+   */
+  [core.MION_ROUTES.thrownErrors]: src_lib_handlers.route(__assignType((ctx) => {
+    return ctx.request.thrownErrors || {};
+  }, ["CallContext", "ctx", () => __ΩRecord, () => core.RpcError, "", 'P"w!2"&P&7$o##/%'])),
+  /**
+   * Route that handles not-found scenarios when a requested route doesn't exist.
+   * This route is registered as an internal mion route.
+   * The route is called by dispatch logic when no matching route is found.
+   * Throws an RpcError that will be caught and stored in thrownErrors by the router.
+   */
+  [core.MION_ROUTES.notFound]: src_lib_handlers.route(__assignType((ctx) => {
+    throw new core.RpcError({
+      statusCode: core.StatusCodes.NOT_FOUND,
+      publicMessage: `Route not found`,
+      type: "route-not-found"
+    });
+  }, ["CallContext", "ctx", "route-not-found", () => core.RpcError, "", 'P"w!2"P.#7$/%'])),
+  /**
+   * Platform error route for strongly typing platform/adapter errors.
+   * Platform errors occur before reaching the router or outside the router
+   * and are platform/adapter related (e.g., HTTP server errors, connection issues).
+   * This route is used for serialization/deserialization of platform errors.
+   * This also prevents users to register a route with the same name.
+   */
+  [core.MION_ROUTES.platformError]: src_lib_handlers.route(__assignType((_ctx) => {
+    return new core.RpcError({
+      publicMessage: "Platform error",
+      type: "platform-error"
+    });
+  }, ["CallContext", "_ctx", () => core.RpcError, "", 'P"w!2"P&7#/$']))
+};
+exports.mionErrorsRoutes = mionErrorsRoutes;
+//# sourceMappingURL=errors.routes.cjs.map

package/.dist/cjs/src/routes/errors.routes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.routes.cjs","sources":["../../../../src/routes/errors.routes.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {Routes} from '../types/general.ts';\nimport type {CallContext} from '../types/context.ts';\nimport {RpcError, MION_ROUTES, StatusCodes} from '@mionjs/core';\nimport {route} from '../lib/handlers.ts';\n\nexport const mionErrorsRoutes = {\n    /**\n     * !IMPORTANT!\n     * This is declared as route mostly to reuse existing router serialization/deserialization functionality.\n     * But \"@thrownErrors\" is expected to be a field in response body that contain all thrown errors from other executables.\n     * thrown Errors are not strongly typed and are all serialized/deserialized as RpcError<string>.\n     * this also prevents users to register a route with the same name.\n     */\n    [MION_ROUTES.thrownErrors]: route((ctx: CallContext): Record<string, RpcError<string>> => {\n        return ctx.request.thrownErrors || {};\n    }),\n    /**\n     * Route that handles not-found scenarios when a requested route doesn't exist.\n     * This route is registered as an internal mion route.\n     * The route is called by dispatch logic when no matching route is found.\n     * Throws an RpcError that will be caught and stored in thrownErrors by the router.\n     */\n    [MION_ROUTES.notFound]: route((ctx: CallContext): RpcError<'route-not-found'> => {\n        throw new RpcError({\n            statusCode: StatusCodes.NOT_FOUND,\n            publicMessage: `Route not found`,\n            type: 'route-not-found',\n        });\n    }),\n    /**\n     * Platform error route for strongly typing platform/adapter errors.\n     * Platform errors occur before reaching the router or outside the router\n     * and are platform/adapter related (e.g., HTTP server errors, connection issues).\n     * This route is used for serialization/deserialization of platform errors.\n     * This also prevents users to register a route with the same name.\n     */\n    [MION_ROUTES.platformError]: route((_ctx: CallContext): RpcError<string> => {\n        // Platform errors are passed through context, this route is for type serialization\n        return new RpcError({\n            publicMessage: 'Platform error',\n            type: 'platform-error',\n        });\n    }),\n} as const satisfies Routes;\n"],"names":["MION_ROUTES","route","RpcError","StatusCodes"],"mappings":";;;;;;;;;AAYO,MAAM,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ5B,CAACA,KAAAA,YAAY,YAAY,GAAGC,iBAAAA,MAAK,aAAC,CAAC,QAAsD;AACrF,WAAO,IAAI,QAAQ,gBAAgB,CAAA;AAAA,EACvC,GAAC,CAAA,eAAA,OAAA,MAAA,WAAA,MAAAC,eAAA,IAAA,kBAAA,CAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOD,CAACF,KAAAA,YAAY,QAAQ,GAAGC,iBAAAA,MAAK,aAAC,CAAC,QAAiD;AAC5E,UAAM,IAAIC,KAAAA,SAAS;AAAA,MACf,YAAYC,KAAAA,YAAY;AAAA,MACxB,eAAe;AAAA,MACf,MAAM;AAAA,IAAA,CACT;AAAA,EACL,GAAC,CAAA,eAAA,OAAA,mBAAA,MAAAD,eAAA,IAAA,eAAA,CAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQD,CAACF,KAAAA,YAAY,aAAa,GAAGC,iBAAAA,MAAK,aAAC,CAAC,SAAuC;AAEvE,WAAO,IAAIC,KAAAA,SAAS;AAAA,MAChB,eAAe;AAAA,MACf,MAAM;AAAA,IAAA,CACT;AAAA,EACL,GAAC,CAAA,eAAA,QAAA,MAAAA,KAAAA,UAAA,IAAA,cAAA,CAAA,CAAA;;;"}

package/.dist/cjs/src/routes/errors.routes.d.ts

@@ -0,0 +1,7 @@
+import { CallContext } from '../types/context.ts';
+import { RpcError } from '@mionjs/core';
+export declare const mionErrorsRoutes: {
+    readonly "@thrownErrors": import('../types/definitions.ts').RouteDef<(ctx: CallContext) => Record<string, RpcError<string>>>;
+    readonly "mion@notFound": import('../types/definitions.ts').RouteDef<(ctx: CallContext) => RpcError<"route-not-found">>;
+    readonly "mion@platformError": import('../types/definitions.ts').RouteDef<(_ctx: CallContext) => RpcError<string>>;
+};

package/.dist/cjs/src/routes/mion.routes.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_publicMethods = require("../types/publicMethods.cjs");
+const src_routes_client_routes = require("./client.routes.cjs");
+const src_routes_errors_routes = require("./errors.routes.cjs");
+const mionRoutes = {
+  ...src_routes_client_routes.mionClientRoutes,
+  ...src_routes_errors_routes.mionErrorsRoutes
+};
+const __ΩMionRoutes = [() => src_types_publicMethods.__ΩPublicApi, () => mionRoutes, "MionRoutes", 'i"o!"w#y'];
+exports.__ΩMionRoutes = __ΩMionRoutes;
+exports.mionRoutes = mionRoutes;
+//# sourceMappingURL=mion.routes.cjs.map

package/.dist/cjs/src/routes/mion.routes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mion.routes.cjs","sources":["../../../../src/routes/mion.routes.ts"],"sourcesContent":["import {Routes} from '../types/general.ts';\nimport {PublicApi} from '../types/publicMethods.ts';\nimport {mionClientRoutes} from './client.routes.ts';\nimport {mionErrorsRoutes} from './errors.routes.ts';\n\nexport const mionRoutes = {\n    ...mionClientRoutes,\n    ...mionErrorsRoutes,\n} as const satisfies Routes;\n\nexport type MionRoutes = PublicApi<typeof mionRoutes>;\n"],"names":["mionClientRoutes","mionErrorsRoutes"],"mappings":";;;;;AAKO,MAAM,aAAa;AAAA,EACtB,GAAGA,yBAAAA;AAAAA,EACH,GAAGC,yBAAAA;;;;;"}

package/.dist/cjs/src/routes/mion.routes.d.ts

@@ -0,0 +1,10 @@
+import { PublicApi } from '../types/publicMethods.ts';
+export declare const mionRoutes: {
+    readonly "@thrownErrors": import('../types/definitions.ts').RouteDef<(ctx: import('../types/context.ts').CallContext) => Record<string, import('@mionjs/core/.dist/esm/index.js').RpcError<string>>>;
+    readonly "mion@notFound": import('../types/definitions.ts').RouteDef<(ctx: import('../types/context.ts').CallContext) => import('@mionjs/core/.dist/esm/index.js').RpcError<"route-not-found">>;
+    readonly "mion@platformError": import('../types/definitions.ts').RouteDef<(_ctx: import('../types/context.ts').CallContext) => import('@mionjs/core/.dist/esm/index.js').RpcError<string>>;
+    readonly "mion@methodsMetadataById": import('../types/definitions.ts').RouteDef<(ctx: any, methodsIds: string[], getAllRemoteMethods?: boolean) => import('@mionjs/core/.dist/esm/index.js').SerializableMethodsData | import('@mionjs/core/.dist/esm/index.js').RpcError<"rpc-metadata-not-found">>;
+    readonly "mion@methodsMetadataByPath": import('../types/definitions.ts').RouteDef<(ctx: any, path: string, getAllRemoteMethods?: boolean) => import('@mionjs/core/.dist/esm/index.js').SerializableMethodsData | import('@mionjs/core/.dist/esm/index.js').RpcError<"rpc-metadata-not-found">>;
+};
+export type MionRoutes = PublicApi<typeof mionRoutes>;
+export declare type __ΩMionRoutes = any[];

package/.dist/cjs/src/routes/serializer.routes.cjs

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_types_context = require("../types/context.cjs");
+const src_types_general = require("../types/general.cjs");
+const src_types_publicMethods = require("../types/publicMethods.cjs");
+const core = require("@mionjs/core");
+const src_lib_handlers = require("../lib/handlers.cjs");
+const src_router = require("../router.cjs");
+const src_types_remoteMethods = require("../types/remoteMethods.cjs");
+const src_lib_dispatchError = require("../lib/dispatchError.cjs");
+function deserializeRequestBody(context) {
+  if (!context.request.rawBody)
+    return;
+  let parsedBody;
+  switch (context.request.bodyType) {
+    case core.SerializerModes.stringifyJson:
+      try {
+        parsedBody = JSON.parse(context.request.rawBody);
+      } catch (err) {
+        throw new core.RpcError({
+          statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+          type: "parsing-json-request-error",
+          publicMessage: `Invalid json request body: ${err?.message || "unknown parsing error."}`
+        });
+      }
+      break;
+    case core.SerializerModes.binary: {
+      const rawBody = context.request.rawBody;
+      const { body } = core.deserializeBinaryBody(context.path, rawBody, false);
+      parsedBody = body;
+      break;
+    }
+    case core.SerializerModes.json:
+      parsedBody = context.request.rawBody;
+      break;
+    default:
+      throw new Error(`Invalid body type ${context.request.bodyType}`);
+  }
+  if (parsedBody) {
+    if (Array.isArray(parsedBody)) {
+      parsedBody = { [src_router.getRouteExecutableFromPath(context.path).id]: parsedBody };
+    }
+    if (typeof parsedBody !== "object")
+      throw new core.RpcError({
+        statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+        type: "invalid-request-body",
+        publicMessage: "Wrong request body. Expecting a body containing the route name and parameters."
+      });
+    context.request.body = parsedBody;
+  }
+}
+deserializeRequestBody.__type = [() => src_types_context.__ΩCallContext, "context", () => src_types_publicMethods.__ΩMayReturnError, "deserializeRequestBody", 'Pn!2"n#/$'];
+function serializeResponseBody(context, opts) {
+  const response = context.response;
+  const respBody = response.body;
+  const bodyType = context.response.serializer;
+  const thrownErrors = context.request.thrownErrors;
+  if (thrownErrors)
+    response.body["@thrownErrors"] = thrownErrors;
+  switch (bodyType) {
+    case core.SerializerModes.stringifyJson: {
+      response.headers.set("content-type", "application/json; charset=utf-8");
+      const body = stringifyBody(context, context.executionChain.methods, respBody);
+      response.rawBody = body;
+      break;
+    }
+    case core.SerializerModes.json: {
+      response.headers.set("content-type", "application/json; charset=utf-8");
+      prepareBodyForJson(context, context.executionChain.methods, respBody);
+      break;
+    }
+    case core.SerializerModes.binary: {
+      response.headers.set("content-type", "application/octet-stream");
+      serializeBinaryBody(context, context.executionChain.methods, respBody);
+      break;
+    }
+    default:
+      throw new Error(`Invalid body type ${context.request.bodyType}`);
+  }
+}
+serializeResponseBody.__type = [() => src_types_context.__ΩCallContext, "context", () => src_types_general.__ΩRouterOptions, "opts", () => src_types_publicMethods.__ΩMayReturnError, "serializeResponseBody", 'Pn!2"n#2$n%/&'];
+function serializeBinaryBody(context, executionChain, respBody) {
+  const response = context.response;
+  const { serializer, buffer } = core.serializeBinaryBody(context.path, executionChain, respBody, true, context.routesFlowRouteIds);
+  response.binSerializer = serializer;
+  response.rawBody = new Uint8Array(buffer);
+}
+serializeBinaryBody.__type = [() => src_types_context.__ΩCallContext, "context", () => src_types_remoteMethods.__ΩRemoteMethod, "executionChain", () => src_types_context.__ΩResponseBody, "respBody", "serializeBinaryBody", `Pn!2"n#F2$n%2&$/'`];
+function stringifyBody(context, executionChain, respBody) {
+  const props = [];
+  for (let i = 0; i < executionChain.length; i++) {
+    const method = executionChain[i];
+    const returnValue = respBody[method.id];
+    if (!method.hasReturnData || typeof returnValue === "undefined")
+      continue;
+    try {
+      const jsonValue = stringifyHandlerReturnValue(method, returnValue);
+      if (!jsonValue)
+        continue;
+      props.push(`${JSON.stringify(method.id)}:${jsonValue}`);
+    } catch (e) {
+      onStringifyExecutableError(context, method, e);
+    }
+  }
+  const thrownErrors = respBody["@thrownErrors"];
+  if (thrownErrors) {
+    const method = src_router.getRouteExecutable(core.MION_ROUTES.thrownErrors);
+    try {
+      const jsonValue = stringifyHandlerReturnValue(method, thrownErrors);
+      if (jsonValue)
+        props.push(`${JSON.stringify(method.id)}:${jsonValue}`);
+    } catch (e) {
+      onStringifyExecutableError(context, method, e);
+    }
+  }
+  return `{${props.join(",")}}`;
+}
+stringifyBody.__type = [() => src_types_context.__ΩCallContext, "context", () => src_types_remoteMethods.__ΩRemoteMethod, "executionChain", () => src_types_context.__ΩResponseBody, "respBody", "stringifyBody", `Pn!2"n#F2$n%2&&/'`];
+function onStringifyExecutableError(context, method, e) {
+  const err = new core.RpcError({
+    statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+    type: "json-stringify-response-error",
+    publicMessage: `Failed to stringify return value for handler ${method.id}, expected response type: ${method.returnJitFns.stringifyJson.typeName}`,
+    originalError: e,
+    errorData: { methodId: method.id }
+  });
+  src_lib_dispatchError.onExecutableError(context, method, err);
+}
+onStringifyExecutableError.__type = [() => src_types_context.__ΩCallContext, "context", () => src_types_remoteMethods.__ΩRemoteMethod, "method", "e", "onStringifyExecutableError", 'Pn!2"n#2$"2%"/&'];
+function stringifyHandlerReturnValue(method, returnValue) {
+  if (!method.hasReturnData)
+    return "";
+  if (method.returnJitFns.prepareForJson.isNoop)
+    JSON.stringify(returnValue);
+  return method.returnJitFns.stringifyJson.fn(returnValue);
+}
+stringifyHandlerReturnValue.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "method", "returnValue", "stringifyHandlerReturnValue", 'Pn!2""2#&/$'];
+function prepareBodyForJson(context, executionChain, respBody) {
+  for (let i = 0; i < executionChain.length; i++) {
+    const method = executionChain[i];
+    const returnValue = respBody[method.id];
+    if (!method.hasReturnData || typeof returnValue === "undefined")
+      continue;
+    try {
+      const preparedValue = prepareHandlerReturnValue(method, returnValue);
+      if (preparedValue !== void 0)
+        respBody[method.id] = preparedValue;
+    } catch (e) {
+      onPrepareForJsonExecutableError(context, method, e);
+    }
+  }
+  const thrownErrors = respBody["@thrownErrors"];
+  if (thrownErrors) {
+    const method = src_router.getRouteExecutable(core.MION_ROUTES.thrownErrors);
+    try {
+      const preparedValue = prepareHandlerReturnValue(method, thrownErrors);
+      if (preparedValue !== void 0)
+        respBody[method.id] = preparedValue;
+    } catch (e) {
+      onPrepareForJsonExecutableError(context, method, e);
+    }
+  }
+}
+prepareBodyForJson.__type = [() => src_types_context.__ΩCallContext, "context", () => src_types_remoteMethods.__ΩRemoteMethod, "executionChain", () => src_types_context.__ΩResponseBody, "respBody", "prepareBodyForJson", `Pn!2"n#F2$n%2&$/'`];
+function onPrepareForJsonExecutableError(context, method, e) {
+  const err = new core.RpcError({
+    statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+    type: "prepare-for-json-response-error",
+    publicMessage: `Failed to prepare return value for JSON for handler ${method.id}, expected response type: ${method.returnJitFns.prepareForJson.typeName}`,
+    originalError: e,
+    errorData: { methodId: method.id }
+  });
+  src_lib_dispatchError.onExecutableError(context, method, err);
+}
+onPrepareForJsonExecutableError.__type = [() => src_types_context.__ΩCallContext, "context", () => src_types_remoteMethods.__ΩRemoteMethod, "method", "e", "onPrepareForJsonExecutableError", 'Pn!2"n#2$"2%"/&'];
+function prepareHandlerReturnValue(method, returnValue) {
+  if (!method.hasReturnData)
+    return void 0;
+  if (method.returnJitFns.prepareForJson.isNoop)
+    return returnValue;
+  return method.returnJitFns.prepareForJson.fn(returnValue);
+}
+prepareHandlerReturnValue.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "method", "returnValue", "prepareHandlerReturnValue", 'Pn!2""2#"/$'];
+const serializerMiddleFns = {
+  mionDeserializeRequest: src_lib_handlers.rawMiddleFn(deserializeRequestBody, { runOnError: true }),
+  mionSerializeResponse: src_lib_handlers.rawMiddleFn(serializeResponseBody, { runOnError: true })
+};
+exports.deserializeRequestBody = deserializeRequestBody;
+exports.serializeResponseBody = serializeResponseBody;
+exports.serializerMiddleFns = serializerMiddleFns;
+//# sourceMappingURL=serializer.routes.cjs.map

package/.dist/cjs/src/routes/serializer.routes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.routes.cjs","sources":["../../../../src/routes/serializer.routes.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {MionResponse, MionRequest, CallContext, ResponseBody} from '../types/context.ts';\nimport {RouterOptions} from '../types/general.ts';\nimport {MiddleFnsCollection, MayReturnError} from '../types/publicMethods.ts';\nimport {\n    AnyObject,\n    Mutable,\n    MION_ROUTES,\n    StatusCodes,\n    serializeBinaryBody as coreSerializeBinaryBody,\n    deserializeBinaryBody as coreDeserializeBinaryBody,\n    SerializerModes,\n} from '@mionjs/core';\nimport {rawMiddleFn} from '../lib/handlers.ts';\nimport {getRouteExecutableFromPath, getRouteExecutable} from '../router.ts';\nimport {RpcError} from '@mionjs/core';\nimport {RemoteMethod} from '../types/remoteMethods.ts';\nimport {onExecutableError} from '../lib/dispatchError.ts';\n\n// ############# PUBLIC METHODS #############\n\n/**\n * Deserializes the request body and stores it in the request body property.\n * This method is called before any other middleFn or route handler.\n * For binary requests, the body is parsed lazily per-method in dispatch.ts.\n * @mion:middleFn\n */\nexport function deserializeRequestBody(context: CallContext): MayReturnError {\n    if (!context.request.rawBody) return; // empty body\n    let parsedBody: any;\n    switch (context.request.bodyType) {\n        case SerializerModes.stringifyJson: // jit stringify json\n            try {\n                parsedBody = JSON.parse(context.request.rawBody as string);\n            } catch (err: any) {\n                throw new RpcError({\n                    statusCode: StatusCodes.UNEXPECTED_ERROR,\n                    type: 'parsing-json-request-error',\n                    publicMessage: `Invalid json request body: ${err?.message || 'unknown parsing error.'}`,\n                });\n            }\n            break;\n        case SerializerModes.binary: {\n            // binary\n            const rawBody = context.request.rawBody as Uint8Array;\n            const {body} = coreDeserializeBinaryBody(context.path, rawBody, false);\n            parsedBody = body;\n            break;\n        }\n        case SerializerModes.json: // Object (pre-parsed body from platforms like Google Cloud Functions where Express auto-parses JSON)\n            parsedBody = context.request.rawBody;\n            break;\n        default:\n            throw new Error(`Invalid body type ${context.request.bodyType}`);\n    }\n    if (parsedBody) {\n        if (Array.isArray(parsedBody)) {\n            // when the body is an array we assume it's a single route call and we have to reconstruct the body\n            // http://my-api.com/route1 [p1, p2, p3] => {route1: [p1, p2, p3]}\n            parsedBody = {[getRouteExecutableFromPath(context.path).id]: parsedBody};\n        }\n        if (typeof parsedBody !== 'object')\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'invalid-request-body',\n                publicMessage: 'Wrong request body. Expecting a body containing the route name and parameters.',\n            });\n        (context.request as Mutable<MionRequest>).body = parsedBody;\n    }\n}\n\n/**\n * Serializes the response body and stores it in the response rawBody property.\n * This method is called after any other middleFn or route handler.\n * @mion:middleFn\n */\nexport function serializeResponseBody(context: CallContext, opts: RouterOptions): MayReturnError {\n    const response = context.response as Mutable<MionResponse>;\n    const respBody: AnyObject = response.body;\n    const bodyType = context.response.serializer;\n    const thrownErrors = context.request.thrownErrors as Record<string, RpcError<string>> | undefined;\n    // Add thrownErrors to response body before the serializer runs\n    if (thrownErrors) (response.body as Mutable<AnyObject>)['@thrownErrors'] = thrownErrors;\n    switch (bodyType) {\n        case SerializerModes.stringifyJson: {\n            // json - use stringifyJson JIT function\n            response.headers.set('content-type', 'application/json; charset=utf-8');\n            const body = stringifyBody(context, context.executionChain.methods, respBody);\n            response.rawBody = body;\n            break;\n        }\n        case SerializerModes.json: {\n            // pre-serialized object - only prepare for JSON, don't stringify\n            // Platform adapters will handle the actual JSON stringification\n            // prepareForJson mutates response.body in place, so we don't set rawBody\n            response.headers.set('content-type', 'application/json; charset=utf-8');\n            prepareBodyForJson(context, context.executionChain.methods, respBody);\n            break;\n        }\n        case SerializerModes.binary: {\n            // binary - use toBinary JIT function\n            response.headers.set('content-type', 'application/octet-stream');\n            serializeBinaryBody(context, context.executionChain.methods, respBody);\n            break;\n        }\n        default:\n            throw new Error(`Invalid body type ${context.request.bodyType}`);\n    }\n}\n\n/** Serializes response body to binary format using the core serializeBinaryBody function */\nfunction serializeBinaryBody(context: CallContext, executionChain: RemoteMethod[], respBody: ResponseBody): void {\n    const response = context.response as Mutable<MionResponse>;\n    // For routesFlow, use routesFlowRouteIds from context for proper buffer sizing\n    const {serializer, buffer} = coreSerializeBinaryBody(\n        context.path,\n        executionChain,\n        respBody,\n        true,\n        context.routesFlowRouteIds\n    );\n    response.binSerializer = serializer;\n    response.rawBody = new Uint8Array(buffer);\n}\n\nfunction stringifyBody(context: CallContext, executionChain: RemoteMethod[], respBody: ResponseBody): string {\n    const props: string[] = [];\n    for (let i = 0; i < executionChain.length; i++) {\n        const method = executionChain[i];\n        const returnValue = respBody[method.id];\n        if (!method.hasReturnData || typeof returnValue === 'undefined') continue;\n        try {\n            const jsonValue = stringifyHandlerReturnValue(method, returnValue);\n            if (!jsonValue) continue;\n            props.push(`${JSON.stringify(method.id)}:${jsonValue}`);\n        } catch (e: any) {\n            onStringifyExecutableError(context, method, e);\n        }\n    }\n\n    // Serialize thrownErrors if they exist\n    const thrownErrors = respBody['@thrownErrors'];\n    if (thrownErrors) {\n        const method = getRouteExecutable(MION_ROUTES.thrownErrors)!;\n        try {\n            const jsonValue = stringifyHandlerReturnValue(method, thrownErrors);\n            if (jsonValue) props.push(`${JSON.stringify(method.id)}:${jsonValue}`);\n        } catch (e: any) {\n            onStringifyExecutableError(context, method, e);\n        }\n    }\n    return `{${props.join(',')}}`;\n}\n\nfunction onStringifyExecutableError(context: CallContext, method: RemoteMethod, e: any) {\n    const err = new RpcError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'json-stringify-response-error',\n        publicMessage: `Failed to stringify return value for handler ${method.id}, expected response type: ${method.returnJitFns.stringifyJson.typeName}`,\n        originalError: e,\n        errorData: {methodId: method.id},\n    });\n    onExecutableError(context, method, err);\n}\n\nfunction stringifyHandlerReturnValue(method: RemoteMethod, returnValue: any): string {\n    if (!method.hasReturnData) return '';\n    // id data does not require custom encoding then we use native json\n    if (method.returnJitFns.prepareForJson.isNoop) JSON.stringify(returnValue);\n    return method.returnJitFns.stringifyJson.fn(returnValue);\n}\n\nfunction prepareBodyForJson(context: CallContext, executionChain: RemoteMethod[], respBody: ResponseBody): void {\n    // prepareForJson mutates the response body in place\n    for (let i = 0; i < executionChain.length; i++) {\n        const method = executionChain[i];\n        const returnValue = respBody[method.id];\n        if (!method.hasReturnData || typeof returnValue === 'undefined') continue;\n        try {\n            const preparedValue = prepareHandlerReturnValue(method, returnValue);\n            if (preparedValue !== undefined) (respBody as Mutable<ResponseBody>)[method.id] = preparedValue;\n        } catch (e: any) {\n            onPrepareForJsonExecutableError(context, method, e);\n        }\n    }\n    // Prepare thrownErrors if they exist\n    const thrownErrors = respBody['@thrownErrors'];\n    if (thrownErrors) {\n        const method = getRouteExecutable(MION_ROUTES.thrownErrors)!;\n        try {\n            const preparedValue = prepareHandlerReturnValue(method, thrownErrors);\n            if (preparedValue !== undefined) (respBody as Mutable<ResponseBody>)[method.id] = preparedValue;\n        } catch (e: any) {\n            onPrepareForJsonExecutableError(context, method, e);\n        }\n    }\n}\n\nfunction onPrepareForJsonExecutableError(context: CallContext, method: RemoteMethod, e: any) {\n    const err = new RpcError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'prepare-for-json-response-error',\n        publicMessage: `Failed to prepare return value for JSON for handler ${method.id}, expected response type: ${method.returnJitFns.prepareForJson.typeName}`,\n        originalError: e,\n        errorData: {methodId: method.id},\n    });\n    onExecutableError(context, method, err);\n}\n\nfunction prepareHandlerReturnValue(method: RemoteMethod, returnValue: any): any {\n    if (!method.hasReturnData) return undefined;\n    if (method.returnJitFns.prepareForJson.isNoop) return returnValue;\n    return method.returnJitFns.prepareForJson.fn(returnValue);\n}\n\nexport const serializerMiddleFns = {\n    mionDeserializeRequest: rawMiddleFn(deserializeRequestBody, {runOnError: true}),\n    mionSerializeResponse: rawMiddleFn(serializeResponseBody, {runOnError: true}),\n} satisfies MiddleFnsCollection;\n"],"names":["SerializerModes","RpcError","StatusCodes","coreDeserializeBinaryBody","getRouteExecutableFromPath","coreSerializeBinaryBody","getRouteExecutable","MION_ROUTES","onExecutableError","rawMiddleFn"],"mappings":"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"}

package/.dist/cjs/src/routes/serializer.routes.d.ts

@@ -0,0 +1,9 @@
+import { CallContext } from '../types/context.ts';
+import { RouterOptions } from '../types/general.ts';
+import { MayReturnError } from '../types/publicMethods.ts';
+export declare function deserializeRequestBody(context: CallContext): MayReturnError;
+export declare function serializeResponseBody(context: CallContext, opts: RouterOptions): MayReturnError;
+export declare const serializerMiddleFns: {
+    mionDeserializeRequest: import('../types/definitions.ts').RawMiddleFnDef<typeof deserializeRequestBody>;
+    mionSerializeResponse: import('../types/definitions.ts').RawMiddleFnDef<typeof serializeResponseBody>;
+};

package/.dist/cjs/src/routesFlow.cjs

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mionjs/core");
+const virtual_mionServerPureFns = require("virtual:mion-server-pure-fns");
+const src_router = require("./router.cjs");
+const src_types_general = require("./types/general.cjs");
+const src_types_remoteMethods = require("./types/remoteMethods.cjs");
+const src_types_context = require("./types/context.cjs");
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const routesFlowCache = (Map.Ω = [["&"], [() => src_types_remoteMethods.__ΩMethodsExecutionChain, "n!"]], /* @__PURE__ */ new Map());
+const cacheOrder = [];
+const mappingMethodCache = (Map.Ω = [["&"], [() => src_types_remoteMethods.__ΩRemoteMethod, "n!"]], /* @__PURE__ */ new Map());
+function clearRoutesFlowCache() {
+  routesFlowCache.clear();
+  cacheOrder.length = 0;
+  mappingMethodCache.clear();
+}
+clearRoutesFlowCache.__type = ["clearRoutesFlowCache", "P$/!"];
+function getRoutesFlowCacheSize() {
+  return routesFlowCache.size;
+}
+getRoutesFlowCacheSize.__type = ["getRoutesFlowCacheSize", "P'/!"];
+function getCachedRoutesFlow(query) {
+  return routesFlowCache.get(query);
+}
+getCachedRoutesFlow.__type = ["query", () => src_types_remoteMethods.__ΩMethodsExecutionChain, "getCachedRoutesFlow", 'P&2!Pn"-J/#'];
+function addToRoutesFlowCache(query, chain) {
+  const routerOpts = src_router.getRouterOptions();
+  const maxSize = routerOpts.maxRoutesFlowsCacheSize;
+  if (maxSize <= 0)
+    return;
+  while (cacheOrder.length >= maxSize) {
+    const oldestKey = cacheOrder.shift();
+    if (oldestKey)
+      routesFlowCache.delete(oldestKey);
+  }
+  routesFlowCache.set(query, chain);
+  cacheOrder.push(query);
+}
+addToRoutesFlowCache.__type = ["query", () => src_types_remoteMethods.__ΩMethodsExecutionChain, "chain", "addToRoutesFlowCache", 'P&2!n"2#$/$'];
+function decodeRoutesFlowQuery(urlQuery) {
+  try {
+    const dataParam = urlQuery.startsWith("data=") ? urlQuery.slice(5) : urlQuery;
+    const jsonString = core.fromBase64Url(dataParam);
+    return JSON.parse(jsonString);
+  } catch (e) {
+    throw new core.RpcError({
+      statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+      type: "routesFlow-invalid-query",
+      publicMessage: "RoutesFlow query string is not valid base64url-encoded JSON.",
+      errorData: { parseError: e?.message || "Unknown error" }
+    });
+  }
+}
+decodeRoutesFlowQuery.__type = ["urlQuery", "RoutesFlowQuery", "decodeRoutesFlowQuery", 'P&2!"w"/#'];
+function getRoutesFlowExecutionChain(rawRequest, opts, urlQuery) {
+  if (!urlQuery) {
+    throw new core.RpcError({
+      statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+      type: "routesFlow-missing-query",
+      publicMessage: "RoutesFlow request requires a query string with route paths."
+    });
+  }
+  const query = decodeRoutesFlowQuery(urlQuery);
+  const routePaths = query.routes;
+  const mappings = query.mappings;
+  if (!routePaths || routePaths.length === 0) {
+    throw new core.RpcError({
+      statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+      type: "routesFlow-empty-routes",
+      publicMessage: "RoutesFlow request requires at least one route path in query string."
+    });
+  }
+  const routeIds = routePaths.map(__assignType((path) => path.startsWith("/") ? path.slice(1) : path, ["path", "", 'P"2!"/"']));
+  let executionChain = routesFlowCache.get(urlQuery);
+  if (executionChain)
+    return { executionChain, routesFlowRouteIds: routeIds, mappings };
+  executionChain = buildMergedExecutionChain(routePaths, rawRequest, opts, mappings);
+  addToRoutesFlowCache(urlQuery, executionChain);
+  return { executionChain, routesFlowRouteIds: routeIds, mappings };
+}
+getRoutesFlowExecutionChain.__type = ["rawRequest", () => src_types_general.__ΩRouterOptions, "opts", "urlQuery", () => src_types_context.__ΩRoutesFlowExecutionResult, "getRoutesFlowExecutionChain", 'P#2!n"2#&2$8n%/&'];
+function buildMergedExecutionChain(routePaths, rawRequest, opts, mappings) {
+  const seenIds = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+  const middleMethods = [];
+  let resolvedSerializer;
+  let firstRouteIndex = -1;
+  const defaultSerializerCode = core.SerializerModes[opts.serializer];
+  const startMiddleFnIds = new Set(src_router.startMiddleFns.map(__assignType((m) => m.id, ["m", "", 'P"2!"/"'])));
+  const endMiddleFnIds = new Set(src_router.endMiddleFns.map(__assignType((m) => m.id, ["m", "", 'P"2!"/"'])));
+  for (const routePath of routePaths) {
+    const transformedPath = opts.pathTransform?.(rawRequest, routePath) || routePath;
+    const chain = src_router.getRouteExecutionChain(transformedPath);
+    if (!chain) {
+      throw new core.RpcError({
+        statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+        type: "routesFlow-route-not-found",
+        publicMessage: `Route not found in routesFlow: ${routePath}`,
+        errorData: { routePath }
+      });
+    }
+    if (!resolvedSerializer) {
+      resolvedSerializer = chain.serializer;
+      firstRouteIndex = chain.routeIndex;
+    } else if (resolvedSerializer !== chain.serializer) {
+      resolvedSerializer = defaultSerializerCode;
+    }
+    for (const method of chain.methods) {
+      if (seenIds.has(method.id))
+        continue;
+      if (startMiddleFnIds.has(method.id))
+        continue;
+      if (endMiddleFnIds.has(method.id))
+        continue;
+      seenIds.add(method.id);
+      middleMethods.push(method);
+    }
+  }
+  if (mappings && mappings.length > 0) {
+    insertMappingMethods(middleMethods, mappings);
+  }
+  const mergedMethods = [...src_router.startMiddleFns, ...middleMethods, ...src_router.endMiddleFns];
+  return {
+    // Use the first route's routeIndex since that's where the first route handler is
+    routeIndex: firstRouteIndex,
+    methods: mergedMethods,
+    serializer: resolvedSerializer ?? defaultSerializerCode
+  };
+}
+buildMergedExecutionChain.__type = ["routePaths", "rawRequest", () => src_types_general.__ΩRouterOptions, "opts", "RoutesFlowMapping", "mappings", () => src_types_remoteMethods.__ΩMethodsExecutionChain, "buildMergedExecutionChain", `P&F2!#2"n#2$"w%F2&8n'/(`];
+function insertMappingMethods(middleMethods, mappings) {
+  const idToIndex = (Map.Ω = [["&"], ["'"]], /* @__PURE__ */ new Map());
+  for (let i = 0; i < middleMethods.length; i++) {
+    idToIndex.set(middleMethods[i].id, i);
+  }
+  const insertions = [];
+  for (const mapping of mappings) {
+    const fromIndex = idToIndex.get(mapping.fromId);
+    const toIndex = idToIndex.get(mapping.toId);
+    if (fromIndex === void 0) {
+      throw new core.RpcError({
+        statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+        type: "routesFlow-mapping-invalid-source",
+        publicMessage: `Mapping source route '${mapping.fromId}' not found in routesFlow execution chain.`,
+        errorData: { mapping }
+      });
+    }
+    if (toIndex === void 0) {
+      throw new core.RpcError({
+        statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+        type: "routesFlow-mapping-invalid-target",
+        publicMessage: `Mapping target route '${mapping.toId}' not found in routesFlow execution chain.`,
+        errorData: { mapping }
+      });
+    }
+    if (!virtual_mionServerPureFns.serverPureFnsCache[core.PURE_SERVER_FN_NAMESPACE]?.[mapping.bodyHash]?.fn) {
+      throw new core.RpcError({
+        statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+        type: "routesFlow-mapping-missing-pure-fn",
+        publicMessage: `Mapping pure function '${mapping.bodyHash}' not found. Ensure the function is registered on the server.`,
+        errorData: { mapping }
+      });
+    }
+    insertions.push({
+      index: fromIndex + 1,
+      method: createMappingMethod(mapping)
+    });
+  }
+  insertions.sort(__assignType((a, b) => b.index - a.index, ["a", "b", "", 'P"2!"2""/#']));
+  for (const { index, method } of insertions) {
+    middleMethods.splice(index, 0, method);
+  }
+}
+insertMappingMethods.__type = [() => src_types_remoteMethods.__ΩRemoteMethod, "middleMethods", "RoutesFlowMapping", "mappings", "insertMappingMethods", 'Pn!F2""w#F2$$/%'];
+function createMappingMethod(mapping) {
+  const id = `mionMapFrom_${mapping.fromId}_${mapping.bodyHash}_to_${mapping.toId}`;
+  const cached = mappingMethodCache.get(id);
+  if (cached)
+    return cached;
+  const noopJitFns = core.getNoopJitFns();
+  const method = {
+    type: core.HandlerType.rawMiddleFn,
+    id,
+    isAsync: false,
+    hasReturnData: false,
+    paramsJitHash: "",
+    returnJitHash: "",
+    paramsJitFns: noopJitFns,
+    returnJitFns: noopJitFns,
+    handler: createMappingHandler(mapping),
+    options: { runOnError: false, validateParams: false },
+    methodCaller: runMappingHandler
+  };
+  mappingMethodCache.set(id, method);
+  return method;
+}
+createMappingMethod.__type = ["RoutesFlowMapping", "mapping", () => src_types_remoteMethods.__ΩRemoteMethod, "createMappingMethod", 'P"w!2"n#/$'];
+function createMappingHandler(mapping) {
+  return __assignType((ctx) => {
+    const sourceOutput = ctx.response.body[mapping.fromId];
+    const entry = virtual_mionServerPureFns.serverPureFnsCache[core.PURE_SERVER_FN_NAMESPACE]?.[mapping.bodyHash];
+    if (!entry?.fn) {
+      throw new core.RpcError({
+        statusCode: core.StatusCodes.UNEXPECTED_ERROR,
+        type: "routesFlow-mapping-missing-pure-fn",
+        publicMessage: `Mapping pure function '${mapping.bodyHash}' not found at runtime.`
+      });
+    }
+    const mappedValue = entry.fn(sourceOutput);
+    const targetParams = ctx.request.body[mapping.toId];
+    if (targetParams)
+      targetParams[mapping.paramIndex] = mappedValue;
+  }, ["CallContext", "ctx", "", 'P"w!2""/#']);
+}
+createMappingHandler.__type = ["RoutesFlowMapping", "mapping", "createMappingHandler", 'P"w!2""/#'];
+async function runMappingHandler(context, executable, ...args) {
+  return executable.handler(context);
+}
+runMappingHandler.__type = ["CallContext", "context", () => src_types_remoteMethods.__ΩRemoteMethod, "executable", "args", "runMappingHandler", 'P"w!2"n#2$#@2%"/&'];
+exports.clearRoutesFlowCache = clearRoutesFlowCache;
+exports.getCachedRoutesFlow = getCachedRoutesFlow;
+exports.getRoutesFlowCacheSize = getRoutesFlowCacheSize;
+exports.getRoutesFlowExecutionChain = getRoutesFlowExecutionChain;
+//# sourceMappingURL=routesFlow.cjs.map

package/.dist/cjs/src/routesFlow.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"routesFlow.cjs","sources":["../../../src/routesFlow.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {\n    RpcError,\n    SerializerCode,\n    SerializerModes,\n    StatusCodes,\n    HandlerType,\n    getNoopJitFns,\n    PURE_SERVER_FN_NAMESPACE,\n    fromBase64Url,\n} from '@mionjs/core';\nimport {serverPureFnsCache} from 'virtual:mion-server-pure-fns';\nimport {getRouteExecutionChain, getRouterOptions, startMiddleFns, endMiddleFns} from './router.ts';\nimport {RouterOptions} from './types/general.ts';\nimport {MethodsExecutionChain, RemoteMethod} from './types/remoteMethods.ts';\nimport {RoutesFlowExecutionResult} from './types/context.ts';\nimport type {CallContext} from './types/context.ts';\nimport type {RoutesFlowQuery, RoutesFlowMapping} from '@mionjs/core';\n\n// ############# ROUTES_FLOW CACHE #############\n\n/** FILO cache for merged execution chains. Key is the query string, value is the cached chain. */\nconst routesFlowCache = new Map<string, MethodsExecutionChain>();\nconst cacheOrder: string[] = [];\n/** Cache for mapping RemoteMethods keyed by their unique ID */\nconst mappingMethodCache = new Map<string, RemoteMethod>();\n\n/** Clears the routesFlow cache and mapping method cache - useful for testing */\nexport function clearRoutesFlowCache(): void {\n    routesFlowCache.clear();\n    cacheOrder.length = 0;\n    mappingMethodCache.clear();\n}\n\n/** Returns the current routesFlow cache size */\nexport function getRoutesFlowCacheSize(): number {\n    return routesFlowCache.size;\n}\n\n/** Returns a cached routesFlow chain by query string */\nexport function getCachedRoutesFlow(query: string): MethodsExecutionChain | undefined {\n    return routesFlowCache.get(query);\n}\n\n/** Adds a merged chain to the cache with FILO eviction */\nfunction addToRoutesFlowCache(query: string, chain: MethodsExecutionChain): void {\n    const routerOpts = getRouterOptions();\n    const maxSize = routerOpts.maxRoutesFlowsCacheSize;\n    // Caching disabled\n    if (maxSize <= 0) return;\n    // Evict oldest entries if cache is full (FILO - First In, Last Out)\n    while (cacheOrder.length >= maxSize) {\n        const oldestKey = cacheOrder.shift();\n        if (oldestKey) routesFlowCache.delete(oldestKey);\n    }\n    routesFlowCache.set(query, chain);\n    cacheOrder.push(query);\n}\n\n// ############# QUERY PARSING #############\n\n/** Decodes a base64url-encoded JSON routesFlow query string, expects `data=<base64url>` format */\nfunction decodeRoutesFlowQuery(urlQuery: string): RoutesFlowQuery {\n    try {\n        const dataParam = urlQuery.startsWith('data=') ? urlQuery.slice(5) : urlQuery;\n        const jsonString = fromBase64Url(dataParam);\n        return JSON.parse(jsonString) as RoutesFlowQuery;\n    } catch (e: any) {\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'routesFlow-invalid-query',\n            publicMessage: 'RoutesFlow query string is not valid base64url-encoded JSON.',\n            errorData: {parseError: e?.message || 'Unknown error'},\n        });\n    }\n}\n\n// ############# ROUTES_FLOW #############\n\n/** Builds or retrieves a cached merged execution chain for routesFlow requests */\nexport function getRoutesFlowExecutionChain(\n    rawRequest: unknown,\n    opts: RouterOptions,\n    urlQuery?: string\n): RoutesFlowExecutionResult {\n    // Validate urlQuery is provided\n    if (!urlQuery) {\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'routesFlow-missing-query',\n            publicMessage: 'RoutesFlow request requires a query string with route paths.',\n        });\n    }\n\n    // Decode base64+JSON query\n    const query = decodeRoutesFlowQuery(urlQuery);\n    const routePaths = query.routes;\n    const mappings = query.mappings;\n\n    if (!routePaths || routePaths.length === 0) {\n        throw new RpcError({\n            statusCode: StatusCodes.UNEXPECTED_ERROR,\n            type: 'routesFlow-empty-routes',\n            publicMessage: 'RoutesFlow request requires at least one route path in query string.',\n        });\n    }\n\n    // Convert paths to route IDs (remove leading slash)\n    const routeIds = routePaths.map((path) => (path.startsWith('/') ? path.slice(1) : path));\n\n    // Check cache first\n    let executionChain = routesFlowCache.get(urlQuery);\n    if (executionChain) return {executionChain, routesFlowRouteIds: routeIds, mappings};\n\n    // Build merged execution chain\n    executionChain = buildMergedExecutionChain(routePaths, rawRequest, opts, mappings);\n    addToRoutesFlowCache(urlQuery, executionChain);\n    return {executionChain, routesFlowRouteIds: routeIds, mappings};\n}\n\n/**\n * Builds a merged execution chain from multiple route paths.\n * The merged chain includes all methods from all routes, with deduplication by ID.\n *\n * The chain is structured as:\n * 1. Start middleFns (e.g., mionDeserializeRequest) - from first route, at the beginning\n * 2. Middle methods (routes and their middleFns) - merged from all routes, with mapping steps inserted\n * 3. End middleFns (e.g., mionSerializeResponse) - from first route, at the end\n *\n * When mappings are provided, mapping steps are inserted after the source route\n * and before the target route to transform output → input.\n */\nfunction buildMergedExecutionChain(\n    routePaths: string[],\n    rawRequest: unknown,\n    opts: RouterOptions,\n    mappings?: RoutesFlowMapping[]\n): MethodsExecutionChain {\n    const seenIds = new Set<string>();\n    const middleMethods: RemoteMethod[] = [];\n    let resolvedSerializer: SerializerCode | undefined;\n    let firstRouteIndex = -1;\n    const defaultSerializerCode = SerializerModes[opts.serializer];\n\n    // Build sets of start and end middleFn IDs for filtering\n    const startMiddleFnIds = new Set(startMiddleFns.map((m) => m.id));\n    const endMiddleFnIds = new Set(endMiddleFns.map((m) => m.id));\n\n    // Process each route path\n    for (const routePath of routePaths) {\n        // Apply path transform if configured\n        const transformedPath = opts.pathTransform?.(rawRequest, routePath) || routePath;\n        const chain = getRouteExecutionChain(transformedPath);\n        if (!chain) {\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'routesFlow-route-not-found',\n                publicMessage: `Route not found in routesFlow: ${routePath}`,\n                errorData: {routePath},\n            });\n        }\n\n        // Resolve serializer - use first route's serializer, or fall back to default if conflicting\n        if (!resolvedSerializer) {\n            resolvedSerializer = chain.serializer;\n            // Track the route index from the first route (relative to start middleFns)\n            firstRouteIndex = chain.routeIndex;\n        } else if (resolvedSerializer !== chain.serializer) {\n            resolvedSerializer = defaultSerializerCode;\n        }\n\n        // Add middle methods from this route's chain, deduplicating by ID\n        // Skip start and end middleFns - they will be added separately\n        for (const method of chain.methods) {\n            if (seenIds.has(method.id)) continue;\n            if (startMiddleFnIds.has(method.id)) continue;\n            if (endMiddleFnIds.has(method.id)) continue;\n            seenIds.add(method.id);\n            middleMethods.push(method);\n        }\n    }\n\n    // Insert mapping methods between source and target routes\n    if (mappings && mappings.length > 0) {\n        insertMappingMethods(middleMethods, mappings);\n    }\n\n    // Build final chain: start middleFns + middle methods + end middleFns\n    const mergedMethods = [...startMiddleFns, ...middleMethods, ...endMiddleFns];\n\n    return {\n        // Use the first route's routeIndex since that's where the first route handler is\n        routeIndex: firstRouteIndex,\n        methods: mergedMethods,\n        serializer: resolvedSerializer ?? defaultSerializerCode,\n    };\n}\n\n// ############# MAPPING METHODS #############\n\n/**\n * Inserts mapping methods into the middleMethods array in the correct position.\n * Each mapping method is inserted after the source route (fromId) and before the target route (toId).\n * Mappings are processed in reverse insertion order to maintain correct indices.\n */\nfunction insertMappingMethods(middleMethods: RemoteMethod[], mappings: RoutesFlowMapping[]): void {\n    // Build a map of route ID → index in middleMethods for quick lookup\n    const idToIndex = new Map<string, number>();\n    for (let i = 0; i < middleMethods.length; i++) {\n        idToIndex.set(middleMethods[i].id, i);\n    }\n\n    // Collect insertions: each mapping creates one insertion point\n    const insertions: Array<{index: number; method: RemoteMethod}> = [];\n\n    for (const mapping of mappings) {\n        const fromIndex = idToIndex.get(mapping.fromId);\n        const toIndex = idToIndex.get(mapping.toId);\n\n        if (fromIndex === undefined) {\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'routesFlow-mapping-invalid-source',\n                publicMessage: `Mapping source route '${mapping.fromId}' not found in routesFlow execution chain.`,\n                errorData: {mapping},\n            });\n        }\n        if (toIndex === undefined) {\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'routesFlow-mapping-invalid-target',\n                publicMessage: `Mapping target route '${mapping.toId}' not found in routesFlow execution chain.`,\n                errorData: {mapping},\n            });\n        }\n\n        // Validate the pure function exists in the serverPureFnsCache (populated by mion vite plugin)\n        if (!serverPureFnsCache[PURE_SERVER_FN_NAMESPACE]?.[mapping.bodyHash]?.fn) {\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'routesFlow-mapping-missing-pure-fn',\n                publicMessage: `Mapping pure function '${mapping.bodyHash}' not found. Ensure the function is registered on the server.`,\n                errorData: {mapping},\n            });\n        }\n\n        // Insert after the source route (fromIndex + 1)\n        insertions.push({\n            index: fromIndex + 1,\n            method: createMappingMethod(mapping),\n        });\n    }\n\n    // Sort insertions by index descending so splice doesn't shift subsequent indices\n    insertions.sort((a, b) => b.index - a.index);\n\n    for (const {index, method} of insertions) {\n        middleMethods.splice(index, 0, method);\n    }\n}\n\n/** Creates or retrieves a cached RemoteMethod that acts as a raw middleFn to execute a mapping between routes */\nfunction createMappingMethod(mapping: RoutesFlowMapping): RemoteMethod {\n    const id = `mionMapFrom_${mapping.fromId}_${mapping.bodyHash}_to_${mapping.toId}`;\n    const cached = mappingMethodCache.get(id);\n    if (cached) return cached;\n\n    const noopJitFns = getNoopJitFns();\n    const method = {\n        type: HandlerType.rawMiddleFn,\n        id,\n        isAsync: false,\n        hasReturnData: false,\n        paramsJitHash: '',\n        returnJitHash: '',\n        paramsJitFns: noopJitFns,\n        returnJitFns: noopJitFns,\n        handler: createMappingHandler(mapping),\n        options: {runOnError: false, validateParams: false},\n        methodCaller: runMappingHandler,\n    } as RemoteMethod;\n\n    mappingMethodCache.set(id, method);\n    return method;\n}\n\n/** Creates the handler function for a mapping step */\nfunction createMappingHandler(mapping: RoutesFlowMapping) {\n    return (ctx: CallContext) => {\n        // Get the output from the source route\n        const sourceOutput = ctx.response.body[mapping.fromId];\n\n        // Resolve and execute the pure function from serverPureFnsCache (populated by mion vite plugin)\n        const entry = serverPureFnsCache[PURE_SERVER_FN_NAMESPACE]?.[mapping.bodyHash];\n        if (!entry?.fn) {\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'routesFlow-mapping-missing-pure-fn',\n                publicMessage: `Mapping pure function '${mapping.bodyHash}' not found at runtime.`,\n            });\n        }\n        const mappedValue = entry.fn(sourceOutput);\n\n        // Replace null at paramIndex in target route's params\n        const targetParams = ctx.request.body[mapping.toId] as any[];\n        if (targetParams) (targetParams as any[])[mapping.paramIndex] = mappedValue;\n    };\n}\n\n/** Custom method caller for mapping handlers — only passes the context */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nasync function runMappingHandler(context: CallContext, executable: RemoteMethod, ...args: unknown[]) {\n    return executable.handler(context);\n}\n"],"names":["__ΩMethodsExecutionChain","__ΩRemoteMethod","getRouterOptions","fromBase64Url","RpcError","StatusCodes","SerializerModes","startMiddleFns","endMiddleFns","getRouteExecutionChain","serverPureFnsCache","PURE_SERVER_FN_NAMESPACE","getNoopJitFns","HandlerType"],"mappings":"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"}

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

@@ -0,0 +1,7 @@
+import { RouterOptions } from './types/general.ts';
+import { MethodsExecutionChain } from './types/remoteMethods.ts';
+import { RoutesFlowExecutionResult } from './types/context.ts';
+export declare function clearRoutesFlowCache(): void;
+export declare function getRoutesFlowCacheSize(): number;
+export declare function getCachedRoutesFlow(query: string): MethodsExecutionChain | undefined;
+export declare function getRoutesFlowExecutionChain(rawRequest: unknown, opts: RouterOptions, urlQuery?: string): RoutesFlowExecutionResult;