react-api-adts/dist/result.js

Helpful algebraic data types for API handling in React apps.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UnreachableError = exports.InternalError = exports.AuthError = exports.ValidError = exports.Success = exports.Result = exports.futureResultFromPromise = void 0;
function futureResultFromPromise(promise) {
    return {
        promise() {
            return promise;
        },
        then(fun) {
            return promise.then(fun);
        },
        handle(handlers) {
            var _a;
            (_a = handlers.loading) === null || _a === void 0 ? void 0 : _a.call(handlers);
            promise.then(res => res.handle(handlers));
        }
    };
}
exports.futureResultFromPromise = futureResultFromPromise;
class Result {
    constructor(res) {
        this.res = res;
    }
    handle(handlers) {
        this.match(handlers);
    }
    match(handlers) {
        switch (this.res.kind) {
            case "success":
                return handlers.success(this.res.response);
            case "validation-error":
                return handlers.invalid(this.res.details);
            case "authentication-error":
                return handlers.denied(this.res.details);
            case "internal-error":
                return handlers.error(this.res.errorMsg);
            case "unreachable-error":
                return handlers.unreachable();
        }
        throw "ADT type error: Unknown result type.";
    }
    isSuccess() {
        return this.res.success;
    }
    isError() {
        return !this.res.success;
    }
}
exports.Result = Result;
class Success extends Result {
    constructor(response) {
        super({
            kind: "success",
            success: true,
            response
        });
    }
}
exports.Success = Success;
class ValidError extends Result {
    constructor(details) {
        super({
            kind: "validation-error",
            success: false,
            details
        });
    }
}
exports.ValidError = ValidError;
class AuthError extends Result {
    constructor(details) {
        super({
            kind: "authentication-error",
            success: false,
            details
        });
    }
}
exports.AuthError = AuthError;
class InternalError extends Result {
    constructor(errorMsg) {
        super({
            kind: "internal-error",
            success: false,
            errorMsg
        });
    }
}
exports.InternalError = InternalError;
class UnreachableError extends Result {
    constructor() {
        super({
            kind: "unreachable-error",
            success: false
        });
    }
}
exports.UnreachableError = UnreachableError;