rescript-relay 4.0.0 → 4.2.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # master
 
+# 4.2.0
+
+- Simplify `missingFieldHandlers`. https://github.com/zth/rescript-relay/pull/589
+- Fix behavior of `refetchVariables` on optional variables. https://github.com/zth/rescript-relay/pull/588
+- Support `@exhaustive` on inline fragments.
+
+# 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",
@@ -56,7 +56,7 @@
     "react-dom": "18.2.0",
     "react-relay": "20.1.1",
     "relay-runtime": "20.1.1",
-    "rescript": "12.0.0-rc.3"
+    "rescript": "12.0.0"
   },
   "peerDependencies": {
     "@rescript/react": ">=0.13.0",
@@ -64,6 +64,14 @@
     "relay-runtime": "20.1.1",
     "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,15 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
-let React = require("react");
 let Utils = require("./utils");
-let ReactRelay = require("react-relay");
 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").default;
-let LiveResolverStore$1 = require("relay-runtime/lib/store/live-resolvers/LiveResolverStore");
+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) {
@@ -79,31 +77,6 @@ let RecordSourceSelectorProxy = {
 
 let ReadOnlyRecordSourceProxy = {};
 
-function unwrapNormalizationArgument(wrapped) {
-  let match = wrapped.kind;
-  if (match === "Literal") {
-    return {
-      TAG: "Literal",
-      _0: wrapped
-    };
-  } else if (match === "ListValue") {
-    return {
-      TAG: "ListValue",
-      _0: wrapped
-    };
-  } else if (match === "ObjectValue") {
-    return {
-      TAG: "ObjectValue",
-      _0: wrapped
-    };
-  } else {
-    return {
-      TAG: "Variable",
-      _0: wrapped
-    };
-  }
-}
-
 function makeScalarMissingFieldHandler(handle) {
   return {
     kind: "scalar",
@@ -126,21 +99,23 @@ function makePluralLinkedMissingFieldHandler(handle) {
 }
 
 let MissingFieldHandler = {
-  unwrapNormalizationArgument: unwrapNormalizationArgument,
   makeScalarMissingFieldHandler: makeScalarMissingFieldHandler,
   makeLinkedMissingFieldHandler: makeLinkedMissingFieldHandler,
   makePluralLinkedMissingFieldHandler: makePluralLinkedMissingFieldHandler
 };
 
-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);
+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 = {};
 
@@ -229,14 +204,14 @@ function make(source, gcReleaseBufferSize, queryCacheExpirationTime) {
 }
 
 function makeLiveStore(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore(source, {
+  return new LiveResolverStore$1(source, {
     gcReleaseBufferSize: gcReleaseBufferSize,
     queryCacheExpirationTime: queryCacheExpirationTime
   });
 }
 
 function _makeLiveStoreCjs(source, gcReleaseBufferSize, queryCacheExpirationTime) {
-  return new LiveResolverStore$1(source, {
+  return new LiveResolverStore(source, {
     gcReleaseBufferSize: gcReleaseBufferSize,
     queryCacheExpirationTime: queryCacheExpirationTime
   });
@@ -295,68 +270,6 @@ let Environment = {
   invalidateAllOfConnection: invalidateAllOfConnection
 };
 
-function RescriptRelay$Context$Provider(props) {
-  let provider = ReactRelay.ReactRelayContext.Provider;
-  return React.createElement(provider, {
-    value: {
-      environment: props.environment
-    },
-    children: props.children
-  });
-}
-
-let Provider = {
-  make: RescriptRelay$Context$Provider
-};
-
-let Context = {
-  Provider: Provider
-};
-
-let EnvironmentNotFoundInContext = /* @__PURE__ */Primitive_exceptions.create("RescriptRelay.EnvironmentNotFoundInContext");
-
-function useEnvironmentFromContext() {
-  let context = React.useContext(ReactRelay.ReactRelayContext);
-  if (context !== undefined) {
-    return Primitive_option.valFromOption(context).environment;
-  }
-  throw {
-    RE_EXN_ID: EnvironmentNotFoundInContext,
-    Error: new Error()
-  };
-}
-
-function MakeLoadQuery(C) {
-  let load = (environment, variables, fetchPolicy, fetchKey, networkCacheConfig) => ReactRelay.loadQuery(environment, C.query, C.convertVariables(variables), {
-    fetchKey: fetchKey,
-    fetchPolicy: fetchPolicy,
-    networkCacheConfig: networkCacheConfig
-  });
-  let queryRefToObservable = token => Primitive_option.fromNullable(token.source);
-  let queryRefToPromise = token => new Promise((resolve, param) => {
-    let o = queryRefToObservable(token);
-    if (o !== undefined) {
-      Primitive_option.valFromOption(o).subscribe({
-        complete: () => resolve({
-          TAG: "Ok",
-          _0: undefined
-        })
-      });
-      return;
-    } else {
-      return resolve({
-        TAG: "Error",
-        _0: undefined
-      });
-    }
-  });
-  return {
-    load: load,
-    queryRefToObservable: queryRefToObservable,
-    queryRefToPromise: queryRefToPromise
-  };
-}
-
 let Mutation_failed = /* @__PURE__ */Primitive_exceptions.create("RescriptRelay.Mutation_failed");
 
 exports.CatchResult = CatchResult;
@@ -374,9 +287,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 */
+/* ./utils Not a pure module */

package/src/RescriptRelay.res

@@ -347,78 +347,65 @@ module ReadOnlyRecordSourceProxy = {
 }
 
 module MissingFieldHandler = {
-  @@warning("-30")
-  type t
-
-  type normalizationArgumentWrapped = {kind: [#ListValue | #Literal | #ObjectValue | #Variable]}
-
-  type rec normalizationListValueArgument = {
-    name: string,
-    items: array<Nullable.t<normalizationArgumentWrapped>>,
-  }
-  and normalizationLiteralArgument = {
-    name: string,
-    @as("type") type_: Nullable.t<string>,
-    value: JSON.t,
-  }
-  and normalizationObjectValueArgument = {
-    name: string,
-    fields: Nullable.t<array<normalizationArgumentWrapped>>,
-  }
-  and normalizationVariableArgument = {
-    name: string,
-    @as("type") type_: Nullable.t<string>,
-    variableName: string,
-  }
-
-  type normalizationArgument =
-    | ListValue(normalizationListValueArgument)
-    | Literal(normalizationLiteralArgument)
-    | ObjectValue(normalizationObjectValueArgument)
-    | Variable(normalizationVariableArgument)
-
-  let unwrapNormalizationArgument = wrapped =>
-    switch wrapped.kind {
-    | #ListValue => ListValue(Obj.magic(wrapped))
-    | #Literal => Literal(Obj.magic(wrapped))
-    | #ObjectValue => ObjectValue(Obj.magic(wrapped))
-    | #Variable => Variable(Obj.magic(wrapped))
-    }
+  @tag("kind")
+  type rec normalizationArgument =
+    | ListValue({name: string, items: array<null<normalizationArgument>>})
+    | Literal({name: string, @as("type") type_: nullable<string>, value: JSON.t})
+    | ObjectValue({name: string, fields: array<normalizationArgument>})
+    | Variable({name: string, @as("type") type_: nullable<string>, variableName: string})
 
   type normalizationScalarField = {
-    alias: Nullable.t<string>,
+    alias: nullable<string>,
     name: string,
-    args: Nullable.t<array<normalizationArgumentWrapped>>,
-    storageKey: Nullable.t<string>,
+    args: nullable<array<normalizationArgument>>,
+    storageKey: nullable<string>,
   }
 
-  let makeScalarMissingFieldHandler = handle =>
-    Obj.magic({
-      "kind": #scalar,
-      "handle": handle,
-    })
-
   type normalizationLinkedField = {
-    alias: Nullable.t<string>,
+    alias: nullable<string>,
     name: string,
-    storageKey: Nullable.t<string>,
-    args: Nullable.t<array<normalizationArgument>>,
-    concreteType: Nullable.t<string>,
+    storageKey: nullable<string>,
+    args: nullable<array<normalizationArgument>>,
+    concreteType: nullable<string>,
     plural: bool,
     selections: array<JSON.t>,
   }
 
-  let makeLinkedMissingFieldHandler = handle =>
-    Obj.magic({
-      "kind": #linked,
-      "handle": handle,
-    })
-
-  let makePluralLinkedMissingFieldHandler = handle =>
-    Obj.magic({
-      "kind": #pluralLinked,
-      "handle": handle,
-    })
+  @tag("kind")
+  type rec t =
+    | @as("scalar")
+    Scalar({
+        handle: (
+          normalizationScalarField,
+          nullable<'record>,
+          'args,
+          ReadOnlyRecordSourceProxy.t,
+        ) => nullable<'scalarValue>,
+      }): t
+    | @as("linked")
+    Linked({
+        handle: (
+          normalizationLinkedField,
+          nullable<'record>,
+          'args,
+          ReadOnlyRecordSourceProxy.t,
+        ) => nullable<dataId>,
+      }): t
+    | @as("pluralLinked")
+    PluralLinked({
+        handle: (
+          normalizationLinkedField,
+          nullable<'record>,
+          'args,
+          ReadOnlyRecordSourceProxy.t,
+        ) => nullable<array<nullable<dataId>>>,
+      }): t
+
+  let makeScalarMissingFieldHandler = handle => Scalar({handle: handle})
+
+  let makeLinkedMissingFieldHandler = handle => Linked({handle: handle})
+
+  let makePluralLinkedMissingFieldHandler = handle => PluralLinked({handle: handle})
 }
 
 // This handler below enables automatic resolution of all cached items through the Node interface
@@ -428,9 +415,9 @@ let nodeInterfaceMissingFieldHandler = MissingFieldHandler.makeLinkedMissingFiel
   args,
   _store,
 ) =>
-  switch (Nullable.toOption(record), field["name"], Nullable.toOption(args["id"])) {
-  | (Some(record), "node", argsId) if record->RecordProxy.getType == storeRootType => argsId
-  | _ => None
+  switch (record, field.name, args["id"]) {
+  | (Value(record), "node", argsId) if record->RecordProxy.getType == storeRootType => argsId
+  | _ => undefined
   }
 )
 
@@ -827,33 +814,7 @@ module Environment = {
   }
 }
 
-module Context = {
-  type t
-
-  type contextShape = {"environment": Environment.t}
-
-  @module("react-relay")
-  external context: React.Context.t<option<contextShape>> = "ReactRelayContext"
-
-  module Provider = {
-    @react.component
-    let make = (~environment: Environment.t, ~children) => {
-      let provider = React.Context.provider(context)
-      React.createElement(provider, {value: Some({"environment": environment}), children})
-    }
-  }
-}
-
-exception EnvironmentNotFoundInContext
-
-let useEnvironmentFromContext = () => {
-  let context = React.useContext(Context.context)
-
-  switch context {
-  | Some(ctx) => ctx["environment"]
-  | None => throw(EnvironmentNotFoundInContext)
-  }
-}
+/* React Context moved to RescriptRelayReact */
 
 type fetchPolicy =
   | @as("store-only") StoreOnly
@@ -870,69 +831,7 @@ type fetchQueryOptions = {
   fetchPolicy?: fetchPolicy,
 }
 
-type loadQueryConfig = {
-  fetchKey: option<string>,
-  fetchPolicy: option<fetchPolicy>,
-  networkCacheConfig: option<cacheConfig>,
-}
-
-@module("react-relay")
-external loadQuery: (Environment.t, queryNode<'a>, 'variables, loadQueryConfig) => 'queryResponse =
-  "loadQuery"
-
-module type MakeLoadQueryConfig = {
-  type variables
-  type loadedQueryRef
-  type response
-  type node
-  let query: queryNode<node>
-  let convertVariables: variables => variables
-}
-
-module MakeLoadQuery = (C: MakeLoadQueryConfig) => {
-  let load: (
-    ~environment: Environment.t,
-    ~variables: C.variables,
-    ~fetchPolicy: fetchPolicy=?,
-    ~fetchKey: string=?,
-    ~networkCacheConfig: cacheConfig=?,
-  ) => C.loadedQueryRef = (
-    ~environment,
-    ~variables,
-    ~fetchPolicy=?,
-    ~fetchKey=?,
-    ~networkCacheConfig=?,
-  ) =>
-    loadQuery(
-      environment,
-      C.query,
-      variables->C.convertVariables,
-      {
-        fetchKey,
-        fetchPolicy,
-        networkCacheConfig,
-      },
-    )
-
-  type rawPreloadToken<'response> = {source: Nullable.t<Observable.t<'response>>}
-  external tokenToRaw: C.loadedQueryRef => rawPreloadToken<C.response> = "%identity"
-
-  let queryRefToObservable = token => {
-    let raw = token->tokenToRaw
-    raw.source->Nullable.toOption
-  }
-
-  let queryRefToPromise = token => {
-    Promise.make((resolve, _) => {
-      switch token->queryRefToObservable {
-      | None => resolve(Error())
-      | Some(o) =>
-        open Observable
-        let _: subscription = o->subscribe(makeObserver(~complete=() => resolve(Ok())))
-      }
-    })
-  }
-}
+/* React loadQuery helpers moved to RescriptRelayReact */
 
 type mutationError = {message: string}
 
@@ -944,6 +843,4 @@ external commitLocalUpdate: (
   ~updater: RecordSourceSelectorProxy.t => unit,
 ) => unit = "commitLocalUpdate"
 
-@module("react-relay")
-external useSubscribeToInvalidationState: (array<dataId>, unit => unit) => Disposable.t =
-  "useSubscribeToInvalidationState"
+/* React invalidation subscribe moved to RescriptRelayReact */

package/src/RescriptRelay.resi

@@ -635,68 +635,75 @@ module ReadOnlyRecordSourceProxy: {
 
 Feed a list of missing field handlers into `Environment.make` if you want to use them.*/
 module MissingFieldHandler: {
-  @@warning("-30")
-
-  /**A missing field handler, which is a way of teaching Relay more about the relations in your schema, so it can fulfill more things from the cache. Read more [in this section of the Relay docs](https://relay.dev/docs/guided-tour/reusing-cached-data/filling-in-missing-data/).*/
-  type t
-
-  type normalizationArgumentWrapped = {kind: [#ListValue | #Literal | #ObjectValue | #Variable]}
+  @tag("kind")
+  type rec normalizationArgument =
+    | ListValue({name: string, items: array<null<normalizationArgument>>})
+    | Literal({name: string, @as("type") type_: nullable<string>, value: JSON.t})
+    | ObjectValue({name: string, fields: array<normalizationArgument>})
+    | Variable({name: string, @as("type") type_: nullable<string>, variableName: string})
 
-  type rec normalizationListValueArgument = {
-    name: string,
-    items: array<Nullable.t<normalizationArgumentWrapped>>,
-  }
-  and normalizationLiteralArgument = {
-    name: string,
-    @as("type") type_: Nullable.t<string>,
-    value: JSON.t,
-  }
-  and normalizationObjectValueArgument = {
-    name: string,
-    fields: Nullable.t<array<normalizationArgumentWrapped>>,
-  }
-  and normalizationVariableArgument = {
+  type normalizationScalarField = {
+    alias: nullable<string>,
     name: string,
-    @as("type") type_: Nullable.t<string>,
-    variableName: string,
+    args: nullable<array<normalizationArgument>>,
+    storageKey: nullable<string>,
   }
 
-  type normalizationArgument =
-    | ListValue(normalizationListValueArgument)
-    | Literal(normalizationLiteralArgument)
-    | ObjectValue(normalizationObjectValueArgument)
-    | Variable(normalizationVariableArgument)
-
-  let unwrapNormalizationArgument: normalizationArgumentWrapped => normalizationArgument
-
-  type normalizationScalarField = {
-    alias: Nullable.t<string>,
+  type normalizationLinkedField = {
+    alias: nullable<string>,
     name: string,
-    args: Nullable.t<array<normalizationArgumentWrapped>>,
-    storageKey: Nullable.t<string>,
+    storageKey: nullable<string>,
+    args: nullable<array<normalizationArgument>>,
+    concreteType: nullable<string>,
+    plural: bool,
+    selections: array<JSON.t>,
   }
 
-  /**Make a `MissingFieldHandler.t` for scalar fields. Give this a handler function that returns `Js.null` (to indicate that data exists but is null), `Js.undefined` (to indicate data is still missing), or a scalar value (to indicate that the value exists even though it's not in the cache, and is the value you send back).*/
+  /**A missing field handler, which is a way of teaching Relay more about the relations in your schema, so it can fulfill more things from the cache. Read more [in this section of the Relay docs](https://relay.dev/docs/guided-tour/reusing-cached-data/filling-in-missing-data/).*/
+  @tag("kind")
+  type rec t =
+    /** a `MissingFieldHandler.t` for scalar fields. Give this a handler function that returns `null` (to indicate that data exists but is null), `undefined` (to indicate data is still missing), or a scalar value (to indicate that the value exists even though it's not in the cache, and is the value you send back).*/
+    | @as("scalar")
+    Scalar({
+        handle: (
+          normalizationScalarField,
+          nullable<'record>,
+          'args,
+          ReadOnlyRecordSourceProxy.t,
+        ) => nullable<'scalarValue>,
+      }): t
+    /** a `MissingFieldHandler.t` for linked fields (other objects/records). Give this a handler function that returns `null` (to indicate that the link exists but the linked record is null), `undefined` (to indicate data is still missing), or a `dataId` of the record that is linked at this field.*/
+    | @as("linked")
+    Linked({
+        handle: (
+          normalizationLinkedField,
+          nullable<'record>,
+          'args,
+          ReadOnlyRecordSourceProxy.t,
+        ) => nullable<dataId>,
+      }): t
+    /** a `MissingFieldHandler.t` for lists of linked fields (other objects/records). Give this a handler function that returns `null` (to indicate that the link exists but the linked array of records is null), `undefined` (to indicate data is still missing), or an array of `nullable<dataId>` where the `dataId`'s are the linked records/objects.*/
+    | @as("pluralLinked")
+    PluralLinked({
+        handle: (
+          normalizationLinkedField,
+          nullable<'record>,
+          'args,
+          ReadOnlyRecordSourceProxy.t,
+        ) => nullable<array<nullable<dataId>>>,
+      }): t
+
+  /**Make a `MissingFieldHandler.t` for scalar fields. Give this a handler function that returns `null` (to indicate that data exists but is null), `undefined` (to indicate data is still missing), or a scalar value (to indicate that the value exists even though it's not in the cache, and is the value you send back).*/
   let makeScalarMissingFieldHandler: (
     (
       normalizationScalarField,
       Nullable.t<'record>,
       'args,
       ReadOnlyRecordSourceProxy.t,
-    ) => 'scalarValue
+    ) => Nullable.t<'scalarValue>
   ) => t
 
-  type normalizationLinkedField = {
-    alias: Nullable.t<string>,
-    name: string,
-    storageKey: Nullable.t<string>,
-    args: Nullable.t<array<normalizationArgument>>,
-    concreteType: Nullable.t<string>,
-    plural: bool,
-    selections: array<JSON.t>,
-  }
-
-  /**Make a `MissingFieldHandler.t` for linked fields (other objects/records). Give this a handler function that returns `Js.null` (to indicate that the link exists but the linked record is null), `Js.undefined` (to indicate data is still missing), or a `dataId` of the record that is linked at this field.*/
+  /**Make a `MissingFieldHandler.t` for linked fields (other objects/records). Give this a handler function that returns `null` (to indicate that the link exists but the linked record is null), `undefined` (to indicate data is still missing), or a `dataId` of the record that is linked at this field.*/
   let makeLinkedMissingFieldHandler: (
     (
       normalizationLinkedField,
@@ -706,7 +713,7 @@ module MissingFieldHandler: {
     ) => Nullable.t<dataId>
   ) => t
 
-  /**Make a `MissingFieldHandler.t` for lists of linked fields (other objects/records). Give this a handler function that returns `Js.null` (to indicate that the link exists but the linked record is null), `Js.undefined` (to indicate data is still missing), or an array of `Js.Nullable.t<dataId>` where the `dataId`'s are the linked records/objects.*/
+  /**Make a `MissingFieldHandler.t` for lists of linked fields (other objects/records). Give this a handler function that returns `null` (to indicate that the link exists but the linked array of records is null), `undefined` (to indicate data is still missing), or an array of `nullable<dataId>` where the `dataId`'s are the linked records/objects.*/
   let makePluralLinkedMissingFieldHandler: (
     (
       normalizationLinkedField,
@@ -1534,34 +1541,7 @@ type fetchQueryFetchPolicy =
 /**An error from a mutation.*/
 type mutationError = {message: string}
 
-/**Context provider for the Relay environment.*/
-module Context: {
-  /**Type representing the context.*/
-  type t
-
-  /**The expected shape of the context.*/
-  type contextShape = {"environment": Environment.t}
-
-  /**The actual React context coming from Relay.*/
-  @module("react-relay")
-  external context: React.Context.t<option<contextShape>> = "ReactRelayContext"
-
-  /**The context provider you wrap your app in and pass your `Environment` for Relay to work.*/
-  module Provider: {
-    /**The React component you wrap your app in and pass your `Environment` for Relay to work.*/
-    type props<'environment, 'children> = {
-      environment: 'environment,
-      children: 'children,
-    }
-    let make: props<Environment.t, React.element> => React.element
-  }
-}
-
-/**An exception saying that the environment could not be found in the context. Means you forgot to wrap your app in `<RescriptRelay.Context.Provider environment=RelayEnv.environment>`*/
-exception EnvironmentNotFoundInContext
-
-/**Hook for getting the current environment from context.*/
-let useEnvironmentFromContext: unit => Environment.t
+/* React Context moved to RescriptRelayReact */
 
 /**An exception detailing that a mutation failed.*/
 exception Mutation_failed(array<mutationError>)
@@ -1603,38 +1583,7 @@ external commitLocalUpdate: (
   ~updater: RecordSourceSelectorProxy.t => unit,
 ) => unit = "commitLocalUpdate"
 
-/**
-  Subscribes to invalidation events for specific records.
-
-  Executes a callback whenever any of the specified records are invalidated.
-  Useful for triggering refetches or UI updates when cached data becomes stale.
-
-  ## Parameters
-  - Array of `dataId`s to watch for invalidation
-  - Callback function executed when any watched record is invalidated
-
-  ## Examples
-
-  ```rescript
-  // Watch for user invalidation and refetch
-  let disposable = RescriptRelay.useSubscribeToInvalidationState(
-    [user.__id],
-    () => {
-      // Refetch user data when invalidated
-      UserQuery.fetchPromised(~environment, ~variables={id: user.id})
-      ->Promise.done
-    }
-  )
-
-  // Clean up subscription
-  React.useEffect1(() => {
-    Some(() => disposable->RescriptRelay.Disposable.dispose)
-  }, [disposable])
-  ```
-*/
-@module("react-relay")
-external useSubscribeToInvalidationState: (array<dataId>, unit => unit) => Disposable.t =
-  "useSubscribeToInvalidationState"
+/* React invalidation subscribe moved to RescriptRelayReact */
 
 /**Options valid when fetching a query outside of React's render method (like when using `Query.fetch`).*/
 type fetchQueryOptions = {
@@ -1642,35 +1591,4 @@ type fetchQueryOptions = {
   fetchPolicy?: fetchPolicy,
 }
 
-type loadQueryConfig = {
-  fetchKey: option<string>,
-  fetchPolicy: option<fetchPolicy>,
-  networkCacheConfig: option<cacheConfig>,
-}
-
-@module("react-relay")
-external loadQuery: (Environment.t, queryNode<'a>, 'variables, loadQueryConfig) => 'queryResponse =
-  "loadQuery"
-
-module type MakeLoadQueryConfig = {
-  type variables
-  type loadedQueryRef
-  type response
-  type node
-  let query: queryNode<node>
-  let convertVariables: variables => variables
-}
-
-module MakeLoadQuery: (C: MakeLoadQueryConfig) =>
-{
-  let load: (
-    ~environment: Environment.t,
-    ~variables: C.variables,
-    ~fetchPolicy: fetchPolicy=?,
-    ~fetchKey: string=?,
-    ~networkCacheConfig: cacheConfig=?,
-  ) => C.loadedQueryRef
-
-  let queryRefToObservable: C.loadedQueryRef => option<Observable.t<C.response>>
-  let queryRefToPromise: C.loadedQueryRef => promise<Belt.Result.t<unit, unit>>
-}
+/* React loadQuery helpers moved to RescriptRelayReact */

package/src/RescriptRelayReact.bs.js

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+let React = require("react");
+let ReactRelay = require("react-relay");
+let Primitive_option = require("@rescript/runtime/lib/js/Primitive_option.js");
+let Primitive_exceptions = require("@rescript/runtime/lib/js/Primitive_exceptions.js");
+
+function RescriptRelayReact$Context$Provider(props) {
+  let provider = ReactRelay.ReactRelayContext.Provider;
+  return React.createElement(provider, {
+    value: {
+      environment: props.environment
+    },
+    children: props.children
+  });
+}
+
+let Provider = {
+  make: RescriptRelayReact$Context$Provider
+};
+
+let Context = {
+  Provider: Provider
+};
+
+let EnvironmentNotFoundInContext = /* @__PURE__ */Primitive_exceptions.create("RescriptRelayReact.EnvironmentNotFoundInContext");
+
+function useEnvironmentFromContext() {
+  let context = React.useContext(ReactRelay.ReactRelayContext);
+  if (context !== undefined) {
+    return Primitive_option.valFromOption(context).environment;
+  }
+  throw {
+    RE_EXN_ID: EnvironmentNotFoundInContext,
+    Error: new Error()
+  };
+}
+
+function MakeLoadQuery(C) {
+  let load = (environment, variables, fetchPolicy, fetchKey, networkCacheConfig) => ReactRelay.loadQuery(environment, C.query, C.convertVariables(variables), {
+    fetchKey: fetchKey,
+    fetchPolicy: fetchPolicy,
+    networkCacheConfig: networkCacheConfig
+  });
+  let queryRefToObservable = token => Primitive_option.fromNullable(token.source);
+  let queryRefToPromise = token => new Promise((resolve, param) => {
+    let o = queryRefToObservable(token);
+    if (o !== undefined) {
+      Primitive_option.valFromOption(o).subscribe({
+        complete: () => resolve({
+          TAG: "Ok",
+          _0: undefined
+        })
+      });
+      return;
+    } else {
+      return resolve({
+        TAG: "Error",
+        _0: undefined
+      });
+    }
+  });
+  return {
+    load: load,
+    queryRefToObservable: queryRefToObservable,
+    queryRefToPromise: queryRefToPromise
+  };
+}
+
+exports.Context = Context;
+exports.EnvironmentNotFoundInContext = EnvironmentNotFoundInContext;
+exports.useEnvironmentFromContext = useEnvironmentFromContext;
+exports.MakeLoadQuery = MakeLoadQuery;
+/* react Not a pure module */

package/src/RescriptRelayReact.res

@@ -0,0 +1,94 @@
+open RescriptRelay
+
+module Context = {
+  type t
+  type contextShape = {"environment": Environment.t}
+  @module("react-relay")
+  external context: React.Context.t<option<contextShape>> = "ReactRelayContext"
+
+  module Provider = {
+    @react.component
+    let make = (~environment: Environment.t, ~children) => {
+      let provider = React.Context.provider(context)
+      React.createElement(provider, {value: Some({"environment": environment}), children})
+    }
+  }
+}
+
+exception EnvironmentNotFoundInContext
+
+let useEnvironmentFromContext = () => {
+  let context = React.useContext(Context.context)
+  switch context {
+  | Some(ctx) => ctx["environment"]
+  | None => throw(EnvironmentNotFoundInContext)
+  }
+}
+
+type loadQueryConfig = {
+  fetchKey: option<string>,
+  fetchPolicy: option<fetchPolicy>,
+  networkCacheConfig: option<cacheConfig>,
+}
+
+@module("react-relay")
+external loadQuery: (Environment.t, queryNode<'a>, 'variables, loadQueryConfig) => 'queryResponse =
+  "loadQuery"
+
+module type MakeLoadQueryConfig = {
+  type variables
+  type loadedQueryRef
+  type response
+  type node
+  let query: queryNode<node>
+  let convertVariables: variables => variables
+}
+
+module MakeLoadQuery = (C: MakeLoadQueryConfig) => {
+  let load: (
+    ~environment: Environment.t,
+    ~variables: C.variables,
+    ~fetchPolicy: fetchPolicy=?,
+    ~fetchKey: string=?,
+    ~networkCacheConfig: cacheConfig=?,
+  ) => C.loadedQueryRef = (
+    ~environment,
+    ~variables,
+    ~fetchPolicy=?,
+    ~fetchKey=?,
+    ~networkCacheConfig=?,
+  ) =>
+    loadQuery(
+      environment,
+      C.query,
+      variables->C.convertVariables,
+      {
+        fetchKey,
+        fetchPolicy,
+        networkCacheConfig,
+      },
+    )
+
+  type rawPreloadToken<'response> = {source: Nullable.t<Observable.t<'response>>}
+  external tokenToRaw: C.loadedQueryRef => rawPreloadToken<C.response> = "%identity"
+
+  let queryRefToObservable = token => {
+    let raw = token->tokenToRaw
+    raw.source->Nullable.toOption
+  }
+
+  let queryRefToPromise = token => {
+    Promise.make((resolve, _) => {
+      switch token->queryRefToObservable {
+      | None => resolve(Error())
+      | Some(o) =>
+        open Observable
+        let _: subscription = o->subscribe(makeObserver(~complete=() => resolve(Ok())))
+      }
+    })
+  }
+}
+
+@module("react-relay")
+external useSubscribeToInvalidationState: (array<dataId>, unit => unit) => Disposable.t =
+  "useSubscribeToInvalidationState"

package/src/RescriptRelay_FragmentNonReact.bs.js

@@ -0,0 +1,23 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+let RelayRuntime = require("relay-runtime");
+let Experimental = require("relay-runtime/experimental");
+let ResolverFragments = require("relay-runtime/lib/store/ResolverFragments");
+
+function read(node, convertFragment, fRef) {
+  return convertFragment(ResolverFragments.readFragment(fRef, node));
+}
+
+function readInlineData_(node, convertFragment, fRef) {
+  return convertFragment(RelayRuntime.readInlineData(fRef, node));
+}
+
+function waitForFragmentData(environment, node, convertFragment, fRef) {
+  return Experimental.waitForFragmentData(environment, node, fRef).then(res => Promise.resolve(convertFragment(res)));
+}
+
+exports.read = read;
+exports.readInlineData_ = readInlineData_;
+exports.waitForFragmentData = waitForFragmentData;
+/* relay-runtime Not a pure module */

package/src/RescriptRelay_FragmentNonReact.res

@@ -0,0 +1,29 @@
+/* React-free Fragment runtime: read, readInlineData, waitForFragmentData */
+
+open RescriptRelay
+
+type fragmentNode<'node> = RescriptRelay.fragmentNode<'node>
+
+@module("relay-runtime/lib/store/ResolverFragments")
+external readFragment_: (fragmentNode<'node>, 'fragmentRef) => 'fragment = "readFragment"
+
+@module("relay-runtime")
+external readInlineData: (fragmentNode<'node>, 'fragmentRef) => 'fragment = "readInlineData"
+
+@module("relay-runtime/experimental")
+external waitForFragmentData_: (
+  Environment.t,
+  fragmentNode<'node>,
+  'fragmentRef,
+) => promise<'fragment> = "waitForFragmentData"
+
+let read = (~node, ~convertFragment: 'fragment => 'fragment, ~fRef) =>
+  fRef->readFragment_(node)->convertFragment
+
+let readInlineData_ = (~node, ~convertFragment: 'fragment => 'fragment, ~fRef) =>
+  fRef->readInlineData(node)->convertFragment
+
+let waitForFragmentData = (~environment, ~node, ~convertFragment: 'fragment => 'fragment, ~fRef) =>
+  waitForFragmentData_(environment, node, fRef)->Promise.then(res =>
+    res->convertFragment->Promise.resolve
+  )

package/src/RescriptRelay_Internal.bs.js

@@ -33,15 +33,15 @@ function internal_removeUndefinedAndConvertNullsRaw(record) {
     let value = param[1];
     let key = param[0];
     let match = Primitive_object.equal(value, Primitive_option.some(undefined));
-    if (value !== undefined) {
+    if (match) {
       return [
         key,
-        Primitive_option.valFromOption(value)
+        null
       ];
-    } else if (match) {
+    } else if (value !== undefined) {
       return [
         key,
-        null
+        Primitive_option.valFromOption(value)
       ];
     } else {
       return;

package/src/RescriptRelay_Internal.res

@@ -20,8 +20,8 @@ let internal_cleanObjectFromUndefinedRaw = record =>
 let internal_removeUndefinedAndConvertNullsRaw = record =>
   internal_keepMapFieldsRaw(record, ((key, value)) => {
     switch (value, value == Some(None)) {
-    | (Some(value), _) => Some((key, Nullable.make(value)))
     | (_, true) => Some((key, Nullable.null))
+    | (Some(value), _) => Some((key, Nullable.make(value)))
     | (None, _) => None
     }
   })

package/src/RescriptRelay_MutationNonReact.bs.js

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+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");
+
+function commitMutation(convertVariables, node, convertResponse, convertWrapRawResponse) {
+  return (environment, variables, optimisticUpdater, optimisticResponse, updater, onCompleted, onError, uploadables) => {
+    let tmp = {
+      mutation: node,
+      variables: convertVariables(variables)
+    };
+    let tmp$1 = onCompleted !== undefined ? (res, err) => onCompleted(convertResponse(res), err) : undefined;
+    if (tmp$1 !== undefined) {
+      tmp.onCompleted = Primitive_option.valFromOption(tmp$1);
+    }
+    if (onError !== undefined) {
+      tmp.onError = Primitive_option.valFromOption(onError);
+    }
+    let tmp$2 = Stdlib_Option.map(optimisticResponse, convertWrapRawResponse);
+    if (tmp$2 !== undefined) {
+      tmp.optimisticResponse = Primitive_option.valFromOption(tmp$2);
+    }
+    if (optimisticUpdater !== undefined) {
+      tmp.optimisticUpdater = Primitive_option.valFromOption(optimisticUpdater);
+    }
+    let tmp$3 = Stdlib_Option.map(updater, u => ((store, response) => u(store, convertResponse(response))));
+    if (tmp$3 !== undefined) {
+      tmp.updater = Primitive_option.valFromOption(tmp$3);
+    }
+    if (uploadables !== undefined) {
+      tmp.uploadables = Primitive_option.valFromOption(uploadables);
+    }
+    return RelayRuntime.commitMutation(environment, tmp);
+  };
+}
+
+exports.commitMutation = commitMutation;
+/* relay-runtime Not a pure module */

package/src/RescriptRelay_MutationNonReact.res

@@ -0,0 +1,56 @@
+/* React-free Mutation runtime: commitMutation only */
+
+type mutationNode<'node> = RescriptRelay.mutationNode<'node>
+
+@obj
+external makeConfig: (
+  ~mutation: mutationNode<'node>,
+  ~variables: 'variables,
+  ~onCompleted: ('response, option<JSON.t>) => unit=?,
+  ~onError: JsExn.t => unit=?,
+  ~optimisticResponse: 'rawResponse=?,
+  ~optimisticUpdater: RescriptRelay.RecordSourceSelectorProxy.t => unit=?,
+  ~updater: (RescriptRelay.RecordSourceSelectorProxy.t, 'response) => unit=?,
+  ~uploadables: RescriptRelay.uploadables=?,
+  unit,
+) => 'config = ""
+
+@module("relay-runtime")
+external commitMutation: (RescriptRelay.Environment.t, 'config) => RescriptRelay.Disposable.t =
+  "commitMutation"
+
+let commitMutation = (
+  ~convertVariables: 'variables => 'variables,
+  ~node: 'm,
+  ~convertResponse: 'response => 'response,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) =>
+  (
+    ~environment: RescriptRelay.Environment.t,
+    ~variables: 'variables,
+    ~optimisticUpdater=?,
+    ~optimisticResponse: option<'rawResponse>=?,
+    ~updater: option<(RescriptRelay.RecordSourceSelectorProxy.t, 'response) => unit>=?,
+    ~onCompleted: option<('response, option<JSON.t>) => unit>=?,
+    ~onError: option<JsExn.t => unit>=?,
+    ~uploadables: option<RescriptRelay.uploadables>=?,
+  ) =>
+    commitMutation(
+      environment,
+      makeConfig(
+        ~mutation=node,
+        ~variables=variables->convertVariables,
+        ~onCompleted=?switch onCompleted {
+        | Some(f) => Some((res, err) => f(res->convertResponse, err))
+        | None => None
+        },
+        ~onError?,
+        ~optimisticResponse=?optimisticResponse->Option.map(convertWrapRawResponse),
+        ~optimisticUpdater?,
+        ~updater=?updater->Option.map(u =>
+          (store, response) => u(store, response->convertResponse)
+        ),
+        ~uploadables?,
+        (),
+      ),
+    )

package/src/RescriptRelay_QueryNonReact.bs.js

@@ -0,0 +1,45 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+let RelayRuntime = require("relay-runtime");
+
+function fetch(node, convertResponse, convertVariables) {
+  return (environment, variables, onResult, networkCacheConfig, fetchPolicy) => {
+    RelayRuntime.fetchQuery(environment, node, convertVariables(variables), {
+      networkCacheConfig: networkCacheConfig,
+      fetchPolicy: fetchPolicy
+    }).subscribe({
+      next: res => onResult({
+        TAG: "Ok",
+        _0: convertResponse(res)
+      }),
+      error: err => onResult({
+        TAG: "Error",
+        _0: err
+      })
+    });
+  };
+}
+
+function fetchPromised(node, convertResponse, convertVariables) {
+  return (environment, variables, networkCacheConfig, fetchPolicy) => RelayRuntime.fetchQuery(environment, node, convertVariables(variables), {
+    networkCacheConfig: networkCacheConfig,
+    fetchPolicy: fetchPolicy
+  }).toPromise().then(res => Promise.resolve(convertResponse(res)));
+}
+
+function retain(node, convertVariables) {
+  return (environment, variables) => environment.retain(RelayRuntime.createOperationDescriptor(node, convertVariables(variables)));
+}
+
+function commitLocalPayload(node, convertVariables, convertWrapRawResponse) {
+  return (environment, variables, payload) => {
+    environment.commitPayload(RelayRuntime.createOperationDescriptor(node, convertVariables(variables)), convertWrapRawResponse(payload));
+  };
+}
+
+exports.fetch = fetch;
+exports.fetchPromised = fetchPromised;
+exports.retain = retain;
+exports.commitLocalPayload = commitLocalPayload;
+/* relay-runtime Not a pure module */

package/src/RescriptRelay_QueryNonReact.res

@@ -0,0 +1,108 @@
+/* React-free Query runtime: fetch, fetchPromised, retain, commitLocalPayload */
+
+type subscription
+type observable<'a>
+type operationDescriptor
+
+type queryNode<'node> = RescriptRelay.queryNode<'node>
+
+@module("relay-runtime")
+external fetchQuery: (
+  RescriptRelay.Environment.t,
+  queryNode<'node>,
+  'variables,
+  option<RescriptRelay.fetchQueryOptions>,
+) => observable<'response> = "fetchQuery"
+
+@module("relay-runtime")
+external createOperationDescriptor: (queryNode<'node>, 'variables) => operationDescriptor =
+  "createOperationDescriptor"
+
+/* moved type decls above */
+
+@obj
+external makeObserver: (
+  ~next: 'a => unit=?,
+  ~error: JsExn.t => unit=?,
+  ~complete: unit => unit=?,
+) => 'obs = ""
+
+@send
+external subscribe: (observable<'a>, 'obs) => subscription = "subscribe"
+
+@send
+external toPromise: observable<'a> => promise<'a> = "toPromise"
+
+external ignoreSubscription: subscription => unit = "%ignore"
+
+let fetch = (
+  ~node,
+  ~convertResponse: 'response => 'response,
+  ~convertVariables: 'variables => 'variables,
+) => {
+  (
+    ~environment: RescriptRelay.Environment.t,
+    ~variables: 'variables,
+    ~onResult,
+    ~networkCacheConfig=?,
+    ~fetchPolicy=?,
+  ) => {
+    fetchQuery(
+      environment,
+      node,
+      variables->convertVariables,
+      Some({?networkCacheConfig, ?fetchPolicy}),
+    )
+    ->subscribe(
+      makeObserver(
+        ~next=res => onResult(Ok(res->convertResponse)),
+        ~error=err => onResult(Error(err)),
+      ),
+    )
+    ->ignoreSubscription
+  }
+}
+
+let fetchPromised = (
+  ~node,
+  ~convertResponse: 'response => 'response,
+  ~convertVariables: 'variables => 'variables,
+) => {
+  (
+    ~environment: RescriptRelay.Environment.t,
+    ~variables: 'variables,
+    ~networkCacheConfig=?,
+    ~fetchPolicy=?,
+  ) =>
+    fetchQuery(
+      environment,
+      node,
+      variables->convertVariables,
+      Some({?networkCacheConfig, ?fetchPolicy}),
+    )
+    ->toPromise
+    ->Promise.then(res => res->convertResponse->Promise.resolve)
+}
+
+@send
+external retain_: (RescriptRelay.Environment.t, operationDescriptor) => RescriptRelay.Disposable.t =
+  "retain"
+@send
+external commitPayload: (RescriptRelay.Environment.t, operationDescriptor, 'payload) => unit =
+  "commitPayload"
+
+let retain = (~node, ~convertVariables: 'variables => 'variables) => {
+  (~environment: RescriptRelay.Environment.t, ~variables: 'variables) =>
+    environment->retain_(createOperationDescriptor(node, variables->convertVariables))
+}
+
+let commitLocalPayload = (
+  ~node,
+  ~convertVariables: 'variables => 'variables,
+  ~convertWrapRawResponse: 'rawResponse => 'rawResponse,
+) =>
+  (~environment: RescriptRelay.Environment.t, ~variables: 'variables, ~payload: 'rawResponse) =>
+    environment->commitPayload(
+      createOperationDescriptor(node, variables->convertVariables),
+      payload->convertWrapRawResponse,
+    )