@mionjs/router 0.8.6 → 0.8.8

package/src/routesFlow.ts

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

package/src/types/context.ts

@@ -0,0 +1,119 @@
+/* ########
+ * 2023 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {AnyObject, DataViewSerializer, SerializerCode} from '@mionjs/core';
+import type {RpcError} from '@mionjs/core';
+import type {RoutesFlowMapping} from '@mionjs/core';
+import type {MethodsExecutionChain} from './remoteMethods.ts';
+
+// ####### Call Context #######
+
+// type-call-context-start
+/** The call Context object passed as first parameter to any middleFn or route */
+export interface CallContext<ContextData extends Record<string, any> = any> {
+    /** Route's path after internal transformation */
+    readonly path: string;
+    /** Router's own request object */
+    readonly request: MionRequest;
+    /** Router's own response object */
+    readonly response: MionResponse;
+    /** context data between handlers (route/middleFns) and that is not returned in the response. */
+    shared: ContextData;
+    /** The execution chain of the current route */
+    readonly executionChain: MethodsExecutionChain;
+    /** Query string from URL, used for routesFlow routes */
+    readonly urlQuery?: string;
+    /** Route IDs for routesFlow calls, used for binary serialization buffer sizing */
+    readonly routesFlowRouteIds?: string[];
+}
+// type-call-context-end
+
+// ####### REQUEST & RESPONSE #######
+
+export type RawRequestBody = string | ArrayBuffer | Uint8Array | AnyObject;
+/** Response body can be a string, an arrayBuffer, a Uint8Array, or an object (for pre-serialized responses) */
+export type RawResponseBody = string | ArrayBuffer | Uint8Array | AnyObject;
+
+// type-mion-request-start
+/** Router's own request object, do not confuse with the underlying raw request */
+export interface MionRequest {
+    /** parsed headers */
+    readonly headers: Readonly<Omit<MionHeaders, 'append' | 'set' | 'delete'>>;
+    /** Raw request body, can be string for json, arrayBuffer for binary or a javascript object in the case of pre-parsed body */
+    readonly rawBody: RawRequestBody;
+    readonly bodyType: SerializerCode;
+    /** parsed request body */
+    readonly body: Readonly<AnyObject>;
+    /**
+     * Unexpected or thrown errors that are not part of the route/handler return type.
+     * This includes:
+     * - Validation errors (params, headers)
+     * - Deserialization/serialization errors
+     * - Errors thrown by user code (not returned)
+     * - Route not found errors
+     * - Any other errors thrown during execution
+     *
+     * These errors are serialized separately from the route response and sent to the client
+     * in the thrownErrors middleFn response, allowing them to be properly deserialized
+     * without being part of the route's type signature.
+     */
+    readonly thrownErrors?: Readonly<Record<string, RpcError<string>>>;
+}
+// type-mion-request-end
+
+// type-mion-response-start
+/** Router's own response object, do not confuse with the underlying raw response */
+export interface MionResponse {
+    /** response http status code */
+    readonly statusCode: number;
+    /** response headers */
+    readonly headers: Readonly<MionHeaders>;
+    /** Raw response body, can be string for json or an arrayBuffer for binary. */
+    readonly rawBody: RawResponseBody;
+    readonly serializer: SerializerCode;
+    /** the router response data, body should not be modified manually so marked as Read Only */
+    readonly body: Readonly<ResponseBody>;
+    /** response errors: empty if there were no errors during execution */
+    readonly hasErrors: boolean;
+    readonly binSerializer?: DataViewSerializer | undefined;
+}
+// type-mion-response-end
+
+/**
+ * Similar to Fetch API Headers.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Headers
+ * Headers names must be case insensitive.
+ */
+export interface MionHeaders {
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    set(name: string, value: string): void;
+    get(name: string): string | undefined | null;
+    has(name: string): boolean;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+}
+
+/** Function used to create the context data object on each route call  */
+export type ContextDataFactory<ContextData extends Record<string, any>> = () => ContextData;
+
+// type-response-body-start
+/** Response body, a record containing the result of each handler or an error. */
+export interface ResponseBody extends Record<string, any> {
+    '@thrownErrors'?: Record<string, RpcError<string>>;
+}
+// type-response-body-end
+
+/** Result of getRoutesFlowExecutionChain including the route IDs for buffer sizing */
+export interface RoutesFlowExecutionResult {
+    executionChain: MethodsExecutionChain;
+    /** Route IDs for binary serialization buffer sizing */
+    routesFlowRouteIds?: string[];
+    /** Mappings from the routesFlow query, used for mapping route outputs to inputs */
+    mappings?: RoutesFlowMapping[];
+}

package/src/types/definitions.ts

@@ -0,0 +1,53 @@
+/* ########
+ * 2023 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {Handler, HeaderHandler, RawMiddleFnHandler} from './handlers.ts';
+import {
+    HeadersMiddleFnOptions,
+    HeadersMethod,
+    MiddleFnOptions,
+    MiddleFnMethod,
+    RawMiddleFnOptions,
+    RawMethod,
+    RouteOptions,
+    RouteMethod,
+} from './remoteMethods.ts';
+
+// #######  Routes Definitions #######
+
+// type-route-def-start
+/** Route definition */
+export type RouteDef<H extends Handler = any> = Pick<RouteMethod<H>, 'type' | 'handler'> & {
+    options?: RouteOptions;
+};
+// type-route-def-end
+
+// type-middleFn-def-start
+/** MiddleFn definition, a function that middleFns into the ExecutionChain */
+export type MiddleFnDef<H extends Handler = any> = Pick<MiddleFnMethod<H>, 'type' | 'handler'> & {
+    options?: MiddleFnOptions;
+};
+// type-middleFn-def-end
+
+// type-header-middleFn-def-start
+/** Headers MiddleFn definition, used to handle header params */
+export type HeadersMiddleFnDef<H extends HeaderHandler = any> = Pick<HeadersMethod<H>, 'type' | 'handler'> & {
+    options?: HeadersMiddleFnOptions;
+};
+// type-header-middleFn-def-end
+
+// type-raw-middleFn-def-start
+/**
+ * Raw middleFn, used only to access raw request/response and modify the call context.
+ * Can not declare extra parameters.
+ */
+export type RawMiddleFnDef<H extends RawMiddleFnHandler = any> = Pick<RawMethod<H>, 'type' | 'handler'> & {
+    options?: RawMiddleFnOptions;
+};
+// type-raw-middleFn-def-end
+
+export type AnyHandlerDef = RouteDef | MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;

package/src/types/general.ts

@@ -0,0 +1,84 @@
+/* ########
+ * 2023 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {CoreRouterOptions, SerializerMode} from '@mionjs/core';
+import {ContextDataFactory} from './context.ts';
+import {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from './definitions.ts';
+import type {RunTypeOptions} from '@mionjs/run-types';
+// #######  Router Object #######
+
+/** A route can be a full route definition or just the handler */
+export type Route = RouteDef;
+
+/** A route entry can be a route, a middleFn or sub-routes */
+export type RouterEntry = Routes | MiddleFnDef | RouteDef | RawMiddleFnDef | HeadersMiddleFnDef;
+
+/** Data structure to define all the routes, each entry is a route a middleFn or sub-routes */
+export interface Routes {
+    [key: string]: RouterEntry;
+}
+
+// ####### Router Options #######
+
+/** Global Router Options */
+export interface RouterOptions<Req = any, ContextData extends Record<string, any> = any> extends CoreRouterOptions {
+    /** basePath for all routes, i.e: api/v1.
+     * path separator is added between the prefix and the route */
+    basePath: string;
+    /** suffix for all routes, i.e: .json.
+     * Not path separators is added between the route and the suffix */
+    suffix: string;
+    /** Transform the path before finding a route */
+    pathTransform?: (request: Req, path: string) => string;
+    /** factory function to initialize shared call context data */
+    contextDataFactory?: ContextDataFactory<ContextData>;
+    /**
+     * Default serializer mode for response body serialization.
+     * Can be overridden per-route using route options.
+     * - 'json': Use prepareForJson, platform adapter handles JSON.stringify
+     * - 'binary': Use toBinary JIT function for binary serialization
+     * - 'stringifyJson': Use stringifyJson JIT function for optimized JSON serialization
+     * @default 'stringifyJson'
+     */
+    serializer: SerializerMode;
+    /** run type compiler options for middleFns and routes */
+    runTypeOptions: RunTypeOptions;
+    /** When true, isType and typeErrors reject objects with unknown/extra properties. Can be overridden per-route. */
+    strictTypes?: boolean;
+    /** Used to return public data structure when adding routes */
+    getPublicRoutesData: boolean;
+    /** automatically generate and uuid */
+    autoGenerateErrorId: boolean;
+    /** client routes are initialized by default */
+    skipClientRoutes: boolean;
+    /**
+     * Enable AOT (Ahead-of-Time) mode.
+     * When true, router will use pre-compiled JIT functions from cache
+     * and will NOT load @mionjs/run-types package.
+     * Throws error if any route/middleFn is missing from AOT cache.
+     * @default false
+     */
+    aot: boolean;
+    /**
+     * Maximum size of the CallContext pool for reduced memory allocations.
+     * When set to a value > 0, CallContext objects are reused from a pool
+     * instead of creating new ones for each request. This can improve
+     * performance in high-throughput scenarios by reducing GC pressure.
+     * Set to 0 to disable pooling.
+     * @default 0 (disabled)
+     */
+    maxContextPoolSize: number;
+    /**
+     * Maximum size of the routesFlow execution chain cache.
+     * Caches merged execution chains for routesFlow requests to avoid
+     * recalculating them on every request with the same route combination.
+     * Uses FILO (First In, Last Out) eviction when cache is full.
+     * Set to 0 to disable caching.
+     * @default 100
+     */
+    maxRoutesFlowsCacheSize: number;
+}

package/src/types/guards.ts

@@ -0,0 +1,71 @@
+/* ########
+ * 2023 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from './definitions.ts';
+import {Route, RouterEntry, Routes} from './general.ts';
+import {RawMethod} from './remoteMethods.ts';
+import {HeadersMethod} from './remoteMethods.ts';
+import {RouteMethod} from './remoteMethods.ts';
+import {RemoteMethod} from './remoteMethods.ts';
+import {HandlerType} from '@mionjs/core';
+
+// #######  type guards #######
+
+export function isRouteDef(entry: RouterEntry): entry is RouteDef {
+    return entry.type === HandlerType.route;
+}
+
+export function isMiddleFnDef(entry: RouterEntry): entry is MiddleFnDef {
+    return entry.type === HandlerType.middleFn;
+}
+
+export function isRawMiddleFnDef(entry: RouterEntry): entry is RawMiddleFnDef {
+    return entry.type === HandlerType.rawMiddleFn;
+}
+
+export function isHeadersMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef {
+    return entry.type === HandlerType.headersMiddleFn;
+}
+
+export function isAnyMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef | MiddleFnDef | RawMiddleFnDef {
+    return isMiddleFnDef(entry) || isRawMiddleFnDef(entry) || isHeadersMiddleFnDef(entry);
+}
+
+export function isRoute(entry: RouterEntry): entry is Route {
+    return entry.type === HandlerType.route;
+}
+
+export function isRoutes(entry: RouterEntry | Routes): entry is Route {
+    return typeof entry === 'object';
+}
+
+export function isExecutable(entry: RemoteMethod | {pathPointer: string[]}): entry is RemoteMethod {
+    return (
+        typeof (entry as RemoteMethod)?.id === 'string' &&
+        ((entry as any).routes === 'undefined' || typeof (entry as RemoteMethod).handler === 'function')
+    );
+}
+export function isRawExecutable(entry: RemoteMethod): entry is RawMethod {
+    return entry.type === HandlerType.rawMiddleFn;
+}
+
+export function isPublicExecutable(entry: RemoteMethod): entry is RemoteMethod {
+    return (
+        entry.hasReturnData ||
+        entry.type === HandlerType.route ||
+        !!entry.paramNames?.length ||
+        !!(entry as HeadersMethod).headersParam?.headerNames?.length
+    );
+}
+
+export function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod {
+    return entry.type === HandlerType.headersMiddleFn;
+}
+
+export function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod {
+    return entry.type === HandlerType.route;
+}