ErrorPolicy type

The ErrorPolicy type determines which errors should be handled for example in resilience middlewares like retry or fallback.

Predicate as ErrorPolicy

A predicate function can be used to dynamically determine if an error should be handled:

./samples/predicate.ts

import { fallback } from "eridu-tech/resilience";
import { use } from "eridu-tech/middleware";

class CustomError extends Error {
    constructor(
        readonly errorCode: string,
        message: string,
        cause?: unknown,
    ) {
        super(message, { cause });
        this.name = CustomError.name;
    }
}

const func = use(
    () => Promise.resolve("DATA"),
    [
        fallback({
            fallbackValue: "DEFAULT_VALUE",
            errorPolicy: (error) => error instanceof CustomError,
        }),
    ],
);

await func();

Classes as ErrorPolicy:

You can directly pass an class to match if errors are instance of the class:

./samples/class.ts

import { fallback } from "eridu-tech/resilience";
import { use } from "eridu-tech/middleware";
import { UnexpectedError } from "eridu-tech/utilities";

const func = use(
    () => Promise.resolve("DATA"),
    [
        fallback({
            fallbackValue: "DEFAULT_VALUE",
            errorPolicy: UnexpectedError,
        }),
    ],
);

await func();

You can also pass multiple error classes:

./samples/multiple-classes.ts

import { fallback } from "eridu-tech/resilience";
import { use } from "eridu-tech/middleware";
import { UnexpectedError } from "eridu-tech/utilities";

class CustomErrorB extends Error {
    constructor(message: string, cause?: unknown) {
        super(message, { cause });
        this.name = CustomErrorB.name;
    }
}

const func = use(
    () => Promise.resolve("DATA"),
    [
        fallback({
            fallbackValue: "DEFAULT_VALUE",
            errorPolicy: [UnexpectedError, CustomErrorB],
        }),
    ],
);

await func();

Standard Schema as ErrorPolicy

You can use any standard schema as error policy:

./samples/standard-schema.ts

import { z } from "zod";
import { fallback } from "eridu-tech/resilience";
import { use } from "eridu-tech/middleware";

const func = use(
    () => Promise.resolve("DATA"),
    [
        fallback({
            fallbackValue: "DEFAULT_VALUE",
            errorPolicy: z.object({
                code: z.literal("e20"),
                message: z.string(),
            }),
        }),
    ],
);

await func();

False return values as error

You can treat false return values as errors. This useful when you want to retry functions that return boolean.

./samples/treat-false-as-error.ts

import { retry } from "eridu-tech/resilience";
import { use } from "eridu-tech/middleware";

const func = use(async (): Promise<boolean> => {
    // Will be
    console.log("EXECUTING");
    return false;
}, [
    retry({
        maxAttempts: 4,
        errorPolicy: {
            treatFalseAsError: true,
        },
    }),
]);

await func();

Further information

For further information refer to eridu-tech/utilities API docs.