@casual-simulation/aux-common/rpc/Result.d.ts

Common library for AUX projects

import type { DenialReason } from '../common';
import type { KnownErrorCodes } from './ErrorCodes';
export type Result<T, E extends ErrorType> = Success<T> | Failure<E>;
export interface SuccessOrError<T, E extends ErrorType> {
    success: boolean;
    value?: T;
    error?: E;
}
export interface Success<T> {
    success: true;
    value: T;
}
export interface Failure<E extends ErrorType> {
    success: false;
    error: E;
}
export type ErrorType = {
    errorCode: string;
    errorMessage: string;
    [key: string]: any;
};
export type MatchErrorCodes<T, E extends ErrorType, U> = {
    success: (data: T) => U;
} & {
    [K in E['errorCode']]: (error: Extract<E, {
        errorCode: K;
    }>) => U;
};
export type GenericSuccess<T> = T extends object ? {
    success: true;
} & T : {
    success: true;
    value: T;
};
export type GenericFailure<E extends ErrorType> = {
    success: false;
} & E;
export type GenericResult<T, E extends ErrorType> = GenericSuccess<T> | GenericFailure<E>;
export type SimpleError = {
    errorCode: KnownErrorCodes;
    errorMessage: string;
    reason?: DenialReason;
    issues?: Zod.ZodIssue[];
};
export type WrappedError = {
    errorCode: 'wrapped_error';
    errorMessage: string;
    error: unknown;
};
export interface MultiError<E> {
    errorCode: 'multi_error';
    errorMessage: string;
    errors: E[];
}
export declare function logErrors(multiError: MultiError<ErrorType>, prefix?: string): void;
export declare function logError(error: ErrorType, prefix?: string, log?: (message: string, ...args: any[]) => void): void;
export declare function genericResult<T, E extends ErrorType>(result: Result<T, E>): GenericResult<T, E>;
export declare function mapResult<T, E extends ErrorType, U>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
export declare function flatMapResult<T, E extends ErrorType, U, F extends ErrorType>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;
export declare function matchResult<T, U>(result: Success<T>, cases: {
    success: (data: T) => U;
}): U;
export declare function matchResult<E extends ErrorType, U>(result: Failure<E>, cases: {
    [K in E['errorCode']]: (error: Extract<E, {
        errorCode: K;
    }>) => U;
}): U;
export declare function matchResult<T, E extends ErrorType, U>(result: Result<T, E>, cases: MatchErrorCodes<T, E, U>): U;
export declare function success(): Success<void>;
export declare function success<T>(value: T): Success<T>;
export declare function failure<E extends ErrorType>(error: E): Failure<E>;
export declare function isSuccess<T, E extends ErrorType>(result: Result<T, E>): result is Success<T>;
export declare function isFailure<T, E extends ErrorType>(result: Result<T, E>): result is Failure<E>;
export declare function unwrap<T, E extends ErrorType>(result: Result<T, E>): T;
export declare function logResult<T, E extends ErrorType>(result: Result<T, E>, message?: string): Result<T, E>;
export declare function wrap<T>(fn: () => Promise<T>): Promise<Result<T, WrappedError>>;
export declare function wrap<T>(fn: () => T): Result<T, WrappedError>;
export declare class R<T, E extends ErrorType> implements SuccessOrError<T, E> {
    readonly success: boolean;
    private readonly _data;
    protected constructor(success: boolean, _data: T | E);
    static success<T>(value: T): Success<T>;
    static failure<E extends ErrorType>(error: E): Failure<E>;
    get value(): T;
    get error(): E;
    toString(): string;
    toJSON(): GenericResult<T, E>;
}
//# sourceMappingURL=Result.d.ts.map