@mionjs/client 0.8.10 → 0.13.2

package/src/subRequest.ts

@@ -1,111 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {RpcError} from '@mionjs/core';
-import type {RunTypeError} from '@mionjs/core';
-import type {CallSetup, MiddlewareSubRequest, RequestErrors, RouteSubRequest, SubRequest} from './types.ts';
-import type {MapFromServerFnRef} from '@mionjs/core';
-import type {MionClient} from './client.ts';
-import {TypedEvent} from './lib/typedEvent.ts';
-import {isMapFromRef} from './routesFlow.ts';
-
-/** Implementation of both RouteSubRequest and MiddleFnSubRequest interfaces */
-export class MionSubRequest<S = any, E extends RpcError<string, any> = any>
-    implements RouteSubRequest<any>, MiddlewareSubRequest<any>
-{
-    pointer: string[];
-    id: string;
-    isResolved: boolean = false;
-    params: any[];
-    resolvedValue?: S;
-    error?: E;
-    serializedParams?: any[];
-    mappings: MapFromServerFnRef[] = [];
-
-    constructor(
-        parentProps: string[],
-        handlerId: string,
-        argArray: any[],
-        readonly client: MionClient
-    ) {
-        this.pointer = [...parentProps];
-        this.id = handlerId;
-        this.params = argArray.map((arg, index) => {
-            if (isMapFromRef(arg)) {
-                arg.toRequestId = this.id;
-                arg.paramIndex = index;
-                this.mappings.push(arg);
-                return null;
-            }
-            return arg;
-        });
-    }
-
-    /** Prefills MiddleFn's parameters and returns TypedEvent for event handler registration */
-    prefill(): TypedEvent<S, E> {
-        const typedEvent = new TypedEvent<S, E>(this.id, this.client.handlersRegistry);
-
-        this.client.prefill(this as MiddlewareSubRequest<any>).catch((errors: RequestErrors) => {
-            console.error('Prefill error:', findSubRequestError(this, errors));
-        });
-
-        return typedEvent;
-    }
-
-    /** Removes prefilled value and clears any registered error handlers for this middleFn */
-    removePrefill(): Promise<void> {
-        this.client.handlersRegistry.clearHandlers(this.id);
-        return this.client.removePrefill(this as MiddlewareSubRequest<any>);
-    }
-
-    /** Calls a remote route with optional setup (middleFns, otherRoutes, signal, timeout) */
-    call(setup?: CallSetup<any, any>): Promise<any> {
-        const signal = setup?.signal;
-        const timeout = setup?.timeout;
-        if (!setup || (!setup.otherRoutes && !setup.middleFns)) {
-            return this.client.execute(this as unknown as RouteSubRequest<any>, undefined, undefined, signal, timeout);
-        }
-        if (setup.otherRoutes && setup.otherRoutes.length > 0) {
-            return this.executeWithOtherRoutes(setup.otherRoutes, setup.middleFns, signal, timeout);
-        }
-        return this.client.execute(this as unknown as RouteSubRequest<any>, undefined, setup.middleFns, signal, timeout);
-    }
-
-    private async executeWithOtherRoutes(
-        otherRoutes: RouteSubRequest<any>[],
-        middleFns?: Record<string, MiddlewareSubRequest<any>>,
-        signal?: AbortSignal,
-        timeout?: number
-    ): Promise<any> {
-        const allRoutes = [this as unknown as RouteSubRequest<any>, ...otherRoutes];
-        const [results, errors, mfR, mfE] = await this.client.execute(undefined, allRoutes, middleFns ?? {}, signal, timeout);
-        const emptyResults = allRoutes.map(() => undefined);
-        const emptyErrors = allRoutes.map(() => undefined);
-        return [results ?? emptyResults, errors ?? emptyErrors, mfR, mfE];
-    }
-
-    /** Validates parameters and returns type errors */
-    typeErrors(): Promise<RunTypeError[]> {
-        return this.client
-            .typeErrors(this as SubRequest<any>)
-            .catch((errors: RequestErrors) => Promise.reject(findSubRequestError(this, errors)));
-    }
-}
-
-/** Finds the most relevant error from the errors map for a given sub-request */
-export function findSubRequestError(subRequest: SubRequest<any>, errors: RequestErrors): RpcError<string> {
-    const specificError = errors.get(subRequest.id);
-    if (specificError) return specificError;
-
-    const firstError = errors.values().next().value;
-    if (firstError) return firstError;
-
-    return new RpcError({
-        type: 'unknown-error',
-        publicMessage: 'An unknown error occurred',
-    });
-}

package/src/types.ts

@@ -1,237 +0,0 @@
-/* ########
- * 2022 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {RpcError} from '@mionjs/core';
-import type {CoreRouterOptions, Prettify, RunTypeError, SerializerMode, ValidationError} from '@mionjs/core';
-import type {PublicHeadersFn, PublicMiddleFn, RemoteApi, PublicRoute} from '@mionjs/router';
-import type {TypedEvent} from './lib/typedEvent.ts';
-
-/** Result type for call() - 4-tuple pattern */
-export type Result<
-    RouteSuccess,
-    RouteError,
-    MiddleFnsResults extends Record<string, unknown> = Record<string, unknown>,
-    MiddleFnsErrors extends Record<string, unknown> = Record<string, RpcError<string, unknown>>,
-> = [RouteSuccess | undefined, RouteError | undefined, MiddleFnsResults | undefined, MiddleFnsErrors | undefined];
-
-/** Extract success type from a MiddleFnSubRequest */
-export type MiddleFnSuccess<H> = H extends MiddlewareSubRequest<infer PH> ? HandlerSuccessResponse<PH> : never;
-
-/** Extract error type from a MiddleFnSubRequest */
-export type MiddleFnError<H> = H extends MiddlewareSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> : never;
-
-// type-routesFlow-result-start
-/** Result type for routesFlow() function - 4-tuple pattern matching array input */
-export type WorkflowResult<
-    Routes extends RouteSubRequest<any>[],
-    MiddleFns extends Record<string, MiddlewareSubRequest<any>> = Record<string, MiddlewareSubRequest<any>>,
-> = [
-    WorkflowRouteResults<Routes>,
-    WorkflowRouteErrors<Routes>,
-    {[K in keyof MiddleFns]?: MiddleFnSuccess<MiddleFns[K]>} | undefined,
-    {[K in keyof MiddleFns]?: MiddleFnError<MiddleFns[K]>} | undefined,
-];
-// type-routesFlow-result-end
-
-// type-routesFlow-route-results-start
-/** Extract success types from route subrequests as tuple */
-export type WorkflowRouteResults<Routes extends RouteSubRequest<any>[]> = {
-    [K in keyof Routes]: Routes[K] extends RouteSubRequest<infer PH> ? HandlerSuccessResponse<PH> | undefined : never;
-};
-// type-routesFlow-route-results-end
-
-// type-routesFlow-route-errors-start
-/** Extract error types from route subrequests as tuple */
-export type WorkflowRouteErrors<Routes extends RouteSubRequest<any>[]> = {
-    [K in keyof Routes]: Routes[K] extends RouteSubRequest<infer PH> ? Simplify<HandlerErrors<PH>> | undefined : never;
-};
-// type-routesFlow-route-errors-end
-
-export interface ClientOptions extends CoreRouterOptions {
-    /** Base URL of the server, i.e: http://localhost:3000 */
-    baseURL: string;
-    /** basePath for all routes, i.e: api/v1 */
-    basePath: string;
-    /** suffix for all routes, i.e: .json */
-    suffix: string;
-    /** automatically generate and uuid */
-    autoGenerateErrorId: boolean;
-    /**  default fetch options */
-    fetchOptions: RequestInit;
-    /** enable automatic parameter validation, defaults to true */
-    validateParams: boolean;
-    /** Default serializer mode */
-    serializer: SerializerMode;
-    /** Default timeout in ms for all requests. Per-request timeout in CallSetup overrides this. */
-    timeout?: number;
-}
-
-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[]};
-
-/** Extracts all parameters from a PublicRoute, PublicMiddleFn, or PublicHeadersFn */
-export type RouteParamsType<PM extends PublicMethod> = Parameters<ExtractHandler<PM>>;
-/** Extracts a single parameter at a given index from a PublicRoute, PublicMiddleFn, or PublicHeadersFn */
-export type RouteParamType<PM extends PublicMethod, Index extends number> = Parameters<ExtractHandler<PM>>[Index];
-/** Extracts the headers parameter (first param) from a PublicHeadersFn handler */
-export type HeadersParamsType<PM extends PublicHeadersFn> = Parameters<ExtractHandler<PM>>[0];
-/** Extracts the success return type from a PublicRoute, PublicMiddleFn, or PublicHeadersFn */
-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>>;
-
-/** Handler function for a specific error type */
-export type ErrorHandler<E extends RpcError<string, any>> = (error: E) => void;
-
-/** Handler function for unknown/unhandled errors */
-export type UnknownErrorHandler = (error: RpcError<string, any>) => void;
-
-/** Handler function for successful results */
-export type SuccessHandler<S> = (result: S) => void;
-
-/** Utility type to force TypeScript to evaluate/resolve the type */
-type Simplify<T> = T extends any ? T : never;
-
-/** Extracts all RpcError types from a handler's return type as a union */
-export type HandlerErrors<PH extends (...args: any[]) => Promise<any>> = Simplify<
-    Extract<HandlerResponse<PH>, RpcError<string, any>> | ValidationError
->;
-
-/** Represents a remote method (sub request) */
-export interface SubRequest<PH extends PublicHandler> {
-    pointer: string[];
-    id: string;
-    isResolved: boolean;
-    params: Parameters<PH>;
-    /** The resolved value after the request completes successfully */
-    resolvedValue?: HandlerSuccessResponse<PH>;
-    error?: HandlerFailResponse<PH>;
-    serializedParams?: any[];
-}
-
-/** Unified config object for call() */
-export interface CallSetup<
-    H extends Record<string, MiddlewareSubRequest<any>> = Record<string, never>,
-    OtherRoutes extends RouteSubRequest<any>[] = [],
-> {
-    middleFns?: H;
-    otherRoutes?: [...OtherRoutes];
-    /** AbortSignal to cancel this specific request */
-    signal?: AbortSignal;
-    /** Timeout in ms (overrides ClientOptions.timeout) */
-    timeout?: number;
-}
-
-/** Builder returned by routesFlow() - call .call() to execute */
-export interface RoutesFlowBuilder<Routes extends RouteSubRequest<any>[]> {
-    /** Execute the routes flow */
-    call(setup?: {middleFns?: never; signal?: AbortSignal; timeout?: number}): Promise<WorkflowResult<Routes>>;
-    /** Execute the routes flow with middleware */
-    call<H extends Record<string, MiddlewareSubRequest<any>>>(setup: {
-        middleFns: H;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<WorkflowResult<Routes, H>>;
-}
-
-/** structure returned from the proxy, containing info of the remote route to execute */
-export interface RouteSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
-    /** Validates Route's parameters and returns type errors */
-    typeErrors: () => Promise<RunTypeError[]>;
-
-    /** Calls a remote route and returns a Result 4-tuple */
-    call(setup?: {
-        middleFns?: never;
-        otherRoutes?: never;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<Result<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>>>;
-
-    /** Calls a remote route with middleFns */
-    call<H extends Record<string, MiddlewareSubRequest<any>>>(setup: {
-        middleFns: H;
-        otherRoutes?: never;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<
-        Result<
-            HandlerSuccessResponse<PH>,
-            Simplify<HandlerErrors<PH>>,
-            {[K in keyof H]?: MiddleFnSuccess<H[K]>},
-            {[K in keyof H]?: MiddleFnError<H[K]>}
-        >
-    >;
-
-    /** Calls this route with other routes in a single HTTP request */
-    call<
-        OtherRoutes extends RouteSubRequest<any>[],
-        H extends Record<string, MiddlewareSubRequest<any>> = Record<string, never>,
-    >(setup: {
-        otherRoutes: [...OtherRoutes];
-        middleFns?: H;
-        signal?: AbortSignal;
-        timeout?: number;
-    }): Promise<WorkflowResult<any, H>>;
-}
-
-/** structure returned from the proxy, containing info of the remote middleFn to execute */
-export interface MiddlewareSubRequest<PH extends PublicHandler> extends SubRequest<PH> {
-    /** Validates MiddleFn's parameters and returns type errors */
-    typeErrors: () => Promise<RunTypeError[]>;
-    /** Prefills MiddleFn's parameters for any future request and returns TypedEvent */
-    prefill: () => TypedEvent<HandlerSuccessResponse<PH>, Simplify<HandlerErrors<PH>>>;
-    /** Removes prefilled value */
-    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']>) => RouteSubRequest<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']>) => MiddlewareSubRequest<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 RouteSubRequest<any>, RHList extends MiddlewareSubRequest<any>[]> = [
-    SuccessResponse<RS>,
-    ...SuccessResponses<RHList>,
-];
-
-export type PrefilledMiddleFnsCache = Map<
-    string,
-    SubRequest<any>
->; /** Reference returned by mapFrom() - extends PureServerFnRef with fake() for type-safe routesFlow piping */