@mionjs/client 0.8.0-alpha.0

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

@@ -0,0 +1,152 @@
+import { RpcError, CoreRouterOptions, Prettify, RunTypeError, SerializerMode, ValidationError } from '@mionjs/core';
+import { PublicHeadersFn, PublicMiddleFn, RemoteApi, PublicRoute } from '@mionjs/router';
+import { TypedEvent } from './typedEvent.ts';
+export type Result<RouteSuccess, RouteError, MiddleFnsResults extends Record<string, unknown> = Record<string, unknown>, MiddleFnsErrors extends Record<string, RpcError<string, unknown>> = Record<string, RpcError<string, unknown>>> = [RouteSuccess | undefined, RouteError | undefined, MiddleFnsResults | undefined, MiddleFnsErrors | undefined];
+export type MiddleFnSuccess<H> = H extends HSubRequest<infer PH> ? HandlerSuccessResponse<PH> : never;
+export type MiddleFnError<H> = H extends HSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> : never;
+export type CallWithMiddleFnsResult<RouteSuccess, RouteError, MiddleFns extends Record<string, HSubRequest<any>>> = [
+    RouteSuccess | undefined,
+    RouteError | ValidationError | undefined,
+    {
+        [K in keyof MiddleFns]?: MiddleFnSuccess<MiddleFns[K]>;
+    } | undefined,
+    {
+        [K in keyof MiddleFns]?: MiddleFnError<MiddleFns[K]>;
+    } | undefined
+];
+export type WorkflowResult<Routes extends RSubRequest<any>[], MiddleFns extends Record<string, HSubRequest<any>> = Record<string, HSubRequest<any>>> = [
+    WorkflowRouteResults<Routes>,
+    WorkflowRouteErrors<Routes>,
+    {
+        [K in keyof MiddleFns]?: MiddleFnSuccess<MiddleFns[K]>;
+    } | undefined,
+    {
+        [K in keyof MiddleFns]?: MiddleFnError<MiddleFns[K]>;
+    } | undefined
+];
+export type WorkflowRouteResults<Routes extends RSubRequest<any>[]> = {
+    [K in keyof Routes]: Routes[K] extends RSubRequest<infer PH> ? HandlerSuccessResponse<PH> | undefined : never;
+};
+export type WorkflowRouteErrors<Routes extends RSubRequest<any>[]> = {
+    [K in keyof Routes]: Routes[K] extends RSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> | undefined : never;
+};
+export interface ClientOptions extends CoreRouterOptions {
+    baseURL: string;
+    basePath: string;
+    suffix: string;
+    autoGenerateErrorId: boolean;
+    fetchOptions: RequestInit;
+    validateParams: boolean;
+    serializer: SerializerMode;
+}
+type PublicHandler = (...args: any[]) => Promise<any>;
+type PublicMethod = PublicRoute | PublicMiddleFn | PublicHeadersFn;
+type ExtractHandler<PM extends PublicMethod> = PM extends {
+    handler: infer H;
+} ? H : never;
+export type InitClientOptions = Partial<ClientOptions> & {
+    baseURL: string;
+};
+export type RequestHeaders = {
+    [key: string]: string;
+};
+export type RequestBody = {
+    [key: string]: any[];
+};
+export type RouteParamsType<PM extends PublicMethod> = Parameters<ExtractHandler<PM>>;
+export type RouteParamType<PM extends PublicMethod, Index extends number> = Parameters<ExtractHandler<PM>>[Index];
+export type HeadersParamsType<PM extends PublicHeadersFn> = Parameters<ExtractHandler<PM>>[0];
+export type RouteReturnType<PM extends PublicMethod> = HandlerSuccessResponse<ExtractHandler<PM>>;
+export type HandlerResponse<PH extends PublicHandler> = Awaited<ReturnType<PH>>;
+export type HandlerSuccessResponse<PH extends PublicHandler> = Exclude<HandlerResponse<PH>, RpcError<string>>;
+export type HandlerFailResponse<PH extends PublicHandler> = Extract<HandlerResponse<PH>, RpcError<string>>;
+export type SuccessResponse<MR extends SubRequest<any>> = Required<MR>['resolvedValue'];
+export type SuccessResponses<List extends SubRequest<any>[]> = {
+    [P in keyof List]: SuccessResponse<List[P]>;
+};
+export type FailResponse<MR extends SubRequest<any>> = Required<MR>['error'];
+export type FailResponses<List extends SubRequest<any>[]> = {
+    [P in keyof List]: FailResponse<List[P]>;
+};
+export type RequestErrors = Map<string, RpcError<string>>;
+export type ErrorHandler<E extends RpcError<string, any>> = (error: E) => void;
+export type UnknownErrorHandler = (error: RpcError<string, any>) => void;
+export type SuccessHandler<S> = (result: S) => void;
+type Simplify<T> = T extends any ? T : never;
+export type HandlerErrors<PH extends (...args: any[]) => Promise<any>> = Simplify<Extract<HandlerResponse<PH>, RpcError<string, any>> | ValidationError>;
+export interface SubRequest<PH extends PublicHandler> {
+    pointer: string[];
+    id: string;
+    isResolved: boolean;
+    params: Parameters<PH>;
+    resolvedValue?: HandlerSuccessResponse<PH>;
+    error?: HandlerFailResponse<PH>;
+    serializedParams?: any[];
+}
+export interface RSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
+    typeErrors: () => Promise<RunTypeError[]>;
+    call: () => Promise<Result<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>, Record<string, unknown>, Record<string, RpcError<string, unknown> | ValidationError>>>;
+    callWithMiddleFns: <H extends Record<string, HSubRequest<any>>>(middleFns: H) => Promise<CallWithMiddleFnsResult<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>, H>>;
+    callWithWorkflow: <OtherRoutes extends RSubRequest<any>[], H extends Record<string, HSubRequest<any>>>(otherRoutes: [...OtherRoutes], middleFns?: H) => Promise<WorkflowResult<any, H>>;
+}
+export interface HSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
+    typeErrors: () => Promise<RunTypeError[]>;
+    prefill: () => TypedEvent<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>>;
+    removePrefill: () => Promise<void>;
+}
+export type NonClientRoute = never | PublicMiddleFn | PublicHeadersFn;
+export type ClientRoutes<RA extends RemoteApi> = Prettify<{
+    [Property in keyof RA as RA[Property] extends NonClientRoute ? never : Property]: RA[Property] extends PublicRoute ? (...params: Parameters<RA[Property]['handler']>) => RSubRequest<RA[Property]['handler']> : RA[Property] extends RemoteApi ? ClientRoutes<RA[Property]> : never;
+}>;
+export type NonClientMiddleFn = never | PublicRoute | {
+    [key: string]: PublicRoute;
+};
+export type ClientMiddleFns<RA extends RemoteApi> = Prettify<{
+    [Property in keyof RA as RA[Property] extends NonClientMiddleFn ? never : Property]: RA[Property] extends PublicMiddleFn | PublicHeadersFn ? (...params: Parameters<RA[Property]['handler']>) => HSubRequest<RA[Property]['handler']> : RA[Property] extends RemoteApi ? ClientMiddleFns<RA[Property]> : never;
+}>;
+export type Cleaned<RMS extends RemoteApi> = {
+    [Property in keyof RMS as RMS[Property] extends never ? never : Property]: RMS[Property];
+};
+export type SuccessClientResponse<RS extends RSubRequest<any>, RHList extends HSubRequest<any>[]> = [
+    SuccessResponse<RS>,
+    ...SuccessResponses<RHList>
+];
+export type PrefilledMiddleFnsCache = Map<string, SubRequest<any>>;
+export {};
+export declare type __ΩResult = any[];
+export declare type __ΩMiddleFnSuccess = any[];
+export declare type __ΩMiddleFnError = any[];
+export declare type __ΩCallWithMiddleFnsResult = any[];
+export declare type __ΩWorkflowResult = any[];
+export declare type __ΩWorkflowRouteResults = any[];
+export declare type __ΩWorkflowRouteErrors = any[];
+export declare type __ΩClientOptions = any[];
+export declare type __ΩInitClientOptions = any[];
+export declare type __ΩRequestHeaders = any[];
+export declare type __ΩRequestBody = any[];
+export declare type __ΩRouteParamsType = any[];
+export declare type __ΩRouteParamType = any[];
+export declare type __ΩHeadersParamsType = any[];
+export declare type __ΩRouteReturnType = any[];
+export declare type __ΩHandlerResponse = any[];
+export declare type __ΩHandlerSuccessResponse = any[];
+export declare type __ΩHandlerFailResponse = any[];
+export declare type __ΩSuccessResponse = any[];
+export declare type __ΩSuccessResponses = any[];
+export declare type __ΩFailResponse = any[];
+export declare type __ΩFailResponses = any[];
+export declare type __ΩRequestErrors = any[];
+export declare type __ΩErrorHandler = any[];
+export declare type __ΩUnknownErrorHandler = any[];
+export declare type __ΩSuccessHandler = any[];
+export declare type __ΩHandlerErrors = any[];
+export declare type __ΩSubRequest = any[];
+export declare type __ΩRSubRequest = any[];
+export declare type __ΩHSubRequest = any[];
+export declare type __ΩNonClientRoute = any[];
+export declare type __ΩClientRoutes = any[];
+export declare type __ΩNonClientMiddleFn = any[];
+export declare type __ΩClientMiddleFns = any[];
+export declare type __ΩCleaned = any[];
+export declare type __ΩSuccessClientResponse = any[];
+export declare type __ΩPrefilledMiddleFnsCache = any[];

package/.dist/cjs/src/validation.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const core=require("@mionjs/core"),src_types=require("./types.cjs");function __assignType(fn,args){return fn.__type=args,fn}function validateSubRequests(subRequestIds,req,errors,validateRouteMiddleFns=!0){req.options.validateParams&&subRequestIds.forEach(__assignType(id=>{const subRequest=req.subRequestList[id];validateSubRequest(id,subRequest,errors);const methodMeta=core.routesCache.getMetadata(id);if(validateRouteMiddleFns&&methodMeta?.middleFnIds?.length){const validMiddleFnIds=methodMeta.middleFnIds.filter(__assignType(middleFnId=>middleFnId!=null,["middleFnId","",'P"2!"/"']));validateSubRequests(validMiddleFnIds,req,errors,validateRouteMiddleFns)}},["id","",'P"2!"/"']))}validateSubRequests.__type=["subRequestIds","MionClientRequest","req",()=>src_types.__ΩRequestErrors,"errors","validateRouteMiddleFns","validateSubRequests",`P&F2!"w"2#n$2%"2&$/'`];function validateSubRequest(id,subRequest,errors){if(subRequest?.error||subRequest?.isResolved)return;const mappings=subRequest?.mappings;if(Array.isArray(mappings)&&mappings.length>0)return;const params=subRequest?.params||[],validationResponse=getTypeErrors(id,params);if(!validationResponse)return;const error=validationResponse;errors.set(id,error),subRequest&&(subRequest.error=error,subRequest.isResolved=!0)}validateSubRequest.__type=["id",()=>src_types.__ΩSubRequest,"subRequest",()=>src_types.__ΩRequestErrors,"errors","validateSubRequest",'P&2!"o""2#n$2%$/&'];function getTypeErrors(id,params){const method=core.routesCache.useMethodJitFns(id);if(!method.paramNames||method.paramNames.length===0)return;const paramsJit=method.paramsJitFns;if(!paramsJit.typeErrors.isNoop)try{const validationsResponse=paramsJit.isType.fn(params)||paramsJit.typeErrors.fn(params);if(validationsResponse?.length)return new core.RpcError({type:"validation-error",publicMessage:`Invalid params for Route or MiddleFn '${method.id}', validation failed.`,errorData:validationsResponse})}catch(e){return new core.RpcError({type:"unexpected-validation-error",publicMessage:`Could not validate params for Route or MiddleFn '${method.id}': ${e.message} `})}}getTypeErrors.__type=["id","params","validation-error","unexpected-validation-error",()=>core.RpcError,"getTypeErrors",'P&2!"F2"P$PP.#.$J7%J/&'];exports.validateSubRequest=validateSubRequest;exports.validateSubRequests=validateSubRequests;
+//# sourceMappingURL=validation.cjs.map

package/.dist/cjs/src/validation.cjs.map

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

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

@@ -0,0 +1,4 @@
+import { RequestErrors, SubRequest } from './types.ts';
+import { MionClientRequest } from './request.ts';
+export declare function validateSubRequests(subRequestIds: string[], req: MionClientRequest<any, any>, errors: RequestErrors, validateRouteMiddleFns?: boolean): void;
+export declare function validateSubRequest(id: string, subRequest: SubRequest<any>, errors: RequestErrors): void;