reason-relay/src/ReasonRelay.bs.js

Use Relay with ReScript.

// Generated by ReScript, PLEASE EDIT WITH CARE
'use strict';

var Curry = require("bs-platform/lib/js/curry.js");
var React = require("react");
var Utils = require("./utils");
var $$Promise = require("reason-promise/src/js/promise.bs.js");
var Belt_Array = require("bs-platform/lib/js/belt_Array.js");
var Caml_option = require("bs-platform/lib/js/caml_option.js");
var ReactRelay = require("react-relay");
var RelayRuntime = require("relay-runtime");
var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions.js");
var Hooks = require("react-relay/hooks");

function convertObj(prim, prim$1, prim$2, prim$3) {
  return Utils.traverser(prim, prim$1, prim$2, prim$3);
}

function optArrayOfNullableToOptArrayOfOpt(x) {
  if (x !== undefined) {
    return Belt_Array.map(x, (function (prim) {
                  if (prim == null) {
                    return ;
                  } else {
                    return Caml_option.some(prim);
                  }
                }));
  }
  
}

function getLinkedRecords(t, name, $$arguments, param) {
  return optArrayOfNullableToOptArrayOfOpt(Caml_option.nullable_to_opt(t.getLinkedRecords(name, $$arguments)));
}

var RecordProxy = {
  getLinkedRecords: getLinkedRecords
};

function getPluralRootField(t, fieldName) {
  return optArrayOfNullableToOptArrayOfOpt(Caml_option.nullable_to_opt(t.getPluralRootField(fieldName)));
}

var RecordSourceSelectorProxy = {
  getPluralRootField: getPluralRootField
};

var ConnectionHandler = {};

var Disposable = {};

var Observable = {};

var Network = {};

var RecordSource = {};

function make(source, gcReleaseBufferSize, queryCacheExpirationTime, param) {
  return new RelayRuntime.Store(source, {
              gcReleaseBufferSize: gcReleaseBufferSize,
              queryCacheExpirationTime: queryCacheExpirationTime
            });
}

var Store = {
  make: make
};

function mapRenderPolicy(x) {
  if (x !== undefined) {
    if (x) {
      return "partial";
    } else {
      return "full";
    }
  }
  
}

function make$1(network, store, getDataID, defaultRenderPolicy, treatMissingFieldsAsNull, param) {
  var tmp = {
    network: network,
    store: store,
    missingFieldHandlers: ([
              {
                kind: "linked",
                handle: function(field, record, args, store) {
                  if (
                    record != null &&
                    record.__typename === require("relay-runtime").ROOT_TYPE &&
                    field.name === "node" &&
                    args.hasOwnProperty("id")
                  ) {
                    return args.id;
                  }
                }
              }
            ])
  };
  if (getDataID !== undefined) {
    tmp.UNSTABLE_DO_NOT_USE_getDataID = Caml_option.valFromOption(getDataID);
  }
  var tmp$1 = mapRenderPolicy(defaultRenderPolicy);
  if (tmp$1 !== undefined) {
    tmp.UNSTABLE_defaultRenderPolicy = Caml_option.valFromOption(tmp$1);
  }
  if (treatMissingFieldsAsNull !== undefined) {
    tmp.treatMissingFieldsAsNull = Caml_option.valFromOption(treatMissingFieldsAsNull);
  }
  return new RelayRuntime.Environment(tmp);
}

var Environment = {
  make: make$1
};

var provider = ReactRelay.ReactRelayContext.Provider;

function ReasonRelay$Context$Provider(Props) {
  var environment = Props.environment;
  var children = Props.children;
  return React.createElement(provider, {
              value: {
                environment: environment
              },
              children: children
            });
}

var Provider = {
  make: ReasonRelay$Context$Provider
};

var EnvironmentNotFoundInContext = Caml_exceptions.create("ReasonRelay.EnvironmentNotFoundInContext");

function useEnvironmentFromContext(param) {
  var context = React.useContext(ReactRelay.ReactRelayContext);
  if (context !== undefined) {
    return Caml_option.valFromOption(context).environment;
  }
  throw {
        RE_EXN_ID: EnvironmentNotFoundInContext,
        Error: new Error()
      };
}

function mapFetchPolicy(x) {
  if (x === undefined) {
    return ;
  }
  switch (x) {
    case /* StoreOnly */0 :
        return "store-only";
    case /* StoreOrNetwork */1 :
        return "store-or-network";
    case /* StoreAndNetwork */2 :
        return "store-and-network";
    case /* NetworkOnly */3 :
        return "network-only";
    
  }
}

function mapFetchQueryFetchPolicy(x) {
  if (x !== undefined) {
    if (x) {
      return "store-or-network";
    } else {
      return "network-only";
    }
  }
  
}

function MakeLoadQuery(C) {
  var load = function (environment, variables, fetchPolicy, fetchKey, networkCacheConfig, param) {
    return Hooks.loadQuery(environment, C.query, Curry._1(C.convertVariables, variables), {
                fetchKey: fetchKey,
                fetchPolicy: mapFetchPolicy(fetchPolicy),
                networkCacheConfig: networkCacheConfig
              });
  };
  var queryRefToObservable = function (token) {
    return Caml_option.nullable_to_opt(token.source);
  };
  var queryRefToPromise = function (token) {
    var match = $$Promise.pending(undefined);
    var resolve = match[1];
    var o = queryRefToObservable(token);
    if (o !== undefined) {
      Caml_option.valFromOption(o).subscribe({
            complete: (function (param) {
                return Curry._1(resolve, {
                            TAG: /* Ok */0,
                            _0: undefined
                          });
              })
          });
    } else {
      Curry._1(resolve, {
            TAG: /* Error */1,
            _0: undefined
          });
    }
    return match[0];
  };
  return {
          load: load,
          queryRefToObservable: queryRefToObservable,
          queryRefToPromise: queryRefToPromise
        };
}

var Mutation_failed = Caml_exceptions.create("ReasonRelay.Mutation_failed");

var Context = {
  Provider: Provider
};

exports.convertObj = convertObj;
exports.RecordProxy = RecordProxy;
exports.RecordSourceSelectorProxy = RecordSourceSelectorProxy;
exports.ConnectionHandler = ConnectionHandler;
exports.Observable = Observable;
exports.Network = Network;
exports.RecordSource = RecordSource;
exports.Store = Store;
exports.mapRenderPolicy = mapRenderPolicy;
exports.Disposable = Disposable;
exports.Environment = Environment;
exports.mapFetchPolicy = mapFetchPolicy;
exports.mapFetchQueryFetchPolicy = mapFetchQueryFetchPolicy;
exports.Context = Context;
exports.EnvironmentNotFoundInContext = EnvironmentNotFoundInContext;
exports.useEnvironmentFromContext = useEnvironmentFromContext;
exports.Mutation_failed = Mutation_failed;
exports.MakeLoadQuery = MakeLoadQuery;
/* provider Not a pure module */