@mionjs/router 0.8.10 → 0.13.0

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

@@ -1,191 +1,119 @@
-import { __ΩCallContext as ___CallContext, __ΩResponseBody as ___ResponseBody } from "../types/context.js";
-import { __ΩRouterOptions as ___RouterOptions } from "../types/general.js";
-import { __ΩMayReturnError as ___MayReturnError } from "../types/publicMethods.js";
-import { SerializerModes, deserializeBinaryBody, RpcError, StatusCodes, serializeBinaryBody as serializeBinaryBody$1, MION_ROUTES } from "@mionjs/core";
-import { rawMiddleFn } from "../lib/handlers.js";
-import { getRouteExecutableFromPath, getRouteExecutable } from "../router.js";
-import { __ΩRemoteMethod as ___RemoteMethod } from "../types/remoteMethods.js";
-import { onExecutableError } from "../lib/dispatchError.js";
+import { JSON_CONTENT_TYPE } from "../constants.js";
+import { recordUndeclaredError } from "../lib/dispatchError.js";
+import { rawMiddleware } from "../lib/handlers.js";
+import { getRouteExecutable, getRouterOptions } from "../router.js";
+import { FatalError, MION_ROUTES, SerializerModes, StatusCodes, isRpcError } from "@mionjs/core";
+//#region src/routes/serializer.routes.ts
+/** Runs before any other middleware or route handler. Registered through `rawMiddleware`: it runs before the
+* response contract exists, so it throws rather than answering with a declared error.
+* @mion:rawMiddleware
+*/
 function deserializeRequestBody(context) {
-  if (!context.request.rawBody)
-    return;
-  let parsedBody;
-  switch (context.request.bodyType) {
-    case SerializerModes.stringifyJson:
-      try {
-        parsedBody = JSON.parse(context.request.rawBody);
-      } catch (err) {
-        throw new RpcError({
-          statusCode: StatusCodes.UNEXPECTED_ERROR,
-          type: "parsing-json-request-error",
-          publicMessage: `Invalid json request body: ${err?.message || "unknown parsing error."}`
-        });
-      }
-      break;
-    case SerializerModes.binary: {
-      const rawBody = context.request.rawBody;
-      const { body } = deserializeBinaryBody(context.path, rawBody, false);
-      parsedBody = body;
-      break;
-    }
-    case SerializerModes.json:
-      parsedBody = context.request.rawBody;
-      break;
-    default:
-      throw new Error(`Invalid body type ${context.request.bodyType}`);
-  }
-  if (parsedBody) {
-    if (Array.isArray(parsedBody)) {
-      parsedBody = { [getRouteExecutableFromPath(context.path).id]: parsedBody };
-    }
-    if (typeof parsedBody !== "object")
-      throw new RpcError({
-        statusCode: StatusCodes.UNEXPECTED_ERROR,
-        type: "invalid-request-body",
-        publicMessage: "Wrong request body. Expecting a body containing the route name and parameters."
-      });
-    context.request.body = parsedBody;
-  }
+	if (!context.readsBody || context.response.hasErrors || !context.request.rawBody) return;
+	rejectOversizedBody(context.request.rawBody, context.maxBodySize);
+	let parsedBody;
+	switch (context.request.bodyType) {
+		case SerializerModes.stringifyJson:
+			try {
+				parsedBody = JSON.parse(context.request.rawBody);
+			} catch (err) {
+				throw new FatalError({
+					statusCode: StatusCodes.UNEXPECTED_ERROR,
+					type: "parsing-json-request-error",
+					publicMessage: "Invalid json request body.",
+					originalError: err
+				});
+			}
+			break;
+		case SerializerModes.json:
+			parsedBody = context.request.rawBody;
+			break;
+		default: throw new Error(`Invalid body type ${String(context.request.bodyType)}`);
+	}
+	if (Array.isArray(parsedBody)) {
+		const { methods, routeIndex } = context.executionChain;
+		parsedBody = { [methods[routeIndex].id]: parsedBody };
+	}
+	if (parsedBody === null || typeof parsedBody !== "object") throw new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "invalid-request-body",
+		publicMessage: "Wrong request body. Expecting a body containing the route name and parameters."
+	});
+	context.request.body = parsedBody;
+	if (getRouterOptions().releaseRawBody) context.request.rawBody = "";
 }
-deserializeRequestBody.__type = [() => ___CallContext, "context", () => ___MayReturnError, "deserializeRequestBody", 'Pn!2"n#/$'];
-function serializeResponseBody(context, opts) {
-  const response = context.response;
-  const respBody = response.body;
-  const bodyType = context.response.serializer;
-  const thrownErrors = context.request.thrownErrors;
-  if (thrownErrors)
-    response.body["@thrownErrors"] = thrownErrors;
-  switch (bodyType) {
-    case SerializerModes.stringifyJson: {
-      response.headers.set("content-type", "application/json; charset=utf-8");
-      const body = stringifyBody(context, context.executionChain.methods, respBody);
-      response.rawBody = body;
-      break;
-    }
-    case SerializerModes.json: {
-      response.headers.set("content-type", "application/json; charset=utf-8");
-      prepareBodyForJson(context, context.executionChain.methods, respBody);
-      break;
-    }
-    case SerializerModes.binary: {
-      response.headers.set("content-type", "application/octet-stream");
-      serializeBinaryBody(context, context.executionChain.methods, respBody);
-      break;
-    }
-    default:
-      throw new Error(`Invalid body type ${context.request.bodyType}`);
-  }
-}
-serializeResponseBody.__type = [() => ___CallContext, "context", () => ___RouterOptions, "opts", () => ___MayReturnError, "serializeResponseBody", 'Pn!2"n#2$n%/&'];
-function serializeBinaryBody(context, executionChain, respBody) {
-  const response = context.response;
-  const { serializer, buffer } = serializeBinaryBody$1(context.path, executionChain, respBody, true, context.routesFlowRouteIds);
-  response.binSerializer = serializer;
-  response.rawBody = new Uint8Array(buffer);
-}
-serializeBinaryBody.__type = [() => ___CallContext, "context", () => ___RemoteMethod, "executionChain", () => ___ResponseBody, "respBody", "serializeBinaryBody", `Pn!2"n#F2$n%2&$/'`];
-function stringifyBody(context, executionChain, respBody) {
-  const props = [];
-  for (let i = 0; i < executionChain.length; i++) {
-    const method = executionChain[i];
-    const returnValue = respBody[method.id];
-    if (!method.hasReturnData || typeof returnValue === "undefined")
-      continue;
-    try {
-      const jsonValue = stringifyHandlerReturnValue(method, returnValue);
-      if (!jsonValue)
-        continue;
-      props.push(`${JSON.stringify(method.id)}:${jsonValue}`);
-    } catch (e) {
-      onStringifyExecutableError(context, method, e);
-    }
-  }
-  const thrownErrors = respBody["@thrownErrors"];
-  if (thrownErrors) {
-    const method = getRouteExecutable(MION_ROUTES.thrownErrors);
-    try {
-      const jsonValue = stringifyHandlerReturnValue(method, thrownErrors);
-      if (jsonValue)
-        props.push(`${JSON.stringify(method.id)}:${jsonValue}`);
-    } catch (e) {
-      onStringifyExecutableError(context, method, e);
-    }
-  }
-  return `{${props.join(",")}}`;
+/** The router-level check of the limit the context carries (the chain's number, capped by the platform's).
+*  The node / uws adapters stopped the read at the same number; this is what holds on a platform that hands
+*  the body over whole. A string is measured in UTF-16 code units, never more than its byte length, so the
+*  byte-exact adapter limit always fires first. */
+function rejectOversizedBody(rawBody, maxBodySize) {
+	if (typeof rawBody !== "string" || rawBody.length <= maxBodySize) return;
+	throw new FatalError({
+		statusCode: StatusCodes.PAYLOAD_TOO_LARGE,
+		type: "request-payload-too-large",
+		publicMessage: "Payload Too Large"
+	});
 }
-stringifyBody.__type = [() => ___CallContext, "context", () => ___RemoteMethod, "executionChain", () => ___ResponseBody, "respBody", "stringifyBody", `Pn!2"n#F2$n%2&&/'`];
-function onStringifyExecutableError(context, method, e) {
-  const err = new RpcError({
-    statusCode: StatusCodes.UNEXPECTED_ERROR,
-    type: "json-stringify-response-error",
-    publicMessage: `Failed to stringify return value for handler ${method.id}, expected response type: ${method.returnJitFns.stringifyJson.typeName}`,
-    originalError: e,
-    errorData: { methodId: method.id }
-  });
-  onExecutableError(context, method, err);
+/** Runs after any other middleware or route handler. Registered through `rawMiddleware`: it IS the layer that
+* writes the answer, so it has no declared error to return and throws instead.
+* @mion:rawMiddleware
+*/
+function serializeResponseBody(context, opts) {
+	const response = context.response;
+	const respBody = response.body;
+	response.contentType = JSON_CONTENT_TYPE;
+	prepareBodyForJson(context, context.executionChain.methods, respBody);
 }
-onStringifyExecutableError.__type = [() => ___CallContext, "context", () => ___RemoteMethod, "method", "e", "onStringifyExecutableError", 'Pn!2"n#2$"2%"/&'];
-function stringifyHandlerReturnValue(method, returnValue) {
-  if (!method.hasReturnData)
-    return "";
-  if (method.returnJitFns.prepareForJson.isNoop)
-    JSON.stringify(returnValue);
-  return method.returnJitFns.stringifyJson.fn(returnValue);
+/** A mistyped handler's undeclared error stays raw JSON: the success encoder would mangle it, the client reads its brand. */
+function isUndeclaredError(method, value) {
+	return isRpcError(value) && !method.returnJitFns.isType.fn(value);
 }
-stringifyHandlerReturnValue.__type = [() => ___RemoteMethod, "method", "returnValue", "stringifyHandlerReturnValue", 'Pn!2""2#&/$'];
 function prepareBodyForJson(context, executionChain, respBody) {
-  for (let i = 0; i < executionChain.length; i++) {
-    const method = executionChain[i];
-    const returnValue = respBody[method.id];
-    if (!method.hasReturnData || typeof returnValue === "undefined")
-      continue;
-    try {
-      const preparedValue = prepareHandlerReturnValue(method, returnValue);
-      if (preparedValue !== void 0)
-        respBody[method.id] = preparedValue;
-    } catch (e) {
-      onPrepareForJsonExecutableError(context, method, e);
-    }
-  }
-  const thrownErrors = respBody["@thrownErrors"];
-  if (thrownErrors) {
-    const method = getRouteExecutable(MION_ROUTES.thrownErrors);
-    try {
-      const preparedValue = prepareHandlerReturnValue(method, thrownErrors);
-      if (preparedValue !== void 0)
-        respBody[method.id] = preparedValue;
-    } catch (e) {
-      onPrepareForJsonExecutableError(context, method, e);
-    }
-  }
+	for (let i = 0; i < executionChain.length; i++) {
+		const method = executionChain[i];
+		if (!method.hasReturnData || !Object.hasOwn(respBody, method.id)) continue;
+		const returnValue = respBody[method.id];
+		if (typeof returnValue === "undefined") continue;
+		try {
+			const preparedValue = prepareHandlerReturnValue(method, returnValue);
+			if (preparedValue !== void 0) respBody[method.id] = preparedValue;
+		} catch (e) {
+			onPrepareForJsonExecutableError(context, method, e);
+		}
+	}
+	const thrownErrors = context.request.thrownErrors;
+	if (thrownErrors) {
+		respBody["@thrownErrors"] = thrownErrors;
+		const method = getRouteExecutable(MION_ROUTES.thrownErrors);
+		try {
+			const preparedValue = prepareHandlerReturnValue(method, thrownErrors);
+			if (preparedValue !== void 0) respBody[method.id] = preparedValue;
+		} catch (e) {
+			onPrepareForJsonExecutableError(context, method, e);
+		}
+	}
 }
-prepareBodyForJson.__type = [() => ___CallContext, "context", () => ___RemoteMethod, "executionChain", () => ___ResponseBody, "respBody", "prepareBodyForJson", `Pn!2"n#F2$n%2&$/'`];
 function onPrepareForJsonExecutableError(context, method, e) {
-  const err = new RpcError({
-    statusCode: StatusCodes.UNEXPECTED_ERROR,
-    type: "prepare-for-json-response-error",
-    publicMessage: `Failed to prepare return value for JSON for handler ${method.id}, expected response type: ${method.returnJitFns.prepareForJson.typeName}`,
-    originalError: e,
-    errorData: { methodId: method.id }
-  });
-  onExecutableError(context, method, err);
+	const err = new FatalError({
+		statusCode: StatusCodes.UNEXPECTED_ERROR,
+		type: "prepare-for-json-response-error",
+		publicMessage: `Failed to prepare return value for JSON for handler ${method.id}, expected response type: ${method.returnJitFns.json.encode.typeName}`,
+		originalError: e,
+		errorData: { methodId: method.id }
+	});
+	recordUndeclaredError(context, method.id, err);
 }
-onPrepareForJsonExecutableError.__type = [() => ___CallContext, "context", () => ___RemoteMethod, "method", "e", "onPrepareForJsonExecutableError", 'Pn!2"n#2$"2%"/&'];
 function prepareHandlerReturnValue(method, returnValue) {
-  if (!method.hasReturnData)
-    return void 0;
-  if (method.returnJitFns.prepareForJson.isNoop)
-    return returnValue;
-  return method.returnJitFns.prepareForJson.fn(returnValue);
+	if (!method.hasReturnData) return void 0;
+	const { json } = method.returnJitFns;
+	if (json.encode.isNoop || isUndeclaredError(method, returnValue)) return returnValue;
+	return json.encode.fn(returnValue);
 }
-prepareHandlerReturnValue.__type = [() => ___RemoteMethod, "method", "returnValue", "prepareHandlerReturnValue", 'Pn!2""2#"/$'];
-const serializerMiddleFns = {
-  mionDeserializeRequest: rawMiddleFn(deserializeRequestBody, { runOnError: true }),
-  mionSerializeResponse: rawMiddleFn(serializeResponseBody, { runOnError: true })
-};
-export {
-  deserializeRequestBody,
-  serializeResponseBody,
-  serializerMiddleFns
+var serializerMiddlewares = {
+	mionDeserializeRequest: rawMiddleware(deserializeRequestBody, { alwaysRun: true }),
+	["mionSerializeResponse"]: rawMiddleware(serializeResponseBody, { alwaysRun: true })
 };
-//# sourceMappingURL=serializer.routes.js.map
+//#endregion
+export { deserializeRequestBody, serializeResponseBody, serializerMiddlewares };
+
+//# sourceMappingURL=serializer.routes.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"serializer.routes.js","sources":["../../../../src/routes/serializer.routes.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {MionResponse, MionRequest, CallContext, ResponseBody} from '../types/context.ts';\nimport {RouterOptions} from '../types/general.ts';\nimport {MiddleFnsCollection, MayReturnError} from '../types/publicMethods.ts';\nimport {\n    AnyObject,\n    Mutable,\n    MION_ROUTES,\n    StatusCodes,\n    serializeBinaryBody as coreSerializeBinaryBody,\n    deserializeBinaryBody as coreDeserializeBinaryBody,\n    SerializerModes,\n} from '@mionjs/core';\nimport {rawMiddleFn} from '../lib/handlers.ts';\nimport {getRouteExecutableFromPath, getRouteExecutable} from '../router.ts';\nimport {RpcError} from '@mionjs/core';\nimport {RemoteMethod} from '../types/remoteMethods.ts';\nimport {onExecutableError} from '../lib/dispatchError.ts';\n\n// ############# PUBLIC METHODS #############\n\n/**\n * Deserializes the request body and stores it in the request body property.\n * This method is called before any other middleFn or route handler.\n * For binary requests, the body is parsed lazily per-method in dispatch.ts.\n * @mion:middleFn\n */\nexport function deserializeRequestBody(context: CallContext): MayReturnError {\n    if (!context.request.rawBody) return; // empty body\n    let parsedBody: any;\n    switch (context.request.bodyType) {\n        case SerializerModes.stringifyJson: // jit stringify json\n            try {\n                parsedBody = JSON.parse(context.request.rawBody as string);\n            } catch (err: any) {\n                throw new RpcError({\n                    statusCode: StatusCodes.UNEXPECTED_ERROR,\n                    type: 'parsing-json-request-error',\n                    publicMessage: `Invalid json request body: ${err?.message || 'unknown parsing error.'}`,\n                });\n            }\n            break;\n        case SerializerModes.binary: {\n            // binary\n            const rawBody = context.request.rawBody as Uint8Array;\n            const {body} = coreDeserializeBinaryBody(context.path, rawBody, false);\n            parsedBody = body;\n            break;\n        }\n        case SerializerModes.json: // Object (pre-parsed body from platforms like Google Cloud Functions where Express auto-parses JSON)\n            parsedBody = context.request.rawBody;\n            break;\n        default:\n            throw new Error(`Invalid body type ${context.request.bodyType}`);\n    }\n    if (parsedBody) {\n        if (Array.isArray(parsedBody)) {\n            // when the body is an array we assume it's a single route call and we have to reconstruct the body\n            // http://my-api.com/route1 [p1, p2, p3] => {route1: [p1, p2, p3]}\n            parsedBody = {[getRouteExecutableFromPath(context.path).id]: parsedBody};\n        }\n        if (typeof parsedBody !== 'object')\n            throw new RpcError({\n                statusCode: StatusCodes.UNEXPECTED_ERROR,\n                type: 'invalid-request-body',\n                publicMessage: 'Wrong request body. Expecting a body containing the route name and parameters.',\n            });\n        (context.request as Mutable<MionRequest>).body = parsedBody;\n    }\n}\n\n/**\n * Serializes the response body and stores it in the response rawBody property.\n * This method is called after any other middleFn or route handler.\n * @mion:middleFn\n */\nexport function serializeResponseBody(context: CallContext, opts: RouterOptions): MayReturnError {\n    const response = context.response as Mutable<MionResponse>;\n    const respBody: AnyObject = response.body;\n    const bodyType = context.response.serializer;\n    const thrownErrors = context.request.thrownErrors as Record<string, RpcError<string>> | undefined;\n    // Add thrownErrors to response body before the serializer runs\n    if (thrownErrors) (response.body as Mutable<AnyObject>)['@thrownErrors'] = thrownErrors;\n    switch (bodyType) {\n        case SerializerModes.stringifyJson: {\n            // json - use stringifyJson JIT function\n            response.headers.set('content-type', 'application/json; charset=utf-8');\n            const body = stringifyBody(context, context.executionChain.methods, respBody);\n            response.rawBody = body;\n            break;\n        }\n        case SerializerModes.json: {\n            // pre-serialized object - only prepare for JSON, don't stringify\n            // Platform adapters will handle the actual JSON stringification\n            // prepareForJson mutates response.body in place, so we don't set rawBody\n            response.headers.set('content-type', 'application/json; charset=utf-8');\n            prepareBodyForJson(context, context.executionChain.methods, respBody);\n            break;\n        }\n        case SerializerModes.binary: {\n            // binary - use toBinary JIT function\n            response.headers.set('content-type', 'application/octet-stream');\n            serializeBinaryBody(context, context.executionChain.methods, respBody);\n            break;\n        }\n        default:\n            throw new Error(`Invalid body type ${context.request.bodyType}`);\n    }\n}\n\n/** Serializes response body to binary format using the core serializeBinaryBody function */\nfunction serializeBinaryBody(context: CallContext, executionChain: RemoteMethod[], respBody: ResponseBody): void {\n    const response = context.response as Mutable<MionResponse>;\n    // For routesFlow, use routesFlowRouteIds from context for proper buffer sizing\n    const {serializer, buffer} = coreSerializeBinaryBody(\n        context.path,\n        executionChain,\n        respBody,\n        true,\n        context.routesFlowRouteIds\n    );\n    response.binSerializer = serializer;\n    response.rawBody = new Uint8Array(buffer);\n}\n\nfunction stringifyBody(context: CallContext, executionChain: RemoteMethod[], respBody: ResponseBody): string {\n    const props: string[] = [];\n    for (let i = 0; i < executionChain.length; i++) {\n        const method = executionChain[i];\n        const returnValue = respBody[method.id];\n        if (!method.hasReturnData || typeof returnValue === 'undefined') continue;\n        try {\n            const jsonValue = stringifyHandlerReturnValue(method, returnValue);\n            if (!jsonValue) continue;\n            props.push(`${JSON.stringify(method.id)}:${jsonValue}`);\n        } catch (e: any) {\n            onStringifyExecutableError(context, method, e);\n        }\n    }\n\n    // Serialize thrownErrors if they exist\n    const thrownErrors = respBody['@thrownErrors'];\n    if (thrownErrors) {\n        const method = getRouteExecutable(MION_ROUTES.thrownErrors)!;\n        try {\n            const jsonValue = stringifyHandlerReturnValue(method, thrownErrors);\n            if (jsonValue) props.push(`${JSON.stringify(method.id)}:${jsonValue}`);\n        } catch (e: any) {\n            onStringifyExecutableError(context, method, e);\n        }\n    }\n    return `{${props.join(',')}}`;\n}\n\nfunction onStringifyExecutableError(context: CallContext, method: RemoteMethod, e: any) {\n    const err = new RpcError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'json-stringify-response-error',\n        publicMessage: `Failed to stringify return value for handler ${method.id}, expected response type: ${method.returnJitFns.stringifyJson.typeName}`,\n        originalError: e,\n        errorData: {methodId: method.id},\n    });\n    onExecutableError(context, method, err);\n}\n\nfunction stringifyHandlerReturnValue(method: RemoteMethod, returnValue: any): string {\n    if (!method.hasReturnData) return '';\n    // id data does not require custom encoding then we use native json\n    if (method.returnJitFns.prepareForJson.isNoop) JSON.stringify(returnValue);\n    return method.returnJitFns.stringifyJson.fn(returnValue);\n}\n\nfunction prepareBodyForJson(context: CallContext, executionChain: RemoteMethod[], respBody: ResponseBody): void {\n    // prepareForJson mutates the response body in place\n    for (let i = 0; i < executionChain.length; i++) {\n        const method = executionChain[i];\n        const returnValue = respBody[method.id];\n        if (!method.hasReturnData || typeof returnValue === 'undefined') continue;\n        try {\n            const preparedValue = prepareHandlerReturnValue(method, returnValue);\n            if (preparedValue !== undefined) (respBody as Mutable<ResponseBody>)[method.id] = preparedValue;\n        } catch (e: any) {\n            onPrepareForJsonExecutableError(context, method, e);\n        }\n    }\n    // Prepare thrownErrors if they exist\n    const thrownErrors = respBody['@thrownErrors'];\n    if (thrownErrors) {\n        const method = getRouteExecutable(MION_ROUTES.thrownErrors)!;\n        try {\n            const preparedValue = prepareHandlerReturnValue(method, thrownErrors);\n            if (preparedValue !== undefined) (respBody as Mutable<ResponseBody>)[method.id] = preparedValue;\n        } catch (e: any) {\n            onPrepareForJsonExecutableError(context, method, e);\n        }\n    }\n}\n\nfunction onPrepareForJsonExecutableError(context: CallContext, method: RemoteMethod, e: any) {\n    const err = new RpcError({\n        statusCode: StatusCodes.UNEXPECTED_ERROR,\n        type: 'prepare-for-json-response-error',\n        publicMessage: `Failed to prepare return value for JSON for handler ${method.id}, expected response type: ${method.returnJitFns.prepareForJson.typeName}`,\n        originalError: e,\n        errorData: {methodId: method.id},\n    });\n    onExecutableError(context, method, err);\n}\n\nfunction prepareHandlerReturnValue(method: RemoteMethod, returnValue: any): any {\n    if (!method.hasReturnData) return undefined;\n    if (method.returnJitFns.prepareForJson.isNoop) return returnValue;\n    return method.returnJitFns.prepareForJson.fn(returnValue);\n}\n\nexport const serializerMiddleFns = {\n    mionDeserializeRequest: rawMiddleFn(deserializeRequestBody, {runOnError: true}),\n    mionSerializeResponse: rawMiddleFn(serializeResponseBody, {runOnError: true}),\n} satisfies MiddleFnsCollection;\n"],"names":["coreDeserializeBinaryBody","coreSerializeBinaryBody"],"mappings":"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"}
+{"version":3,"file":"serializer.routes.js","names":[],"sources":["../../../../src/routes/serializer.routes.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {MionResponse, MionRequest, CallContext, ResponseBody, RawRequestBody} from '../types/context.ts';\nimport {RouterOptions} from '../types/general.ts';\nimport {MiddlewaresCollection, MayReturnError} from '../types/publicMethods.ts';\nimport {AnyObject, Mutable, MION_ROUTES, StatusCodes, SerializerModes} from '@mionjs/core';\nimport {rawMiddleware} from '../lib/handlers.ts';\nimport {JSON_CONTENT_TYPE} from '../constants.ts';\nimport {getRouteExecutable, getRouterOptions} from '../router.ts';\nimport {FatalError, isRpcError} from '@mionjs/core';\nimport {RemoteMethod} from '../types/remoteMethods.ts';\nimport {recordUndeclaredError} from '../lib/dispatchError.ts';\n\n// ############# PUBLIC METHODS #############\n\n/** Runs before any other middleware or route handler. Registered through `rawMiddleware`: it runs before the\n * response contract exists, so it throws rather than answering with a declared error.\n * @mion:rawMiddleware\n */\nexport function deserializeRequestBody(context: CallContext): MayReturnError {\n  // a request that already failed never parses: a not-found chain has no route to feed and the adapter\n  // skipped the read; a caller that handed a body anyway (aws, gcloud, dispatchRoute) gets the same answer\n  if (!context.readsBody || context.response.hasErrors || !context.request.rawBody) return;\n  rejectOversizedBody(context.request.rawBody, context.maxBodySize);\n  let parsedBody: any;\n  switch (context.request.bodyType) {\n    case SerializerModes.stringifyJson: // jit stringify json\n      try {\n        parsedBody = JSON.parse(context.request.rawBody as string);\n      } catch (err: any) {\n        // Fixed text: the engine's parse message (which quotes the offending input) stays on originalError\n        throw new FatalError({\n          statusCode: StatusCodes.UNEXPECTED_ERROR,\n          type: 'parsing-json-request-error',\n          publicMessage: 'Invalid json request body.',\n          originalError: err,\n        });\n      }\n      break;\n    case SerializerModes.json: // Object (pre-parsed body from platforms like Google Cloud Functions where Express auto-parses JSON)\n      parsedBody = context.request.rawBody;\n      break;\n    default:\n      throw new Error(`Invalid body type ${String(context.request.bodyType)}`);\n  }\n  if (Array.isArray(parsedBody)) {\n    // an array body is a single route call, rebuilt as a body: /route1 [p1, p2] => {route1: [p1, p2]}\n    // the chain already knows which member is the route, so this costs no second router lookup\n    const {methods, routeIndex} = context.executionChain;\n    parsedBody = {[methods[routeIndex].id]: parsedBody};\n  }\n  // `null`, `0`, `false` and `\"\"` are valid JSON documents but not a request body\n  if (parsedBody === null || typeof parsedBody !== 'object')\n    throw new FatalError({\n      statusCode: StatusCodes.UNEXPECTED_ERROR,\n      type: 'invalid-request-body',\n      publicMessage: 'Wrong request body. Expecting a body containing the route name and parameters.',\n    });\n  (context.request as Mutable<MionRequest>).body = parsedBody;\n  // Nothing reads the raw body after this. An empty string rather than undefined, because `rawBody` is a\n  // non-optional public field: it frees the body without making every consumer's read a maybe.\n  if (getRouterOptions().releaseRawBody) (context.request as Mutable<MionRequest>).rawBody = '';\n}\n\n/** The router-level check of the limit the context carries (the chain's number, capped by the platform's).\n *  The node / uws adapters stopped the read at the same number; this is what holds on a platform that hands\n *  the body over whole. A string is measured in UTF-16 code units, never more than its byte length, so the\n *  byte-exact adapter limit always fires first. */\nfunction rejectOversizedBody(rawBody: RawRequestBody, maxBodySize: number): void {\n  // A pre-parsed object body has no wire size here and is never refused for being unmeasurable:\n  // `dispatchRoute`, a batch and a test all pass bodies that never crossed a wire. The adapter handing a\n  // parsed body over still has the wire size, so it owns the check (gcloud measures content-length first).\n  if (typeof rawBody !== 'string' || rawBody.length <= maxBodySize) return;\n  throw new FatalError({\n    statusCode: StatusCodes.PAYLOAD_TOO_LARGE,\n    type: 'request-payload-too-large',\n    publicMessage: 'Payload Too Large',\n  });\n}\n\n/** Runs after any other middleware or route handler. Registered through `rawMiddleware`: it IS the layer that\n * writes the answer, so it has no declared error to return and throws instead.\n * @mion:rawMiddleware\n */\nexport function serializeResponseBody(context: CallContext, opts: RouterOptions): MayReturnError {\n  const response = context.response as Mutable<MionResponse>;\n  const respBody: AnyObject = response.body;\n  // prepareBodyForJson mutates in place; the adapter stringifies the body\n  response.contentType = JSON_CONTENT_TYPE;\n  prepareBodyForJson(context, context.executionChain.methods, respBody);\n}\n\n/** A mistyped handler's undeclared error stays raw JSON: the success encoder would mangle it, the client reads its brand. */\nfunction isUndeclaredError(method: RemoteMethod, value: unknown): boolean {\n  return isRpcError(value) && !method.returnJitFns.isType.fn(value);\n}\n\nfunction prepareBodyForJson(context: CallContext, executionChain: RemoteMethod[], respBody: ResponseBody): void {\n  for (let i = 0; i < executionChain.length; i++) {\n    const method = executionChain[i];\n    // own key only: a skipped member named like `toString` would otherwise encode Object.prototype's function\n    if (!method.hasReturnData || !Object.hasOwn(respBody, method.id)) continue;\n    const returnValue = respBody[method.id];\n    if (typeof returnValue === 'undefined') continue;\n    try {\n      const preparedValue = prepareHandlerReturnValue(method, returnValue);\n      if (preparedValue !== undefined) (respBody as Mutable<ResponseBody>)[method.id] = preparedValue;\n    } catch (e: any) {\n      onPrepareForJsonExecutableError(context, method, e);\n    }\n  }\n  // read off the request after the loop: a failure inside it creates the map when it is the first error\n  const thrownErrors = context.request.thrownErrors;\n  if (thrownErrors) {\n    (respBody as Mutable<ResponseBody>)['@thrownErrors'] = thrownErrors;\n    const method = getRouteExecutable(MION_ROUTES.thrownErrors)!;\n    try {\n      const preparedValue = prepareHandlerReturnValue(method, thrownErrors);\n      if (preparedValue !== undefined) (respBody as Mutable<ResponseBody>)[method.id] = preparedValue;\n    } catch (e: any) {\n      onPrepareForJsonExecutableError(context, method, e);\n    }\n  }\n}\n\nfunction onPrepareForJsonExecutableError(context: CallContext, method: RemoteMethod, e: any) {\n  const err = new FatalError({\n    statusCode: StatusCodes.UNEXPECTED_ERROR,\n    type: 'prepare-for-json-response-error',\n    publicMessage: `Failed to prepare return value for JSON for handler ${method.id}, expected response type: ${method.returnJitFns.json.encode.typeName}`,\n    originalError: e,\n    errorData: {methodId: method.id},\n  });\n  recordUndeclaredError(context, method.id, err);\n}\n\nfunction prepareHandlerReturnValue(method: RemoteMethod, returnValue: any): any {\n  if (!method.hasReturnData) return undefined;\n  const {json} = method.returnJitFns;\n  // an undeclared error is left as it is: the platform's JSON.stringify writes its own fields\n  if (json.encode.isNoop || isUndeclaredError(method, returnValue)) return returnValue;\n  return json.encode.fn(returnValue);\n}\n\nconst SERIALIZE_RESPONSE_ID = 'mionSerializeResponse';\n\nexport const serializerMiddlewares = {\n  mionDeserializeRequest: rawMiddleware(deserializeRequestBody, {alwaysRun: true}),\n  [SERIALIZE_RESPONSE_ID]: rawMiddleware(serializeResponseBody, {alwaysRun: true}),\n} satisfies MiddlewaresCollection;\n"],"mappings":"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"}

package/.dist/esm/src/types/context.d.ts

@@ -1,4 +1,4 @@
-import { AnyObject, DataViewSerializer, SerializerCode, RpcError, RoutesFlowMapping } from '@mionjs/core';
+import { AnyObject, SerializerCode, RpcError } from '@mionjs/core';
 import { MethodsExecutionChain } from './remoteMethods.ts';
 export interface CallContext<ContextData extends Record<string, any> = any> {
     readonly path: string;
@@ -6,11 +6,13 @@ export interface CallContext<ContextData extends Record<string, any> = any> {
     readonly response: MionResponse;
     shared: ContextData;
     readonly executionChain: MethodsExecutionChain;
+    readonly maxBodySize: number;
+    readonly readsBody: boolean;
     readonly urlQuery?: string;
-    readonly routesFlowRouteIds?: string[];
+    readonly batchId?: string;
+    readonly batchRouteIds?: string[];
 }
-export type RawRequestBody = string | ArrayBuffer | Uint8Array | AnyObject;
-export type RawResponseBody = string | ArrayBuffer | Uint8Array | AnyObject;
+export type RawRequestBody = string | AnyObject;
 export interface MionRequest {
     readonly headers: Readonly<Omit<MionHeaders, 'append' | 'set' | 'delete'>>;
     readonly rawBody: RawRequestBody;
@@ -20,12 +22,16 @@ export interface MionRequest {
 }
 export interface MionResponse {
     readonly statusCode: number;
+    readonly contentType: string;
     readonly headers: Readonly<MionHeaders>;
-    readonly rawBody: RawResponseBody;
-    readonly serializer: SerializerCode;
     readonly body: Readonly<ResponseBody>;
     readonly hasErrors: boolean;
-    readonly binSerializer?: DataViewSerializer | undefined;
+    readonly fatalError?: RpcError<string>;
+}
+export type ResponseDefaults = Readonly<Record<string, string>>;
+export interface PooledHeaders extends MionHeaders {
+    readonly unused: boolean;
+    readonly defaults: ResponseDefaults;
 }
 export interface MionHeaders {
     append(name: string, value: string): void;
@@ -41,18 +47,4 @@ export type ContextDataFactory<ContextData extends Record<string, any>> = () =>
 export interface ResponseBody extends Record<string, any> {
     '@thrownErrors'?: Record<string, RpcError<string>>;
 }
-export interface RoutesFlowExecutionResult {
-    executionChain: MethodsExecutionChain;
-    routesFlowRouteIds?: string[];
-    mappings?: RoutesFlowMapping[];
-}
-export declare type __ΩCallContext = any[];
-export declare type __ΩRawRequestBody = any[];
-export declare type __ΩRawResponseBody = any[];
-export declare type __ΩMionRequest = any[];
-export declare type __ΩMionResponse = any[];
-export declare type __ΩMionHeaders = any[];
-export declare type __ΩContextDataFactory = any[];
-export declare type __ΩResponseBody = any[];
-export declare type __ΩRoutesFlowExecutionResult = any[];
 //# sourceMappingURL=context.d.ts.map

package/.dist/esm/src/types/context.js

@@ -1,31 +0,0 @@
-const __ΩReadonly = ["T", "Readonly", 'l+e#!e"!fRb!Pde"!gN#%w"y'];
-const __ΩOmit = ["T", "K", () => __ΩPick, () => __ΩExclude, "Omit", 'b!b"e!!e!!ge!"o$#o##w%y'];
-const __ΩRecord = ["K", "T", "Record", `l'e#"Rb!b"Pde"!N#!w#y`];
-const __ΩIterableIterator = ["T", "TReturn", "TNext", () => __ΩIterator, 0, () => Symbol.iterator, "IterableIterator", `b!"c""c#Pe"!e""e"#o$$Pe#!e#"e##o%$1&Mw'y`];
-const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
-const __ΩExclude = ["T", "U", "Exclude", 'l6!Re$!RPe#!e$"qk#%QRb!b"Pde"!p)w#y'];
-const __ΩIterator = ["T", "TReturn", "TNext", "param0", () => __ΩIteratorResult, "next", "value", () => __ΩIteratorResult, "return", "e", () => __ΩIteratorResult, "throw", "Iterator", `b!"c""c#PPPPGPe%#GJ@2$e#!e#"o%#1&Pe#"2'8e#!e#"o(#1)8P"2*8e#!e#"o+#1,8Mw-y`];
-const __ΩIteratorResult = ["T", "TReturn", () => __ΩIteratorYieldResult, () => __ΩIteratorReturnResult, "IteratorResult", 'b!"c"Pe"!o#"e""o$"Jw%y'];
-const __ΩIteratorYieldResult = ["TYield", false, "done", "value", "IteratorYieldResult", 'b!P."4#8e"!4$Mw%y'];
-const __ΩIteratorReturnResult = ["TReturn", true, "done", "value", "IteratorReturnResult", 'b!P."4#e"!4$Mw%y'];
-const __ΩCallContext = ["ContextData", "path", () => __ΩMionRequest, "request", () => __ΩMionResponse, "response", "shared", "MethodsExecutionChain", "executionChain", "urlQuery", "routesFlowRouteIds", "CallContext", `"c!P&4"9n#4$9n%4&9e"!4'"w(4)9&4*89&F4+89Mw,y`];
-const __ΩRawRequestBody = ["AnyObject", "RawRequestBody", 'P&_W"w!Jw"y'];
-const __ΩRawResponseBody = ["AnyObject", "RawResponseBody", 'P&_W"w!Jw"y'];
-const __ΩMionRequest = [() => __ΩReadonly, () => __ΩOmit, () => __ΩMionHeaders, "append", "set", "delete", "headers", () => __ΩRawRequestBody, "rawBody", "SerializerCode", "bodyType", () => __ΩReadonly, "AnyObject", "body", () => __ΩReadonly, () => __ΩRecord, "RpcError", "thrownErrors", "MionRequest", `Pn#P.$.%.&Jo"#o!"4'9n(4)9"w*4+9"w-o,"4.9&"w1o0#o/"4289Mw3y`];
-const __ΩMionResponse = ["statusCode", () => __ΩReadonly, () => __ΩMionHeaders, "headers", () => __ΩRawResponseBody, "rawBody", "SerializerCode", "serializer", () => __ΩReadonly, () => __ΩResponseBody, "body", "hasErrors", "DataViewSerializer", "binSerializer", "MionResponse", `P'4!9n#o""4$9n%4&9"w'4(9n*o)"4+9)4,9P"w--J4.89Mw/y`];
-const __ΩMionHeaders = ["name", "value", "append", "delete", "set", "get", "has", () => __ΩIterableIterator, "entries", () => __ΩIterableIterator, "keys", () => __ΩIterableIterator, "values", "MionHeaders", `PP&2!&2"$1#P&2!$1$P&2!&2"$1%P&2!P&-,J1&P&2!)1'PP&&Go("1)P&o*"1+P&o,"1-Mw.y`];
-const __ΩContextDataFactory = ["ContextData", "", "ContextDataFactory", 'b!Pe"!/"w#y'];
-const __ΩResponseBody = [() => __ΩRecord, () => __ΩRecord, "RpcError", "@thrownErrors", "ResponseBody", 'P&"o!#&"w#o"#4$8Mw%y'];
-const __ΩRoutesFlowExecutionResult = ["MethodsExecutionChain", "executionChain", "routesFlowRouteIds", "RoutesFlowMapping", "mappings", "RoutesFlowExecutionResult", 'P"w!4"&F4#8"w$F4%8Mw&y'];
-export {
-  __ΩCallContext,
-  __ΩContextDataFactory,
-  __ΩMionHeaders,
-  __ΩMionRequest,
-  __ΩMionResponse,
-  __ΩRawRequestBody,
-  __ΩRawResponseBody,
-  __ΩResponseBody,
-  __ΩRoutesFlowExecutionResult
-};
-//# sourceMappingURL=context.js.map

package/.dist/esm/src/types/definitions.d.ts

@@ -1,21 +1,33 @@
-import { Handler, HeaderHandler, RawMiddleFnHandler } from './handlers.ts';
-import { HeadersMiddleFnOptions, HeadersMethod, MiddleFnOptions, MiddleFnMethod, RawMiddleFnOptions, RawMethod, RouteOptions, RouteMethod } from './remoteMethods.ts';
-export type RouteDef<H extends Handler = any> = Pick<RouteMethod<H>, 'type' | 'handler'> & {
-    options?: RouteOptions;
-};
-export type MiddleFnDef<H extends Handler = any> = Pick<MiddleFnMethod<H>, 'type' | 'handler'> & {
-    options?: MiddleFnOptions;
-};
-export type HeadersMiddleFnDef<H extends HeaderHandler = any> = Pick<HeadersMethod<H>, 'type' | 'handler'> & {
-    options?: HeadersMiddleFnOptions;
-};
-export type RawMiddleFnDef<H extends RawMiddleFnHandler = any> = Pick<RawMethod<H>, 'type' | 'handler'> & {
-    options?: RawMiddleFnOptions;
-};
-export type AnyHandlerDef = RouteDef | MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;
-export declare type __ΩRouteDef = any[];
-export declare type __ΩMiddleFnDef = any[];
-export declare type __ΩHeadersMiddleFnDef = any[];
-export declare type __ΩRawMiddleFnDef = any[];
-export declare type __ΩAnyHandlerDef = any[];
+import { Handler, HeaderHandler, RawMiddlewareHandler } from './handlers.ts';
+import { HandlerType, RtMarkerPayload } from '@mionjs/core';
+import { HeadersMiddlewareOptions, MiddlewareOptions, RawMiddlewareOptions, RouteOptions } from './remoteMethods.ts';
+import { RouterOptions } from './general.ts';
+export type DeclaredRouterOptions = Partial<RouterOptions>;
+export interface RouteDef<H extends Handler = any, RO extends RouteOptions = RouteOptions, O extends DeclaredRouterOptions = DeclaredRouterOptions> {
+    type: typeof HandlerType.route;
+    handler: H;
+    options?: RO;
+    rtFns?: RtMarkerPayload;
+    readonly routerOptions?: O;
+}
+export interface MiddlewareDef<H extends Handler = any, RO extends MiddlewareOptions = MiddlewareOptions, O extends DeclaredRouterOptions = DeclaredRouterOptions> {
+    type: typeof HandlerType.middleware;
+    handler: H;
+    options?: RO;
+    rtFns?: RtMarkerPayload;
+    readonly routerOptions?: O;
+}
+export interface HeadersMiddlewareDef<H extends HeaderHandler = any, RO extends HeadersMiddlewareOptions = HeadersMiddlewareOptions, O extends DeclaredRouterOptions = DeclaredRouterOptions> {
+    type: typeof HandlerType.headersMiddleware;
+    handler: H;
+    options?: RO;
+    rtFns?: RtMarkerPayload;
+    readonly routerOptions?: O;
+}
+export interface RawMiddlewareDef<H extends RawMiddlewareHandler = any> {
+    type: typeof HandlerType.rawMiddleware;
+    handler: H;
+    options?: RawMiddlewareOptions;
+}
+export type AnyHandlerDef = RouteDef | MiddlewareDef | HeadersMiddlewareDef | RawMiddlewareDef;
 //# sourceMappingURL=definitions.d.ts.map

package/.dist/esm/src/types/definitions.js

@@ -1,15 +0,0 @@
-import { __ΩRouteMethod as ___RouteMethod, __ΩRouteOptions as ___RouteOptions, __ΩMiddleFnMethod as ___MiddleFnMethod, __ΩMiddleFnOptions as ___MiddleFnOptions, __ΩHeadersMethod as ___HeadersMethod, __ΩHeadersMiddleFnOptions as ___HeadersMiddleFnOptions, __ΩRawMethod as ___RawMethod, __ΩRawMiddleFnOptions as ___RawMiddleFnOptions } from "./remoteMethods.js";
-const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
-const __ΩRouteDef = ["H", () => __ΩPick, () => ___RouteMethod, "type", "handler", () => ___RouteOptions, "options", "RouteDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
-const __ΩMiddleFnDef = ["H", () => __ΩPick, () => ___MiddleFnMethod, "type", "handler", () => ___MiddleFnOptions, "options", "MiddleFnDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
-const __ΩHeadersMiddleFnDef = ["H", () => __ΩPick, () => ___HeadersMethod, "type", "handler", () => ___HeadersMiddleFnOptions, "options", "HeadersMiddleFnDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
-const __ΩRawMiddleFnDef = ["H", () => __ΩPick, () => ___RawMethod, "type", "handler", () => ___RawMiddleFnOptions, "options", "RawMiddleFnDef", `"c!Pe"!o#"P.$.%Jo"#Pn&4'8MKw(y`];
-const __ΩAnyHandlerDef = [() => __ΩRouteDef, () => __ΩMiddleFnDef, () => __ΩHeadersMiddleFnDef, () => __ΩRawMiddleFnDef, "AnyHandlerDef", 'Pn!n"n#n$Jw%y'];
-export {
-  __ΩAnyHandlerDef,
-  __ΩHeadersMiddleFnDef,
-  __ΩMiddleFnDef,
-  __ΩRawMiddleFnDef,
-  __ΩRouteDef
-};
-//# sourceMappingURL=definitions.js.map

package/.dist/esm/src/types/general.d.ts

@@ -1,9 +1,8 @@
-import { CoreRouterOptions, SerializerMode } from '@mionjs/core';
+import { CoreRouterOptions, ParserOption } from '@mionjs/core';
 import { ContextDataFactory } from './context.ts';
-import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
-import { RunTypeOptions } from '@mionjs/run-types';
+import { HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef, RouteDef } from './definitions.ts';
 export type Route = RouteDef;
-export type RouterEntry = Routes | MiddleFnDef | RouteDef | RawMiddleFnDef | HeadersMiddleFnDef;
+export type RouterEntry = Routes | MiddlewareDef | RouteDef | RawMiddlewareDef | HeadersMiddlewareDef;
 export interface Routes {
     [key: string]: RouterEntry;
 }
@@ -12,18 +11,19 @@ export interface RouterOptions<Req = any, ContextData extends Record<string, any
     suffix: string;
     pathTransform?: (request: Req, path: string) => string;
     contextDataFactory?: ContextDataFactory<ContextData>;
-    serializer: SerializerMode;
-    runTypeOptions: RunTypeOptions;
-    strictTypes?: boolean;
+    parser?: ParserOption;
+    sanitizeParams?: boolean;
     getPublicRoutesData: boolean;
     autoGenerateErrorId: boolean;
-    skipClientRoutes: boolean;
-    aot: boolean;
-    maxContextPoolSize: number;
-    maxRoutesFlowsCacheSize: number;
+    alwaysAwait: boolean;
+    maxBodySizeFactor: number;
+    releaseRawBody: boolean;
+    responseHeaders: Record<string, string>;
+    apiVersionCheck: boolean;
+    getAllRemoteMethodsMaxNumber: number;
+}
+export interface HostRequestHandler {
+    node?(req: unknown, res: unknown): void;
+    fetch?(req: Request): Response | Promise<Response>;
 }
-export declare type __ΩRoute = any[];
-export declare type __ΩRouterEntry = any[];
-export declare type __ΩRoutes = any[];
-export declare type __ΩRouterOptions = any[];
 //# sourceMappingURL=general.d.ts.map

package/.dist/esm/src/types/general.js

@@ -1,14 +0,0 @@
-import { __ΩCoreRouterOptions as ___CoreRouterOptions, __ΩSerializerMode as ___SerializerMode } from "@mionjs/core";
-import { __ΩContextDataFactory as ___ContextDataFactory } from "./context.js";
-import { __ΩRouteDef as ___RouteDef, __ΩMiddleFnDef as ___MiddleFnDef, __ΩRawMiddleFnDef as ___RawMiddleFnDef, __ΩHeadersMiddleFnDef as ___HeadersMiddleFnDef } from "./definitions.js";
-const __ΩRoute = [() => ___RouteDef, "Route", 'n!w"y'];
-const __ΩRouterEntry = [() => __ΩRoutes, () => ___MiddleFnDef, () => ___RouteDef, () => ___RawMiddleFnDef, () => ___HeadersMiddleFnDef, "RouterEntry", 'Pn!n"n#n$n%Jw&y'];
-const __ΩRoutes = [() => __ΩRouterEntry, "Routes", 'P&n!LMw"y'];
-const __ΩRouterOptions = ["Req", "ContextData", () => ___CoreRouterOptions, "basePath", "suffix", "request", "path", "", "pathTransform", () => ___ContextDataFactory, "contextDataFactory", () => ___SerializerMode, "serializer", "RunTypeOptions", "runTypeOptions", "strictTypes", "getPublicRoutesData", "autoGenerateErrorId", "skipClientRoutes", "aot", "maxContextPoolSize", "maxRoutesFlowsCacheSize", "RouterOptions", `"c!"c"Pn#&4$&4%Pe#!2&&2'&/(4)8e""o*"4+8n,4-"w.4/)408)41)42)43)44'45'46Mw7y`];
-export {
-  __ΩRoute,
-  __ΩRouterEntry,
-  __ΩRouterOptions,
-  __ΩRoutes
-};
-//# sourceMappingURL=general.js.map

package/.dist/esm/src/types/guards.d.ts

@@ -1,18 +1,18 @@
-import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
+import { HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef, RouteDef } from './definitions.ts';
 import { Route, RouterEntry, Routes } from './general.ts';
 import { RawMethod, HeadersMethod, RouteMethod, RemoteMethod } from './remoteMethods.ts';
 export declare function isRouteDef(entry: RouterEntry): entry is RouteDef;
-export declare function isMiddleFnDef(entry: RouterEntry): entry is MiddleFnDef;
-export declare function isRawMiddleFnDef(entry: RouterEntry): entry is RawMiddleFnDef;
-export declare function isHeadersMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef;
-export declare function isAnyMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef | MiddleFnDef | RawMiddleFnDef;
+export declare function isMiddlewareDef(entry: RouterEntry): entry is MiddlewareDef;
+export declare function isRawMiddlewareDef(entry: RouterEntry): entry is RawMiddlewareDef;
+export declare function isHeadersMiddlewareDef(entry: RouterEntry): entry is HeadersMiddlewareDef;
+export declare function isAnyMiddlewareDef(entry: RouterEntry): entry is HeadersMiddlewareDef | MiddlewareDef | RawMiddlewareDef;
 export declare function isRoute(entry: RouterEntry): entry is Route;
-export declare function isRoutes(entry: RouterEntry | Routes): entry is Route;
+export declare function isRoutes(entry: RouterEntry | Routes): entry is Routes;
 export declare function isExecutable(entry: RemoteMethod | {
     pathPointer: string[];
 }): entry is RemoteMethod;
 export declare function isRawExecutable(entry: RemoteMethod): entry is RawMethod;
-export declare function isPublicExecutable(entry: RemoteMethod): entry is RemoteMethod;
+export declare function isPublicExecutable(executable: RemoteMethod): boolean;
 export declare function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod;
 export declare function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod;
 //# sourceMappingURL=guards.d.ts.map