rescript-relay 4.1.0 → 4.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-relay",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "main": "src/RescriptRelay.res",
   "license": "MIT",
   "author": "Gabriel Nordeborn",

package/src/RescriptRelay.bs.js

@@ -77,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",
@@ -124,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 = {};
 
@@ -311,4 +288,4 @@ exports.Disposable = Disposable;
 exports.RelayFieldLogger = RelayFieldLogger;
 exports.Environment = Environment;
 exports.Mutation_failed = Mutation_failed;
-/* 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
   }
 )
 

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,

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
     }
   })