@mionjs/router 0.13.2 → 0.14.0

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

@@ -1,41 +0,0 @@
-import { HostRequestHandler, Route, RouterOptions, RouterEntry } from './types/general.ts';
-import { RemoteMethod, MethodsExecutionChain, RawMethod, HeadersMethod, MiddlewareMethod, RouteMethod } from './types/remoteMethods.ts';
-import { PrivateDef, MiddlewaresCollection } from './types/publicMethods.ts';
-import { HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef } from './types/definitions.ts';
-import { ResponseDefaults } from './types/context.ts';
-import { MionRouter, RouterOptionsInput, RouterOptionsArg } from './types/mionRouter.ts';
-export declare let startMiddlewares: RemoteMethod[];
-export declare let endMiddlewares: RemoteMethod[];
-export declare const getRouteExecutionChain: (path: string) => MethodsExecutionChain | undefined;
-export declare const getNotFoundExecutionChain: (id: string) => MethodsExecutionChain | undefined;
-export declare const getRouteEntries: () => MapIterator<[string, MethodsExecutionChain]>;
-export declare const geRoutesSize: () => number;
-export declare const getRouteExecutable: (id: string) => RouteMethod<any> | undefined;
-export declare const getMiddlewareExecutable: (id: string) => RawMethod<any> | HeadersMethod<any> | MiddlewareMethod<any> | undefined;
-export declare const getMiddlewaresSize: () => number;
-export declare const getComplexity: () => number;
-export declare const getRouterOptions: <Opts extends RouterOptions>() => Readonly<Opts>;
-export declare const getBuildVersion: () => string | undefined;
-export declare const getResponseDefaults: () => ResponseDefaults;
-export declare const getAnyExecutable: (id: string) => RawMethod<any> | HeadersMethod<any> | RouteMethod<any> | MiddlewareMethod<any> | undefined;
-export declare function setPlatformConfig(config: Record<string, unknown>): void;
-export declare const getPlatformConfig: () => Readonly<Record<string, unknown>> | undefined;
-export declare function setHostOwnsSocket(ownsSocket: boolean): void;
-export declare const hostOwnsSocket: () => boolean;
-export declare function handOverToHost(handler: HostRequestHandler): boolean;
-export declare const getHostRequestHandler: () => HostRequestHandler | undefined;
-export declare const resetRouter: () => void;
-export declare function createMionRouter<const O extends RouterOptionsInput = RouterOptionsInput>(opts?: RouterOptionsArg<O>): MionRouter<O>;
-export declare function addStartMiddlewares(middlewaresDef: MiddlewaresCollection, appendBeforeExisting?: boolean): void;
-export declare function addEndMiddlewares(middlewaresDef: MiddlewaresCollection, prependAfterExisting?: boolean): void;
-export declare function isPrivateDefinition(entry: RouterEntry, id: string): entry is PrivateDef;
-export declare function getTotalExecutables(): number;
-export declare function getAllExecutablesIds(): string[];
-export declare function shouldFullGenerateSpec(): boolean;
-export declare function getExecutableFromMiddleware(middleware: MiddlewareDef | HeadersMiddlewareDef, middlewarePointer: string[], nestLevel: number): MiddlewareMethod | HeadersMethod;
-export declare function getExecutableFromRawMiddleware(middleware: RawMiddlewareDef, middlewarePointer: string[], nestLevel: number): RawMethod;
-export declare function getExecutableFromRoute(route: Route, routePointer: string[], nestLevel: number): RouteMethod;
-export declare const getPlatformMaxBodySize: () => number;
-export declare const getPlatformRequestCap: () => number | undefined;
-export declare function getMaxRouteBodySize(): number;
-//# sourceMappingURL=router.d.ts.map

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

@@ -1,84 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src_lib_handlers = require("../lib/handlers.cjs");
-const require_A0Qb_IugtMk3 = require("../../.mion/types/A0Qb_IugtMk3.cjs");
-const require_A0Qb_UM4R4B0 = require("../../.mion/types/A0Qb_UM4R4B0.cjs");
-const require_A0Qb_PGJvDQM = require("../../.mion/types/A0Qb_PGJvDQM.cjs");
-const require_Ky89_IugtMk3 = require("../../.mion/types/Ky89_IugtMk3.cjs");
-const require_Ky89_UM4R4B0 = require("../../.mion/types/Ky89_UM4R4B0.cjs");
-const require_Ky89_PGJvDQM = require("../../.mion/types/Ky89_PGJvDQM.cjs");
-const require_OBOg_IugtMk3 = require("../../.mion/types/OBOg_IugtMk3.cjs");
-const require_OBOg_UM4R4B0 = require("../../.mion/types/OBOg_UM4R4B0.cjs");
-const require_OBOg_PGJvDQM = require("../../.mion/types/OBOg_PGJvDQM.cjs");
-const require_Xhuv_IugtMk3 = require("../../.mion/types/Xhuv_IugtMk3.cjs");
-const require_Xhuv_UM4R4B0 = require("../../.mion/types/Xhuv_UM4R4B0.cjs");
-const require_Xhuv_PGJvDQM = require("../../.mion/types/Xhuv_PGJvDQM.cjs");
-const require_mzca_IugtMk3 = require("../../.mion/types/mzca_IugtMk3.cjs");
-const require_VIdAjpHu1X = require("../../.mion/types/rt/VIdAjpHu1X.cjs");
-let _mionjs_core = require("@mionjs/core");
-//#region src/routes/errors.routes.ts
-var DEFAULT_WIRE = { parser: {
-	params: "clone",
-	return: "clone"
-} };
-var mionErrorsRoutes = {
-	/** Not a real endpoint: reuses the JSON round trip for the "@thrownErrors" body field, and reserves the name. */
-	[_mionjs_core.MION_ROUTES.thrownErrors]: require_src_lib_handlers.route((ctx) => {
-		return ctx.request.thrownErrors || {};
-	}, DEFAULT_WIRE, [
-		require_Xhuv_IugtMk3.__rt_Xhuv_IugtMk3,
-		require_OBOg_IugtMk3.__rt_OBOg_IugtMk3,
-		require_mzca_IugtMk3.__rt_mzca_IugtMk3,
-		require_A0Qb_IugtMk3.__rt_A0Qb_IugtMk3,
-		require_Ky89_IugtMk3.__rt_Ky89_IugtMk3
-	], [
-		require_Xhuv_PGJvDQM.__rt_Xhuv_PGJvDQM,
-		require_OBOg_PGJvDQM.__rt_OBOg_PGJvDQM,
-		require_A0Qb_PGJvDQM.__rt_A0Qb_PGJvDQM,
-		require_Ky89_PGJvDQM.__rt_Ky89_PGJvDQM
-	], require_VIdAjpHu1X.__rt_IugtMk3, require_VIdAjpHu1X.__rt_PGJvDQM, require_VIdAjpHu1X.__rt_uCLmI7s, require_VIdAjpHu1X.__rt_MixeVT4),
-	/** Strongly types the errors an adapter raises rather than a handler: before the router sees the request
-	*  (an HTTP server error, a connection issue), or after the route resolved (a body the adapter refused,
-	*  which then runs the chain's alwaysRun members). Registering it also stops a user route taking the name. */
-	[_mionjs_core.MION_ROUTES.platformError]: require_src_lib_handlers.route((_ctx) => {
-		return new _mionjs_core.RpcError({
-			publicMessage: "Platform error",
-			type: "platform-error"
-		});
-	}, DEFAULT_WIRE, [
-		require_Xhuv_IugtMk3.__rt_Xhuv_IugtMk3,
-		require_OBOg_IugtMk3.__rt_OBOg_IugtMk3,
-		require_mzca_IugtMk3.__rt_mzca_IugtMk3,
-		require_A0Qb_IugtMk3.__rt_A0Qb_IugtMk3,
-		require_Ky89_IugtMk3.__rt_Ky89_IugtMk3
-	], [
-		require_Xhuv_UM4R4B0.__rt_Xhuv_UM4R4B0,
-		require_OBOg_UM4R4B0.__rt_OBOg_UM4R4B0,
-		require_A0Qb_UM4R4B0.__rt_A0Qb_UM4R4B0,
-		require_Ky89_UM4R4B0.__rt_Ky89_UM4R4B0
-	], require_VIdAjpHu1X.__rt_IugtMk3, require_VIdAjpHu1X.__rt_UM4R4B0, require_VIdAjpHu1X.__rt_uCLmI7s, require_VIdAjpHu1X.__rt_bad1FdU)
-};
-/** The first member of each of mion's two not-found chains. It throws, so the dispatcher skips every later
-*  member that does not declare `alwaysRun`: a failed request never reaches a session loader or an auth step.
-*  Raw middlewares rather than routes: nobody declared this request, so there is no params or return contract
-*  to compile, and the error belongs in the undeclared `@thrownErrors` slot. The batch id is the only
-*  untrusted input and it is never echoed. */
-var notFoundMiddleware = require_src_lib_handlers.rawMiddleware(() => {
-	throw new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.NOT_FOUND,
-		publicMessage: `Route not found`,
-		type: "route-not-found"
-	});
-});
-var batchNotFoundMiddleware = require_src_lib_handlers.rawMiddleware(() => {
-	throw new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.NOT_FOUND,
-		type: "batch-unknown-id",
-		publicMessage: "Batch id not registered on this server. Batches are compiled by the build; rebuild the client and the server together."
-	});
-});
-//#endregion
-exports.batchNotFoundMiddleware = batchNotFoundMiddleware;
-exports.mionErrorsRoutes = mionErrorsRoutes;
-exports.notFoundMiddleware = notFoundMiddleware;
-
-//# sourceMappingURL=errors.routes.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"errors.routes.cjs","names":[],"sources":["../../../../src/routes/errors.routes.ts"],"sourcesContent":["/* ########\n * 2023 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport type {Routes} from '../types/general.ts';\nimport type {CallContext} from '../types/context.ts';\nimport {RpcError, FatalError, MION_ROUTES, StatusCodes} from '@mionjs/core';\nimport {route, rawMiddleware} from '../lib/handlers.ts';\n\n// mion's own routes, registered by initRouter for every app. Declared at module level rather than\n// through the router factory: a marker call site inside the generic `createMionRouter` would carry an\n// unresolved type parameter and `initRouter` takes the widened options type, so either way the build\n// compiles them against the built-in default parser. So each one PINS that default: without the\n// pin the runtime resolves the router-wide `parser`, it disagrees with what the build compiled,\n// and the router refuses to start.\nconst DEFAULT_WIRE = {parser: {params: 'clone', return: 'clone'}} as const;\n\nexport const mionErrorsRoutes = {\n  /** Not a real endpoint: reuses the JSON round trip for the \"@thrownErrors\" body field, and reserves the name. */\n  [MION_ROUTES.thrownErrors]: route((ctx: CallContext): Record<string, RpcError<string>> => {\n    return ctx.request.thrownErrors || {};\n  }, DEFAULT_WIRE),\n  /** Strongly types the errors an adapter raises rather than a handler: before the router sees the request\n   *  (an HTTP server error, a connection issue), or after the route resolved (a body the adapter refused,\n   *  which then runs the chain's alwaysRun members). Registering it also stops a user route taking the name. */\n  [MION_ROUTES.platformError]: route((_ctx: CallContext): RpcError<string> => {\n    // The real platform error rides on the context; this value only gives the route its type\n    return new RpcError({\n      publicMessage: 'Platform error',\n      type: 'platform-error',\n    });\n  }, DEFAULT_WIRE),\n} as const satisfies Routes;\n\n/** The first member of each of mion's two not-found chains. It throws, so the dispatcher skips every later\n *  member that does not declare `alwaysRun`: a failed request never reaches a session loader or an auth step.\n *  Raw middlewares rather than routes: nobody declared this request, so there is no params or return contract\n *  to compile, and the error belongs in the undeclared `@thrownErrors` slot. The batch id is the only\n *  untrusted input and it is never echoed. */\nexport const notFoundMiddleware = rawMiddleware((): void => {\n  throw new FatalError({\n    statusCode: StatusCodes.NOT_FOUND,\n    publicMessage: `Route not found`,\n    type: 'route-not-found',\n  });\n});\n\nexport const batchNotFoundMiddleware = rawMiddleware((): void => {\n  throw new FatalError({\n    statusCode: StatusCodes.NOT_FOUND,\n    type: 'batch-unknown-id',\n    publicMessage:\n      'Batch id not registered on this server. Batches are compiled by the build; rebuild the client and the server together.',\n  });\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,IAAM,eAAe,EAAC,QAAQ;CAAC,QAAQ;CAAS,QAAQ;AAAO,EAAC;AAEhE,IAAa,mBAAmB;;EAE7B,aAAA,YAAY,eAAe,yBAAA,OAAO,QAAuD;EACxF,OAAO,IAAI,QAAQ,gBAAgB,CAAC;CACtC,GAAG,cAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;CAAA,GAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;CAAA,GAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,YAAY;;;;EAId,aAAA,YAAY,gBAAgB,yBAAA,OAAO,SAAwC;EAE1E,OAAO,IAAI,aAAA,SAAS;GAClB,eAAe;GACf,MAAM;EACR,CAAC;CACH,GAAG,cAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;CAAA,GAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;EAAA,qBAAA;CAAA,GAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,cAAA,mBAAA,YAAY;AACjB;;;;;;AAOA,IAAa,qBAAqB,yBAAA,oBAA0B;CAC1D,MAAM,IAAI,aAAA,WAAW;EACnB,YAAY,aAAA,YAAY;EACxB,eAAe;EACf,MAAM;CACR,CAAC;AACH,CAAC;AAED,IAAa,0BAA0B,yBAAA,oBAA0B;CAC/D,MAAM,IAAI,aAAA,WAAW;EACnB,YAAY,aAAA,YAAY;EACxB,MAAM;EACN,eACE;CACJ,CAAC;AACH,CAAC"}

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

@@ -1,19 +0,0 @@
-import { CallContext } from '../types/context.ts';
-import { RpcError } from '@mionjs/core';
-export declare const mionErrorsRoutes: {
-    readonly "@thrownErrors": import('../types/definitions.ts').RouteDef<(ctx: CallContext) => Record<string, RpcError<string>>, {
-        readonly parser: {
-            readonly params: "clone";
-            readonly return: "clone";
-        };
-    }, Partial<import('../types/general.ts').RouterOptions<any, any>>>;
-    readonly "mion@platformError": import('../types/definitions.ts').RouteDef<(_ctx: CallContext) => RpcError<string>, {
-        readonly parser: {
-            readonly params: "clone";
-            readonly return: "clone";
-        };
-    }, Partial<import('../types/general.ts').RouterOptions<any, any>>>;
-};
-export declare const notFoundMiddleware: import('../types/definitions.ts').RawMiddlewareDef<() => void>;
-export declare const batchNotFoundMiddleware: import('../types/definitions.ts').RawMiddlewareDef<() => void>;
-//# sourceMappingURL=errors.routes.d.ts.map

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

@@ -1,122 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src_constants = require("../constants.cjs");
-const require_src_lib_dispatchError = require("../lib/dispatchError.cjs");
-const require_src_lib_handlers = require("../lib/handlers.cjs");
-const require_src_router = require("../router.cjs");
-let _mionjs_core = require("@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.readsBody || context.response.hasErrors || !context.request.rawBody) return;
-	rejectOversizedBody(context.request.rawBody, context.maxBodySize);
-	let parsedBody;
-	switch (context.request.bodyType) {
-		case _mionjs_core.SerializerModes.stringifyJson:
-			try {
-				parsedBody = JSON.parse(context.request.rawBody);
-			} catch (err) {
-				throw new _mionjs_core.FatalError({
-					statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
-					type: "parsing-json-request-error",
-					publicMessage: "Invalid json request body.",
-					originalError: err
-				});
-			}
-			break;
-		case _mionjs_core.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 _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
-		type: "invalid-request-body",
-		publicMessage: "Wrong request body. Expecting a body containing the route name and parameters."
-	});
-	context.request.body = parsedBody;
-	if (require_src_router.getRouterOptions().releaseRawBody) context.request.rawBody = "";
-}
-/** 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 _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.PAYLOAD_TOO_LARGE,
-		type: "request-payload-too-large",
-		publicMessage: "Payload Too Large"
-	});
-}
-/** 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 = require_src_constants.JSON_CONTENT_TYPE;
-	prepareBodyForJson(context, context.executionChain.methods, respBody);
-}
-/** 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 (0, _mionjs_core.isRpcError)(value) && !method.returnJitFns.isType.fn(value);
-}
-function prepareBodyForJson(context, executionChain, respBody) {
-	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 = require_src_router.getRouteExecutable(_mionjs_core.MION_ROUTES.thrownErrors);
-		try {
-			const preparedValue = prepareHandlerReturnValue(method, thrownErrors);
-			if (preparedValue !== void 0) respBody[method.id] = preparedValue;
-		} catch (e) {
-			onPrepareForJsonExecutableError(context, method, e);
-		}
-	}
-}
-function onPrepareForJsonExecutableError(context, method, e) {
-	const err = new _mionjs_core.FatalError({
-		statusCode: _mionjs_core.StatusCodes.UNEXPECTED_ERROR,
-		type: "prepare-for-json-response-error",
-		publicMessage: `Failed to prepare return value for JSON for handler ${method.id}, expected response type: ${method.returnJitFns.json.encode.typeName}`,
-		originalError: e,
-		errorData: { methodId: method.id }
-	});
-	require_src_lib_dispatchError.recordUndeclaredError(context, method.id, err);
-}
-function prepareHandlerReturnValue(method, 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);
-}
-var serializerMiddlewares = {
-	mionDeserializeRequest: require_src_lib_handlers.rawMiddleware(deserializeRequestBody, { alwaysRun: true }),
-	["mionSerializeResponse"]: require_src_lib_handlers.rawMiddleware(serializeResponseBody, { alwaysRun: true })
-};
-//#endregion
-exports.deserializeRequestBody = deserializeRequestBody;
-exports.serializeResponseBody = serializeResponseBody;
-exports.serializerMiddlewares = serializerMiddlewares;
-
-//# sourceMappingURL=serializer.routes.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"serializer.routes.cjs","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":";;;;;;;;;;;AAwBA,SAAgB,uBAAuB,SAAsC;CAG3E,IAAI,CAAC,QAAQ,aAAa,QAAQ,SAAS,aAAa,CAAC,QAAQ,QAAQ,SAAS;CAClF,oBAAoB,QAAQ,QAAQ,SAAS,QAAQ,WAAW;CAChE,IAAI;CACJ,QAAQ,QAAQ,QAAQ,UAAxB;EACE,KAAK,aAAA,gBAAgB;GACnB,IAAI;IACF,aAAa,KAAK,MAAM,QAAQ,QAAQ,OAAiB;GAC3D,SAAS,KAAU;IAEjB,MAAM,IAAI,aAAA,WAAW;KACnB,YAAY,aAAA,YAAY;KACxB,MAAM;KACN,eAAe;KACf,eAAe;IACjB,CAAC;GACH;GACA;EACF,KAAK,aAAA,gBAAgB;GACnB,aAAa,QAAQ,QAAQ;GAC7B;EACF,SACE,MAAM,IAAI,MAAM,qBAAqB,OAAO,QAAQ,QAAQ,QAAQ,GAAG;CAC3E;CACA,IAAI,MAAM,QAAQ,UAAU,GAAG;EAG7B,MAAM,EAAC,SAAS,eAAc,QAAQ;EACtC,aAAa,GAAE,QAAQ,YAAY,KAAK,WAAU;CACpD;CAEA,IAAI,eAAe,QAAQ,OAAO,eAAe,UAC/C,MAAM,IAAI,aAAA,WAAW;EACnB,YAAY,aAAA,YAAY;EACxB,MAAM;EACN,eAAe;CACjB,CAAC;CACH,QAAS,QAAiC,OAAO;CAGjD,IAAI,mBAAA,iBAAiB,EAAE,gBAAgB,QAAS,QAAiC,UAAU;AAC7F;;;;;AAMA,SAAS,oBAAoB,SAAyB,aAA2B;CAI/E,IAAI,OAAO,YAAY,YAAY,QAAQ,UAAU,aAAa;CAClE,MAAM,IAAI,aAAA,WAAW;EACnB,YAAY,aAAA,YAAY;EACxB,MAAM;EACN,eAAe;CACjB,CAAC;AACH;;;;;AAMA,SAAgB,sBAAsB,SAAsB,MAAqC;CAC/F,MAAM,WAAW,QAAQ;CACzB,MAAM,WAAsB,SAAS;CAErC,SAAS,cAAc,sBAAA;CACvB,mBAAmB,SAAS,QAAQ,eAAe,SAAS,QAAQ;AACtE;;AAGA,SAAS,kBAAkB,QAAsB,OAAyB;CACxE,QAAA,GAAA,aAAA,YAAkB,KAAK,KAAK,CAAC,OAAO,aAAa,OAAO,GAAG,KAAK;AAClE;AAEA,SAAS,mBAAmB,SAAsB,gBAAgC,UAA8B;CAC9G,KAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;EAC9C,MAAM,SAAS,eAAe;EAE9B,IAAI,CAAC,OAAO,iBAAiB,CAAC,OAAO,OAAO,UAAU,OAAO,EAAE,GAAG;EAClE,MAAM,cAAc,SAAS,OAAO;EACpC,IAAI,OAAO,gBAAgB,aAAa;EACxC,IAAI;GACF,MAAM,gBAAgB,0BAA0B,QAAQ,WAAW;GACnE,IAAI,kBAAkB,KAAA,GAAW,SAAoC,OAAO,MAAM;EACpF,SAAS,GAAQ;GACf,gCAAgC,SAAS,QAAQ,CAAC;EACpD;CACF;CAEA,MAAM,eAAe,QAAQ,QAAQ;CACrC,IAAI,cAAc;EAChB,SAAoC,mBAAmB;EACvD,MAAM,SAAS,mBAAA,mBAAmB,aAAA,YAAY,YAAY;EAC1D,IAAI;GACF,MAAM,gBAAgB,0BAA0B,QAAQ,YAAY;GACpE,IAAI,kBAAkB,KAAA,GAAW,SAAoC,OAAO,MAAM;EACpF,SAAS,GAAQ;GACf,gCAAgC,SAAS,QAAQ,CAAC;EACpD;CACF;AACF;AAEA,SAAS,gCAAgC,SAAsB,QAAsB,GAAQ;CAC3F,MAAM,MAAM,IAAI,aAAA,WAAW;EACzB,YAAY,aAAA,YAAY;EACxB,MAAM;EACN,eAAe,uDAAuD,OAAO,GAAG,4BAA4B,OAAO,aAAa,KAAK,OAAO;EAC5I,eAAe;EACf,WAAW,EAAC,UAAU,OAAO,GAAE;CACjC,CAAC;CACD,8BAAA,sBAAsB,SAAS,OAAO,IAAI,GAAG;AAC/C;AAEA,SAAS,0BAA0B,QAAsB,aAAuB;CAC9E,IAAI,CAAC,OAAO,eAAe,OAAO,KAAA;CAClC,MAAM,EAAC,SAAQ,OAAO;CAEtB,IAAI,KAAK,OAAO,UAAU,kBAAkB,QAAQ,WAAW,GAAG,OAAO;CACzE,OAAO,KAAK,OAAO,GAAG,WAAW;AACnC;AAIA,IAAa,wBAAwB;CACnC,wBAAwB,yBAAA,cAAc,wBAAwB,EAAC,WAAW,KAAI,CAAC;EAC9E,0BAAwB,yBAAA,cAAc,uBAAuB,EAAC,WAAW,KAAI,CAAC;AACjF"}

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

@@ -1,10 +0,0 @@
-import { CallContext } from '../types/context.ts';
-import { RouterOptions } from '../types/general.ts';
-import { MayReturnError } from '../types/publicMethods.ts';
-export declare function deserializeRequestBody(context: CallContext): MayReturnError;
-export declare function serializeResponseBody(context: CallContext, opts: RouterOptions): MayReturnError;
-export declare const serializerMiddlewares: {
-    mionDeserializeRequest: import('../types/definitions.ts').RawMiddlewareDef<typeof deserializeRequestBody>;
-    mionSerializeResponse: import('../types/definitions.ts').RawMiddlewareDef<typeof serializeResponseBody>;
-};
-//# sourceMappingURL=serializer.routes.d.ts.map

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

@@ -1,50 +0,0 @@
-import { AnyObject, SerializerCode, RpcError } from '@mionjs/core';
-import { MethodsExecutionChain } from './remoteMethods.ts';
-export interface CallContext<ContextData extends Record<string, any> = any> {
-    readonly path: string;
-    readonly request: MionRequest;
-    readonly response: MionResponse;
-    shared: ContextData;
-    readonly executionChain: MethodsExecutionChain;
-    readonly maxBodySize: number;
-    readonly readsBody: boolean;
-    readonly urlQuery?: string;
-    readonly batchId?: string;
-    readonly batchRouteIds?: string[];
-}
-export type RawRequestBody = string | AnyObject;
-export interface MionRequest {
-    readonly headers: Readonly<Omit<MionHeaders, 'append' | 'set' | 'delete'>>;
-    readonly rawBody: RawRequestBody;
-    readonly bodyType: SerializerCode;
-    readonly body: Readonly<AnyObject>;
-    readonly thrownErrors?: Readonly<Record<string, RpcError<string>>>;
-}
-export interface MionResponse {
-    readonly statusCode: number;
-    readonly contentType: string;
-    readonly headers: Readonly<MionHeaders>;
-    readonly body: Readonly<ResponseBody>;
-    readonly hasErrors: boolean;
-    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;
-    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>;
-}
-export type ContextDataFactory<ContextData extends Record<string, any>> = () => ContextData;
-export interface ResponseBody extends Record<string, any> {
-    '@thrownErrors'?: Record<string, RpcError<string>>;
-}
-//# sourceMappingURL=context.d.ts.map

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

@@ -1,33 +0,0 @@
-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/cjs/src/types/general.d.ts

@@ -1,29 +0,0 @@
-import { CoreRouterOptions, ParserOption } from '@mionjs/core';
-import { ContextDataFactory } from './context.ts';
-import { HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef, RouteDef } from './definitions.ts';
-export type Route = RouteDef;
-export type RouterEntry = Routes | MiddlewareDef | RouteDef | RawMiddlewareDef | HeadersMiddlewareDef;
-export interface Routes {
-    [key: string]: RouterEntry;
-}
-export interface RouterOptions<Req = any, ContextData extends Record<string, any> = any> extends CoreRouterOptions {
-    basePath: string;
-    suffix: string;
-    pathTransform?: (request: Req, path: string) => string;
-    contextDataFactory?: ContextDataFactory<ContextData>;
-    parser?: ParserOption;
-    sanitizeParams?: boolean;
-    getPublicRoutesData: boolean;
-    autoGenerateErrorId: boolean;
-    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>;
-}
-//# sourceMappingURL=general.d.ts.map

package/.dist/cjs/src/types/guards.cjs

@@ -1,59 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _mionjs_core = require("@mionjs/core");
-//#region src/types/guards.ts
-function isRouteDef(entry) {
-	return entry.type === _mionjs_core.HandlerType.route;
-}
-function isMiddlewareDef(entry) {
-	return entry.type === _mionjs_core.HandlerType.middleware;
-}
-function isRawMiddlewareDef(entry) {
-	return entry.type === _mionjs_core.HandlerType.rawMiddleware;
-}
-function isHeadersMiddlewareDef(entry) {
-	return entry.type === _mionjs_core.HandlerType.headersMiddleware;
-}
-function isAnyMiddlewareDef(entry) {
-	return isMiddlewareDef(entry) || isRawMiddlewareDef(entry) || isHeadersMiddlewareDef(entry);
-}
-function isRoute(entry) {
-	return entry.type === _mionjs_core.HandlerType.route;
-}
-function isRoutes(entry) {
-	return typeof entry === "object";
-}
-function isExecutable(entry) {
-	return typeof entry?.id === "string" && typeof entry.handler === "function";
-}
-function isRawExecutable(entry) {
-	return entry.type === _mionjs_core.HandlerType.rawMiddleware;
-}
-/** What the metadata route exposes: whatever the client must encode or decode. NOT access control. */
-function isPublicExecutable(executable) {
-	if (executable.type === _mionjs_core.HandlerType.rawMiddleware) return false;
-	if (executable.type === _mionjs_core.HandlerType.route) return true;
-	const hasPublicParams = !!executable.paramsCount;
-	const hasHeaderParams = !!executable.headersParam?.headerNames?.length;
-	return hasPublicParams || hasHeaderParams || executable.hasReturnData;
-}
-function isHeaderExecutable(entry) {
-	return entry.type === _mionjs_core.HandlerType.headersMiddleware;
-}
-function isRouteExecutable(entry) {
-	return entry.type === _mionjs_core.HandlerType.route;
-}
-//#endregion
-exports.isAnyMiddlewareDef = isAnyMiddlewareDef;
-exports.isExecutable = isExecutable;
-exports.isHeaderExecutable = isHeaderExecutable;
-exports.isHeadersMiddlewareDef = isHeadersMiddlewareDef;
-exports.isMiddlewareDef = isMiddlewareDef;
-exports.isPublicExecutable = isPublicExecutable;
-exports.isRawExecutable = isRawExecutable;
-exports.isRawMiddlewareDef = isRawMiddlewareDef;
-exports.isRoute = isRoute;
-exports.isRouteDef = isRouteDef;
-exports.isRouteExecutable = isRouteExecutable;
-exports.isRoutes = isRoutes;
-
-//# sourceMappingURL=guards.cjs.map

package/.dist/cjs/src/types/guards.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"guards.cjs","names":[],"sources":["../../../../src/types/guards.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 {HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef, RouteDef} from './definitions.ts';\nimport {Route, RouterEntry, Routes} from './general.ts';\nimport {RawMethod} from './remoteMethods.ts';\nimport {HeadersMethod} from './remoteMethods.ts';\nimport {RouteMethod} from './remoteMethods.ts';\nimport {RemoteMethod} from './remoteMethods.ts';\nimport {HandlerType} from '@mionjs/core';\n\n// #######  type guards #######\n\nexport function isRouteDef(entry: RouterEntry): entry is RouteDef {\n  return entry.type === HandlerType.route;\n}\n\nexport function isMiddlewareDef(entry: RouterEntry): entry is MiddlewareDef {\n  return entry.type === HandlerType.middleware;\n}\n\nexport function isRawMiddlewareDef(entry: RouterEntry): entry is RawMiddlewareDef {\n  return entry.type === HandlerType.rawMiddleware;\n}\n\nexport function isHeadersMiddlewareDef(entry: RouterEntry): entry is HeadersMiddlewareDef {\n  return entry.type === HandlerType.headersMiddleware;\n}\n\nexport function isAnyMiddlewareDef(entry: RouterEntry): entry is HeadersMiddlewareDef | MiddlewareDef | RawMiddlewareDef {\n  return isMiddlewareDef(entry) || isRawMiddlewareDef(entry) || isHeadersMiddlewareDef(entry);\n}\n\nexport function isRoute(entry: RouterEntry): entry is Route {\n  return entry.type === HandlerType.route;\n}\n\nexport function isRoutes(entry: RouterEntry | Routes): entry is Routes {\n  return typeof entry === 'object';\n}\n\nexport function isExecutable(entry: RemoteMethod | {pathPointer: string[]}): entry is RemoteMethod {\n  return typeof (entry as RemoteMethod)?.id === 'string' && typeof (entry as RemoteMethod).handler === 'function';\n}\nexport function isRawExecutable(entry: RemoteMethod): entry is RawMethod {\n  return entry.type === HandlerType.rawMiddleware;\n}\n\n/** What the metadata route exposes: whatever the client must encode or decode. NOT access control. */\nexport function isPublicExecutable(executable: RemoteMethod): boolean {\n  if (executable.type === HandlerType.rawMiddleware) return false;\n  if (executable.type === HandlerType.route) return true;\n  const hasPublicParams = !!executable.paramsCount;\n  const hasHeaderParams = !!(executable as HeadersMethod).headersParam?.headerNames?.length;\n  return hasPublicParams || hasHeaderParams || executable.hasReturnData;\n}\n\nexport function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod {\n  return entry.type === HandlerType.headersMiddleware;\n}\n\nexport function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod {\n  return entry.type === HandlerType.route;\n}\n"],"mappings":";;;AAiBA,SAAgB,WAAW,OAAuC;CAChE,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC;AAEA,SAAgB,gBAAgB,OAA4C;CAC1E,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC;AAEA,SAAgB,mBAAmB,OAA+C;CAChF,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC;AAEA,SAAgB,uBAAuB,OAAmD;CACxF,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC;AAEA,SAAgB,mBAAmB,OAAsF;CACvH,OAAO,gBAAgB,KAAK,KAAK,mBAAmB,KAAK,KAAK,uBAAuB,KAAK;AAC5F;AAEA,SAAgB,QAAQ,OAAoC;CAC1D,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC;AAEA,SAAgB,SAAS,OAA8C;CACrE,OAAO,OAAO,UAAU;AAC1B;AAEA,SAAgB,aAAa,OAAsE;CACjG,OAAO,OAAQ,OAAwB,OAAO,YAAY,OAAQ,MAAuB,YAAY;AACvG;AACA,SAAgB,gBAAgB,OAAyC;CACvE,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC;;AAGA,SAAgB,mBAAmB,YAAmC;CACpE,IAAI,WAAW,SAAS,aAAA,YAAY,eAAe,OAAO;CAC1D,IAAI,WAAW,SAAS,aAAA,YAAY,OAAO,OAAO;CAClD,MAAM,kBAAkB,CAAC,CAAC,WAAW;CACrC,MAAM,kBAAkB,CAAC,CAAE,WAA6B,cAAc,aAAa;CACnF,OAAO,mBAAmB,mBAAmB,WAAW;AAC1D;AAEA,SAAgB,mBAAmB,OAA6C;CAC9E,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC;AAEA,SAAgB,kBAAkB,OAA2C;CAC3E,OAAO,MAAM,SAAS,aAAA,YAAY;AACpC"}

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

@@ -1,18 +0,0 @@
-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 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 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(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

package/.dist/cjs/src/types/handlers.d.ts

@@ -1,16 +0,0 @@
-import { HeadersSubset } from '@mionjs/core';
-import { CallContext } from './context.ts';
-import { RouterOptions } from './general.ts';
-import { MayReturnError } from './publicMethods.ts';
-export type Handler<Context extends CallContext = any, Params extends any[] = any[], Ret = any> = (context: Context, ...parameters: Params) => Ret | Promise<Ret>;
-export type HeaderHandler<Context extends CallContext = any, ExpectedHeaders extends HeadersSubset<any> = any, Params extends any[] = any[], Ret = any> = (context: Context, headers: ExpectedHeaders, ...parameters: Params) => Ret | Promise<Ret>;
-export type RawMiddlewareHandler<Context extends CallContext = any, RawReq = any, RawResp = any, Opts extends RouterOptions<RawReq> = RouterOptions<RawReq>> = (ctx: Context, request: RawReq, response: RawResp, opts: Opts) => MayReturnError;
-export type AnyHandler<Context extends CallContext = any, Params extends any[] = any, Ret = any> = Handler<Context, Params, Ret>;
-export type HandlerParams<H extends AnyHandler> = Parameters<H> extends [any, ...infer P] ? P : [];
-export type HandlerReturn<H extends AnyHandler> = Awaited<ReturnType<H>>;
-export type HandlerIsAsync<H extends AnyHandler> = true extends IsPromiseArm<ReturnType<H>> ? true : false;
-type IsPromiseArm<T> = T extends PromiseLike<any> ? true : false;
-export type HeaderHandlerHeaders<H extends HeaderHandler> = Parameters<H> extends [any, infer HS, ...any[]] ? HS : never;
-export type HeaderHandlerParams<H extends HeaderHandler> = Parameters<H> extends [any, any, ...infer P] ? P : [];
-export {};
-//# sourceMappingURL=handlers.d.ts.map

package/.dist/cjs/src/types/mionRouter.d.ts

@@ -1,44 +0,0 @@
-import { CompTimeArgs, InjectBuildVersion, InjectRunTypeId } from '@mionjs/run-types';
-import { ParserLiteralGuard, HeaderMarkerSlots, MarkerSlots } from './parser.ts';
-import { CallContext, ContextDataFactory } from './context.ts';
-import { RouterOptions, Routes } from './general.ts';
-import { Handler, HandlerParams, HandlerReturn, HandlerIsAsync, HeaderHandler, HeaderHandlerHeaders, HeaderHandlerParams, RawMiddlewareHandler } from './handlers.ts';
-import { HeadersMiddlewareDef, MiddlewareDef, RawMiddlewareDef, RouteDef } from './definitions.ts';
-import { PlainHeadersMiddlewareOptions, PlainMiddlewareOptions, PlainRouteOptions, RawMiddlewareOptions, MiddlewareOptions, HeadersMiddlewareOptions, RouteOptions } from './remoteMethods.ts';
-import { ApiBuildVersion, PublicApi } from './publicMethods.ts';
-export type RouterOptionsInput = Partial<RouterOptions>;
-export type RouterOptionsArg<O extends RouterOptionsInput> = O & ParserLiteralGuard<O>;
-export type ContextDataOf<O extends RouterOptionsInput> = O extends {
-    contextDataFactory: ContextDataFactory<infer ContextData>;
-} ? ContextData : any;
-export type RouterCallContext<O extends RouterOptionsInput> = CallContext<ContextDataOf<O>>;
-type RouteSlots<O, H extends Handler, RO> = MarkerSlots<HandlerParams<H>, HandlerReturn<H>, RO, O>;
-type HeadersRouteSlots<O, H extends HeaderHandler, RO> = MarkerSlots<HeaderHandlerParams<H>, HandlerReturn<H>, RO, O>;
-type HeaderSlots<H extends HeaderHandler> = HeaderMarkerSlots<HeaderHandlerHeaders<H>>;
-export interface RouteHelper<O extends RouterOptionsInput, M extends boolean | undefined = undefined> {
-    <H extends Handler<RouterCallContext<O>>, const RO extends RouteOptions = PlainRouteOptions>(handler: H, opts?: CompTimeArgs<RO>, paramsFns?: RouteSlots<O, H, RO>[0], returnFns?: RouteSlots<O, H, RO>[1], paramsId?: RouteSlots<O, H, RO>[2], returnId?: RouteSlots<O, H, RO>[3], isAsyncId?: InjectRunTypeId<HandlerIsAsync<H>>, syncId?: RouteSlots<O, H, RO>[4]): RouteDef<H, PinnedMutation<RO, M>, O>;
-}
-export type PinnedMutation<RO, M extends boolean | undefined> = M extends boolean ? RO & {
-    isMutation: M;
-} : RO;
-export interface MiddlewareHelper<O extends RouterOptionsInput> {
-    <H extends Handler<RouterCallContext<O>>, const RO extends MiddlewareOptions = PlainMiddlewareOptions>(handler: H, opts?: CompTimeArgs<RO>, paramsFns?: RouteSlots<O, H, RO>[0], returnFns?: RouteSlots<O, H, RO>[1], paramsId?: RouteSlots<O, H, RO>[2], returnId?: RouteSlots<O, H, RO>[3], isAsyncId?: InjectRunTypeId<HandlerIsAsync<H>>, syncId?: RouteSlots<O, H, RO>[4]): MiddlewareDef<H, RO, O>;
-}
-export interface HeadersMiddlewareHelper<O extends RouterOptionsInput> {
-    <H extends HeaderHandler<RouterCallContext<O>>, const RO extends HeadersMiddlewareOptions = PlainHeadersMiddlewareOptions>(handler: H, opts?: CompTimeArgs<RO>, headersFns?: HeaderSlots<H>[0], paramsFns?: HeadersRouteSlots<O, H, RO>[0], returnFns?: HeadersRouteSlots<O, H, RO>[1], headersId?: HeaderSlots<H>[1], paramsId?: HeadersRouteSlots<O, H, RO>[2], returnId?: HeadersRouteSlots<O, H, RO>[3], isAsyncId?: InjectRunTypeId<HandlerIsAsync<H>>, syncId?: HeadersRouteSlots<O, H, RO>[4]): HeadersMiddlewareDef<H, RO, O>;
-}
-export interface RawMiddlewareHelper<O extends RouterOptionsInput> {
-    <H extends RawMiddlewareHandler<RouterCallContext<O>>>(handler: H, opts?: RawMiddlewareOptions): RawMiddlewareDef<H>;
-}
-export interface MionRouter<O extends RouterOptionsInput = RouterOptionsInput> {
-    readonly options: Readonly<O>;
-    readonly route: RouteHelper<O>;
-    readonly query: RouteHelper<O, false>;
-    readonly mutation: RouteHelper<O, true>;
-    readonly middleware: MiddlewareHelper<O>;
-    readonly headersMiddleware: HeadersMiddlewareHelper<O>;
-    readonly rawMiddleware: RawMiddlewareHelper<O>;
-    initRoutes<R extends Routes, const Version extends string = string>(routes: R, buildVersion?: InjectBuildVersion<PublicApi<R>> & Version): PublicApi<R> & ApiBuildVersion<Version>;
-}
-export {};
-//# sourceMappingURL=mionRouter.d.ts.map