rescript-relay/src/RescriptRelay.bs.js

Use Relay with ReScript.

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

let Utils = require("./utils");
let Stdlib_Option = require("@rescript/runtime/lib/js/Stdlib_Option.js");
let RelayRuntime = require("relay-runtime");
let Primitive_option = require("@rescript/runtime/lib/js/Primitive_option.js");
let Primitive_exceptions = require("@rescript/runtime/lib/js/Primitive_exceptions.js");
let LiveResolverStore = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore");
let LiveResolverStore$1 = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore").default;

function toOption(t) {
  if (t.ok === true) {
    return Primitive_option.some(t.value);
  }
}

function toResult(t) {
  if (t.ok === true) {
    return {
      TAG: "Ok",
      _0: t.value
    };
  } else {
    return {
      TAG: "Error",
      _0: t.errors
    };
  }
}

let CatchResult = {
  toOption: toOption,
  toResult: toResult
};

let SuspenseSentinel = {};

function convertObj(prim0, prim1, prim2, prim3) {
  return Utils.traverser(prim0, prim1, prim2, prim3);
}

function optArrayOfNullableToOptArrayOfOpt(x) {
  if (x !== undefined) {
    return x.map(prim => {
      if (prim == null) {
        return;
      } else {
        return Primitive_option.some(prim);
      }
    });
  }
}

function getLinkedRecords(t, name, $$arguments) {
  return optArrayOfNullableToOptArrayOfOpt(Primitive_option.fromNullable(t.getLinkedRecords(name, $$arguments)));
}

let RecordProxy = {
  getLinkedRecords: getLinkedRecords
};

function getPluralRootField(t, fieldName) {
  return optArrayOfNullableToOptArrayOfOpt(Primitive_option.fromNullable(t.getPluralRootField(fieldName)));
}

function invalidateRecordsByIds(store, recordIds) {
  recordIds.forEach(dataId => Stdlib_Option.forEach(Primitive_option.fromNullable(store.get(dataId)), r => {
    r.invalidateRecord();
  }));
}

let RecordSourceSelectorProxy = {
  getPluralRootField: getPluralRootField,
  invalidateRecordsByIds: invalidateRecordsByIds
};

let ReadOnlyRecordSourceProxy = {};

function makeScalarMissingFieldHandler(handle) {
  return {
    kind: "scalar",
    handle: handle
  };
}

function makeLinkedMissingFieldHandler(handle) {
  return {
    kind: "linked",
    handle: handle
  };
}

function makePluralLinkedMissingFieldHandler(handle) {
  return {
    kind: "pluralLinked",
    handle: handle
  };
}

let MissingFieldHandler = {
  makeScalarMissingFieldHandler: makeScalarMissingFieldHandler,
  makeLinkedMissingFieldHandler: makeLinkedMissingFieldHandler,
  makePluralLinkedMissingFieldHandler: makePluralLinkedMissingFieldHandler
};

let nodeInterfaceMissingFieldHandler = {
  kind: "linked",
  handle: (field, record, args, _store) => {
    let match = field.name;
    let match$1 = args.id;
    if ((record == null) || match !== "node" || record.getType() !== RelayRuntime.ROOT_TYPE) {
      return;
    } else {
      return match$1;
    }
  }
};

let ConnectionHandler = {};

let Disposable = {};

let Observable = {};

let preloadResources = (function preloadResources(operation, variables, response) {
  let metadata = operation.metadata;
  if (metadata == null) return;
  let codesplits = metadata.codesplits;
  if (codesplits == null) return;
  let data = response.data;

  function pathExists(obj, path) {
    let current = obj;

    for (let i = 0; i < path.length; i++) {
      let segment = path[i];

      if (Array.isArray(current)) {
        return current.some((item) => pathExists(item, path.slice(i)));
      } else if (current != null && current.hasOwnProperty(segment)) {
        current = current[segment];
      } else if (current != null && (segment.startsWith("$$u$$") || segment.startsWith("$$i$$"))) {
        let isInterface = segment.startsWith("$$i$$");
        let expectedTypename = segment.slice(5);
        if (
          (
            !isInterface &&
            current.hasOwnProperty("__typename") &&
            current.__typename === expectedTypename) || 
          (
            isInterface &&
            current.hasOwnProperty("__is" + expectedTypename) &&
            current["__is" + expectedTypename] != null
          )
        ) {
          if (i + 1 === path.length) {
            // End
            return true;
          } else {
            continue;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    }

    return current != null;
  }

  function run() {
    for (let instruction of codesplits) {
      let path = instruction[0];
      let func = instruction[1];
      if (pathExists(data, path.split("."))) {
        func(variables);
      }
    }
  }

  if ("requestIdleCallback" in window) {
    requestIdleCallback(run);
  } else {
    setTimeout(() => {
      Promise.resolve().then(run);
    }, 1);
  }
});

let Network = {
  preloadResources: preloadResources
};

let RecordSource = {};

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

function makeLiveStore(source, gcReleaseBufferSize, queryCacheExpirationTime) {
  return new LiveResolverStore$1(source, {
    gcReleaseBufferSize: gcReleaseBufferSize,
    queryCacheExpirationTime: queryCacheExpirationTime
  });
}

function _makeLiveStoreCjs(source, gcReleaseBufferSize, queryCacheExpirationTime) {
  return new LiveResolverStore(source, {
    gcReleaseBufferSize: gcReleaseBufferSize,
    queryCacheExpirationTime: queryCacheExpirationTime
  });
}

let Store = {
  make: make,
  makeLiveStore: makeLiveStore,
  _makeLiveStoreCjs: _makeLiveStoreCjs
};

let RelayFieldLogger = {};

function make$1(network, store, getDataID, treatMissingFieldsAsNull, missingFieldHandlers, relayFieldLogger, isServer) {
  return new RelayRuntime.Environment({
    network: network,
    store: store,
    getDataID: getDataID,
    treatMissingFieldsAsNull: treatMissingFieldsAsNull,
    missingFieldHandlers: missingFieldHandlers !== undefined ? missingFieldHandlers.concat([nodeInterfaceMissingFieldHandler]) : [nodeInterfaceMissingFieldHandler],
    relayFieldLogger: relayFieldLogger,
    isServer: isServer
  });
}

function findAllConnectionIds(environment, connectionKey, parentId) {
  let ids = [];
  let value = environment.getStore().getSource()._records.get(parentId);
  if (value !== undefined) {
    Object.entries(value).forEach(param => {
      if (param[0].startsWith("__" + connectionKey + "_connection")) {
        ids.push(param[1].__ref);
        return;
      }
    });
  }
  return ids;
}

function invalidateAllOfConnection(environment, connectionKey, parentId, excludedIdsOpt) {
  let excludedIds = excludedIdsOpt !== undefined ? excludedIdsOpt : [];
  RelayRuntime.commitLocalUpdate(environment, store => {
    findAllConnectionIds(environment, connectionKey, parentId).forEach(dataId => {
      if (!excludedIds.includes(dataId)) {
        return Stdlib_Option.forEach(Primitive_option.fromNullable(store.get(dataId)), r => {
          r.invalidateRecord();
        });
      }
    });
  });
}

let Environment = {
  make: make$1,
  findAllConnectionIds: findAllConnectionIds,
  invalidateAllOfConnection: invalidateAllOfConnection
};

let Mutation_failed = /* @__PURE__ */Primitive_exceptions.create("RescriptRelay.Mutation_failed");

exports.CatchResult = CatchResult;
exports.SuspenseSentinel = SuspenseSentinel;
exports.convertObj = convertObj;
exports.RecordProxy = RecordProxy;
exports.RecordSourceSelectorProxy = RecordSourceSelectorProxy;
exports.ReadOnlyRecordSourceProxy = ReadOnlyRecordSourceProxy;
exports.MissingFieldHandler = MissingFieldHandler;
exports.ConnectionHandler = ConnectionHandler;
exports.Observable = Observable;
exports.Network = Network;
exports.RecordSource = RecordSource;
exports.Store = Store;
exports.Disposable = Disposable;
exports.RelayFieldLogger = RelayFieldLogger;
exports.Environment = Environment;
exports.Mutation_failed = Mutation_failed;
/* ./utils Not a pure module */