+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ ++ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ ++ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 | 1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1x + + +10x + + + + +10x +10x +10x + + +10x +10x +10x +17x +14x +14x +10x +10x +10x + | import { AsyncResult, isFailure, Result, Success } from "./result";
+
+/**
+ * Type for a function that takes an input of type `In` and returns an `AsyncResult` of type `Out` and `E`.
+ * @template In - The input type.
+ * @template Out - The output type.
+ * @template E - The error type.
+ */
+type PipeFn<In, Out, E> = (arg: In) => AsyncResult<Out, E>;
+
+/**
+ * Type to extract the return type of the last function in a tuple of functions.
+ * @template T - The tuple of functions.
+ * @template K - The index of the function in the tuple.
+ */
+type LastReturnType<T extends any[], K> = K extends keyof T
+ ? T[K] extends PipeFn<any, infer S, any>
+ ? S
+ : never
+ : never;
+
+/**
+ * Type to extract the error type from a tuple of functions.
+ * @template T - The tuple of functions.
+ */
+type ExtractError<T extends any[]> = T[number] extends PipeFn<any, any, infer E>
+ ? E
+ : never;
+
+/**
+ * Type for a pipeline of functions, ensuring correct type inference for each function in the tuple.
+ * @template T - The tuple of functions.
+ * @template E - The error type.
+ */
+type Pipeline<T extends any[], E> = {
+ [K in keyof T]: K extends "0"
+ ? T[K] extends PipeFn<infer R, infer S, E>
+ ? PipeFn<R, S, E>
+ : never
+ : T[K] extends PipeFn<infer R, infer S, E>
+ ? PipeFn<LastReturnType<T, K>, S, E>
+ : never;
+};
+
+/**
+ * The `pipe` function composes multiple functions, handling both synchronous and asynchronous processes.
+ * @template T - The tuple of functions.
+ * @template ExtractError<T> - The error type extracted from the tuple of functions.
+ * @param {...Pipeline<T, ExtractError<T>>} fns - The functions to compose.
+ * @returns {Function} A function that takes the input of the first function and returns a `Promise` resolving to a `Result` of the last function's output type and the error type.
+ *
+ * @example
+ * const pipeline = pipe(
+ * async (input: string) => success(parseInt(input)),
+ * async (num: number) => success(num + 1),
+ * async (num: number) => success(num.toString())
+ * );
+ *
+ * pipeline("42").then(result =>
+ * match({
+ * onSuccess: val => console.log("Success:", val),
+ * onFailure: err => console.log("Error:", err)
+ * })(result)
+ * );
+ */
+export const pipe = <
+ T extends [PipeFn<any, any, any>, ...PipeFn<any, any, any>[]]
+>(
+ ...fns: Pipeline<T, ExtractError<T>>
+): ((
+ arg: Parameters<T[0]>[0]
+) => Promise<
+ Result<LastReturnType<T, keyof T & (keyof T)[]["length"]>, ExtractError<T>>
+>) => {
+ return async (
+ arg: Parameters<T[0]>[0]
+ ): Promise<
+ Result<LastReturnType<T, keyof T & (keyof T)[]["length"]>, ExtractError<T>>
+ > => {
+ let result: Result<any, ExtractError<T>> = await fns[0](arg);
+ for (const fn of fns.slice(1)) {
+ if (isFailure(result)) break;
+ result = await fn((result as Success<any>).value);
+ }
+ return result;
+ };
+};
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 | + + + +1x +1x +1x + + + + +1x +1x + + + + + +1x +1x +1x + + + + +1x +1x + + + + + + + + + + + + + + + + + + + + + + +1x +18x + + + + + + + + +1x +21x + + + + + + + +1x + + + + + + + +1x + + + + + + + +1x + + + + + + + + + + + + +1x +1x +14x +14x +14x + + + +14x +14x + + + + + + + + +1x +4x +4x +4x +4x +2x +2x +2x +2x +4x + | /**
+ * Represents a successful result.
+ * @template T - The type of the value.
+ */
+export class Success<T> {
+ readonly isSuccess = true;
+ readonly isFailure = false;
+ /**
+ * Creates an instance of Success.
+ * @param {T} value - The value of the successful result.
+ */
+ constructor(public readonly value: T) {}
+}
+
+/**
+ * Represents a failed result.
+ * @template E - The type of the error.
+ */
+export class Failure<E> {
+ readonly isSuccess = false;
+ readonly isFailure = true;
+ /**
+ * Creates an instance of Failure.
+ * @param {E} error - The error of the failed result.
+ */
+ constructor(public readonly error: E) {}
+}
+
+/**
+ * Type alias for a result which can be either a Success or a Failure.
+ * @template T - The type of the value in case of success.
+ * @template E - The type of the error in case of failure.
+ */
+export type Result<T, E> = Success<T> | Failure<E>;
+
+/**
+ * Type alias for an asynchronous result.
+ * @template T - The type of the value in case of success.
+ * @template E - The type of the error in case of failure.
+ */
+export type AsyncResult<T, E> = Result<T, E> | Promise<Result<T, E>>;
+
+/**
+ * Checks if the given result is a Success.
+ * @template T - The type of the value in case of success.
+ * @template E - The type of the error in case of failure.
+ * @param {Result<T, E>} result - The result to check.
+ * @returns {result is Success<T>} - True if the result is a Success, otherwise false.
+ */
+export const isSuccess = <T, E>(result: Result<T, E>): result is Success<T> =>
+ result.isSuccess;
+
+/**
+ * Checks if the given result is a Failure.
+ * @template T - The type of the value in case of success.
+ * @template E - The type of the error in case of failure.
+ * @param {Result<T, E>} result - The result to check.
+ * @returns {result is Failure<E>} - True if the result is a Failure, otherwise false.
+ */
+export const isFailure = <T, E>(result: Result<T, E>): result is Failure<E> =>
+ result.isFailure;
+
+/**
+ * Creates a success result.
+ * @template T - The type of the value.
+ * @param {T} value - The value of the success result.
+ * @returns {Result<T, never>} - The success result.
+ */
+export const success = <T>(value: T): Result<T, never> => new Success(value);
+
+/**
+ * Creates a failure result.
+ * @template E - The type of the error.
+ * @param {E} error - The error of the failure result.
+ * @returns {Result<never, E>} - The failure result.
+ */
+export const failure = <E>(error: E): Result<never, E> => new Failure(error);
+
+/**
+ * Wraps a value in a success result.
+ * @template T - The type of the value.
+ * @param {T} value - The value to wrap.
+ * @returns {Result<T, never>} - The success result.
+ */
+export const of = <T>(value: T): Result<T, never> => success(value);
+
+/**
+ * Matches a result to a function based on whether it is a success or a failure.
+ * @template T - The type of the value in case of success.
+ * @template E - The type of the error in case of failure.
+ * @template RS - The return type of the success handler.
+ * @template RF - The return type of the failure handler.
+ * @param {Object} handlers - An object containing the success and failure handlers.
+ * @param {(value: T) => RS | Promise<RS>} handlers.onSuccess - The success handler.
+ * @param {(error: E) => RF | Promise<RF>} handlers.onFailure - The failure handler.
+ * @returns {(result: Result<T, E>) => Promise<RS | RF>} - A function that takes a result and returns a promise that resolves to the result of the appropriate handler.
+ */
+export const match =
+ <T, E, RS, RF>({
+ onSuccess,
+ onFailure,
+ }: {
+ onSuccess: (value: T) => RS | Promise<RS>;
+ onFailure: (error: E) => RF | Promise<RF>;
+ }) =>
+ async (result: Result<T, E>): Promise<RS | RF> =>
+ isSuccess(result) ? onSuccess(result.value) : onFailure(result.error);
+
+/**
+ * Converts a promise to a result.
+ * @template T - The type of the value in case of success.
+ * @template E - The type of the error in case of failure.
+ * @param {Promise<T>} promise - The promise to convert.
+ * @returns {Promise<Result<T, E>>} - A promise that resolves to a result.
+ */
+export const fromPromise = async <T, E extends Error = Error>(
+ promise: Promise<T>
+): Promise<Result<T, E>> => {
+ try {
+ const value = await promise;
+ return success(value);
+ } catch (error) {
+ return failure(error as E);
+ }
+};
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| index.ts | +
+
+ |
+ 0% | +0/2 | +0% | +0/1 | +0% | +0/1 | +0% | +0/2 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 | + + | export * from "../lib/pipe"; +export * from "../lib/result"; + |