@mionjs/router 0.8.0-alpha.0

package/.dist/esm/src/router.js

@@ -0,0 +1,431 @@
+import { DEFAULT_ROUTE_OPTIONS, MAX_ROUTE_NESTING, WORKFLOW_KEY } from "./constants.js";
+import { isHeadersMiddleFnDef, isRoute, isRawMiddleFnDef, isMiddleFnDef, isAnyMiddleFnDef, isRoutes, isExecutable, isPublicExecutable } from "./types/guards.js";
+import { MION_ROUTES, getRouterItemId, HandlerType, routesCache, setErrorOptions, isTestEnv, resetRoutesCache, getENV, isMionCompileMode, isMionAOTEmitMode, getRoutePath, SerializerModes } from "@mionjs/core";
+import { getHandlerReflection, getRawMethodReflection } from "./lib/reflection.js";
+import { serializerMiddleFns } from "./routes/serializer.routes.js";
+import { getPublicApi, resetRemoteMethodsMetadata } from "./lib/remoteMethods.js";
+import { getPersistedMethod, addToPersistedMethods, resetPersistedMethods } from "./lib/methodsCache.js";
+import { mionClientRoutes } from "./routes/client.routes.js";
+import { mionErrorsRoutes } from "./routes/errors.routes.js";
+import { clearRoutesFlowCache } from "./routesFlow.js";
+import { clearContextPool } from "./callContext.js";
+const mionInternalRoutes = Object.values(MION_ROUTES);
+const flatRouter = /* @__PURE__ */ new Map();
+const middleFnsById = /* @__PURE__ */ new Map();
+const routesById = /* @__PURE__ */ new Map();
+const rawMiddleFnsById = /* @__PURE__ */ new Map();
+const middleFnNames = /* @__PURE__ */ new Set();
+const routeNames = /* @__PURE__ */ new Set();
+let complexity = 0;
+let routerOptions = { ...DEFAULT_ROUTE_OPTIONS };
+let isRouterInitialized = false;
+let allExecutablesIds;
+const defaultStartMiddleFns = {
+  mionDeserializeRequest: serializerMiddleFns.mionDeserializeRequest
+};
+const defaultEndMiddleFns = {
+  mionSerializeResponse: serializerMiddleFns.mionSerializeResponse
+};
+let startMiddleFnsDef = { ...defaultStartMiddleFns };
+let endMiddleFnsDef = { ...defaultEndMiddleFns };
+let startMiddleFns = [];
+let endMiddleFns = [];
+const getRouteExecutionChain = (path) => flatRouter.get(path);
+const getRouteEntries = () => flatRouter.entries();
+const geRoutesSize = () => flatRouter.size;
+const getRouteExecutable = (id) => routesById.get(id);
+const getMiddleFnExecutable = (id) => middleFnsById.get(id);
+const geMiddleFnsSize = () => middleFnsById.size;
+const getComplexity = () => complexity;
+const getRouterOptions = () => routerOptions;
+const getAnyExecutable = (id) => routesById.get(id) || middleFnsById.get(id) || rawMiddleFnsById.get(id);
+const resetRouter = () => {
+  flatRouter.clear();
+  middleFnsById.clear();
+  routesById.clear();
+  rawMiddleFnsById.clear();
+  middleFnNames.clear();
+  routeNames.clear();
+  complexity = 0;
+  routerOptions = { ...DEFAULT_ROUTE_OPTIONS };
+  startMiddleFnsDef = { ...defaultStartMiddleFns };
+  endMiddleFnsDef = { ...defaultEndMiddleFns };
+  startMiddleFns = [];
+  endMiddleFns = [];
+  isRouterInitialized = false;
+  allExecutablesIds = void 0;
+  resetRemoteMethodsMetadata();
+  resetPersistedMethods();
+  resetRoutesCache();
+  clearContextPool();
+  clearRoutesFlowCache();
+};
+async function initMionRouter(routes, opts) {
+  await initRouter(opts);
+  const publicApi = await registerRoutes(routes);
+  await emitAOTCaches();
+  return publicApi;
+}
+async function initRouter(opts) {
+  if (isRouterInitialized) throw new Error("Router has already been initialized");
+  routerOptions = { ...routerOptions, ...opts };
+  validateSharedDataFactory(routerOptions);
+  Object.freeze(routerOptions);
+  setErrorOptions(routerOptions);
+  if (routerOptions.aot) await loadAOTCaches();
+  isRouterInitialized = true;
+  await registerRoutes({ ...mionErrorsRoutes });
+  if (!routerOptions.skipClientRoutes) await registerRoutes({ ...mionClientRoutes });
+  if (!isTestEnv()) console.log("mion router initialized", { routerOptions });
+  return routerOptions;
+}
+async function registerRoutes(routes) {
+  if (!isRouterInitialized) throw new Error("initRouter should be called first");
+  startMiddleFns = await getExecutablesFromMiddleFnsCollection(startMiddleFnsDef);
+  endMiddleFns = await getExecutablesFromMiddleFnsCollection(endMiddleFnsDef);
+  await recursiveFlatRoutes(routes);
+  if (shouldFullGenerateSpec()) {
+    return getPublicApi(routes);
+  }
+  return {};
+}
+function addStartMiddleFns(middleFnsDef, appendBeforeExisting = true) {
+  if (isRouterInitialized) throw new Error("Can not add start middleFns after the router has been initialized");
+  if (appendBeforeExisting) {
+    startMiddleFnsDef = { ...middleFnsDef, ...startMiddleFnsDef };
+    return;
+  }
+  startMiddleFnsDef = { ...startMiddleFnsDef, ...middleFnsDef };
+}
+function addEndMiddleFns(middleFnsDef, prependAfterExisting = true) {
+  if (isRouterInitialized) throw new Error("Can not add end middleFns after the router has been initialized");
+  if (prependAfterExisting) {
+    endMiddleFnsDef = { ...endMiddleFnsDef, ...middleFnsDef };
+    return;
+  }
+  endMiddleFnsDef = { ...middleFnsDef, ...endMiddleFnsDef };
+}
+function isPrivateDefinition(entry, id) {
+  if (isRoute(entry)) return false;
+  if (isRawMiddleFnDef(entry)) return true;
+  try {
+    const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);
+    if (!executable)
+      throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);
+    return isPrivateExecutable(executable);
+  } catch {
+    return false;
+  }
+}
+function isPrivateExecutable(executable) {
+  if (executable.type === HandlerType.rawMiddleFn) return true;
+  if (executable.type === HandlerType.route) return false;
+  const hasPublicParams = !!executable.paramNames?.length;
+  const hasHeaderParams = !!executable.headersParam?.headerNames?.length;
+  return !hasPublicParams && !hasHeaderParams && !executable.hasReturnData;
+}
+function getTotalExecutables() {
+  return routesById.size + middleFnsById.size + rawMiddleFnsById.size;
+}
+function getAllExecutablesIds() {
+  if (allExecutablesIds) return allExecutablesIds;
+  allExecutablesIds = [...routesById.keys(), ...middleFnsById.keys(), ...rawMiddleFnsById.keys()];
+  return allExecutablesIds;
+}
+function shouldFullGenerateSpec() {
+  return routerOptions.getPublicRoutesData || getENV("GENERATE_ROUTER_SPEC") === "true" || isMionCompileMode();
+}
+function getRouteExecutableFromPath(path) {
+  const executionChain = flatRouter.get(path);
+  if (!executionChain) {
+    return getAnyExecutable(MION_ROUTES.notFound);
+  }
+  return executionChain.methods[executionChain.routeIndex];
+}
+async function loadAOTCaches() {
+  const loader = await import("./lib/aotCacheLoader.js");
+  return loader.loadAOTCaches();
+}
+async function emitAOTCaches() {
+  if (!isMionAOTEmitMode()) return;
+  const aotEmitter = await import("./lib/aotEmitter.js");
+  return aotEmitter.emitAOTCaches();
+}
+async function recursiveFlatRoutes(routes, currentPointer = [], preMiddleFns = [], postMiddleFns = [], nestLevel = 0) {
+  if (nestLevel > MAX_ROUTE_NESTING)
+    throw new Error("Too many nested routes, you can only nest routes ${MAX_ROUTE_NESTING} levels");
+  const entries = Object.entries(routes);
+  if (entries.length === 0)
+    throw new Error(
+      `Invalid route: ${currentPointer.length ? joinPath(...currentPointer) : "*"}. Can Not define empty routes`
+    );
+  let minus1Props = null;
+  for (let index = 0; index < entries.length; index++) {
+    const [key, item] = entries[index];
+    const newPointer = [...currentPointer, key];
+    let routeEntry;
+    if (typeof key !== "string" || !isNaN(key))
+      throw new Error(`Invalid route: ${joinPath(...newPointer)}. Numeric route names are not allowed`);
+    if (key.includes(",")) throw new Error(`Invalid route: ${joinPath(...newPointer)}. Route names cannot contain commas.`);
+    if (key === WORKFLOW_KEY)
+      throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${WORKFLOW_KEY}' is a reserved mion route name.`);
+    if (isAnyMiddleFnDef(item)) {
+      routeEntry = await getExecutableFromAnyMiddleFn(item, newPointer, nestLevel);
+      if (middleFnNames.has(routeEntry.id))
+        throw new Error(
+          `Invalid middleFn: ${joinPath(...newPointer)}. Naming collision, Naming collision, duplicated middleFn.`
+        );
+      middleFnNames.add(routeEntry.id);
+    } else if (isRoute(item)) {
+      routeEntry = await getExecutableFromRoute(item, newPointer, nestLevel);
+      if (routeNames.has(routeEntry.id))
+        throw new Error(`Invalid route: ${joinPath(...newPointer)}. Naming collision, duplicated route`);
+      routeNames.add(routeEntry.id);
+    } else if (isRoutes(item)) {
+      routeEntry = {
+        pathPointer: newPointer,
+        routes: item
+      };
+    } else {
+      const itemType = typeof item;
+      throw new Error(`Invalid route: ${joinPath(...newPointer)}. Type <${itemType}> is not a valid route.`);
+    }
+    minus1Props = await recursiveCreateExecutionChainAsync(
+      routeEntry,
+      newPointer,
+      preMiddleFns,
+      postMiddleFns,
+      nestLevel,
+      index,
+      entries,
+      minus1Props
+    );
+    complexity++;
+  }
+}
+async function recursiveCreateExecutionChainAsync(routeEntry, currentPointer, preMiddleFns, postMiddleFns, nestLevel, index, routeKeyedEntries, minus1Props) {
+  const minus1 = getEntry(index - 1, routeKeyedEntries);
+  const plus1 = getEntry(index + 1, routeKeyedEntries);
+  const props = getRouteEntryProperties(minus1, routeEntry, plus1);
+  if (props.isBetweenRoutes && minus1Props) {
+    props.preLevelMiddleFns = minus1Props.preLevelMiddleFns;
+    props.postLevelMiddleFns = minus1Props.postLevelMiddleFns;
+  } else {
+    for (let i = 0; i < routeKeyedEntries.length; i++) {
+      const [k, entry] = routeKeyedEntries[i];
+      complexity++;
+      if (!isAnyMiddleFnDef(entry)) continue;
+      const newPointer = [...currentPointer.slice(0, -1), k];
+      const executable = await getExecutableFromAnyMiddleFn(entry, newPointer, nestLevel);
+      if (i < index) props.preLevelMiddleFns.push(executable);
+      if (i > index) props.postLevelMiddleFns.push(executable);
+    }
+  }
+  const isExec = isExecutable(routeEntry);
+  if (isExec && props.isRoute) {
+    const path = getRoutePath(routeEntry.pointer, routerOptions);
+    const routeMethod = routeEntry;
+    const levelMethods = [
+      ...preMiddleFns,
+      ...props.preLevelMiddleFns,
+      routeEntry,
+      ...props.postLevelMiddleFns,
+      ...postMiddleFns
+    ];
+    const methods = [...startMiddleFns, ...levelMethods, ...endMiddleFns];
+    const executionChain = {
+      routeIndex: startMiddleFns.length + preMiddleFns.length + props.preLevelMiddleFns.length,
+      methods,
+      serializer: getSerializerCodeFromMode(routeMethod.options.serializer)
+    };
+    const middleFnIds = getPublicMiddleFnIds(methods);
+    if (middleFnIds.length) routeMethod.middleFnIds = middleFnIds;
+    flatRouter.set(path, executionChain);
+  } else if (!isExec) {
+    await recursiveFlatRoutes(
+      routeEntry.routes,
+      routeEntry.pathPointer,
+      [...preMiddleFns, ...props.preLevelMiddleFns],
+      [...props.postLevelMiddleFns, ...postMiddleFns],
+      nestLevel + 1
+    );
+  }
+  return props;
+}
+async function getExecutableFromAnyMiddleFn(middleFn, middleFnPointer, nestLevel) {
+  if (isRawMiddleFnDef(middleFn)) return getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel);
+  return getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel);
+}
+async function getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel) {
+  const isHeader = isHeadersMiddleFnDef(middleFn);
+  const middleFnId = getRouterItemId(middleFnPointer);
+  const existing = middleFnsById.get(middleFnId);
+  if (existing) return existing;
+  const compiledMethod = getPersistedMethod(middleFnId, middleFn.handler);
+  let executable;
+  if (compiledMethod) {
+    executable = compiledMethod;
+  } else {
+    const reflectionData = await getHandlerReflection(middleFn.handler, middleFnId, routerOptions, isHeader);
+    executable = {
+      id: middleFnId,
+      type: isHeader ? HandlerType.headersMiddleFn : HandlerType.middleFn,
+      nestLevel,
+      handler: middleFn.handler,
+      pointer: middleFnPointer,
+      ...reflectionData,
+      options: {
+        runOnError: !!middleFn.options?.runOnError,
+        validateParams: middleFn.options?.validateParams ?? true,
+        validateReturn: middleFn.options?.validateReturn ?? false,
+        description: middleFn.options?.description
+      }
+    };
+    addToPersistedMethods(middleFnId, executable);
+  }
+  middleFnsById.set(middleFnId, executable);
+  routesCache.setMethodJitFns(middleFnId, executable);
+  return executable;
+}
+async function getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel) {
+  const middleFnId = getRouterItemId(middleFnPointer);
+  const existing = rawMiddleFnsById.get(middleFnId);
+  if (existing) return existing;
+  const reflectionData = await getRawMethodReflection(middleFn.handler, middleFnId, routerOptions);
+  const executable = {
+    id: middleFnId,
+    type: HandlerType.rawMiddleFn,
+    nestLevel,
+    handler: middleFn.handler,
+    pointer: middleFnPointer,
+    ...reflectionData,
+    options: {
+      runOnError: !!middleFn.options?.runOnError,
+      validateParams: false,
+      validateReturn: false,
+      description: middleFn.options?.description
+    }
+  };
+  rawMiddleFnsById.set(middleFnId, executable);
+  routesCache.setMethodJitFns(middleFnId, executable);
+  return executable;
+}
+async function getExecutableFromRoute(route, routePointer, nestLevel) {
+  const routeId = getRouterItemId(routePointer);
+  const existing = routesById.get(routeId);
+  if (existing) return existing;
+  const compiledMethod = getPersistedMethod(routeId, route.handler);
+  let executable;
+  if (compiledMethod) {
+    executable = compiledMethod;
+  } else {
+    const reflectionData = await getHandlerReflection(route.handler, routeId, routerOptions);
+    executable = {
+      id: routeId,
+      type: HandlerType.route,
+      nestLevel,
+      handler: route.handler,
+      pointer: routePointer,
+      ...reflectionData,
+      options: {
+        runOnError: false,
+        validateParams: route.options?.validateParams ?? true,
+        validateReturn: route.options?.validateReturn ?? false,
+        description: route.options?.description,
+        serializer: route.options?.serializer ?? routerOptions.serializer,
+        isMutation: route.options?.isMutation
+      }
+    };
+    addToPersistedMethods(routeId, executable);
+  }
+  routesById.set(routeId, executable);
+  routesCache.setMethodJitFns(routeId, executable);
+  return executable;
+}
+function getPublicMiddleFnIds(methods) {
+  const ids = methods.filter((exec) => isPublicExecutable(exec)).map((exec) => getRouterItemId(exec.pointer)).filter((mfId) => {
+    if (mionInternalRoutes.includes(mfId)) return false;
+    const exec = getMiddleFnExecutable(mfId);
+    return exec && isPublicExecutable(exec);
+  });
+  return ids;
+}
+function getEntry(index, keyEntryList) {
+  return keyEntryList[index]?.[1];
+}
+function getRouteEntryProperties(minus1, zero, plus1) {
+  const minus1IsRoute = minus1 && isRoute(minus1);
+  const zeroIsRoute = zero.type === HandlerType.route;
+  const plus1IsRoute = plus1 && isRoute(plus1);
+  const isExec = !!zero.handler;
+  return {
+    isBetweenRoutes: minus1IsRoute && zeroIsRoute && plus1IsRoute,
+    isExecutable: isExec,
+    isRoute: zeroIsRoute,
+    preLevelMiddleFns: [],
+    postLevelMiddleFns: []
+  };
+}
+async function getExecutablesFromMiddleFnsCollection(middleFnsDef) {
+  const results = [];
+  for (const [key, middleFn] of Object.entries(middleFnsDef)) {
+    if (isRawMiddleFnDef(middleFn)) {
+      results.push(await getExecutableFromRawMiddleFn(middleFn, [key], 0));
+    } else if (isHeadersMiddleFnDef(middleFn) || isMiddleFnDef(middleFn)) {
+      results.push(await getExecutableFromMiddleFn(middleFn, [key], 0));
+    } else {
+      throw new Error(`Invalid middleFn: ${key}. Invalid middleFn definition`);
+    }
+  }
+  return results;
+}
+function validateSharedDataFactory(opts) {
+  if (!opts?.contextDataFactory) return;
+  const testSharedData = opts.contextDataFactory();
+  if (typeof testSharedData !== "object" || Array.isArray(testSharedData) || testSharedData === null || Object.keys(testSharedData).length === 0) {
+    throw new Error("contextDataFactory must return a plain object with at least one property");
+  }
+}
+function getSerializerCodeFromMode(mode) {
+  switch (mode) {
+    case "binary":
+      return SerializerModes.binary;
+    case "stringifyJson":
+      return SerializerModes.stringifyJson;
+    case "json":
+    default:
+      return SerializerModes.json;
+  }
+}
+function joinPath(...parts) {
+  return parts.filter(Boolean).join("/");
+}
+export {
+  addEndMiddleFns,
+  addStartMiddleFns,
+  endMiddleFns,
+  geMiddleFnsSize,
+  geRoutesSize,
+  getAllExecutablesIds,
+  getAnyExecutable,
+  getComplexity,
+  getExecutableFromMiddleFn,
+  getExecutableFromRawMiddleFn,
+  getExecutableFromRoute,
+  getMiddleFnExecutable,
+  getRouteEntries,
+  getRouteExecutable,
+  getRouteExecutableFromPath,
+  getRouteExecutionChain,
+  getRouterOptions,
+  getTotalExecutables,
+  initMionRouter,
+  initRouter,
+  isPrivateDefinition,
+  isPrivateExecutable,
+  registerRoutes,
+  resetRouter,
+  shouldFullGenerateSpec,
+  startMiddleFns
+};
+//# sourceMappingURL=router.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"router.js","sources":["../../../src/router.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\n/** Lightweight path join for error messages (avoids Node's 'path' module for edge compatibility) */\nimport type {Route, RouterOptions, Routes, RouterEntry} from './types/general.ts';\nimport type {\n    RemoteMethod,\n    MethodsExecutionChain,\n    RawMethod,\n    HeadersMethod,\n    MiddleFnMethod,\n    RouteMethod,\n} from './types/remoteMethods.ts';\nimport type {PublicApi, PrivateDef, MiddleFnsCollection} from './types/publicMethods.ts';\nimport type {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef} from './types/definitions.ts';\nimport {DEFAULT_ROUTE_OPTIONS, MAX_ROUTE_NESTING, WORKFLOW_KEY} from './constants.ts';\nimport {\n    isRawMiddleFnDef,\n    isHeadersMiddleFnDef,\n    isExecutable,\n    isMiddleFnDef,\n    isRoute,\n    isRoutes,\n    isAnyMiddleFnDef,\n    isPublicExecutable,\n} from './types/guards.ts';\nimport {\n    HandlerType,\n    SerializerModes,\n    SerializerCode,\n    SerializerMode,\n    isTestEnv,\n    isMionCompileMode,\n    isMionAOTEmitMode,\n    resetRoutesCache,\n} from '@mionjs/core';\nimport {getRawMethodReflection, getHandlerReflection} from './lib/reflection.ts';\nimport {serializerMiddleFns} from './routes/serializer.routes.ts';\nimport {getRouterItemId, getRoutePath, getENV, MION_ROUTES, routesCache} from '@mionjs/core';\nimport {setErrorOptions} from '@mionjs/core';\nimport {getPublicApi, resetRemoteMethodsMetadata} from './lib/remoteMethods.ts';\nimport {addToPersistedMethods, getPersistedMethod, resetPersistedMethods} from './lib/methodsCache.ts';\nimport {mionClientRoutes} from './routes/client.routes.ts';\nimport {mionErrorsRoutes} from './routes/errors.routes.ts';\nimport {clearRoutesFlowCache} from './routesFlow.ts';\nimport {clearContextPool} from './callContext.ts';\n\ntype RouterKeyEntryList = [string, RouterEntry][];\ntype RoutesWithId = {\n    pathPointer: string[];\n    routes: Routes;\n};\n\n// ############# PRIVATE STATE #############\n\nconst mionInternalRoutes = Object.values(MION_ROUTES) as string[];\nconst flatRouter: Map<string, MethodsExecutionChain> = new Map(); // Main Router\nconst middleFnsById: Map<string, MiddleFnMethod | HeadersMethod | RawMethod> = new Map();\nconst routesById: Map<string, RouteMethod> = new Map();\nconst rawMiddleFnsById: Map<string, RawMethod> = new Map();\nconst middleFnNames: Set<string> = new Set();\nconst routeNames: Set<string> = new Set();\nlet complexity = 0;\nlet routerOptions: RouterOptions = {...DEFAULT_ROUTE_OPTIONS};\nlet isRouterInitialized = false;\nlet allExecutablesIds: string[] | undefined;\n\n/** Global middleFns to be run before and after any other middleFns or routes set using `registerRoutes` */\nconst defaultStartMiddleFns = {\n    mionDeserializeRequest: serializerMiddleFns.mionDeserializeRequest,\n};\nconst defaultEndMiddleFns = {\n    mionSerializeResponse: serializerMiddleFns.mionSerializeResponse,\n};\nlet startMiddleFnsDef: MiddleFnsCollection = {...defaultStartMiddleFns};\nlet endMiddleFnsDef: MiddleFnsCollection = {...defaultEndMiddleFns};\nexport let startMiddleFns: RemoteMethod[] = [];\nexport let endMiddleFns: RemoteMethod[] = [];\n\n// ############# PUBLIC METHODS #############\n\nexport const getRouteExecutionChain = (path: string) => flatRouter.get(path);\nexport const getRouteEntries = () => flatRouter.entries();\nexport const geRoutesSize = () => flatRouter.size;\nexport const getRouteExecutable = (id: string) => routesById.get(id);\nexport const getMiddleFnExecutable = (id: string) => middleFnsById.get(id);\nexport const geMiddleFnsSize = () => middleFnsById.size;\nexport const getComplexity = () => complexity;\nexport const getRouterOptions = <Opts extends RouterOptions>(): Readonly<Opts> => routerOptions as Opts;\nexport const getAnyExecutable = (id: string) => routesById.get(id) || middleFnsById.get(id) || rawMiddleFnsById.get(id);\n\nexport const resetRouter = () => {\n    flatRouter.clear();\n    middleFnsById.clear();\n    routesById.clear();\n    rawMiddleFnsById.clear();\n    middleFnNames.clear();\n    routeNames.clear();\n    complexity = 0;\n    routerOptions = {...DEFAULT_ROUTE_OPTIONS};\n    startMiddleFnsDef = {...defaultStartMiddleFns};\n    endMiddleFnsDef = {...defaultEndMiddleFns};\n    startMiddleFns = [];\n    endMiddleFns = [];\n    isRouterInitialized = false;\n    allExecutablesIds = undefined;\n    resetRemoteMethodsMetadata();\n    resetPersistedMethods();\n    resetRoutesCache();\n    clearContextPool();\n    clearRoutesFlowCache();\n    // Note: We intentionally do NOT call resetJitFnCaches() here because:\n    // 1. JIT function caches are global and should persist across router resets\n    // 2. The serializableClassRegistry (cleared by resetJitFnCaches) is needed for\n    //    serialization/deserialization of classes like RpcError\n    // resetJitFnCaches() should only be called in specific test scenarios that need\n    // to test AOT cache loading behavior\n};\n\n// simpler router initialization\nexport async function initMionRouter<R extends Routes>(routes: R, opts?: Partial<RouterOptions>): Promise<PublicApi<R>> {\n    await initRouter(opts);\n    const publicApi = await registerRoutes(routes);\n    // Emit AOT caches once after ALL routes (error, client, user) are registered\n    await emitAOTCaches();\n    return publicApi;\n}\n\n/**\n * Initializes the Router.\n * @param application\n * @param contextDataFactory a factory function that returns an object to be shared in the `callContext.shared`\n * @param routerOptions\n * @returns\n */\nexport async function initRouter(opts?: Partial<RouterOptions>): Promise<Readonly<RouterOptions>> {\n    if (isRouterInitialized) throw new Error('Router has already been initialized');\n    routerOptions = {...routerOptions, ...opts};\n    validateSharedDataFactory(routerOptions);\n    Object.freeze(routerOptions);\n    setErrorOptions(routerOptions);\n    if (routerOptions.aot) await loadAOTCaches();\n    isRouterInitialized = true;\n    await registerRoutes({...mionErrorsRoutes});\n    if (!routerOptions.skipClientRoutes) await registerRoutes({...mionClientRoutes});\n    if (!isTestEnv()) console.log('mion router initialized', {routerOptions});\n    return routerOptions;\n}\n\nexport async function registerRoutes<R extends Routes>(routes: R): Promise<PublicApi<R>> {\n    if (!isRouterInitialized) throw new Error('initRouter should be called first');\n    startMiddleFns = await getExecutablesFromMiddleFnsCollection(startMiddleFnsDef);\n    endMiddleFns = await getExecutablesFromMiddleFnsCollection(endMiddleFnsDef);\n    await recursiveFlatRoutes(routes);\n    if (shouldFullGenerateSpec()) {\n        return getPublicApi(routes);\n    }\n    return {} as PublicApi<R>;\n}\n\n/** Add middleFns at the start af the ExecutionChain, adds them before any other existing start middleFns by default */\nexport function addStartMiddleFns(middleFnsDef: MiddleFnsCollection, appendBeforeExisting = true) {\n    if (isRouterInitialized) throw new Error('Can not add start middleFns after the router has been initialized');\n    if (appendBeforeExisting) {\n        startMiddleFnsDef = {...middleFnsDef, ...startMiddleFnsDef};\n        return;\n    }\n    startMiddleFnsDef = {...startMiddleFnsDef, ...middleFnsDef};\n}\n\n/** Add middleFns at the end af the ExecutionChain, adds them after any other existing end middleFns by default */\nexport function addEndMiddleFns(middleFnsDef: MiddleFnsCollection, prependAfterExisting = true) {\n    if (isRouterInitialized) throw new Error('Can not add end middleFns after the router has been initialized');\n    if (prependAfterExisting) {\n        endMiddleFnsDef = {...endMiddleFnsDef, ...middleFnsDef};\n        return;\n    }\n    endMiddleFnsDef = {...middleFnsDef, ...endMiddleFnsDef};\n}\n\nexport function isPrivateDefinition(entry: RouterEntry, id: string): entry is PrivateDef {\n    if (isRoute(entry)) return false;\n    if (isRawMiddleFnDef(entry)) return true;\n    try {\n        const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);\n        if (!executable)\n            throw new Error(`Route or MiddleFn ${id} not found. Please check you have called router.registerRoutes first.`);\n        return isPrivateExecutable(executable);\n    } catch {\n        // error thrown because entry is a Routes object and does not have any handler\n        return false;\n    }\n}\n\nexport function isPrivateExecutable(executable: RemoteMethod): boolean {\n    if (executable.type === HandlerType.rawMiddleFn) return true;\n    if (executable.type === HandlerType.route) return false;\n    const hasPublicParams = !!executable.paramNames?.length;\n    const hasHeaderParams = !!(executable as HeadersMethod).headersParam?.headerNames?.length;\n    return !hasPublicParams && !hasHeaderParams && !executable.hasReturnData;\n}\n\nexport function getTotalExecutables(): number {\n    return routesById.size + middleFnsById.size + rawMiddleFnsById.size;\n}\n\nexport function getAllExecutablesIds(): string[] {\n    if (allExecutablesIds) return allExecutablesIds;\n    allExecutablesIds = [...routesById.keys(), ...middleFnsById.keys(), ...rawMiddleFnsById.keys()];\n    return allExecutablesIds;\n}\n\n// used by codegen\nexport function shouldFullGenerateSpec(): boolean {\n    return routerOptions.getPublicRoutesData || getENV('GENERATE_ROUTER_SPEC') === 'true' || isMionCompileMode();\n}\n\nexport function getRouteExecutableFromPath(path: string): RouteMethod {\n    const executionChain = flatRouter.get(path);\n    if (!executionChain) {\n        // Return the not-found route executable\n        return getAnyExecutable(MION_ROUTES.notFound) as RouteMethod;\n    }\n    return executionChain.methods[executionChain.routeIndex] as RouteMethod;\n}\n\n// ############# PRIVATE METHODS #############\n\nasync function loadAOTCaches() {\n    const loader = await import('./lib/aotCacheLoader.ts');\n    return loader.loadAOTCaches();\n}\n\nasync function emitAOTCaches() {\n    if (!isMionAOTEmitMode()) return;\n    // Dynamic import resolves relative to this source file.\n    // This only runs via vite-node (MION_COMPILE=true), which always resolves from source.\n    const aotEmitter = await import('./lib/aotEmitter.ts');\n    return aotEmitter.emitAOTCaches();\n}\n\n/**\n * Optimized algorithm to flatten the routes object into a list of Executable objects.\n * @param routes\n * @param currentPointer current pointer in the routes object i.e. ['users', 'get']\n * @param preMiddleFns middleFns one level up preceding current pointer\n * @param postMiddleFns middleFns one level up  following the current pointer\n * @param nestLevel\n */\nasync function recursiveFlatRoutes(\n    routes: Routes,\n    currentPointer: string[] = [],\n    preMiddleFns: RemoteMethod[] = [],\n    postMiddleFns: RemoteMethod[] = [],\n    nestLevel = 0\n) {\n    if (nestLevel > MAX_ROUTE_NESTING)\n        throw new Error('Too many nested routes, you can only nest routes ${MAX_ROUTE_NESTING} levels');\n\n    const entries = Object.entries(routes);\n    if (entries.length === 0)\n        throw new Error(\n            `Invalid route: ${currentPointer.length ? joinPath(...currentPointer) : '*'}. Can Not define empty routes`\n        );\n\n    let minus1Props: ReturnType<typeof getRouteEntryProperties> | null = null;\n    for (let index = 0; index < entries.length; index++) {\n        const [key, item] = entries[index];\n        // create the executable items\n        const newPointer = [...currentPointer, key];\n        let routeEntry: RemoteMethod | RoutesWithId;\n        if (typeof key !== 'string' || !isNaN(key as any))\n            throw new Error(`Invalid route: ${joinPath(...newPointer)}. Numeric route names are not allowed`);\n        if (key.includes(',')) throw new Error(`Invalid route: ${joinPath(...newPointer)}. Route names cannot contain commas.`);\n        if (key === WORKFLOW_KEY)\n            throw new Error(`Invalid route: ${joinPath(...newPointer)}. '${WORKFLOW_KEY}' is a reserved mion route name.`);\n\n        // generates a middleFn\n        if (isAnyMiddleFnDef(item)) {\n            routeEntry = await getExecutableFromAnyMiddleFn(item, newPointer, nestLevel);\n            if (middleFnNames.has(routeEntry.id))\n                throw new Error(\n                    `Invalid middleFn: ${joinPath(...newPointer)}. Naming collision, Naming collision, duplicated middleFn.`\n                );\n            middleFnNames.add(routeEntry.id);\n        }\n\n        // generates a route\n        else if (isRoute(item)) {\n            routeEntry = await getExecutableFromRoute(item, newPointer, nestLevel);\n            if (routeNames.has(routeEntry.id))\n                throw new Error(`Invalid route: ${joinPath(...newPointer)}. Naming collision, duplicated route`);\n            routeNames.add(routeEntry.id);\n        }\n\n        // generates structure required to go one level down\n        else if (isRoutes(item)) {\n            routeEntry = {\n                pathPointer: newPointer,\n                routes: item,\n            };\n        }\n\n        // throws an error if the route is invalid\n        else {\n            const itemType = typeof item;\n            throw new Error(`Invalid route: ${joinPath(...newPointer)}. Type <${itemType}> is not a valid route.`);\n        }\n\n        // recurse into sublevels\n        minus1Props = await recursiveCreateExecutionChainAsync(\n            routeEntry,\n            newPointer,\n            preMiddleFns,\n            postMiddleFns,\n            nestLevel,\n            index,\n            entries,\n            minus1Props\n        );\n\n        complexity++;\n    }\n}\n\nasync function recursiveCreateExecutionChainAsync(\n    routeEntry: RemoteMethod | RoutesWithId,\n    currentPointer: string[],\n    preMiddleFns: RemoteMethod[],\n    postMiddleFns: RemoteMethod[],\n    nestLevel: number,\n    index: number,\n    routeKeyedEntries: RouterKeyEntryList,\n    minus1Props: ReturnType<typeof getRouteEntryProperties> | null\n) {\n    const minus1 = getEntry(index - 1, routeKeyedEntries);\n    const plus1 = getEntry(index + 1, routeKeyedEntries);\n    const props = getRouteEntryProperties(minus1, routeEntry, plus1);\n\n    if (props.isBetweenRoutes && minus1Props) {\n        props.preLevelMiddleFns = minus1Props.preLevelMiddleFns;\n        props.postLevelMiddleFns = minus1Props.postLevelMiddleFns;\n    } else {\n        for (let i = 0; i < routeKeyedEntries.length; i++) {\n            const [k, entry] = routeKeyedEntries[i];\n            complexity++;\n            if (!isAnyMiddleFnDef(entry)) continue;\n            const newPointer = [...currentPointer.slice(0, -1), k];\n            const executable = await getExecutableFromAnyMiddleFn(entry, newPointer, nestLevel);\n            if (i < index) props.preLevelMiddleFns.push(executable);\n            if (i > index) props.postLevelMiddleFns.push(executable);\n        }\n    }\n    const isExec = isExecutable(routeEntry);\n\n    if (isExec && props.isRoute) {\n        const path = getRoutePath(routeEntry.pointer, routerOptions);\n        const routeMethod = routeEntry as RouteMethod;\n        const levelMethods = [\n            ...preMiddleFns,\n            ...props.preLevelMiddleFns,\n            routeEntry,\n            ...props.postLevelMiddleFns,\n            ...postMiddleFns,\n        ];\n        const methods = [...startMiddleFns, ...levelMethods, ...endMiddleFns];\n        const executionChain: MethodsExecutionChain = {\n            routeIndex: startMiddleFns.length + preMiddleFns.length + props.preLevelMiddleFns.length,\n            methods,\n            serializer: getSerializerCodeFromMode(routeMethod.options.serializer),\n        };\n        const middleFnIds = getPublicMiddleFnIds(methods);\n        // add middleware functions deps, so can be serialized with the router\n        if (middleFnIds.length) routeMethod.middleFnIds = middleFnIds;\n        flatRouter.set(path, executionChain);\n    } else if (!isExec) {\n        await recursiveFlatRoutes(\n            routeEntry.routes,\n            routeEntry.pathPointer,\n            [...preMiddleFns, ...props.preLevelMiddleFns],\n            [...props.postLevelMiddleFns, ...postMiddleFns],\n            nestLevel + 1\n        );\n    }\n\n    return props;\n}\n\nasync function getExecutableFromAnyMiddleFn(\n    middleFn: MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef,\n    middleFnPointer: string[],\n    nestLevel: number\n) {\n    if (isRawMiddleFnDef(middleFn)) return getExecutableFromRawMiddleFn(middleFn, middleFnPointer, nestLevel);\n    return getExecutableFromMiddleFn(middleFn, middleFnPointer, nestLevel);\n}\n\nexport async function getExecutableFromMiddleFn(\n    middleFn: MiddleFnDef | HeadersMiddleFnDef,\n    middleFnPointer: string[],\n    nestLevel: number\n): Promise<MiddleFnMethod | HeadersMethod> {\n    const isHeader = isHeadersMiddleFnDef(middleFn);\n    // todo fix header id should be same as any other one and then maybe map from id to header name\n    const middleFnId = getRouterItemId(middleFnPointer);\n    const existing = middleFnsById.get(middleFnId);\n    if (existing) return existing as MiddleFnMethod;\n\n    type MixedMiddleFn = (Omit<MiddleFnMethod, 'type'> | Omit<HeadersMethod, 'type'>) & {\n        type: typeof HandlerType.middleFn | typeof HandlerType.headersMiddleFn;\n    };\n\n    const compiledMethod = getPersistedMethod(middleFnId, middleFn.handler);\n    let executable: MixedMiddleFn;\n    if (compiledMethod) {\n        executable = compiledMethod as MixedMiddleFn;\n    } else {\n        const reflectionData = await getHandlerReflection(middleFn.handler, middleFnId, routerOptions, isHeader);\n        executable = {\n            id: middleFnId,\n            type: isHeader ? HandlerType.headersMiddleFn : HandlerType.middleFn,\n            nestLevel,\n            handler: middleFn.handler,\n            pointer: middleFnPointer,\n            ...reflectionData,\n            options: {\n                runOnError: !!middleFn.options?.runOnError,\n                validateParams: middleFn.options?.validateParams ?? true,\n                validateReturn: middleFn.options?.validateReturn ?? false,\n                description: middleFn.options?.description,\n            },\n        };\n        addToPersistedMethods(middleFnId, executable);\n    }\n\n    middleFnsById.set(middleFnId, executable as any);\n    routesCache.setMethodJitFns(middleFnId, executable as any);\n    return executable as any;\n}\n\nexport async function getExecutableFromRawMiddleFn(\n    middleFn: RawMiddleFnDef,\n    middleFnPointer: string[],\n    nestLevel: number\n): Promise<RawMethod> {\n    const middleFnId = getRouterItemId(middleFnPointer);\n    const existing = rawMiddleFnsById.get(middleFnId);\n    if (existing) return existing as RawMethod;\n    const reflectionData = await getRawMethodReflection(middleFn.handler, middleFnId, routerOptions);\n    const executable: RawMethod = {\n        id: middleFnId,\n        type: HandlerType.rawMiddleFn,\n        nestLevel,\n        handler: middleFn.handler,\n        pointer: middleFnPointer,\n        ...reflectionData,\n        options: {\n            runOnError: !!middleFn.options?.runOnError,\n            validateParams: false,\n            validateReturn: false,\n            description: middleFn.options?.description,\n        },\n    };\n    rawMiddleFnsById.set(middleFnId, executable);\n    routesCache.setMethodJitFns(middleFnId, executable as any);\n    return executable;\n}\n\nexport async function getExecutableFromRoute(route: Route, routePointer: string[], nestLevel: number): Promise<RouteMethod> {\n    const routeId = getRouterItemId(routePointer);\n    const existing = routesById.get(routeId);\n    if (existing) return existing as RouteMethod;\n\n    const compiledMethod = getPersistedMethod(routeId, route.handler);\n    let executable: RouteMethod;\n    if (compiledMethod) {\n        executable = compiledMethod as RouteMethod;\n    } else {\n        const reflectionData = await getHandlerReflection(route.handler, routeId, routerOptions);\n        executable = {\n            id: routeId,\n            type: HandlerType.route,\n            nestLevel,\n            handler: route.handler,\n            pointer: routePointer,\n            ...reflectionData,\n            options: {\n                runOnError: false,\n                validateParams: route.options?.validateParams ?? true,\n                validateReturn: route.options?.validateReturn ?? false,\n                description: route.options?.description,\n                serializer: route.options?.serializer ?? routerOptions.serializer,\n                isMutation: route.options?.isMutation,\n            },\n        };\n        addToPersistedMethods(routeId, executable);\n    }\n    routesById.set(routeId, executable);\n    routesCache.setMethodJitFns(routeId, executable as any);\n    return executable;\n}\n\n/** Returns IDs of public middleware methods from the execution chain, excluding internal mion routes. */\nfunction getPublicMiddleFnIds(methods: RemoteMethod[]): string[] {\n    const ids = methods\n        .filter((exec) => isPublicExecutable(exec))\n        .map((exec) => getRouterItemId(exec.pointer))\n        .filter((mfId) => {\n            if (mionInternalRoutes.includes(mfId)) return false;\n            const exec = getMiddleFnExecutable(mfId);\n            return exec && isPublicExecutable(exec);\n        });\n    return ids;\n}\n\nfunction getEntry(index: number, keyEntryList: RouterKeyEntryList) {\n    return keyEntryList[index]?.[1];\n}\n\nfunction getRouteEntryProperties(\n    minus1: RouterEntry | undefined,\n    zero: RemoteMethod | RoutesWithId,\n    plus1: RouterEntry | undefined\n) {\n    const minus1IsRoute = minus1 && isRoute(minus1);\n    const zeroIsRoute = (zero as RemoteMethod).type === HandlerType.route;\n    const plus1IsRoute = plus1 && isRoute(plus1);\n\n    const isExec = !!(zero as RemoteMethod).handler;\n\n    return {\n        isBetweenRoutes: minus1IsRoute && zeroIsRoute && plus1IsRoute,\n        isExecutable: isExec,\n        isRoute: zeroIsRoute,\n        preLevelMiddleFns: [] as RemoteMethod[],\n        postLevelMiddleFns: [] as RemoteMethod[],\n    };\n}\n\nasync function getExecutablesFromMiddleFnsCollection(\n    middleFnsDef: MiddleFnsCollection\n): Promise<(RawMethod | MiddleFnMethod | HeadersMethod)[]> {\n    const results: (RawMethod | MiddleFnMethod | HeadersMethod)[] = [];\n    for (const [key, middleFn] of Object.entries(middleFnsDef)) {\n        if (isRawMiddleFnDef(middleFn)) {\n            results.push(await getExecutableFromRawMiddleFn(middleFn, [key], 0));\n        } else if (isHeadersMiddleFnDef(middleFn) || isMiddleFnDef(middleFn)) {\n            results.push(await getExecutableFromMiddleFn(middleFn, [key], 0));\n        } else {\n            throw new Error(`Invalid middleFn: ${key}. Invalid middleFn definition`);\n        }\n    }\n    return results;\n}\n\n/**\n * Validates that a contextDataFactory returns a valid context data object.\n * @param contextDataFactory The factory function to validate\n * @throws Error if the factory doesn't return a plain object with at least one property\n */\nfunction validateSharedDataFactory(opts?: Partial<RouterOptions>): void {\n    if (!opts?.contextDataFactory) return;\n    const testSharedData = opts.contextDataFactory();\n    if (\n        typeof testSharedData !== 'object' ||\n        Array.isArray(testSharedData) ||\n        testSharedData === null ||\n        Object.keys(testSharedData).length === 0\n    ) {\n        throw new Error('contextDataFactory must return a plain object with at least one property');\n    }\n}\n\n/** Maps serializer mode string to response body type code */\nfunction getSerializerCodeFromMode(mode: SerializerMode | undefined): SerializerCode {\n    switch (mode) {\n        case 'binary':\n            return SerializerModes.binary;\n        case 'stringifyJson':\n            return SerializerModes.stringifyJson;\n        case 'json':\n        default:\n            return SerializerModes.json;\n    }\n}\n\n/** Path replacement as is not available in edge runtime */\nfunction joinPath(...parts: string[]): string {\n    return parts.filter(Boolean).join('/');\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/routes/client.routes.d.ts

@@ -0,0 +1,16 @@
+import { RpcError, SerializableMethodsData } from '@mionjs/core';
+import { RouterOptions } from '../types/general.ts';
+export interface ClientRouteOptions extends RouterOptions {
+    getAllRemoteMethodsMaxNumber?: number;
+}
+export declare const defaultClientRouteOptions: {
+    getAllRemoteMethodsMaxNumber: number;
+};
+declare function mionGetRemoteMethodsDataById(ctx: any, methodsIds: string[], getAllRemoteMethods?: boolean): SerializableMethodsData | RpcError<'rpc-metadata-not-found'>;
+declare function mionGetRemoteMethodsDataByPath(ctx: any, path: string, getAllRemoteMethods?: boolean): SerializableMethodsData | RpcError<'rpc-metadata-not-found'>;
+export declare const mionClientRoutes: {
+    readonly "mion@methodsMetadataById": import('../types/definitions.ts').RouteDef<typeof mionGetRemoteMethodsDataById>;
+    readonly "mion@methodsMetadataByPath": import('../types/definitions.ts').RouteDef<typeof mionGetRemoteMethodsDataByPath>;
+};
+export {};
+export declare type __ΩClientRouteOptions = any[];

package/.dist/esm/src/routes/client.routes.js

@@ -0,0 +1,76 @@
+import { MION_ROUTES, RpcError, __ΩSerializableMethodsData as ___SerializableMethodsData, __ΩAnyObject as ___AnyObject } from "@mionjs/core";
+import { getRouteExecutionChain, getRouterOptions, getTotalExecutables, getAllExecutablesIds, isPrivateExecutable, getAnyExecutable, getMiddleFnExecutable, getRouteExecutable } from "../router.js";
+import { route } from "../lib/handlers.js";
+import { __ΩRouterOptions as ___RouterOptions } from "../types/general.js";
+import { getSerializableMethod, serializeMethodDeps } from "../lib/remoteMethods.js";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+const __ΩClientRouteOptions = [() => ___RouterOptions, "getAllRemoteMethodsMaxNumber", "ClientRouteOptions", `Pn!'4"8Mw#y`];
+const defaultClientRouteOptions = {
+  getAllRemoteMethodsMaxNumber: 100
+};
+const mionInternalRoutes = Object.values(MION_ROUTES);
+function mionGetRemoteMethodsDataById(ctx, methodsIds, getAllRemoteMethods) {
+  const resp = {
+    methods: {},
+    deps: {},
+    purFnDeps: {}
+  };
+  const errorData = {};
+  const maxMethods = (getRouterOptions.Ω = [[() => __ΩClientRouteOptions, "n!"]], getRouterOptions()).getAllRemoteMethodsMaxNumber || defaultClientRouteOptions.getAllRemoteMethodsMaxNumber;
+  const shouldReturnAll = getAllRemoteMethods && getTotalExecutables() <= maxMethods;
+  const idsToReturn = shouldReturnAll ? getAllExecutablesIds().filter(__assignType((id) => !mionInternalRoutes.includes(id) && !isPrivateExecutable(getAnyExecutable(id)), ["id", "", 'P"2!"/"'])) : methodsIds;
+  idsToReturn.forEach(__assignType((id) => addRequiredRemoteMethodsToResponse(id, resp, errorData), ["id", "", 'P"2!"/"']));
+  if (Object.keys(errorData).length)
+    return new RpcError({
+      type: "rpc-metadata-not-found",
+      publicMessage: "Errors getting Remote Methods Metadata",
+      errorData
+    });
+  return resp;
+}
+mionGetRemoteMethodsDataById.__type = ["ctx", "methodsIds", "getAllRemoteMethods", () => ___SerializableMethodsData, "rpc-metadata-not-found", () => RpcError, "mionGetRemoteMethodsDataById", `P"2!&F2")2#8Pn$P.%7&J/'`];
+function mionGetRemoteMethodsDataByPath(ctx, path, getAllRemoteMethods) {
+  const executables = getRouteExecutionChain(path);
+  if (!executables)
+    return new RpcError({
+      type: "rpc-metadata-not-found",
+      publicMessage: `Route ${path} not found`
+    });
+  const privateExecutables = executables.methods.filter(__assignType((e) => !isPrivateExecutable(e), ["e", "", 'P"2!"/"']));
+  return mionGetRemoteMethodsDataById(ctx, privateExecutables.map(__assignType((e) => e.id, ["e", "", 'P"2!"/"'])), getAllRemoteMethods);
+}
+mionGetRemoteMethodsDataByPath.__type = ["ctx", "path", "getAllRemoteMethods", () => ___SerializableMethodsData, "rpc-metadata-not-found", () => RpcError, "mionGetRemoteMethodsDataByPath", `P"2!&2")2#8Pn$P.%7&J/'`];
+function addRequiredRemoteMethodsToResponse(id, resp, errorData) {
+  const { methods, deps, purFnDeps } = resp;
+  if (methods[id])
+    return;
+  if (mionInternalRoutes.includes(id))
+    return;
+  const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);
+  if (!executable) {
+    errorData[id] = `Remote Method ${id} not found`;
+    return;
+  }
+  if (isPrivateExecutable(executable))
+    return;
+  const method = getSerializableMethod(executable);
+  methods[id] = method;
+  method.middleFnIds?.forEach(__assignType((middleFnId) => addRequiredRemoteMethodsToResponse(middleFnId, resp, errorData), ["middleFnId", "", 'P"2!"/"']));
+  serializeMethodDeps(method, deps, purFnDeps);
+}
+addRequiredRemoteMethodsToResponse.__type = ["id", () => ___SerializableMethodsData, "resp", () => ___AnyObject, "errorData", "addRequiredRemoteMethodsToResponse", 'P&2!n"2#n$2%$/&'];
+const mionClientRoutes = {
+  // Client routes always use stringifyJson serialization to avoid mutating data as is cached
+  // These routes are used by the client to fetch metadata and must work regardless of router's default serialization
+  [MION_ROUTES.methodsMetadataById]: route(mionGetRemoteMethodsDataById, { serializer: "stringifyJson" }),
+  [MION_ROUTES.methodsMetadataByPath]: route(mionGetRemoteMethodsDataByPath, { serializer: "stringifyJson" })
+};
+export {
+  __ΩClientRouteOptions,
+  defaultClientRouteOptions,
+  mionClientRoutes
+};
+//# sourceMappingURL=client.routes.js.map

package/.dist/esm/src/routes/client.routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.routes.js","sources":["../../../../src/routes/client.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 {AnyObject, RpcError, MION_ROUTES, SerializableMethodsData} from '@mionjs/core';\nimport {\n    getMiddleFnExecutable,\n    getRouteExecutable,\n    isPrivateExecutable,\n    getRouteExecutionChain,\n    getRouterOptions,\n    getTotalExecutables,\n    getAllExecutablesIds,\n    getAnyExecutable,\n} from '../router.ts';\nimport {route} from '../lib/handlers.ts';\nimport {RouterOptions, Routes} from '../types/general.ts';\nimport {getSerializableMethod, serializeMethodDeps} from '../lib/remoteMethods.ts';\nimport {RemoteMethod} from '../types/remoteMethods.ts';\n\nexport interface ClientRouteOptions extends RouterOptions {\n    getAllRemoteMethodsMaxNumber?: number;\n}\n\nexport const defaultClientRouteOptions = {\n    getAllRemoteMethodsMaxNumber: 100,\n};\n\n// Internal mion routes that should not be exposed to clients\nconst mionInternalRoutes = Object.values(MION_ROUTES) as string[];\n\n/**\n * Returns the metadata for the given method ids.\n * If getAllRemoteMethods is true, all public methods and middleFns are returned.\n * @mion:route\n */\nfunction mionGetRemoteMethodsDataById(\n    ctx,\n    methodsIds: string[],\n    getAllRemoteMethods?: boolean\n): SerializableMethodsData | RpcError<'rpc-metadata-not-found'> {\n    const resp: SerializableMethodsData = {\n        methods: {},\n        deps: {},\n        purFnDeps: {},\n    };\n    const errorData = {};\n    const maxMethods =\n        getRouterOptions<ClientRouteOptions>().getAllRemoteMethodsMaxNumber ||\n        defaultClientRouteOptions.getAllRemoteMethodsMaxNumber;\n    const shouldReturnAll = getAllRemoteMethods && getTotalExecutables() <= maxMethods;\n    const idsToReturn = shouldReturnAll\n        ? getAllExecutablesIds().filter(\n              (id) => !mionInternalRoutes.includes(id) && !isPrivateExecutable(getAnyExecutable(id) as RemoteMethod)\n          )\n        : methodsIds;\n    idsToReturn.forEach((id) => addRequiredRemoteMethodsToResponse(id, resp, errorData));\n\n    if (Object.keys(errorData).length)\n        return new RpcError({\n            type: 'rpc-metadata-not-found',\n            publicMessage: 'Errors getting Remote Methods Metadata',\n            errorData,\n        });\n    return resp;\n}\n\n/**\n * Returns the metadata for the given route path.\n * This include all middleFns in the ExecutionChain of the route.\n * If getAllRemoteMethods is true, all public methods and middleFns are returned.\n * @mion:route\n */\nfunction mionGetRemoteMethodsDataByPath(\n    ctx,\n    path: string,\n    getAllRemoteMethods?: boolean\n): SerializableMethodsData | RpcError<'rpc-metadata-not-found'> {\n    const executables = getRouteExecutionChain(path);\n    if (!executables)\n        return new RpcError({\n            type: 'rpc-metadata-not-found',\n            publicMessage: `Route ${path} not found`,\n        });\n    const privateExecutables = executables.methods.filter((e) => !isPrivateExecutable(e));\n    return mionGetRemoteMethodsDataById(\n        ctx,\n        privateExecutables.map((e) => e.id),\n        getAllRemoteMethods\n    );\n}\n\nfunction addRequiredRemoteMethodsToResponse(id: string, resp: SerializableMethodsData, errorData: AnyObject): void {\n    const {methods, deps, purFnDeps} = resp;\n    if (methods[id]) return;\n    if (mionInternalRoutes.includes(id)) return;\n    const executable = getMiddleFnExecutable(id) || getRouteExecutable(id);\n    if (!executable) {\n        errorData[id] = `Remote Method ${id} not found`;\n        return;\n    }\n    if (isPrivateExecutable(executable)) return;\n    const method = getSerializableMethod(executable as RemoteMethod);\n    methods[id] = method;\n    method.middleFnIds?.forEach((middleFnId) => addRequiredRemoteMethodsToResponse(middleFnId, resp, errorData));\n    serializeMethodDeps(method, deps, purFnDeps);\n}\n\nexport const mionClientRoutes = {\n    // Client routes always use stringifyJson serialization to avoid mutating data as is cached\n    // These routes are used by the client to fetch metadata and must work regardless of router's default serialization\n    [MION_ROUTES.methodsMetadataById]: route(mionGetRemoteMethodsDataById, {serializer: 'stringifyJson'}),\n    [MION_ROUTES.methodsMetadataByPath]: route(mionGetRemoteMethodsDataByPath, {serializer: 'stringifyJson'}),\n} as const satisfies Routes;\n"],"names":[],"mappings":";;;;;;;;;;AA2BO,MAAM,4BAA4B;AAAA,EACrC,8BAA8B;;AAIlC,MAAM,qBAAqB,OAAO,OAAO,WAAW;AAOpD,SAAS,6BACL,KACA,YACA,qBAA6B;AAE7B,QAAM,OAAgC;AAAA,IAClC,SAAS,CAAA;AAAA,IACT,MAAM,CAAA;AAAA,IACN,WAAW,CAAA;AAAA,EAAA;AAEf,QAAM,YAAY,CAAA;AAClB,QAAM,cACF,4DAAA,iBAAA,GAAuC,gCACvC,0BAA0B;AAC9B,QAAM,kBAAkB,uBAAuB,oBAAA,KAAyB;AACxE,QAAM,cAAc,kBACd,uBAAuB,OAAM,aACzB,CAAC,OAAO,CAAC,mBAAmB,SAAS,EAAE,KAAK,CAAC,oBAAoB,iBAAiB,EAAE,CAAiB,GAAC,CAAA,MAAA,IAAA,SAAA,CAAA,CAAA,IAE1G;AACN,cAAY,QAAO,aAAC,CAAC,OAAO,mCAAmC,IAAI,MAAM,SAAS;AAElF,MAAI,OAAO,KAAK,SAAS,EAAE;AACvB,WAAO,IAAI,SAAS;AAAA,MAChB,MAAM;AAAA,MACN,eAAe;AAAA,MACf;AAAA,IAAA,CACH;AACL,SAAO;AACX;;AAQA,SAAS,+BACL,KACA,MACA,qBAA6B;AAE7B,QAAM,cAAc,uBAAuB,IAAI;AAC/C,MAAI,CAAC;AACD,WAAO,IAAI,SAAS;AAAA,MAChB,MAAM;AAAA,MACN,eAAe,SAAS,IAAI;AAAA,IAAA,CAC/B;AACL,QAAM,qBAAqB,YAAY,QAAQ,OAAM,aAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC;AACnF,SAAO,6BACH,KACA,mBAAmB,iBAAI,CAAC,MAAM,EAAE,4BAChC,mBAAmB;AAE3B;;AAEA,SAAS,mCAAmC,IAAY,MAA+B,WAAoB;AACvG,QAAM,EAAC,SAAS,MAAM,UAAA,IAAa;AACnC,MAAI,QAAQ,EAAE;AAAG;AACjB,MAAI,mBAAmB,SAAS,EAAE;AAAG;AACrC,QAAM,aAAa,sBAAsB,EAAE,KAAK,mBAAmB,EAAE;AACrE,MAAI,CAAC,YAAY;AACb,cAAU,EAAE,IAAI,iBAAiB,EAAE;AACnC;AAAA,EACJ;AACA,MAAI,oBAAoB,UAAU;AAAG;AACrC,QAAM,SAAS,sBAAsB,UAA0B;AAC/D,UAAQ,EAAE,IAAI;AACd,SAAO,aAAa,QAAO,aAAC,CAAC,eAAe,mCAAmC,YAAY,MAAM,SAAS;AAC1G,sBAAoB,QAAQ,MAAM,SAAS;AAC/C;;AAEO,MAAM,mBAAmB;AAAA;AAAA;AAAA,EAG5B,CAAC,YAAY,mBAAmB,GAAG,MAAM,8BAA8B,EAAC,YAAY,iBAAgB;AAAA,EACpG,CAAC,YAAY,qBAAqB,GAAG,MAAM,gCAAgC,EAAC,YAAY,gBAAA,CAAgB;;"}

package/.dist/esm/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>>;
+};