@mionjs/router 0.8.7 → 0.8.8

package/src/types/handlers.ts

@@ -0,0 +1,49 @@
+/* ########
+ * 2023 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {HeadersSubset} from '@mionjs/core';
+import {CallContext} from './context.ts';
+import {RouterOptions} from './general.ts';
+import {MayReturnError} from './publicMethods.ts';
+
+// #######  Route Handlers #######
+
+// type-handler-start
+/** Route or MiddleFn Handler  */
+export type Handler<Context extends CallContext = any, Params extends any[] = any[], Ret = any> = (
+    /** Call Context */
+    context: Context,
+    /** Remote Call parameters */
+    ...parameters: Params
+) => Ret | Promise<Ret>;
+// type-handler-end
+
+/** Headers MiddleFn Handler, middleFn handler for when params are sent in the header  */
+export type HeaderHandler<
+    Context extends CallContext = any,
+    ExpectedHeaders extends HeadersSubset<any> = any,
+    Params extends any[] = any[],
+    Ret = any,
+> = (
+    /** Call Context */
+    context: Context,
+    /** Remote Call Headers */
+    headers: ExpectedHeaders,
+    /** Remote Call parameters */
+    ...parameters: Params
+) => Ret | Promise<Ret>;
+
+/** Handler to use with raw middleFns to get access to raw request and response */
+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;
+
+// Handler technically covers any of the other handlers
+export type AnyHandler<Context extends CallContext = any, Params extends any[] = any, Ret = any> = Handler<Context, Params, Ret>;

package/src/types/publicMethods.ts

@@ -0,0 +1,83 @@
+/* ########
+ * 2023 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {Prettify, RpcError, MethodMetadata} from '@mionjs/core';
+import type {CallContext} from './context.ts';
+import type {Routes} from './general.ts';
+import type {Handler} from './handlers.ts';
+import type {HeadersMiddleFnDef, MiddleFnDef, RawMiddleFnDef, RouteDef} from './definitions.ts';
+import {HandlerType} from '@mionjs/core'; // do not import type only
+
+// ####### Raw MiddleFns #######
+
+export type MayReturnError = void | RpcError<string> | Promise<RpcError<string> | void>;
+
+export type MiddleFnsCollection = {
+    [key: string]: MiddleFnDef | HeadersMiddleFnDef | RawMiddleFnDef;
+};
+
+// ####### Private MiddleFns #######
+
+export interface PrivateMiddleFnDef extends MiddleFnDef {
+    handler: (ctx?: any) => void | never | undefined;
+}
+
+export type PrivateDef = PrivateMiddleFnDef | RawMiddleFnDef;
+
+// ####### Remote Methods Metadata #######
+
+/** Data structure containing all public routes & middleFns.
+ * is a Ts Mapped type the remove private middleFns and rawMiddleFns
+ */
+// prettier-ignore
+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 // Routes
+    ? PublicRoute<PublicHandler<Type[Property]['handler']>>
+        : Type[Property] extends Routes // Routes & PureRoutes (recursion)
+        ? PublicApi<Type[Property]>
+        : never;
+}>;
+
+// type-remote-api-start
+/** Same as Public Api but no type mapping, should be easier to use than PublicApi when non strong types are required. */
+export type RemoteApi = {
+    [key: string]: PublicRoute | PublicMiddleFn | PublicHeadersFn | RemoteApi;
+};
+// type-remote-api-end
+
+/** Public Routes, handler type is the same as RemoteRoute but does not include the context  */
+export interface PublicRoute<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.route;
+    middleFnIds: string[];
+    headerNames: undefined;
+    handler: H;
+}
+
+/** Public MiddleFns, handler type is the same as RemoteMiddleFns but does not include the context  */
+export interface PublicMiddleFn<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.middleFn;
+    handler: H;
+}
+
+/** Public HeadersFns, handler type is the same as HeadersFns but does not include the context */
+export interface PublicHeadersFn<H extends Handler = any> extends MethodMetadata {
+    type: typeof HandlerType.headersMiddleFn;
+    headerNames: string[];
+    handler: H;
+}
+
+/** Removes the context from handlers */
+// prettier-ignore
+export type PublicHandler<H extends Handler> =
+    H extends (ctx: CallContext, ...rest: infer Req) => infer Resp
+    ? (...rest: Req) => Promise<Awaited<Resp>>
+    : never;

package/src/types/remoteMethods.ts

@@ -0,0 +1,54 @@
+// ####### Executables #######
+
+import type {HeadersMethodWithJitFns, MethodWithJitFns, RemoteMethodOpts, RouteOnlyOptions, SerializerCode} from '@mionjs/core'; // do not import type only
+import type {AnyHandler, Handler, HeaderHandler, RawMiddleFnHandler} from './handlers.ts'; // do not import type only
+import {HandlerType} from '@mionjs/core'; // do not import type only
+
+/** Contains the handlers for middleFns and routes */
+export interface RemoteMethod<H extends AnyHandler = AnyHandler> extends MethodWithJitFns {
+    /** router options */
+    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' | 'strictTypes'
+    >
+>;
+export type MiddleFnOptions = Partial<
+    Pick<MiddleFnMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError' | 'strictTypes'>
+>;
+export type HeadersMiddleFnOptions = Partial<
+    Pick<HeadersMethod['options'], 'description' | 'validateParams' | 'validateReturn' | 'runOnError' | 'strictTypes'>
+>;
+// RawMiddleFnOptions doesn't need encoding - raw middleFns handle their own serialization
+export type RawMiddleFnOptions = Partial<Pick<RawMethod['options'], 'description' | 'runOnError'>>;
+
+export interface MethodsExecutionChain {
+    routeIndex: number;
+    methods: RemoteMethod[];
+    /** Precalculated serializer code for the route's response body type */
+    serializer: SerializerCode;
+}