rescript-relay 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -1,8 +1,17 @@
 # master
 
-**All work on version `2.x` is in the [2.x branch](https://github.com/zth/rescript-relay/tree/2.x).**
+# 3.1.0
 
-# **Version 3**
+- **Upgrade versions**: `react-relay` and `relay-runtime` to `18.2.0`.
+- Add support for `Fragment.waitForFragmentData`, a new API in Relay 18.2 that lets you wait for fragment data outside of React.
+- Experimental: Add a "non React" mode to the PPX, which makes sure only APIs that don't rely on React directly are exposed. This is intended to be a way to simplify using RescriptRelay without React. Activate by passing `-non-react` to the PPX, like `"ppx-flags": [["rescript-relay/ppx", "-non-react"]]`.
+
+# 3.0.1
+
+- Add `Environment.findAllConnectionIds` for finding all IDs of all connection instances for a specific connection, regardless of what configs that connection has been fetched (and cached) with.
+- Add `RecordSourceSelectorProxy.invalidateRecordsByIds` for invalidating multilple records at the same time.
+- Allow configuring input unions via `inputUnions` in `relay.config.js` as an escape hatch for when `@oneOf` support on your server is tricky to set up.
+- Move `@rescript/react` to `>=0.13.0`.
 
 # 3.0.0 stable
 

package/README.md

@@ -103,8 +103,8 @@ let make = () => {
 There's plenty of work ongoing to bring RescriptRelay to full ReScript v11 support, including uncurried mode. Here's the versioning scheme that'll be followed going forward:
 
 - 1.x will receive critical bug fixes etc, but new features won't be added
-- 2.x will soon ship, and it'll focus on compatibility with ReScript v11, and uncurried mode (uncurried mode will be optional). This is intended to make the transition to v11+ smooth
-- 3.x will also soon ship, and that'll fully embrace uncurried mode (no curried mode available), and add a bunch of new stuff + change existing APIs to make them better and more ergonomic
+- 2.x will focus on compatibility with ReScript v11, and uncurried mode (uncurried mode will be optional). This is intended to make the transition to v11+ smooth
+- 3.x is fully embracing uncurried mode (no curried mode available), and adds a bunch of new stuff + change existing APIs to make them better and more ergonomic
 
 ## Examples
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",
@@ -49,14 +49,14 @@
     "node-fetch": "^2.6.0",
     "react": "18.2.0",
     "react-dom": "18.2.0",
-    "react-relay": "17.0.0",
-    "relay-runtime": "17.0.0",
+    "react-relay": "18.2.0",
+    "relay-runtime": "18.2.0",
     "rescript": "11.1.1"
   },
   "peerDependencies": {
-    "@rescript/react": "^0.12.1",
-    "react-relay": "17.0.0",
-    "relay-runtime": "17.0.0",
+    "@rescript/react": ">=0.13.0",
+    "react-relay": "18.2.0",
+    "relay-runtime": "18.2.0",
     "rescript": "^11.0.0"
   },
   "dependencies": {

package/src/RescriptRelay.bs.js

@@ -3,13 +3,15 @@
 
 var React = require("react");
 var Utils = require("./utils");
+var Js_dict = require("rescript/lib/js/js_dict.js");
 var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var ReactRelay = require("react-relay");
 var RelayRuntime = require("relay-runtime");
 var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
-var LiveResolverStore = require("relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore");
-var LiveResolverStore$1 = require("relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore").default;
+var LiveResolverStore = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore").default;
+var LiveResolverStore$1 = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore");
 
 var SuspenseSentinel = {};
 
@@ -42,8 +44,17 @@ function getPluralRootField(t, fieldName) {
   return optArrayOfNullableToOptArrayOfOpt(Caml_option.nullable_to_opt(t.getPluralRootField(fieldName)));
 }
 
+function invalidateRecordsByIds(store, recordIds) {
+  recordIds.forEach(function (dataId) {
+        Belt_Option.forEach(Caml_option.nullable_to_opt(store.get(dataId)), (function (r) {
+                r.invalidateRecord();
+              }));
+      });
+}
+
 var RecordSourceSelectorProxy = {
-  getPluralRootField: getPluralRootField
+  getPluralRootField: getPluralRootField,
+  invalidateRecordsByIds: invalidateRecordsByIds
 };
 
 var ReadOnlyRecordSourceProxy = {};
@@ -198,14 +209,14 @@ function make(source, gcReleaseBufferSize, queryCacheExpirationTime) {
 }
 
 function makeLiveStore(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore$1(source, {
+  return new LiveResolverStore(source, {
               gcReleaseBufferSize: gcReleaseBufferSize,
               queryCacheExpirationTime: queryCacheExpirationTime
             });
 }
 
 function _makeLiveStoreCjs(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore(source, {
+  return new LiveResolverStore$1(source, {
               gcReleaseBufferSize: gcReleaseBufferSize,
               queryCacheExpirationTime: queryCacheExpirationTime
             });
@@ -231,8 +242,35 @@ function make$1(network, store, getDataID, treatMissingFieldsAsNull, missingFiel
             });
 }
 
+function findAllConnectionIds(environment, connectionKey, parentId) {
+  var ids = [];
+  var value = environment.getStore().getSource()._records.get(parentId);
+  if (value !== undefined) {
+    Js_dict.entries(value).forEach(function (param) {
+          if (param[0].startsWith("__" + connectionKey + "_connection")) {
+            ids.push(param[1].__ref);
+            return ;
+          }
+          
+        });
+  }
+  return ids;
+}
+
+function invalidateAllOfConnection(environment, connectionKey, parentId) {
+  RelayRuntime.commitLocalUpdate(environment, (function (store) {
+          findAllConnectionIds(environment, connectionKey, parentId).forEach(function (dataId) {
+                Belt_Option.forEach(Caml_option.nullable_to_opt(store.get(dataId)), (function (r) {
+                        r.invalidateRecord();
+                      }));
+              });
+        }));
+}
+
 var Environment = {
-  make: make$1
+  make: make$1,
+  findAllConnectionIds: findAllConnectionIds,
+  invalidateAllOfConnection: invalidateAllOfConnection
 };
 
 function RescriptRelay$Context$Provider(props) {

package/src/RescriptRelay.res

@@ -312,6 +312,12 @@ module RecordSourceSelectorProxy = {
     getPluralRootField(t, ~fieldName)->optArrayOfNullableToOptArrayOfOpt
 
   @send external invalidateStore: t => unit = "invalidateStore"
+
+  let invalidateRecordsByIds: (t, array<dataId>) => unit = (store, recordIds) => {
+    recordIds->Js.Array2.forEach(dataId => {
+      store->get(~dataId)->Belt.Option.forEach(r => r->RecordProxy.invalidateRecord)
+    })
+  }
 }
 
 module ReadOnlyRecordSourceProxy = {
@@ -637,9 +643,9 @@ module Store = {
 
   @module @new
   external makeLiveStoreCjs: (RecordSource.t, storeConfig) => t =
-    "relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore"
+    "relay-runtime/lib/store/live-resolvers/LiveResolverStore"
 
-  @module("relay-runtime/lib/store/experimental-live-resolvers/LiveResolverStore") @new
+  @module("relay-runtime/lib/store/live-resolvers/LiveResolverStore") @new
   external makeLiveStore: (RecordSource.t, storeConfig) => t = "default"
 
   @module("relay-runtime") @new
@@ -680,8 +686,19 @@ module Store = {
 module RelayFieldLogger = {
   @tag("kind")
   type arg =
-    | @as("missing_field.log") MissingFieldLog({owner: string, fieldPath: string})
-    | @as("missing_field.throw") MissingFieldThrow({owner: string, fieldPath: string})
+    | @as("missing_required_field.log") MissingRequiredFieldLog({owner: string, fieldPath: string})
+    | @as("missing_required_field.throw")
+    MissingRequiredFieldThrow({
+        owner: string,
+        fieldPath: string,
+      })
+    | @as("missing_expected_data.log") MissingExpectedData({owner: string, fieldPath: string})
+    | @as("missing_expected_data.throw")
+    MissingExpectedDataThrow({
+        owner: string,
+        fieldPath: string,
+        handled: bool,
+      })
     | @as("relay_resolver.error")
     RelayResolverError({
         owner: string,
@@ -734,6 +751,43 @@ module Environment = {
   @send
   external commitPayload: (t, operationDescriptor, 'payload) => unit = "commitPayload"
   @send external retain: (t, operationDescriptor) => Disposable.t = "retain"
+
+  @module("relay-runtime")
+  external commitLocalUpdate: (t, ~updater: RecordSourceSelectorProxy.t => unit) => unit =
+    "commitLocalUpdate"
+
+  @send external mapGet: (Js.Map.t<'key, 'value>, 'key) => option<'value> = "get"
+
+  type recordValue = {__ref: dataId}
+  @get external _records: RecordSource.t => Js.Map.t<string, Js.Dict.t<recordValue>> = "_records"
+
+  let findAllConnectionIds = (environment: t, ~connectionKey: string, ~parentId: dataId) => {
+    let ids = []
+    switch environment->getStore->Store.getSource->_records->mapGet(parentId->dataIdToString) {
+    | Some(value) =>
+      value
+      ->Js.Dict.entries
+      ->Js.Array2.forEach(((key, v)) => {
+        if key->Js.String2.startsWith("__" ++ connectionKey ++ "_connection") {
+          let _ = ids->Js.Array2.push(v.__ref)
+        }
+      })
+    | _ => ()
+    }
+    ids
+  }
+
+  let invalidateAllOfConnection = (environment: t, ~connectionKey: string, ~parentId: dataId) => {
+    environment->commitLocalUpdate(~updater=store => {
+      environment
+      ->findAllConnectionIds(~connectionKey, ~parentId)
+      ->Js.Array2.forEach(dataId => {
+        store
+        ->RecordSourceSelectorProxy.get(~dataId)
+        ->Belt.Option.forEach(r => r->RecordProxy.invalidateRecord)
+      })
+    })
+  }
 }
 
 module Context = {

package/src/RescriptRelay.resi

@@ -399,6 +399,9 @@ module RecordSourceSelectorProxy: {
   /**Invalidates the entire store. This means that _at the next render_, the entire store will be treated as empty, meaning Relay will refetch everything it needs to show the view it's to show.*/
   @send
   external invalidateStore: t => unit = "invalidateStore"
+
+  /**Invalidates each of the provided records by their ID, if they exist. */
+  let invalidateRecordsByIds: (t, array<dataId>) => unit
 }
 
 /**ReadOnlyRecordSourceProxy is the store, but in read-only mode.*/
@@ -741,8 +744,19 @@ module Disposable: {
 module RelayFieldLogger: {
   @tag("kind")
   type arg =
-    | @as("missing_field.log") MissingFieldLog({owner: string, fieldPath: string})
-    | @as("missing_field.throw") MissingFieldThrow({owner: string, fieldPath: string})
+    | @as("missing_required_field.log") MissingRequiredFieldLog({owner: string, fieldPath: string})
+    | @as("missing_required_field.throw")
+    MissingRequiredFieldThrow({
+        owner: string,
+        fieldPath: string,
+      })
+    | @as("missing_expected_data.log") MissingExpectedData({owner: string, fieldPath: string})
+    | @as("missing_expected_data.throw")
+    MissingExpectedDataThrow({
+        owner: string,
+        fieldPath: string,
+        handled: bool,
+      })
     | @as("relay_resolver.error")
     RelayResolverError({
         owner: string,
@@ -785,6 +799,12 @@ module Environment: {
 You should use the generated `Query.retain` function on your queries instead of using this directly.*/
   @send
   external retain: (t, operationDescriptor) => Disposable.t = "retain"
+
+  /**Find all connection IDs for a specific connection and on a specific object. Useful together with `@deleteEdge` and similar where you want to remove something from all connection configurations. */
+  let findAllConnectionIds: (t, ~connectionKey: string, ~parentId: dataId) => array<dataId>
+
+  /**Invalidates all connection configurations of `connectionKey` on `parentId`.*/
+  let invalidateAllOfConnection: (t, ~connectionKey: string, ~parentId: dataId) => unit
 }
 
 /**fetchPolicy controls how you want Relay to resolve your data.*/

package/src/RescriptRelay_Fragment.bs.js

@@ -5,6 +5,7 @@ var React = require("react");
 var Caml_option = require("rescript/lib/js/caml_option.js");
 var ReactRelay = require("react-relay");
 var RescriptRelay_Internal = require("./RescriptRelay_Internal.bs.js");
+var Experimental = require("relay-runtime/experimental");
 var ResolverFragments = require("relay-runtime/lib/store/ResolverFragments");
 var UseBlockingPaginationFragment = require("react-relay/lib/relay-hooks/legacy/useBlockingPaginationFragment").default;
 
@@ -112,6 +113,11 @@ function useRefetchableFragment(node, convertFragment, convertRefetchVariables,
         ];
 }
 
+async function waitForFragmentData(environment, node, convertFragment, fRef) {
+  var fragmentData = await Experimental.waitForFragmentData(environment, node, fRef);
+  return convertFragment(fragmentData);
+}
+
 exports.useFragment = useFragment;
 exports.useFragmentOpt = useFragmentOpt;
 exports.readInlineData = readInlineData;
@@ -119,4 +125,5 @@ exports.read = read;
 exports.usePaginationFragment = usePaginationFragment;
 exports.useBlockingPaginationFragment = useBlockingPaginationFragment;
 exports.useRefetchableFragment = useRefetchableFragment;
+exports.waitForFragmentData = waitForFragmentData;
 /* react Not a pure module */

package/src/RescriptRelay_Fragment.res

@@ -241,3 +241,20 @@ let useRefetchableFragment = (
     ),
   )
 }
+
+@module("relay-runtime/experimental")
+external waitForFragmentData_: (
+  Environment.t,
+  fragmentNode<'node>,
+  'fragmentRef,
+) => promise<'fragment> = "waitForFragmentData"
+
+let waitForFragmentData = async (
+  ~environment,
+  ~node,
+  ~convertFragment: 'fragment => 'fragment,
+  ~fRef,
+) => {
+  let fragmentData = await waitForFragmentData_(environment, node, fRef)
+  convertFragment(fragmentData)
+}

package/src/RescriptRelay_Fragment.resi

@@ -83,3 +83,10 @@ let useRefetchableFragment: (
     ~onComplete: option<Js.Exn.t> => unit=?,
   ) => Disposable.t,
 )
+
+let waitForFragmentData: (
+  ~environment: Environment.t,
+  ~node: fragmentNode<'a>,
+  ~convertFragment: 'fragment => 'fragment,
+  ~fRef: 'b,
+) => promise<'fragment>