rescript-relay 3.5.1 → 4.1.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # master
 
+# 4.1.0
+
+- Add support for `autoExhaustiveTypes` config and a `@nonExhaustive` directive to control automatic exhaustive checks for unions/interfaces.
+
+- Add React-free mode support and split React APIs into `RescriptRelayReact`.
+
+  - New compiler config: `rescriptRelayMode: "Default" | "NonReact"` (defaults to `"Default"`).
+  - PPX `-non-react`
+  - Mark `@rescript/react` and `react-relay` as optional peer deps so non‑React usage does not require them.
+
+- BREAKING: Move all React-specific APIs out of `RescriptRelay` into `RescriptRelayReact`.
+
+  - `RescriptRelay.Context.Provider` -> `RescriptRelayReact.Context.Provider`
+  - `RescriptRelay.useEnvironmentFromContext` -> `RescriptRelayReact.useEnvironmentFromContext`
+  - `RescriptRelay.useSubscribeToInvalidationState` -> `RescriptRelayReact.useSubscribeToInvalidationState`
+
+  Migration:
+
+  - Update imports/usages in app code to reference `RescriptRelayReact` for the APIs listed above.
+  - For non‑React usage, set `rescriptRelayMode: "NonReact"` in `relay.config.js` and pass `-non-react` to the PPX.
+
+# 4.0.0
+
+- Support `@exhaustive` on interfaces as well.
+- Remove `ReactDOMExperimental` module, since everything needed is in the official RescriptReact bindings now.
+- Move fully to ReScript v12. From `4.x`, only v12 is supported.
+
 # 3.5.1
 
 - Build Linux PPX binary in Debian 11 (bullseye) container to improve compatibility with older glibc versions. The binary now requires glibc 2.31 instead of 2.39, supporting Amazon Linux 2023 (Vercel), Ubuntu 20.04+, Debian 11+, and RHEL 9+.

package/README.md

@@ -69,7 +69,7 @@ let make = (~user) => {
     <div>
       <p>
         {React.string(
-          userData.firstName ++ (" has " ++ (userData.friendCount->string_of_int ++ " friends.")),
+          userData.firstName ++ (" has " ++ (userData.friendCount->Int.toString ++ " friends.")),
         )}
       </p>
     </div>
@@ -100,11 +100,21 @@ let make = () => {
 
 ## Note about versioning
 
-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:
+RescriptRelay has moved through a few major lines with different ReScript baselines. Use the compatibility guide below to pick the right versions:
+
+### Compatibility
+
+| RescriptRelay | Required ReScript |
+| ------------- | ----------------- |
+| 4.x and newer | v12.x (or newer)  |
+| 3.x and below | v11.x (or older)  |
+
+Additional context on historical focus areas:
 
 - 1.x will receive critical bug fixes etc, but new features won't be added
-- 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
+- 2.x focuses on compatibility with ReScript v11, and uncurried mode (uncurried mode can be optional). This is intended to make the transition to v11+ smooth
+- 3.x fully embraces uncurried mode (no curried mode available), and adds a bunch of new stuff + changes existing APIs to make them better and more ergonomic
+- 4.x focuses exclusively on ReScript v12+.
 
 ## Examples
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "3.5.1",
+  "version": "4.1.0",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",
@@ -33,31 +33,44 @@
   },
   "scripts": {
     "build": "rescript",
-    "build:test": "./build-compiler-dev.sh && ./rescript-relay-compiler",
+    "build:test": "./build-compiler-dev.sh && ./rescript-relay-compiler && ENABLE_PERSISTING=true ./rescript-relay-compiler && rm ./__tests_preloaded__/__generated__/RelaySchemaAssets_graphql.res",
     "postinstall": "node postinstall.js",
-    "test": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest",
-    "test:ci": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest --ci --runInBand"
+    "test": "jest",
+    "test:ci": "jest --ci --runInBand"
   },
   "devDependencies": {
     "@glennsl/rescript-fetch": "^0.2.0",
-    "@rescript/react": "0.12.2",
+    "@rescript/react": "0.14.0",
     "@testing-library/jest-dom": "^5.16.3",
     "@testing-library/react": "^13.0.0-alpha.6",
     "graphql-query-test-mock": "^0.12.1",
     "jest": "^27.2.4",
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "babel-jest": "^27.2.4",
+    "babel-plugin-dynamic-import-node": "^2.3.3",
     "nock": "^11.7.0",
     "node-fetch": "^2.6.0",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "react-relay": "20.1.1",
     "relay-runtime": "20.1.1",
-    "rescript": "11.1.1"
+    "rescript": "12.0.0"
   },
   "peerDependencies": {
     "@rescript/react": ">=0.13.0",
     "react-relay": "20.1.1",
     "relay-runtime": "20.1.1",
-    "rescript": "^11.0.0"
+    "rescript": "^12.0.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@rescript/react": {
+      "optional": true
+    },
+    "react-relay": {
+      "optional": true
+    }
   },
   "dependencies": {
     "detect-libc": "^2.0.1"

package/src/RescriptRelay.bs.js

@@ -1,45 +1,40 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
-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/live-resolvers/LiveResolverStore").default;
-var LiveResolverStore$1 = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore");
+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 Caml_option.some(t.value);
+    return Primitive_option.some(t.value);
   }
-  
 }
 
 function toResult(t) {
   if (t.ok === true) {
     return {
-            TAG: "Ok",
-            _0: t.value
-          };
+      TAG: "Ok",
+      _0: t.value
+    };
   } else {
     return {
-            TAG: "Error",
-            _0: t.errors
-          };
+      TAG: "Error",
+      _0: t.errors
+    };
   }
 }
 
-var CatchResult = {
+let CatchResult = {
   toOption: toOption,
   toResult: toResult
 };
 
-var SuspenseSentinel = {};
+let SuspenseSentinel = {};
 
 function convertObj(prim0, prim1, prim2, prim3) {
   return Utils.traverser(prim0, prim1, prim2, prim3);
@@ -47,114 +42,111 @@ function convertObj(prim0, prim1, prim2, prim3) {
 
 function optArrayOfNullableToOptArrayOfOpt(x) {
   if (x !== undefined) {
-    return Belt_Array.map(x, (function (prim) {
-                  if (prim == null) {
-                    return ;
-                  } else {
-                    return Caml_option.some(prim);
-                  }
-                }));
+    return x.map(prim => {
+      if (prim == null) {
+        return;
+      } else {
+        return Primitive_option.some(prim);
+      }
+    });
   }
-  
 }
 
 function getLinkedRecords(t, name, $$arguments) {
-  return optArrayOfNullableToOptArrayOfOpt(Caml_option.nullable_to_opt(t.getLinkedRecords(name, $$arguments)));
+  return optArrayOfNullableToOptArrayOfOpt(Primitive_option.fromNullable(t.getLinkedRecords(name, $$arguments)));
 }
 
-var RecordProxy = {
+let RecordProxy = {
   getLinkedRecords: getLinkedRecords
 };
 
 function getPluralRootField(t, fieldName) {
-  return optArrayOfNullableToOptArrayOfOpt(Caml_option.nullable_to_opt(t.getPluralRootField(fieldName)));
+  return optArrayOfNullableToOptArrayOfOpt(Primitive_option.fromNullable(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();
-              }));
-      });
+  recordIds.forEach(dataId => Stdlib_Option.forEach(Primitive_option.fromNullable(store.get(dataId)), r => {
+    r.invalidateRecord();
+  }));
 }
 
-var RecordSourceSelectorProxy = {
+let RecordSourceSelectorProxy = {
   getPluralRootField: getPluralRootField,
   invalidateRecordsByIds: invalidateRecordsByIds
 };
 
-var ReadOnlyRecordSourceProxy = {};
+let ReadOnlyRecordSourceProxy = {};
 
 function unwrapNormalizationArgument(wrapped) {
-  var match = wrapped.kind;
+  let match = wrapped.kind;
   if (match === "Literal") {
     return {
-            TAG: "Literal",
-            _0: wrapped
-          };
+      TAG: "Literal",
+      _0: wrapped
+    };
   } else if (match === "ListValue") {
     return {
-            TAG: "ListValue",
-            _0: wrapped
-          };
+      TAG: "ListValue",
+      _0: wrapped
+    };
   } else if (match === "ObjectValue") {
     return {
-            TAG: "ObjectValue",
-            _0: wrapped
-          };
+      TAG: "ObjectValue",
+      _0: wrapped
+    };
   } else {
     return {
-            TAG: "Variable",
-            _0: wrapped
-          };
+      TAG: "Variable",
+      _0: wrapped
+    };
   }
 }
 
 function makeScalarMissingFieldHandler(handle) {
   return {
-          kind: "scalar",
-          handle: handle
-        };
+    kind: "scalar",
+    handle: handle
+  };
 }
 
 function makeLinkedMissingFieldHandler(handle) {
   return {
-          kind: "linked",
-          handle: handle
-        };
+    kind: "linked",
+    handle: handle
+  };
 }
 
 function makePluralLinkedMissingFieldHandler(handle) {
   return {
-          kind: "pluralLinked",
-          handle: handle
-        };
+    kind: "pluralLinked",
+    handle: handle
+  };
 }
 
-var MissingFieldHandler = {
+let MissingFieldHandler = {
   unwrapNormalizationArgument: unwrapNormalizationArgument,
   makeScalarMissingFieldHandler: makeScalarMissingFieldHandler,
   makeLinkedMissingFieldHandler: makeLinkedMissingFieldHandler,
   makePluralLinkedMissingFieldHandler: makePluralLinkedMissingFieldHandler
 };
 
-var nodeInterfaceMissingFieldHandler = makeLinkedMissingFieldHandler(function (field, record, args, _store) {
-      var match = field.name;
-      var match$1 = args.id;
-      if ((record == null) || !(match === "node" && record.getType() === RelayRuntime.ROOT_TYPE && !(match$1 == null))) {
-        return ;
-      } else {
-        return Caml_option.some(match$1);
-      }
-    });
+let nodeInterfaceMissingFieldHandler = makeLinkedMissingFieldHandler((field, record, args, _store) => {
+  let match = field.name;
+  let match$1 = args.id;
+  if ((record == null) || match !== "node" || record.getType() !== RelayRuntime.ROOT_TYPE || (match$1 == null)) {
+    return;
+  } else {
+    return Primitive_option.some(match$1);
+  }
+});
 
-var ConnectionHandler = {};
+let ConnectionHandler = {};
 
-var Disposable = {};
+let Disposable = {};
 
-var Observable = {};
+let Observable = {};
 
-var preloadResources = (function preloadResources(operation, variables, response) {
+let preloadResources = (function preloadResources(operation, variables, response) {
   let metadata = operation.metadata;
   if (metadata == null) return;
   let codesplits = metadata.codesplits;
@@ -221,159 +213,87 @@ var preloadResources = (function preloadResources(operation, variables, response
   }
 });
 
-var Network = {
+let Network = {
   preloadResources: preloadResources
 };
 
-var RecordSource = {};
+let RecordSource = {};
 
 function make(source, gcReleaseBufferSize, queryCacheExpirationTime) {
   return new RelayRuntime.Store(source, {
-              gcReleaseBufferSize: gcReleaseBufferSize,
-              queryCacheExpirationTime: queryCacheExpirationTime
-            });
+    gcReleaseBufferSize: gcReleaseBufferSize,
+    queryCacheExpirationTime: queryCacheExpirationTime
+  });
 }
 
 function makeLiveStore(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore(source, {
-              gcReleaseBufferSize: gcReleaseBufferSize,
-              queryCacheExpirationTime: queryCacheExpirationTime
-            });
+  return new LiveResolverStore$1(source, {
+    gcReleaseBufferSize: gcReleaseBufferSize,
+    queryCacheExpirationTime: queryCacheExpirationTime
+  });
 }
 
 function _makeLiveStoreCjs(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore$1(source, {
-              gcReleaseBufferSize: gcReleaseBufferSize,
-              queryCacheExpirationTime: queryCacheExpirationTime
-            });
+  return new LiveResolverStore(source, {
+    gcReleaseBufferSize: gcReleaseBufferSize,
+    queryCacheExpirationTime: queryCacheExpirationTime
+  });
 }
 
-var Store = {
+let Store = {
   make: make,
   makeLiveStore: makeLiveStore,
   _makeLiveStoreCjs: _makeLiveStoreCjs
 };
 
-var RelayFieldLogger = {};
+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 ? Belt_Array.concat(missingFieldHandlers, [nodeInterfaceMissingFieldHandler]) : [nodeInterfaceMissingFieldHandler],
-              relayFieldLogger: relayFieldLogger,
-              isServer: isServer
-            });
+    network: network,
+    store: store,
+    getDataID: getDataID,
+    treatMissingFieldsAsNull: treatMissingFieldsAsNull,
+    missingFieldHandlers: missingFieldHandlers !== undefined ? missingFieldHandlers.concat([nodeInterfaceMissingFieldHandler]) : [nodeInterfaceMissingFieldHandler],
+    relayFieldLogger: relayFieldLogger,
+    isServer: isServer
+  });
 }
 
 function findAllConnectionIds(environment, connectionKey, parentId) {
-  var ids = [];
-  var value = environment.getStore().getSource()._records.get(parentId);
+  let ids = [];
+  let 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 ;
-          }
-          
-        });
+    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) {
-  var excludedIds = excludedIdsOpt !== undefined ? excludedIdsOpt : [];
-  RelayRuntime.commitLocalUpdate(environment, (function (store) {
-          findAllConnectionIds(environment, connectionKey, parentId).forEach(function (dataId) {
-                if (!excludedIds.includes(dataId)) {
-                  return Belt_Option.forEach(Caml_option.nullable_to_opt(store.get(dataId)), (function (r) {
-                                r.invalidateRecord();
-                              }));
-                }
-                
-              });
-        }));
+  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();
+        });
+      }
+    });
+  });
 }
 
-var Environment = {
+let Environment = {
   make: make$1,
   findAllConnectionIds: findAllConnectionIds,
   invalidateAllOfConnection: invalidateAllOfConnection
 };
 
-function RescriptRelay$Context$Provider(props) {
-  var provider = ReactRelay.ReactRelayContext.Provider;
-  return React.createElement(provider, {
-              value: {
-                environment: props.environment
-              },
-              children: props.children
-            });
-}
-
-var Provider = {
-  make: RescriptRelay$Context$Provider
-};
-
-var Context = {
-  Provider: Provider
-};
-
-var EnvironmentNotFoundInContext = /* @__PURE__ */Caml_exceptions.create("RescriptRelay.EnvironmentNotFoundInContext");
-
-function useEnvironmentFromContext() {
-  var context = React.useContext(ReactRelay.ReactRelayContext);
-  if (context !== undefined) {
-    return Caml_option.valFromOption(context).environment;
-  }
-  throw {
-        RE_EXN_ID: EnvironmentNotFoundInContext,
-        Error: new Error()
-      };
-}
-
-function MakeLoadQuery(C) {
-  var load = function (environment, variables, fetchPolicy, fetchKey, networkCacheConfig) {
-    return ReactRelay.loadQuery(environment, C.query, C.convertVariables(variables), {
-                fetchKey: fetchKey,
-                fetchPolicy: fetchPolicy,
-                networkCacheConfig: networkCacheConfig
-              });
-  };
-  var queryRefToObservable = function (token) {
-    return Caml_option.nullable_to_opt(token.source);
-  };
-  var queryRefToPromise = function (token) {
-    return new Promise((function (resolve, param) {
-                  var o = queryRefToObservable(token);
-                  if (o !== undefined) {
-                    Caml_option.valFromOption(o).subscribe({
-                          complete: (function () {
-                              resolve({
-                                    TAG: "Ok",
-                                    _0: undefined
-                                  });
-                            })
-                        });
-                    return ;
-                  } else {
-                    return resolve({
-                                TAG: "Error",
-                                _0: undefined
-                              });
-                  }
-                }));
-  };
-  return {
-          load: load,
-          queryRefToObservable: queryRefToObservable,
-          queryRefToPromise: queryRefToPromise
-        };
-}
-
-var Mutation_failed = /* @__PURE__ */Caml_exceptions.create("RescriptRelay.Mutation_failed");
+let Mutation_failed = /* @__PURE__ */Primitive_exceptions.create("RescriptRelay.Mutation_failed");
 
 exports.CatchResult = CatchResult;
 exports.SuspenseSentinel = SuspenseSentinel;
@@ -390,9 +310,5 @@ exports.Store = Store;
 exports.Disposable = Disposable;
 exports.RelayFieldLogger = RelayFieldLogger;
 exports.Environment = Environment;
-exports.Context = Context;
-exports.EnvironmentNotFoundInContext = EnvironmentNotFoundInContext;
-exports.useEnvironmentFromContext = useEnvironmentFromContext;
 exports.Mutation_failed = Mutation_failed;
-exports.MakeLoadQuery = MakeLoadQuery;
 /* nodeInterfaceMissingFieldHandler Not a pure module */