errors.re

module Errors = {
  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 responseError = {
    baseError,
    code: int,
  };
  exception NoHostAvailableError(baseError);
  exception ResponseError(responseError);
  exception DriverInternalError(baseError);
  exception AuthenticationError(baseError);
  exception ArgumentError(baseError);
  exception OperationTimedOutError(baseError);
  exception NotSupportedError(baseError);
  exception UnknownError(unit);
  exception NilResultSetError(unit);
  [%%bs.raw{|
    function isErrorOfClass(obj, errClass) {
      return (obj instanceof errClass);
    }
  |}];
  external isErrorOfClass : ('a, t) => bool = "";
  let fromJSError = (e) => {
    if (isErrorOfClass(e, errNoHostAvailableError)) {
      NoHostAvailableError(baseErrorFromJs(e));
    } else if (isErrorOfClass(e, errResponseError)) {
      ResponseError(responseErrorFromJs(e));
    } 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();
    }
  };
};

Generates "not_implemented" calls:

function fromJSError(e) {
  if (Caml_missing_polyfill.not_implemented(" not implemented by bucklescript yet\n")) {
    return [
            NoHostAvailableError,
            baseErrorFromJs(e)
          ];
  } else if (Caml_missing_polyfill.not_implemented(" not implemented by bucklescript yet\n")) {
    return [
            ResponseError,
            responseErrorFromJs(e)
          ];
  } else if (Caml_missing_polyfill.not_implemented(" not implemented by bucklescript yet\n")) {
    return [
            DriverInternalError,
            baseErrorFromJs(e)
          ];
  } else if (Caml_missing_polyfill.not_implemented(" not implemented by bucklescript yet\n")) {
    return [
            AuthenticationError,
            baseErrorFromJs(e)
          ];
  } else if (Caml_missing_polyfill.not_implemented(" not implemented by bucklescript yet\n")) {
    return [
            ArgumentError,
            baseErrorFromJs(e)
          ];
  } else if (Caml_missing_polyfill.not_implemented(" not implemented by bucklescript yet\n")) {
    return [
            OperationTimedOutError,
            baseErrorFromJs(e)
          ];
  } else if (Caml_missing_polyfill.not_implemented(" not implemented by bucklescript yet\n")) {
    return [
            NotSupportedError,
            baseErrorFromJs(e)
          ];
  } else {
    return [
            UnknownError,
            /* () */0
          ];
  }
}