@mionjs/router 0.8.0-alpha.0

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

@@ -0,0 +1,57 @@
+import { AnyObject, DataViewSerializer, SerializerCode, RpcError, RoutesFlowMapping } 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 urlQuery?: string;
+    readonly routesFlowRouteIds?: string[];
+}
+export type RawRequestBody = string | ArrayBuffer | Uint8Array | AnyObject;
+export type RawResponseBody = string | ArrayBuffer | Uint8Array | 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 headers: Readonly<MionHeaders>;
+    readonly rawBody: RawResponseBody;
+    readonly serializer: SerializerCode;
+    readonly body: Readonly<ResponseBody>;
+    readonly hasErrors: boolean;
+    readonly binSerializer?: DataViewSerializer | undefined;
+}
+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>>;
+}
+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[];

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

@@ -0,0 +1,31 @@
+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/context.js.map

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

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

@@ -0,0 +1,20 @@
+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[];

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

@@ -0,0 +1,15 @@
+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/definitions.js.map

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

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

@@ -0,0 +1,27 @@
+import { CoreRouterOptions, SerializerMode } from '@mionjs/core';
+import { ContextDataFactory } from './context.ts';
+import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
+import { RunTypeOptions } from '@mionjs/run-types';
+export type Route = RouteDef;
+export type RouterEntry = Routes | MiddleFnDef | RouteDef | RawMiddleFnDef | HeadersMiddleFnDef;
+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>;
+    serializer: SerializerMode;
+    runTypeOptions: RunTypeOptions;
+    getPublicRoutesData: boolean;
+    autoGenerateErrorId: boolean;
+    skipClientRoutes: boolean;
+    aot: boolean;
+    maxContextPoolSize: number;
+    maxRoutesFlowsCacheSize: number;
+}
+export declare type __ΩRoute = any[];
+export declare type __ΩRouterEntry = any[];
+export declare type __ΩRoutes = any[];
+export declare type __ΩRouterOptions = any[];

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

@@ -0,0 +1,14 @@
+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", "getPublicRoutesData", "autoGenerateErrorId", "skipClientRoutes", "aot", "maxContextPoolSize", "maxRoutesFlowsCacheSize", "RouterOptions", `"c!"c"Pn#&4$&4%Pe#!2&&2'&/(4)8e""o*"4+8n,4-"w.4/)40)41)42)43'44'45Mw6y`];
+export {
+  __ΩRoute,
+  __ΩRouterEntry,
+  __ΩRouterOptions,
+  __ΩRoutes
+};
+//# sourceMappingURL=general.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, 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 isRoute(entry: RouterEntry): entry is Route;
+export declare function isRoutes(entry: RouterEntry | Routes): entry is Route;
+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 isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod;
+export declare function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod;

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

@@ -0,0 +1,66 @@
+import { __ΩRouterEntry as ___RouterEntry, __ΩRoutes as ___Routes } from "./general.js";
+import { __ΩRemoteMethod as ___RemoteMethod } from "./remoteMethods.js";
+import { HandlerType } from "@mionjs/core";
+function isRouteDef(entry) {
+  return entry.type === HandlerType.route;
+}
+isRouteDef.__type = [() => ___RouterEntry, "entry", "isRouteDef", 'Pn!2"!/#'];
+function isMiddleFnDef(entry) {
+  return entry.type === HandlerType.middleFn;
+}
+isMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isMiddleFnDef", 'Pn!2"!/#'];
+function isRawMiddleFnDef(entry) {
+  return entry.type === HandlerType.rawMiddleFn;
+}
+isRawMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isRawMiddleFnDef", 'Pn!2"!/#'];
+function isHeadersMiddleFnDef(entry) {
+  return entry.type === HandlerType.headersMiddleFn;
+}
+isHeadersMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isHeadersMiddleFnDef", 'Pn!2"!/#'];
+function isAnyMiddleFnDef(entry) {
+  return isMiddleFnDef(entry) || isRawMiddleFnDef(entry) || isHeadersMiddleFnDef(entry);
+}
+isAnyMiddleFnDef.__type = [() => ___RouterEntry, "entry", "isAnyMiddleFnDef", 'Pn!2"!/#'];
+function isRoute(entry) {
+  return entry.type === HandlerType.route;
+}
+isRoute.__type = [() => ___RouterEntry, "entry", "isRoute", 'Pn!2"!/#'];
+function isRoutes(entry) {
+  return typeof entry === "object";
+}
+isRoutes.__type = [() => ___RouterEntry, () => ___Routes, "entry", "isRoutes", 'PPn!n"J2#!/$'];
+function isExecutable(entry) {
+  return typeof entry?.id === "string" && (entry.routes === "undefined" || typeof entry.handler === "function");
+}
+isExecutable.__type = [() => ___RemoteMethod, "pathPointer", "entry", "isExecutable", 'PPn!P&F4"MJ2#!/$'];
+function isRawExecutable(entry) {
+  return entry.type === HandlerType.rawMiddleFn;
+}
+isRawExecutable.__type = [() => ___RemoteMethod, "entry", "isRawExecutable", 'Pn!2"!/#'];
+function isPublicExecutable(entry) {
+  return entry.hasReturnData || entry.type === HandlerType.route || !!entry.paramNames?.length || !!entry.headersParam?.headerNames?.length;
+}
+isPublicExecutable.__type = [() => ___RemoteMethod, "entry", "isPublicExecutable", 'Pn!2"!/#'];
+function isHeaderExecutable(entry) {
+  return entry.type === HandlerType.headersMiddleFn;
+}
+isHeaderExecutable.__type = [() => ___RemoteMethod, "entry", "isHeaderExecutable", 'Pn!2"!/#'];
+function isRouteExecutable(entry) {
+  return entry.type === HandlerType.route;
+}
+isRouteExecutable.__type = [() => ___RemoteMethod, "entry", "isRouteExecutable", 'Pn!2"!/#'];
+export {
+  isAnyMiddleFnDef,
+  isExecutable,
+  isHeaderExecutable,
+  isHeadersMiddleFnDef,
+  isMiddleFnDef,
+  isPublicExecutable,
+  isRawExecutable,
+  isRawMiddleFnDef,
+  isRoute,
+  isRouteDef,
+  isRouteExecutable,
+  isRoutes
+};
+//# sourceMappingURL=guards.js.map

package/.dist/esm/src/types/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","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 {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, 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 isMiddleFnDef(entry: RouterEntry): entry is MiddleFnDef {\n    return entry.type === HandlerType.middleFn;\n}\n\nexport function isRawMiddleFnDef(entry: RouterEntry): entry is RawMiddleFnDef {\n    return entry.type === HandlerType.rawMiddleFn;\n}\n\nexport function isHeadersMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef {\n    return entry.type === HandlerType.headersMiddleFn;\n}\n\nexport function isAnyMiddleFnDef(entry: RouterEntry): entry is HeadersMiddleFnDef | MiddleFnDef | RawMiddleFnDef {\n    return isMiddleFnDef(entry) || isRawMiddleFnDef(entry) || isHeadersMiddleFnDef(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 Route {\n    return typeof entry === 'object';\n}\n\nexport function isExecutable(entry: RemoteMethod | {pathPointer: string[]}): entry is RemoteMethod {\n    return (\n        typeof (entry as RemoteMethod)?.id === 'string' &&\n        ((entry as any).routes === 'undefined' || typeof (entry as RemoteMethod).handler === 'function')\n    );\n}\nexport function isRawExecutable(entry: RemoteMethod): entry is RawMethod {\n    return entry.type === HandlerType.rawMiddleFn;\n}\n\nexport function isPublicExecutable(entry: RemoteMethod): entry is RemoteMethod {\n    return (\n        entry.hasReturnData ||\n        entry.type === HandlerType.route ||\n        !!entry.paramNames?.length ||\n        !!(entry as HeadersMethod).headersParam?.headerNames?.length\n    );\n}\n\nexport function isHeaderExecutable(entry: RemoteMethod): entry is HeadersMethod {\n    return entry.type === HandlerType.headersMiddleFn;\n}\n\nexport function isRouteExecutable(entry: RemoteMethod): entry is RouteMethod {\n    return entry.type === HandlerType.route;\n}\n"],"names":[],"mappings":";;;AAiBM,SAAU,WAAW,OAAkB;AACzC,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,cAAc,OAAkB;AAC5C,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,iBAAiB,OAAkB;AAC/C,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,qBAAqB,OAAkB;AACnD,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,iBAAiB,OAAkB;AAC/C,SAAO,cAAc,KAAK,KAAK,iBAAiB,KAAK,KAAK,qBAAqB,KAAK;AACxF;;AAEM,SAAU,QAAQ,OAAkB;AACtC,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,SAAS,OAA2B;AAChD,SAAO,OAAO,UAAU;AAC5B;;AAEM,SAAU,aAAa,OAA6C;AACtE,SACI,OAAQ,OAAwB,OAAO,aACrC,MAAc,WAAW,eAAe,OAAQ,MAAuB,YAAY;AAE7F;;AACM,SAAU,gBAAgB,OAAmB;AAC/C,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,mBAAmB,OAAmB;AAClD,SACI,MAAM,iBACN,MAAM,SAAS,YAAY,SAC3B,CAAC,CAAC,MAAM,YAAY,UACpB,CAAC,CAAE,MAAwB,cAAc,aAAa;AAE9D;;AAEM,SAAU,mBAAmB,OAAmB;AAClD,SAAO,MAAM,SAAS,YAAY;AACtC;;AAEM,SAAU,kBAAkB,OAAmB;AACjD,SAAO,MAAM,SAAS,YAAY;AACtC;;"}

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

@@ -0,0 +1,12 @@
+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 RawMiddleFnHandler<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 declare type __ΩHandler = any[];
+export declare type __ΩHeaderHandler = any[];
+export declare type __ΩRawMiddleFnHandler = any[];
+export declare type __ΩAnyHandler = any[];

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

@@ -0,0 +1,13 @@
+import { __ΩRouterOptions as ___RouterOptions } from "./general.js";
+import { __ΩMayReturnError as ___MayReturnError } from "./publicMethods.js";
+const __ΩHandler = ["Context", "Params", "Ret", "context", "parameters", "", "Handler", '"c!"Fc""c#Pe"!2$e""@2%Pe##e##`J/&w\'y'];
+const __ΩHeaderHandler = ["Context", "ExpectedHeaders", "Params", "Ret", "context", "headers", "parameters", "", "HeaderHandler", '"c!"c""Fc#"c$Pe"!2%e""2&e"#@2\'Pe#$e#$`J/(w)y'];
+const __ΩRawMiddleFnHandler = ["Context", "RawReq", "RawResp", () => ___RouterOptions, "Opts", "ctx", "request", "response", "opts", () => ___MayReturnError, "", "RawMiddleFnHandler", `"c!"c""c#e!"o$"c%Pe"!2&e""2'e"#2(e"$2)n*/+w,y`];
+const __ΩAnyHandler = ["Context", "Params", "Ret", () => __ΩHandler, "AnyHandler", '"c!"c""c#e!!e!"e!#o$$w%y'];
+export {
+  __ΩAnyHandler,
+  __ΩHandler,
+  __ΩHeaderHandler,
+  __ΩRawMiddleFnHandler
+};
+//# sourceMappingURL=handlers.js.map

package/.dist/esm/src/types/handlers.js.map

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

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

@@ -0,0 +1,45 @@
+import { Prettify, RpcError, MethodMetadata, HandlerType } from '@mionjs/core';
+import { CallContext } from './context.ts';
+import { Routes } from './general.ts';
+import { Handler } from './handlers.ts';
+import { HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef } from './definitions.ts';
+export type MayReturnError = void | RpcError<string> | Promise<RpcError<string> | void>;
+export type MiddleFnsCollection = {
+    [key: string]: MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;
+};
+export interface PrivateMiddleFnDef extends MiddleFnDef {
+    handler: (ctx?: any) => void | never | undefined;
+}
+export type PrivateDef = PrivateMiddleFnDef | RawMiddleFnDef;
+export type PublicApi<Type extends Routes> = Prettify<{
+    [Property in keyof Type as Type[Property] extends PrivateDef ? never : Property]: Type[Property] extends MiddleFnDef ? PublicMiddleFn<PublicHandler<Type[Property]['handler']>> : Type[Property] extends HeadersMiddleFnDef ? PublicHeadersFn<PublicHandler<Type[Property]['handler']>> : Type[Property] extends RouteDef ? PublicRoute<PublicHandler<Type[Property]['handler']>> : Type[Property] extends Routes ? PublicApi<Type[Property]> : never;
+}>;
+export type RemoteApi = {
+    [key: string]: PublicRoute | PublicMiddleFn | PublicHeadersFn | RemoteApi;
+};
+export interface PublicRoute<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.route;
+    middleFnIds: string[];
+    headerNames: undefined;
+    handler: H;
+}
+export interface PublicMiddleFn<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.middleFn;
+    handler: H;
+}
+export interface PublicHeadersFn<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.headersMiddleFn;
+    headerNames: string[];
+    handler: H;
+}
+export type PublicHandler<H extends Handler> = H extends (ctx: CallContext, ...rest: infer Req) => infer Resp ? (...rest: Req) => Promise<Awaited<Resp>> : never;
+export declare type __ΩMayReturnError = any[];
+export declare type __ΩMiddleFnsCollection = any[];
+export declare type __ΩPrivateMiddleFnDef = any[];
+export declare type __ΩPrivateDef = any[];
+export declare type __ΩPublicApi = any[];
+export declare type __ΩRemoteApi = any[];
+export declare type __ΩPublicRoute = any[];
+export declare type __ΩPublicMiddleFn = any[];
+export declare type __ΩPublicHeadersFn = any[];
+export declare type __ΩPublicHandler = any[];

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

@@ -0,0 +1,24 @@
+const __ΩAwaited = ["T", "onfulfilled", "args", "then", "value", "", 0, "Awaited", `lŒe$!Re"!o'"R!RPde#!Ph"!2%h&"@2#"/&qk'.QRPde#!p0Re$!RPdde#!P%PPh$!2"h$"@2#"1$MKqkJRQRPde%!pVRPe#!P,-Jqk#vQRb!Pde"!p~w(y`];
+const __ΩMayReturnError = ["RpcError", "MayReturnError", 'P$"w!P"w!$J`Jw"y'];
+const __ΩMiddleFnsCollection = ["MiddleFnDef", "HeadersMiddleFnDef", "RawMiddleFnDef", "MiddleFnsCollection", 'P&P"w!"w""w#JLMw$y'];
+const __ΩPrivateMiddleFnDef = ["MiddleFnDef", "ctx", "", "handler", "PrivateMiddleFnDef", 'P"w!P"2"8P$!-J/#4$Mw%y'];
+const __ΩPrivateDef = [() => __ΩPrivateMiddleFnDef, "RawMiddleFnDef", "PrivateDef", 'Pn!"w"Jw#y'];
+const __ΩPublicApi = ["Type", "Prettify", "PublicApi", 'b!"w"w#y'];
+const __ΩRemoteApi = [() => __ΩPublicRoute, () => __ΩPublicMiddleFn, () => __ΩPublicHeadersFn, 0, "RemoteApi", 'P&Pn!n"n#n$JLMw%y'];
+const __ΩPublicRoute = ["H", "MethodMetadata", () => HandlerType.route, "type", "middleFnIds", "headerNames", "handler", "PublicRoute", `"c!P"w"i#4$&F4%-4&e"!4'Mw(y`];
+const __ΩPublicMiddleFn = ["H", "MethodMetadata", () => HandlerType.middleFn, "type", "handler", "PublicMiddleFn", '"c!P"w"i#4$e"!4%Mw&y'];
+const __ΩPublicHeadersFn = ["H", "MethodMetadata", () => HandlerType.headersMiddleFn, "type", "headerNames", "handler", "PublicHeadersFn", `"c!P"w"i#4$&F4%e"!4&Mw'y`];
+const __ΩPublicHandler = ["H", "CallContext", "ctx", "rest", "", () => __ΩAwaited, "PublicHandler", 'lSPe#!@2$e#"o&"`/%R!RPdde#!P"w"2#h"!@2$h""/%qk#4QRb!Pde"!p6w\'y'];
+export {
+  __ΩMayReturnError,
+  __ΩMiddleFnsCollection,
+  __ΩPrivateDef,
+  __ΩPrivateMiddleFnDef,
+  __ΩPublicApi,
+  __ΩPublicHandler,
+  __ΩPublicHeadersFn,
+  __ΩPublicMiddleFn,
+  __ΩPublicRoute,
+  __ΩRemoteApi
+};
+//# sourceMappingURL=publicMethods.js.map

package/.dist/esm/src/types/publicMethods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicMethods.js","sources":["../../../../src/types/publicMethods.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 {Prettify, RpcError, MethodMetadata} from '@mionjs/core';\nimport type {CallContext} from './context.ts';\nimport type {Routes} from './general.ts';\nimport type {Handler} from './handlers.ts';\nimport type {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from './definitions.ts';\nimport {HandlerType} from '@mionjs/core'; // do not import type only\n\n// ####### Raw MiddleFns #######\n\nexport type MayReturnError = void | RpcError<string> | Promise<RpcError<string> | void>;\n\nexport type MiddleFnsCollection = {\n    [key: string]: MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;\n};\n\n// ####### Private MiddleFns #######\n\nexport interface PrivateMiddleFnDef extends MiddleFnDef {\n    handler: (ctx?: any) => void | never | undefined;\n}\n\nexport type PrivateDef = PrivateMiddleFnDef | RawMiddleFnDef;\n\n// ####### Remote Methods Metadata #######\n\n/** Data structure containing all public routes & middleFns.\n * is a Ts Mapped type the remove private middleFns and rawMiddleFns\n */\n// prettier-ignore\nexport type PublicApi<Type extends Routes> = Prettify<{\n    [Property in keyof Type as Type[Property] extends PrivateDef ? never : Property]\n    : Type[Property] extends MiddleFnDef\n    ? PublicMiddleFn<PublicHandler<Type[Property]['handler']>>\n    : Type[Property] extends HeadersMiddleFnDef\n    ? PublicHeadersFn<PublicHandler<Type[Property]['handler']>>\n    : Type[Property] extends RouteDef // Routes\n    ? PublicRoute<PublicHandler<Type[Property]['handler']>>\n        : Type[Property] extends Routes // Routes & PureRoutes (recursion)\n        ? PublicApi<Type[Property]>\n        : never;\n}>;\n\n// type-remote-api-start\n/** Same as Public Api but no type mapping, should be easier to use than PublicApi when non strong types are required. */\nexport type RemoteApi = {\n    [key: string]: PublicRoute | PublicMiddleFn | PublicHeadersFn | RemoteApi;\n};\n// type-remote-api-end\n\n/** Public Routes, handler type is the same as RemoteRoute but does not include the context  */\nexport interface PublicRoute<H extends Handler = any> extends MethodMetadata {\n    type: typeof HandlerType.route;\n    middleFnIds: string[];\n    headerNames: undefined;\n    handler: H;\n}\n\n/** Public MiddleFns, handler type is the same as RemoteMiddleFns but does not include the context  */\nexport interface PublicMiddleFn<H extends Handler = any> extends MethodMetadata {\n    type: typeof HandlerType.middleFn;\n    handler: H;\n}\n\n/** Public HeadersFns, handler type is the same as HeadersFns but does not include the context */\nexport interface PublicHeadersFn<H extends Handler = any> extends MethodMetadata {\n    type: typeof HandlerType.headersMiddleFn;\n    headerNames: string[];\n    handler: H;\n}\n\n/** Removes the context from handlers */\n// prettier-ignore\nexport type PublicHandler<H extends Handler> =\n    H extends (ctx: CallContext, ...rest: infer Req) => infer Resp\n    ? (...rest: Req) => Promise<Awaited<Resp>>\n    : never;\n"],"names":[],"mappings":";;;;;;;iEA0D6B,OAAK,QAAA,eAAA,eAAA,WAAA,eAAA,6BAAA;oEAQL,UAAQ,QAAA,WAAA,kBAAA,sBAAA;qEAMR,iBAAe,QAAA,eAAA,WAAA,mBAAA,0BAAA;;"}

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

@@ -0,0 +1,44 @@
+import { HeadersMethodWithJitFns, MethodWithJitFns, RemoteMethodOpts, RouteOnlyOptions, SerializerCode, HandlerType } from '@mionjs/core';
+import { AnyHandler, Handler, HeaderHandler, RawMiddleFnHandler } from './handlers.ts';
+export interface RemoteMethod<H extends AnyHandler = AnyHandler> extends MethodWithJitFns {
+    options: RemoteMethodOpts;
+    handler: H;
+    methodCaller?: (...args: any[]) => any;
+}
+export interface RouteMethod<H extends Handler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.route;
+    options: RouteOnlyOptions;
+}
+export interface MiddleFnMethod<H extends Handler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.middleFn;
+}
+export interface HeadersMethod<H extends HeaderHandler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.headersMiddleFn;
+    headersParam: HeadersMethodWithJitFns;
+}
+export interface RawMethod<H extends RawMiddleFnHandler = any> extends RemoteMethod<H> {
+    type: typeof HandlerType.rawMiddleFn;
+    options: RemoteMethodOpts & {
+        validateParams: false;
+        validateReturn?: false;
+    };
+}
+export type RouteOptions = Partial<Pick<RouteMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'serializer' | 'isMutation'>>;
+export type MiddleFnOptions = Partial<Pick<MiddleFnMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>>;
+export type HeadersMiddleFnOptions = Partial<Pick<HeadersMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>>;
+export type RawMiddleFnOptions = Partial<Pick<RawMethod['options'], 'description' | 'runOnError'>>;
+export interface MethodsExecutionChain {
+    routeIndex: number;
+    methods: RemoteMethod[];
+    serializer: SerializerCode;
+}
+export declare type __ΩRemoteMethod = any[];
+export declare type __ΩRouteMethod = any[];
+export declare type __ΩMiddleFnMethod = any[];
+export declare type __ΩHeadersMethod = any[];
+export declare type __ΩRawMethod = any[];
+export declare type __ΩRouteOptions = any[];
+export declare type __ΩMiddleFnOptions = any[];
+export declare type __ΩHeadersMiddleFnOptions = any[];
+export declare type __ΩRawMiddleFnOptions = any[];
+export declare type __ΩMethodsExecutionChain = any[];

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

@@ -0,0 +1,25 @@
+const __ΩPartial = ["T", "Partial", 'l+e#!e"!fRb!Pde"!gN#"w"y'];
+const __ΩPick = ["T", "K", "Pick", 'l+e#!e"!fRb!b"Pde""N#!w#y'];
+const __ΩRemoteMethod = ["AnyHandler", "H", "MethodWithJitFns", "RemoteMethodOpts", "options", "handler", "args", "", "methodCaller", "RemoteMethod", `"w!c"P"w#"w$4%e"!4&P"@2'"/(4)8Mw*y`];
+const __ΩRouteMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.route, "type", "RouteOnlyOptions", "options", "RouteMethod", `"c!Pe"!o""i#4$"w%4&Mw'y`];
+const __ΩMiddleFnMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.middleFn, "type", "MiddleFnMethod", '"c!Pe"!o""i#4$Mw%y'];
+const __ΩHeadersMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.headersMiddleFn, "type", "HeadersMethodWithJitFns", "headersParam", "HeadersMethod", `"c!Pe"!o""i#4$"w%4&Mw'y`];
+const __ΩRawMethod = ["H", () => __ΩRemoteMethod, () => HandlerType.rawMiddleFn, "type", "RemoteMethodOpts", false, "validateParams", false, "validateReturn", "options", "RawMethod", `"c!Pe"!o""i#4$P"w%P.&4'.(4)8MK4*Mw+y`];
+const __ΩRouteOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩRouteMethod, "options", "description", "validateParams", "validateReturn", "serializer", "isMutation", "RouteOptions", `n#.$fP.%.&.'.(.)Jo"#o!"w*y`];
+const __ΩMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩMiddleFnMethod, "options", "description", "validateParams", "validateReturn", "runOnError", "MiddleFnOptions", `n#.$fP.%.&.'.(Jo"#o!"w)y`];
+const __ΩHeadersMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩHeadersMethod, "options", "description", "validateParams", "validateReturn", "runOnError", "HeadersMiddleFnOptions", `n#.$fP.%.&.'.(Jo"#o!"w)y`];
+const __ΩRawMiddleFnOptions = [() => __ΩPartial, () => __ΩPick, () => __ΩRawMethod, "options", "description", "runOnError", "RawMiddleFnOptions", `n#.$fP.%.&Jo"#o!"w'y`];
+const __ΩMethodsExecutionChain = ["routeIndex", () => __ΩRemoteMethod, "methods", "SerializerCode", "serializer", "MethodsExecutionChain", `P'4!n"F4#"w$4%Mw&y`];
+export {
+  __ΩHeadersMethod,
+  __ΩHeadersMiddleFnOptions,
+  __ΩMethodsExecutionChain,
+  __ΩMiddleFnMethod,
+  __ΩMiddleFnOptions,
+  __ΩRawMethod,
+  __ΩRawMiddleFnOptions,
+  __ΩRemoteMethod,
+  __ΩRouteMethod,
+  __ΩRouteOptions
+};
+//# sourceMappingURL=remoteMethods.js.map

package/.dist/esm/src/types/remoteMethods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteMethods.js","sources":["../../../../src/types/remoteMethods.ts"],"sourcesContent":["// ####### Executables #######\n\nimport type {HeadersMethodWithJitFns, MethodWithJitFns, RemoteMethodOpts, RouteOnlyOptions, SerializerCode} from '@mionjs/core'; // do not import type only\nimport type {AnyHandler, Handler, HeaderHandler, RawMiddleFnHandler} from './handlers.ts'; // do not import type only\nimport {HandlerType} from '@mionjs/core'; // do not import type only\n\n/** Contains the handlers for middleFns and routes */\nexport interface RemoteMethod<H extends AnyHandler = AnyHandler> extends MethodWithJitFns {\n    /** router options */\n    options: RemoteMethodOpts;\n    handler: H;\n    methodCaller?: (...args: any[]) => any;\n}\n\nexport interface RouteMethod<H extends Handler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.route;\n    options: RouteOnlyOptions;\n}\nexport interface MiddleFnMethod<H extends Handler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.middleFn;\n}\nexport interface HeadersMethod<H extends HeaderHandler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.headersMiddleFn;\n    headersParam: HeadersMethodWithJitFns;\n}\nexport interface RawMethod<H extends RawMiddleFnHandler = any> extends RemoteMethod<H> {\n    type: typeof HandlerType.rawMiddleFn;\n    options: RemoteMethodOpts & {\n        validateParams: false;\n        validateReturn?: false;\n    };\n}\n\nexport type RouteOptions = Partial<\n    Pick<RouteMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'serializer' | 'isMutation'>\n>;\nexport type MiddleFnOptions = Partial<\n    Pick<MiddleFnMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>\n>;\nexport type HeadersMiddleFnOptions = Partial<\n    Pick<HeadersMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError'>\n>;\n// RawMiddleFnOptions doesn't need encoding - raw middleFns handle their own serialization\nexport type RawMiddleFnOptions = Partial<Pick<RawMethod['options'], 'description' | 'runOnError'>>;\n\nexport interface MethodsExecutionChain {\n    routeIndex: number;\n    methods: RemoteMethod[];\n    /** Precalculated serializer code for the route's response body type */\n    serializer: SerializerCode;\n}\n"],"names":[],"mappings":";;;sEAe6B,OAAK,QAAA,oBAAA,WAAA,eAAA,yBAAA;yEAIL,UAAQ,QAAA,kBAAA,oBAAA;wEAGR,iBAAe,QAAA,2BAAA,gBAAA,iBAAA,yBAAA;oEAIf,aAAW,QAAA,oBAAA,OAAA,kBAAA,OAAA,kBAAA,WAAA,aAAA,sCAAA;;;;;;"}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90-dark.png">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png">
+    <img alt='mion, Typescript Full Stack APIs' src='https://raw.githubusercontent.com/MionKit/mion/master/assets/public/bannerx90.png'>
+  </picture>
+</p>
+<p align="center">
+  <strong>RPC Like router with automatic Validation and Serialization.
+  </strong>
+</p>
+<p align=center>
+
+  <img src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+  <img src="https://img.shields.io/badge/license-MIT-97ca00.svg?style=flat-square&maxAge=99999999" alt="npm"  style="max-width:100%;">
+</p>
+
+# `@mionjs/router`
+
+🚀 Lightweight and fast HTTP router with automatic validation and serialization out of the box.
+
+Thanks to it's **Remote Method Call** routing style is quite performant as there is no need to parse URLs or match regular expressions when finding a route. Just a direct mapping from url to the route handler.
+
+mion's is lightweight and fast. Unlike traditional routers. The Http method is not relevant, there are no parameters in the Url and data is sent and received in JSON format via the request body or headers. mion's router leverages a simple in-memory map for route lookup, making it extremely fast.
+
+## Check Out The [Website And Documentation](http://mion.io) 📚
+
+[![mion-website-banner](https://raw.githubusercontent.com/MionKit/mion/master/assets/public/mion-website-banner.png)](http://mion.io)
+
+---
+
+## &nbsp;
+
+_[MIT](../../LICENSE) LICENSE_

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@mionjs/router",
+  "version": "0.8.0-alpha.0",
+  "type": "module",
+  "description": "Typescript RPC Like router with automatic Validation and Serialization",
+  "keywords": [
+    "typescript",
+    "API",
+    "RPC",
+    "json",
+    "schema",
+    "generate",
+    "server",
+    "serverless",
+    "framework",
+    "node"
+  ],
+  "author": "ma jerez",
+  "homepage": "https://mion.io/",
+  "license": "MIT",
+  "browser": {},
+  "exports": {
+    ".": {
+      "source": "./index.ts",
+      "types": "./.dist/esm/index.d.ts",
+      "require": "./.dist/cjs/index.cjs",
+      "default": "./.dist/esm/index.js"
+    },
+    "./aot": {
+      "source": "./src/lib/aotEmitter.ts",
+      "types": "./.dist/esm/src/lib/aotEmitter.d.ts",
+      "require": "./.dist/cjs/src/lib/aotEmitter.cjs",
+      "default": "./.dist/esm/src/lib/aotEmitter.js"
+    }
+  },
+  "directories": {
+    "lib": ".dist"
+  },
+  "files": [
+    ".dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MionKit/mion.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "dev": "vite build --watch",
+    "dev:test": "vitest watch",
+    "lint": "npx eslint src",
+    "format": "prettier --write src/**/*.ts",
+    "build": "vite build",
+    "clean": "rimraf .dist & rimraf .coverage",
+    "fresh-start": "npm run clean && rimraf node_modules"
+  },
+  "bugs": {
+    "url": "https://github.com/MionKit/mion/issues"
+  },
+  "dependencies": {
+    "@mionjs/core": "^0.8.0-alpha.0",
+    "@mionjs/run-types": "^0.8.0-alpha.0"
+  },
+  "gitHead": "5d2ec524ba39d040338ce8946d8edf78aa7291a3"
+}