@hazae41/jsonrpc/dist/cjs/mods/rpc/err.cjs

Rust-like JSON-RPC for TypeScript

'use strict';

var result = require('@hazae41/result');
var index = require('../../libs/errors/index.cjs');

exports.RpcErrInit = void 0;
(function (RpcErrInit) {
    function from(response) {
        return response.toJSON();
    }
    RpcErrInit.from = from;
})(exports.RpcErrInit || (exports.RpcErrInit = {}));
class RpcError extends Error {
    code;
    message;
    data;
    #class = RpcError;
    name = this.#class.name;
    static codes = {
        ParseError: -32700,
        InvalidRequest: -32600,
        MethodNotFound: -32601,
        InvalidParams: -32602,
        InternalError: -32603
    };
    static messages = {
        ParseError: "Parse error",
        InvalidRequest: "Invalid Request",
        MethodNotFound: "Method not found",
        InvalidParams: "Invalid params",
        InternalError: "Internal error",
        ServerError: "Server error"
    };
    constructor(code, message, data = undefined) {
        super(message);
        this.code = code;
        this.message = message;
        this.data = data;
    }
    static from(init) {
        const { code, message, data } = init;
        return new RpcError(code, message, data);
    }
    static rewrap(error) {
        if (error instanceof RpcError)
            return error;
        return new RpcInternalError(index.Errors.toString(error));
    }
    toJSON() {
        const { code, message, data } = this;
        return { code, message, data };
    }
}
class RpcParseError extends RpcError {
    #class = RpcParseError;
    name = this.#class.name;
    static code = RpcError.codes.ParseError;
    static message = RpcError.messages.ParseError;
    constructor(message = RpcError.messages.ParseError) {
        super(RpcError.codes.ParseError, message);
    }
}
class RpcInvalidRequestError extends RpcError {
    #class = RpcInvalidRequestError;
    name = this.#class.name;
    static code = RpcError.codes.InvalidRequest;
    static message = RpcError.messages.InvalidRequest;
    constructor(message = RpcError.messages.InvalidRequest) {
        super(RpcError.codes.InvalidRequest, message);
    }
}
class RpcMethodNotFoundError extends RpcError {
    #class = RpcMethodNotFoundError;
    name = this.#class.name;
    static code = RpcError.codes.MethodNotFound;
    static message = RpcError.messages.MethodNotFound;
    constructor(message = RpcError.messages.MethodNotFound) {
        super(RpcError.codes.MethodNotFound, message);
    }
}
class RpcInvalidParamsError extends RpcError {
    #class = RpcInvalidParamsError;
    name = this.#class.name;
    static code = RpcError.codes.InvalidParams;
    static message = RpcError.messages.InvalidParams;
    constructor(message = RpcError.messages.InvalidParams) {
        super(RpcError.codes.InvalidParams, message);
    }
}
class RpcInternalError extends RpcError {
    #class = RpcInternalError;
    name = this.#class.name;
    static code = RpcError.codes.InternalError;
    static message = RpcError.messages.InternalError;
    constructor(message = RpcError.messages.InternalError) {
        super(RpcError.codes.InternalError, message);
    }
}
class RpcErr extends result.Err {
    id;
    error;
    jsonrpc = "2.0";
    constructor(id, error) {
        super(error);
        this.id = id;
        this.error = error;
    }
    static from(init) {
        return new RpcErr(init.id, RpcError.from(init.error));
    }
    static rewrap(id, result) {
        return new RpcErr(id, RpcError.rewrap(result.inner));
    }
    toJSON() {
        const { jsonrpc, id } = this;
        const error = this.error.toJSON();
        return { jsonrpc, id, error };
    }
}

exports.RpcErr = RpcErr;
exports.RpcError = RpcError;
exports.RpcInternalError = RpcInternalError;
exports.RpcInvalidParamsError = RpcInvalidParamsError;
exports.RpcInvalidRequestError = RpcInvalidRequestError;
exports.RpcMethodNotFoundError = RpcMethodNotFoundError;
exports.RpcParseError = RpcParseError;
//# sourceMappingURL=err.cjs.map