@mionjs/client 0.8.0-alpha.0

package/.dist/esm/src/clientMethodsMetadata.js

@@ -0,0 +1,162 @@
+import { pureFnsCache, jitFnsCache } from "virtual:mion-aot/caches";
+import { MION_ROUTES, getRoutePath, isRpcError, RpcError, addSerializedJitCaches, isTestEnv, routesCache, addRoutesToCache } from "@mionjs/core";
+import { __ΩClientOptions as ___ClientOptions } from "./types.js";
+import { STORAGE_KEY } from "./constants.js";
+import { deserializeResponseBody } from "./serializer.js";
+import { getStorage } from "./storage.js";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  return fn.__type = args, fn;
+}
+async function fetchRemoteMethodsMetadata(methodIds, options) {
+  validateClientCaches(), restoreFromLocalStorage(methodIds, options);
+  const missingAfterLocal = methodIds.filter(__assignType((path) => !routesCache.hasMetadata(path), ["path", "", 'P"2!"/"']));
+  if (!missingAfterLocal.length)
+    return;
+  const shouldReturnAllMethods = !0, body = {
+    [MION_ROUTES.methodsMetadataById]: [missingAfterLocal, shouldReturnAllMethods]
+  };
+  try {
+    const path = getRoutePath([MION_ROUTES.methodsMetadataById], options), url = new URL(path, options.baseURL), response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }), deserialized = await deserializeResponseBody(response), platformError = deserialized[MION_ROUTES.platformError], serializableMethodsData = deserialized[MION_ROUTES.methodsMetadataById];
+    if (isRpcError(platformError))
+      throw platformError;
+    if (isRpcError(serializableMethodsData))
+      throw serializableMethodsData;
+    if (!serializableMethodsData)
+      throw new RpcError({
+        type: "cant-fetch-remote-methods-metadata",
+        publicMessage: "Failed to fetch remote methods metadata",
+        errorData: { response }
+      });
+    storeDependencies(serializableMethodsData.deps, serializableMethodsData.purFnDeps, options), storeMethodsMetadata(serializableMethodsData.methods, options), addToCaches(serializableMethodsData);
+  } catch (error) {
+    throw new Error(`Error fetching validation and serialization metadata: ${error?.message}`);
+  }
+}
+fetchRemoteMethodsMetadata.__type = ["methodIds", () => ___ClientOptions, "options", "fetchRemoteMethodsMetadata", 'P&F2!n"2#"/$'];
+function getSerializedMethodDataKey(methodId, options) {
+  return `${STORAGE_KEY}:serialized-method-data:${options.baseURL}:${methodId}`;
+}
+getSerializedMethodDataKey.__type = ["methodId", () => ___ClientOptions, "options", "getSerializedMethodDataKey", 'P&2!n"2#"/$'];
+function getJitCompiledFnKey(jitFnHash, options) {
+  return `${STORAGE_KEY}:jit-compiled-fn:${options.baseURL}:${jitFnHash}`;
+}
+getJitCompiledFnKey.__type = ["jitFnHash", () => ___ClientOptions, "options", "getJitCompiledFnKey", 'P&2!n"2#"/$'];
+function getJitPureFnKey(namespace, pureFnHash, options) {
+  return `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:${namespace}:${pureFnHash}`;
+}
+getJitPureFnKey.__type = ["namespace", "pureFnHash", () => ___ClientOptions, "options", "getJitPureFnKey", 'P&2!&2"n#2$"/%'];
+function storeDependencies(deps, pureFnDeps, options) {
+  Object.entries(deps).forEach(__assignType(([hash, jitFnData]) => {
+    const key = getJitCompiledFnKey(hash, options);
+    try {
+      getStorage().setItem(key, JSON.stringify(jitFnData));
+    } catch (error) {
+      console.warn(`Failed to store JIT function dependency ${hash}:`, error);
+    }
+  }, ["JitCompiledFnData", "param0", "", 'PP&"w!G2""/#'])), Object.entries(pureFnDeps).forEach(__assignType(([namespace, nsPureFns]) => {
+    Object.entries(nsPureFns).forEach(__assignType(([fnHash, pureFnData]) => {
+      const key = getJitPureFnKey(namespace, fnHash, options);
+      try {
+        getStorage().setItem(key, JSON.stringify(pureFnData));
+      } catch (error) {
+        console.warn(`Failed to store pure function dependency ${namespace}::${fnHash}:`, error);
+      }
+    }, ["PureFunctionData", "param0", "", 'PP&"w!G2""/#']));
+  }, ["param0", "", 'P"2!"/"']));
+}
+storeDependencies.__type = [() => __ΩRecord, "JitCompiledFnData", "deps", "PureFnsDataCache", "pureFnDeps", () => ___ClientOptions, "options", "storeDependencies", `P&"w"o!#2#"w$2%n&2'"/(`];
+function storeMethodsMetadata(methods, options) {
+  Object.entries(methods).forEach(__assignType(([methodId, methodData]) => {
+    const key = getSerializedMethodDataKey(methodId, options);
+    try {
+      getStorage().setItem(key, JSON.stringify(methodData));
+    } catch (error) {
+      console.warn(`Failed to store method metadata ${methodId}:`, error);
+    }
+  }, ["param0", "", 'P"2!"/"']));
+}
+storeMethodsMetadata.__type = ["MethodsCache", "methods", () => ___ClientOptions, "options", "storeMethodsMetadata", 'P"w!2"n#2$"/%'];
+function restoreAllDependencies(options) {
+  const deps = {}, pureFnDeps = {}, pureFnKeyPrefix = `${STORAGE_KEY}:jit-pure-fn:${options.baseURL}:`;
+  for (let i = 0; i < getStorage().length; i++) {
+    const key = getStorage().key(i);
+    if (key?.startsWith(`${STORAGE_KEY}:jit-compiled-fn:${options.baseURL}:`))
+      try {
+        const data = getStorage().getItem(key);
+        if (data) {
+          const parsedData = JSON.parse(data);
+          deps[parsedData.jitFnHash] = parsedData;
+        }
+      } catch (error) {
+        console.warn(`Failed to restore JIT function from key ${key}:`, error);
+      }
+  }
+  for (let i = 0; i < getStorage().length; i++) {
+    const key = getStorage().key(i);
+    if (key?.startsWith(pureFnKeyPrefix))
+      try {
+        const data = getStorage().getItem(key);
+        if (data) {
+          const parsedData = JSON.parse(data), namespace = key.slice(pureFnKeyPrefix.length).split(":")[0] || parsedData.namespace;
+          pureFnDeps[namespace] || (pureFnDeps[namespace] = {}), pureFnDeps[namespace][parsedData.fnName] = parsedData;
+        }
+      } catch (error) {
+        console.warn(`Failed to restore pure function from key ${key}:`, error);
+      }
+  }
+  (Object.keys(deps).length > 0 || Object.keys(pureFnDeps).length > 0) && addSerializedJitCaches(deps, pureFnDeps);
+}
+restoreAllDependencies.__type = [() => ___ClientOptions, "options", "restoreAllDependencies", 'Pn!2""/#'];
+function restoreFromLocalStorage(methodIds, options) {
+  restoreAllDependencies(options);
+  const methods = {};
+  let anyMethodsRestored = !1;
+  methodIds.forEach(__assignType((id) => {
+    if (routesCache.hasMetadata(id))
+      return;
+    const methodKey = getSerializedMethodDataKey(id, options), methodMetaJson = getStorage().getItem(methodKey);
+    if (methodMetaJson)
+      try {
+        const methodMeta = JSON.parse(methodMetaJson);
+        methods[id] = methodMeta, anyMethodsRestored = !0;
+      } catch (error) {
+        console.warn(`Failed to restore method metadata for ${id}:`, error), getStorage().removeItem(methodKey);
+      }
+  }, ["id", "", 'P"2!"/"'])), anyMethodsRestored && addToCaches({
+    methods,
+    deps: {},
+    purFnDeps: {}
+  });
+}
+restoreFromLocalStorage.__type = ["methodIds", () => ___ClientOptions, "options", "restoreFromLocalStorage", 'P&F2!n"2#"/$'];
+function addToCaches(serializableMethodsData) {
+  addSerializedJitCaches(serializableMethodsData.deps, serializableMethodsData.purFnDeps), addRoutesToCache(serializableMethodsData.methods);
+}
+addToCaches.__type = ["SerializableMethodsData", "serializableMethodsData", "addToCaches", 'P"w!2""/#'];
+function getAOTCaches() {
+  return { jitFnsCache, pureFnsCache };
+}
+getAOTCaches.__type = ["getAOTCaches", 'P"/!'];
+let clientCachesValidated = !1;
+function validateClientCaches() {
+  if (clientCachesValidated || isTestEnv())
+    return;
+  clientCachesValidated = !0;
+  const missingRoutes = Object.values(MION_ROUTES).filter(__assignType((routeId) => !routesCache.hasMetadata(routeId), ["routeId", "", 'P"2!"/"']));
+  if (missingRoutes.length > 0)
+    throw new Error(`AOT cache not loaded: Required MION_ROUTES not found in router cache: ${missingRoutes.join(", ")}. Make sure to import '@mionjs/client/aot' or 'virtual:mion-aot/caches' before using the client.`);
+}
+validateClientCaches.__type = ["validateClientCaches", 'P"/!'];
+export {
+  fetchRemoteMethodsMetadata,
+  getAOTCaches,
+  restoreAllDependencies,
+  storeDependencies,
+  storeMethodsMetadata
+};
+//# sourceMappingURL=clientMethodsMetadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clientMethodsMetadata.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,6 @@
+import { ClientOptions } from './types.ts';
+export declare const DEFAULT_PREFILL_OPTIONS: ClientOptions;
+export declare const MAX_GET_URL_LENGTH = 4096;
+export declare const STORAGE_KEY = "mionkit:client";
+export declare const ROUTES_FLOW_KEY = "mion-routes-flow";
+export declare const ROUTES_FLOW_PATH = "/mion-routes-flow";

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

@@ -0,0 +1,25 @@
+const DEFAULT_PREFILL_OPTIONS = {
+  baseURL: "",
+  fetchOptions: {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" }
+  },
+  /** Prefix for all routes, i.e: api/v1 */
+  basePath: "",
+  /** Suffix for all routes, i.e: .json */
+  suffix: "",
+  /** Enables automatic parameter validation */
+  validateParams: !0,
+  /** Set true to automatically generate and id for every error */
+  autoGenerateErrorId: !1,
+  /** Default serializer mode - stringifyJson as default native serializer */
+  serializer: "stringifyJson"
+}, MAX_GET_URL_LENGTH = 4096, STORAGE_KEY = "mionkit:client", ROUTES_FLOW_KEY = "mion-routes-flow", ROUTES_FLOW_PATH = `/${ROUTES_FLOW_KEY}`;
+export {
+  DEFAULT_PREFILL_OPTIONS,
+  MAX_GET_URL_LENGTH,
+  ROUTES_FLOW_KEY,
+  ROUTES_FLOW_PATH,
+  STORAGE_KEY
+};
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/handlersRegistry.d.ts

@@ -0,0 +1,18 @@
+import { RpcError } from '@mionjs/core';
+import { ErrorHandler, SuccessHandler } from './types';
+export declare class HandlersRegistry {
+    private errorHandlers;
+    private successHandlers;
+    register(handlerId: string, errorType: string, handler: ErrorHandler<any>): void;
+    unregister(handlerId: string, errorType: string): void;
+    hasHandler(handlerId: string, errorType: string): boolean;
+    executeHandler(handlerId: string, error: RpcError<string>): boolean;
+    registerSuccess(handlerId: string, handler: SuccessHandler<any>): void;
+    unregisterSuccess(handlerId: string): void;
+    hasSuccessHandler(handlerId: string): boolean;
+    executeSuccessHandler(handlerId: string, result: any): boolean;
+    clearHandlers(handlerId: string): void;
+    clearAll(): void;
+    getHandlerIds(): string[];
+    getErrorTypes(handlerId: string): string[];
+}

package/.dist/esm/src/handlersRegistry.js

@@ -0,0 +1,70 @@
+class HandlersRegistry {
+  errorHandlers = /* @__PURE__ */ new Map();
+  successHandlers = /* @__PURE__ */ new Map();
+  /** Register an error handler for a specific handler (middleFn) and error type */
+  register(handlerId, errorType, handler) {
+    let handlerMap = this.errorHandlers.get(handlerId);
+    handlerMap || (handlerMap = /* @__PURE__ */ new Map(), this.errorHandlers.set(handlerId, handlerMap)), handlerMap.set(errorType, handler);
+  }
+  /** Unregister an error handler for a specific handler and error type */
+  unregister(handlerId, errorType) {
+    const handlerMap = this.errorHandlers.get(handlerId);
+    handlerMap && (handlerMap.delete(errorType), handlerMap.size === 0 && this.errorHandlers.delete(handlerId));
+  }
+  /** Check if an error handler exists for a specific handler ID and error type */
+  hasHandler(handlerId, errorType) {
+    return this.errorHandlers.get(handlerId)?.has(errorType) ?? !1;
+  }
+  /** Get and execute the handler for an error, if it exists */
+  executeHandler(handlerId, error) {
+    const handlerMap = this.errorHandlers.get(handlerId);
+    if (!handlerMap)
+      return !1;
+    const handler = handlerMap.get(error.type);
+    return handler ? (handler(error), !0) : !1;
+  }
+  /** Register a success handler for a specific middleFn */
+  registerSuccess(handlerId, handler) {
+    this.successHandlers.set(handlerId, handler);
+  }
+  /** Unregister a success handler for a specific middleFn */
+  unregisterSuccess(handlerId) {
+    this.successHandlers.delete(handlerId);
+  }
+  /** Check if a success handler exists for a specific handler ID */
+  hasSuccessHandler(handlerId) {
+    return this.successHandlers.has(handlerId);
+  }
+  /** Get and execute the success handler for a middleFn result, if it exists */
+  executeSuccessHandler(handlerId, result) {
+    const handler = this.successHandlers.get(handlerId);
+    return handler ? (handler(result), !0) : !1;
+  }
+  /** Clear all handlers (both error and success) for a specific handler ID */
+  clearHandlers(handlerId) {
+    this.errorHandlers.delete(handlerId), this.successHandlers.delete(handlerId);
+  }
+  /** Clear all registered handlers (both error and success) */
+  clearAll() {
+    this.errorHandlers.clear(), this.successHandlers.clear();
+  }
+  /** Get all registered handler IDs */
+  getHandlerIds() {
+    const errorIds = Array.from(this.errorHandlers.keys()), successIds = Array.from(this.successHandlers.keys());
+    return [.../* @__PURE__ */ new Set([...errorIds, ...successIds])];
+  }
+  /** Get all error types registered for a handler ID */
+  getErrorTypes(handlerId) {
+    const handlerMap = this.errorHandlers.get(handlerId);
+    return handlerMap ? Array.from(handlerMap.keys()) : [];
+  }
+  static __type = ["ErrorHandler", "errorHandlers", function() {
+    return /* @__PURE__ */ new Map();
+  }, "SuccessHandler", "successHandlers", function() {
+    return /* @__PURE__ */ new Map();
+  }, "handlerId", "errorType", "handler", "register", "unregister", "hasHandler", "RpcError", "error", "executeHandler", "registerSuccess", "unregisterSuccess", "hasSuccessHandler", "result", "executeSuccessHandler", "clearHandlers", "clearAll", "getHandlerIds", "getErrorTypes", "HandlersRegistry", `&&"w!EE3";>#&"w$E3%;>&P&2'&2("w!2)$0*P&2'&2($0+P&2'&2()0,P&2'"w-2.)0/P&2'"w$2)$00P&2'$01P&2')02P&2'"23)04P&2'$05P$06P&F07P&2'&F085w9`];
+}
+export {
+  HandlersRegistry
+};
+//# sourceMappingURL=handlersRegistry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handlersRegistry.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/request.d.ts

@@ -0,0 +1,30 @@
+import { ResponseBody } from '@mionjs/router';
+import { ClientOptions, HSubRequest, SubRequest, RSubRequest, PrefilledMiddleFnsCache } from './types.ts';
+import { RunTypeError } from '@mionjs/core';
+export declare class MionClientRequest<RR extends RSubRequest<any>, MiddleFnRequestsList extends HSubRequest<any>[]> {
+    readonly options: ClientOptions;
+    private readonly prefilledMiddleFnsCache;
+    readonly route?: RR | undefined;
+    readonly middleFns?: MiddleFnRequestsList | undefined;
+    readonly workflowSubRequests?: RSubRequest<any>[] | undefined;
+    readonly path: string;
+    readonly requestId: string;
+    readonly subRequestList: {
+        [key: string]: SubRequest<any>;
+    };
+    response: Response | undefined;
+    constructor(options: ClientOptions, prefilledMiddleFnsCache: PrefilledMiddleFnsCache, route?: RR | undefined, middleFns?: MiddleFnRequestsList | undefined, workflowSubRequests?: RSubRequest<any>[] | undefined);
+    call(): Promise<ResponseBody>;
+    validateParams(subReqList?: SubRequest<any>[]): Promise<RunTypeError[]>;
+    prefill(subReqList?: SubRequest<any>[]): Promise<void>;
+    removePrefill(subRequests?: SubRequest<any>[]): Promise<void>;
+    addSubRequest(subRequest: SubRequest<any>): void;
+    private onError;
+    private getResponseValueFromBodyOrHeader;
+    private restorePrefilledMiddleFns;
+    private restorePrefilledMiddleFnsForWorkflow;
+    private storePrefilledMiddleFns;
+    private removePrefilledMiddleFns;
+    private isQueryRoute;
+    private getPrefilledMiddleFnCacheKey;
+}

package/.dist/esm/src/request.js

@@ -0,0 +1,289 @@
+import { __ΩSubRequest as ___SubRequest, __ΩClientOptions as ___ClientOptions, __ΩPrefilledMiddleFnsCache as ___PrefilledMiddleFnsCache, __ΩRSubRequest as ___RSubRequest, __ΩRequestErrors as ___RequestErrors } from "./types.js";
+import { getRoutePath, toBase64Url, MION_ROUTES, isRpcError, RpcError, routesCache, HandlerType, HeadersSubset } from "@mionjs/core";
+import { fetchRemoteMethodsMetadata } from "./clientMethodsMetadata.js";
+import { validateSubRequests } from "./validation.js";
+import { serializeRequestBody, deserializeResponseBody } from "./serializer.js";
+import { ROUTES_FLOW_KEY, MAX_GET_URL_LENGTH } from "./constants.js";
+const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
+function __assignType(fn, args) {
+  return fn.__type = args, fn;
+}
+class MionClientRequest {
+  options;
+  prefilledMiddleFnsCache;
+  route;
+  middleFns;
+  workflowSubRequests;
+  path;
+  requestId;
+  subRequestList = {};
+  response;
+  constructor(options, prefilledMiddleFnsCache, route, middleFns, workflowSubRequests) {
+    if (this.options = options, this.prefilledMiddleFnsCache = prefilledMiddleFnsCache, this.route = route, this.middleFns = middleFns, this.workflowSubRequests = workflowSubRequests, workflowSubRequests && workflowSubRequests.length > 0) {
+      const routePaths = workflowSubRequests.map(__assignType((sr) => getRoutePath(sr.pointer, this.options), ["sr", "", 'P"2!"/"'])), query = buildRoutesFlowQuery(routePaths, workflowSubRequests), flowPath = getRoutePath([ROUTES_FLOW_KEY], this.options);
+      this.path = `${flowPath}?data=${toBase64Url(JSON.stringify(query))}`, this.requestId = "mion-routes-flow", workflowSubRequests.forEach(__assignType((sr) => this.addSubRequest(sr), ["sr", "", 'P"2!"/"']));
+    } else
+      this.path = route ? getRoutePath(route.pointer, this.options) : "no-route", this.requestId = route ? route.id : "no-route", route && this.addSubRequest(route);
+    middleFns && middleFns.forEach(__assignType((middleFn) => this.addSubRequest(middleFn), ["middleFn", "", 'P"2!"/"']));
+  }
+  /** Calls a remote route */
+  async call() {
+    const errors = /* @__PURE__ */ new Map();
+    try {
+      const subRequestIds = Object.keys(this.subRequestList);
+      if (await fetchRemoteMethodsMetadata(subRequestIds, this.options), this.restorePrefilledMiddleFns(errors), errors.size || (validateSubRequests(subRequestIds, this, errors), errors.size))
+        return Promise.reject(errors);
+    } catch (error) {
+      return this.onError(error, "Error preparing request", errors), Promise.reject(errors);
+    }
+    try {
+      const serialized = serializeRequestBody(this), headersFromParams = extractRequestHeaders(this), url = new URL(this.path, this.options.baseURL);
+      let fetchOptions;
+      if (this.isQueryRoute() && serialized.contentType.includes("json")) {
+        const encoded = toBase64Url(serialized.body), testUrl = new URL(this.path, this.options.baseURL);
+        testUrl.searchParams.set("data", encoded), testUrl.toString().length <= MAX_GET_URL_LENGTH ? (url.searchParams.set("data", encoded), fetchOptions = {
+          ...this.options.fetchOptions,
+          method: "GET",
+          headers: { ...this.options.fetchOptions.headers, ...headersFromParams },
+          body: void 0
+        }) : fetchOptions = {
+          ...this.options.fetchOptions,
+          method: "POST",
+          headers: {
+            ...this.options.fetchOptions.headers,
+            ...headersFromParams,
+            "Content-Type": serialized.contentType
+          },
+          body: serialized.body
+        };
+      } else
+        fetchOptions = {
+          ...this.options.fetchOptions,
+          method: "POST",
+          headers: { ...this.options.fetchOptions.headers, ...headersFromParams, "Content-Type": serialized.contentType },
+          body: serialized.body
+        };
+      this.response = await fetch(url, fetchOptions);
+    } catch (error) {
+      return this.onError(error, "Error executing request", errors), Promise.reject(errors);
+    }
+    try {
+      const deserialized = await deserializeResponseBody(this.response);
+      if (MION_ROUTES.platformError in deserialized) {
+        const platformError = deserialized[MION_ROUTES.platformError];
+        return Object.entries(this.subRequestList).forEach(__assignType(([id, methodMeta]) => {
+          methodMeta.isResolved = !0, methodMeta.error = platformError, errors.set(id, platformError);
+        }, ["param0", "", 'P"2!"/"'])), Promise.reject(errors);
+      }
+      return Object.entries(this.subRequestList).forEach(__assignType(([id, methodMeta]) => {
+        const resp = this.getResponseValueFromBodyOrHeader(id, deserialized, this.response.headers);
+        methodMeta.isResolved = !0, isRpcError(resp) ? (methodMeta.error = resp, errors.set(id, resp)) : methodMeta.resolvedValue = resp;
+      }, ["param0", "", 'P"2!"/"'])), Object.entries(deserialized).forEach(__assignType(([id, value]) => {
+        !(id in this.subRequestList) && isRpcError(value) && errors.set(id, value);
+      }, ["param0", "", 'P"2!"/"'])), errors.size ? Promise.reject(errors) : deserialized;
+    } catch (error) {
+      return this.onError(error, "Error parsing response", errors), Promise.reject(errors);
+    }
+  }
+  /** Validate params */
+  async validateParams(subReqList) {
+    subReqList && subReqList.forEach(__assignType((subRequest) => this.addSubRequest(subRequest), ["subRequest", "", 'P"2!"/"']));
+    const errors = /* @__PURE__ */ new Map();
+    try {
+      const subRequestIds = Object.keys(this.subRequestList);
+      return await fetchRemoteMethodsMetadata(subRequestIds, this.options), validateSubRequests(subRequestIds, this, errors, !1), Object.values(this.subRequestList).map(__assignType((subRequest) => subRequest.error?.errorData || [], ["subRequest", "", 'P"2!"/"'])).flat();
+    } catch (error) {
+      return this.onError(error, "Error preparing request", errors), Promise.reject(errors);
+    }
+  }
+  /** Prefills and stores SubRequest */
+  async prefill(subReqList) {
+    subReqList && subReqList.forEach(__assignType((subRequest) => this.addSubRequest(subRequest), ["subRequest", "", 'P"2!"/"']));
+    const errors = /* @__PURE__ */ new Map();
+    try {
+      const subRequestIds = Object.keys(this.subRequestList);
+      return await fetchRemoteMethodsMetadata(subRequestIds, this.options), validateSubRequests(subRequestIds, this, errors, !1), errors.size || (serializeRequestBody(this), this.storePrefilledMiddleFns(errors), errors.size) ? Promise.reject(errors) : void 0;
+    } catch (error) {
+      return this.onError(error, "Error preparing request", errors), Promise.reject(errors);
+    }
+  }
+  /** Removes Prefills and stores SubRequest */
+  async removePrefill(subRequests) {
+    subRequests && subRequests.forEach(__assignType((subRequest) => this.addSubRequest(subRequest), ["subRequest", "", 'P"2!"/"'])), this.removePrefilledMiddleFns();
+  }
+  addSubRequest(subRequest) {
+    if (subRequest.isResolved)
+      throw new Error(`SubRequest ${subRequest.id} is already resolved`);
+    this.subRequestList[subRequest.id] = subRequest;
+  }
+  onError(error, stageMessage, errors) {
+    if (isRpcError(error)) {
+      errors.set(this.requestId, error);
+      return;
+    }
+    const message = error?.message ? `${stageMessage}: ${error.message}` : `${stageMessage}: Unknown Error`;
+    errors.set(this.requestId, new RpcError({
+      type: error?.name || "unknown-error",
+      publicMessage: message,
+      originalError: error instanceof Error ? error : void 0
+    }));
+  }
+  getResponseValueFromBodyOrHeader(id, respBody, headers) {
+    const headersSubset = reconstructHeadersSubsetFromResponse(id, headers);
+    return headersSubset || respBody[id];
+  }
+  restorePrefilledMiddleFns(errors) {
+    if (this.workflowSubRequests && this.workflowSubRequests.length > 0) {
+      this.restorePrefilledMiddleFnsForWorkflow(errors);
+      return;
+    }
+    const methodMeta = routesCache.getMetadata(this.requestId);
+    if (!methodMeta) {
+      errors.set(this.requestId, new RpcError({
+        type: "route-metadata-not-found",
+        publicMessage: `Metadata for Route '${this.requestId} not found.'.`
+      }));
+      return;
+    }
+    (methodMeta.middleFnIds?.filter(__assignType((id) => !!id && this.requestId !== id, ["id", "", 'P"2!"/"'])) || []).forEach(__assignType((id) => {
+      if (this.subRequestList[id])
+        return;
+      const cacheKey = this.getPrefilledMiddleFnCacheKey(id), cachedSubRequest = this.prefilledMiddleFnsCache.get(cacheKey);
+      if (cachedSubRequest) {
+        const clonedSubRequest = {
+          ...cachedSubRequest,
+          isResolved: !1,
+          resolvedValue: void 0,
+          error: void 0
+        };
+        this.addSubRequest(clonedSubRequest);
+      }
+    }, ["id", "", 'P"2!"/"']));
+  }
+  /** Restore prefilled middleFns for all routes in a routesFlow, deduplicating by ID */
+  restorePrefilledMiddleFnsForWorkflow(errors) {
+    const workflowRouteIds = new Set(this.workflowSubRequests.map(__assignType((sr) => sr.id, ["sr", "", 'P"2!"/"'])));
+    for (const routeSubRequest of this.workflowSubRequests) {
+      const methodMeta = routesCache.getMetadata(routeSubRequest.id);
+      if (!methodMeta) {
+        errors.set(routeSubRequest.id, new RpcError({
+          type: "route-metadata-not-found",
+          publicMessage: `Metadata for Route '${routeSubRequest.id}' not found.`
+        }));
+        continue;
+      }
+      (methodMeta.middleFnIds?.filter(__assignType((id) => !!id && !workflowRouteIds.has(id), ["id", "", 'P"2!"/"'])) || []).forEach(__assignType((id) => {
+        if (this.subRequestList[id])
+          return;
+        const cacheKey = this.getPrefilledMiddleFnCacheKey(id), cachedSubRequest = this.prefilledMiddleFnsCache.get(cacheKey);
+        if (cachedSubRequest) {
+          const clonedSubRequest = {
+            ...cachedSubRequest,
+            isResolved: !1,
+            resolvedValue: void 0,
+            error: void 0
+          };
+          this.addSubRequest(clonedSubRequest);
+        }
+      }, ["id", "", 'P"2!"/"']));
+    }
+  }
+  storePrefilledMiddleFns(errors) {
+    Object.keys(this.subRequestList).forEach(__assignType((id) => {
+      const subRequest = this.subRequestList[id], methodMeta = routesCache.getMetadata(id);
+      if (!methodMeta)
+        throw new Error(`Remote method ${id} not found.`);
+      if (methodMeta.type === HandlerType.route) {
+        errors.set(id, new RpcError({
+          type: "routes-cant-be-prefilled",
+          publicMessage: `Remote method ${id} is a route and can't be prefilled.`
+        }));
+        return;
+      }
+      const cacheKey = this.getPrefilledMiddleFnCacheKey(id);
+      this.prefilledMiddleFnsCache.set(cacheKey, subRequest);
+    }, ["id", "", 'P"2!"/"']));
+  }
+  removePrefilledMiddleFns() {
+    Object.keys(this.subRequestList).forEach(__assignType((id) => {
+      const cacheKey = this.getPrefilledMiddleFnCacheKey(id);
+      this.prefilledMiddleFnsCache.delete(cacheKey);
+    }, ["id", "", 'P"2!"/"']));
+  }
+  /** Returns true if the route is a query (isMutation === false) and not a routesFlow */
+  isQueryRoute() {
+    return this.workflowSubRequests ? !1 : routesCache.getMetadata(this.requestId)?.options?.isMutation === !1;
+  }
+  getPrefilledMiddleFnCacheKey(id) {
+    return `${this.options.baseURL}:${id}`;
+  }
+  static __type = ["RR", "MiddleFnRequestsList", "path", "requestId", () => ___SubRequest, "subRequestList", function() {
+    return {};
+  }, "response", () => ___ClientOptions, "options", () => ___PrefilledMiddleFnsCache, "prefilledMiddleFnsCache", "route", "middleFns", () => ___RSubRequest, "workflowSubRequests", "constructor", "ResponseBody", "call", () => ___SubRequest, "subReqList", "RunTypeError", "validateParams", () => ___SubRequest, "prefill", () => ___SubRequest, "subRequests", "removePrefill", () => ___SubRequest, "subRequest", "addSubRequest", "error", "stageMessage", () => ___RequestErrors, "errors", "onError", "id", "respBody", "headers", "getResponseValueFromBodyOrHeader", () => ___RequestErrors, "restorePrefilledMiddleFns", () => ___RequestErrors, "restorePrefilledMiddleFnsForWorkflow", () => ___RequestErrors, "storePrefilledMiddleFns", "removePrefilledMiddleFns", "isQueryRoute", "getPrefilledMiddleFnCacheKey", "MionClientRequest", 'b!b"&3#9&3$9P&"o%"LM3&9>\'P!-J3(Pn)2*:9n+2,;9e"!2-8:9e""2.8:9"o/"F208:9"01P"w2`03P"o4"F258"w6F`07P"o8"F258$`09P"o:"F2;8$`0<P"o="2>"0?P"2@&2AnB2C$0D;P&2E"w22F!2G"0H;PnI2C$0J;PnK2C$0L;PnM2C$0N;P$0O;P)0P;P&2E&0Q;5wR'];
+}
+function extractRequestHeaders(req) {
+  const headers = {}, subRequestIds = Object.keys(req.subRequestList);
+  for (let i = 0; i < subRequestIds.length; i++) {
+    const id = subRequestIds[i], subRequest = req.subRequestList[id];
+    if (!subRequest)
+      continue;
+    const method = routesCache.getMetadata(id);
+    if (!method || method.type !== HandlerType.headersMiddleFn || !method.headersParam)
+      continue;
+    const params = subRequest.params, extracted = extractHeadersFromParams(params);
+    Object.assign(headers, extracted);
+  }
+  return headers;
+}
+extractRequestHeaders.__type = [() => MionClientRequest, "req", () => __ΩRecord, "extractRequestHeaders", 'PP""7!2"&&o##/$'];
+function extractHeadersFromParams(params) {
+  if (!params || params.length === 0)
+    throw new RpcError({
+      type: "missing-headers-param",
+      publicMessage: "HeadersFn requires a HeadersSubset parameter."
+    });
+  const firstParam = params[0];
+  if (firstParam instanceof HeadersSubset || firstParam && typeof firstParam == "object" && "headers" in firstParam && typeof firstParam.headers == "object")
+    return firstParam.headers;
+  throw new RpcError({
+    type: "invalid-headers-param",
+    publicMessage: "HeadersFn first parameter must be a HeadersSubset instance or object with headers property."
+  });
+}
+extractHeadersFromParams.__type = ["params", () => __ΩRecord, "extractHeadersFromParams", 'P"F2!&&o"#/#'];
+function reconstructHeadersSubsetFromResponse(methodId, responseHeaders) {
+  const method = routesCache.getMetadata(methodId);
+  if (!method?.headersReturn?.headerNames || method.headersReturn.headerNames.length === 0)
+    return;
+  const headerNames = method.headersReturn.headerNames, headersMap = {};
+  for (const name of headerNames) {
+    const value = responseHeaders.get(name);
+    value != null && (headersMap[name] = value);
+  }
+  if (Object.keys(headersMap).length > 0)
+    return new HeadersSubset(headersMap);
+}
+reconstructHeadersSubsetFromResponse.__type = ["methodId", "responseHeaders", () => HeadersSubset, "reconstructHeadersSubsetFromResponse", 'P&2!!2"PP&&7#-J/$'];
+function buildRoutesFlowQuery(routePaths, workflowSubRequests) {
+  const allMappings = [];
+  for (const sr of workflowSubRequests) {
+    const mappings = sr.mappings;
+    if (Array.isArray(mappings) && mappings.length > 0)
+      for (const ref of mappings)
+        allMappings.push({
+          fromId: ref.fromRequestId,
+          toId: ref.toRequestId,
+          bodyHash: ref.bodyHash,
+          paramIndex: ref.paramIndex
+        });
+  }
+  return {
+    routes: routePaths,
+    mappings: allMappings.length > 0 ? allMappings : void 0
+  };
+}
+buildRoutesFlowQuery.__type = ["routePaths", () => ___RSubRequest, "workflowSubRequests", "RoutesFlowQuery", "buildRoutesFlowQuery", 'P&F2!"o""F2#"w$/%'];
+export {
+  MionClientRequest
+};
+//# sourceMappingURL=request.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,6 @@
+import { HSubRequest, RSubRequest, SubRequest, WorkflowResult } from './types.ts';
+import { MapFromServerFnRef } from '@mionjs/core';
+export declare function routesFlow<Routes extends RSubRequest<any>[], MiddleFns extends Record<string, HSubRequest<any>> = Record<string, never>>(routeSubRequests: [...Routes], middleFns?: MiddleFns): Promise<WorkflowResult<Routes, MiddleFns>>;
+export declare const mapFromSymbol: unique symbol;
+export declare function mapFrom<FromSR extends SubRequest<any>, MappedInput>(source: FromSR, mapper: (value: FromSR['resolvedValue']) => MappedInput, bodyHash?: string): MapFromServerFnRef<(value: FromSR['resolvedValue']) => MappedInput>;
+export declare function isMapFromRef(ref: any): ref is MapFromServerFnRef<any>;