error_example.re

module Errors: {
  type t;
  type baseError = {
    name: string,
    info: string,
    message: string
  };
  type noHostAvailableError = {
    name: string,
    info: string,
    message: string,
    innerErrors: list((string, string))
  };
  type responseError = {
    name: string,
    info: string,
    message: string,
    code: int
  };
  exception NoHostAvailableError(noHostAvailableError);
  exception ResponseError(responseError);
  exception DriverInternalError(baseError);
  exception AuthenticationError(baseError);
  exception ArgumentError(baseError);
  exception OperationTimedOutError(baseError);
  exception NotSupportedError(baseError);
  exception UnknownError(unit);
  exception NilResultSetError(unit);
  exception InvalidJSError(string);
  type jse = {
    .
    "name": string,
    "info": string,
    "message": string,
    "innerErrors": Js.Nullable.t(Js.Dict.t(jse)),
    "code": Js.Nullable.t(int)
  };
  let fromJSError: jse => exn;
} = {
  type t;
  type errors = {
    .
    "_NoHostAvailableError": t,
    "_ResponseError": t,
    "_DriverInternalError": t,
    "_AuthenticationError": t,
    "_ArgumentError": t,
    "_OperationTimedOutError": t,
    "_NotSupportedError": t
  };
  [@bs.module "cassandra-driver"] external errors : errors = "";
  let errNoHostAvailableError = errors##_NoHostAvailableError;
  let errResponseError = errors##_ResponseError;
  let errDriverInternalError = errors##_DriverInternalError;
  let errAuthenticationError = errors##_AuthenticationError;
  let errArgumentError = errors##_ArgumentError;
  let errOperationTimedOutError = errors##_OperationTimedOutError;
  let errNotSupportedError = errors##_NotSupportedError;
  [@bs.deriving jsConverter]
  type baseError = {
    name: string,
    info: string,
    message: string
  };
  [@bs.deriving jsConverter]
  type noHostAvailableError = {
    name: string,
    info: string,
    message: string,
    innerErrors: list((string, string))
  };
  [@bs.deriving jsConverter]
  type responseError = {
    name: string,
    info: string,
    message: string,
    code: int
  };
  exception NoHostAvailableError(noHostAvailableError);
  exception ResponseError(responseError);
  exception DriverInternalError(baseError);
  exception AuthenticationError(baseError);
  exception ArgumentError(baseError);
  exception OperationTimedOutError(baseError);
  exception NotSupportedError(baseError);
  exception UnknownError(unit);
  exception NilResultSetError(unit);
  exception InvalidJSError(string);
  [%%bs.raw
    {|
    function isErrorOfClass(obj, errClass) {
      return (obj instanceof errClass);
    }
  |}
  ];
  [@bs.val] external isErrorOfClass : ('a, t) => bool = "";
  type jse = {
    .
    "name": string,
    "info": string,
    "message": string,
    "innerErrors": Js.Nullable.t(Js.Dict.t(jse)),
    "code": Js.Nullable.t(int)
  };
  let fromJSError = (e: jse) =>
    if (isErrorOfClass(e, errNoHostAvailableError)) {
      switch (Js.toOption(e##innerErrors)) {
      | Some(innerErrors) =>
        Js.log(innerErrors);
        NoHostAvailableError({
          name: e##name,
          info: e##info,
          message: e##message,
          innerErrors:
            Js.Dict.entries(innerErrors)
            |> Js.Array.map(((k, v)) => (k, v##message))
            |> Array.to_list
        });
      | None =>
        raise(
          InvalidJSError(
            "`innerErrors` is not present in NoHostAvailableError"
          )
        )
      };
    } else if (isErrorOfClass(e, errResponseError)) {
      switch (Js.toOption(e##code)) {
      | Some(code) =>
        ResponseError({
          name: e##name,
          info: e##info,
          message: e##message,
          code
        })
      | None => raise(InvalidJSError("`code` is not present in ResponseError"))
      };
    } else if (isErrorOfClass(e, errDriverInternalError)) {
      DriverInternalError(baseErrorFromJs(e));
    } else if (isErrorOfClass(e, errAuthenticationError)) {
      AuthenticationError(baseErrorFromJs(e));
    } else if (isErrorOfClass(e, errArgumentError)) {
      ArgumentError(baseErrorFromJs(e));
    } else if (isErrorOfClass(e, errOperationTimedOutError)) {
      OperationTimedOutError(baseErrorFromJs(e));
    } else if (isErrorOfClass(e, errNotSupportedError)) {
      NotSupportedError(baseErrorFromJs(e));
    } else {
      UnknownError();
    };
};