relay-runtime 10.0.1 → 10.1.3

package/util/NormalizationNode.js.flow

@@ -12,6 +12,8 @@
 
 'use strict';
 
+import type {ConcreteRequest} from './RelayConcreteNode';
+
 /**
  * Represents a single operation used to processing and normalize runtime
  * request results.
@@ -34,7 +36,6 @@ export type NormalizationLinkedHandle = {|
   +args: ?$ReadOnlyArray<NormalizationArgument>,
   +handle: string,
   +key: string,
-  // T45504512: new connection model
   // NOTE: this property is optional because it's expected to be rarely used
   +dynamicKey?: ?NormalizationArgument,
   +filters: ?$ReadOnlyArray<string>,
@@ -48,10 +49,10 @@ export type NormalizationScalarHandle = {|
   +args: ?$ReadOnlyArray<NormalizationArgument>,
   +handle: string,
   +key: string,
-  // T45504512: new connection model
   // NOTE: this property is optional because it's expected to be rarely used
   +dynamicKey?: ?NormalizationArgument,
   +filters: ?$ReadOnlyArray<string>,
+  +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
 |};
 
 export type NormalizationArgument =
@@ -73,6 +74,7 @@ export type NormalizationClientExtension = {|
 |};
 
 export type NormalizationField =
+  | NormalizationFlightField
   | NormalizationScalarField
   | NormalizationLinkedField;
 
@@ -138,6 +140,14 @@ export type NormalizationScalarField = {|
   +storageKey: ?string,
 |};
 
+export type NormalizationFlightField = {|
+  +kind: 'FlightField',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+  +storageKey: ?string,
+|};
+
 export type NormalizationTypeDiscriminator = {|
   +kind: 'TypeDiscriminator',
   +abstractKey: string,
@@ -148,6 +158,7 @@ export type NormalizationSelection =
   | NormalizationClientExtension
   | NormalizationDefer
   | NormalizationField
+  | NormalizationFlightField
   | NormalizationHandle
   | NormalizationInlineFragment
   | NormalizationModuleImport
@@ -196,3 +207,7 @@ export type NormalizationSelectableNode =
   | NormalizationOperation
   | NormalizationSplitOperation
   | NormalizationStream;
+
+export type NormalizationRootNode =
+  | ConcreteRequest
+  | NormalizationSplitOperation;

package/util/ReaderNode.js.flow

@@ -179,6 +179,14 @@ export type ReaderScalarField = {|
   +storageKey: ?string,
 |};
 
+export type ReaderFlightField = {|
+  +kind: 'FlightField',
+  +alias: ?string,
+  +name: string,
+  +args: ?$ReadOnlyArray<ReaderArgument>,
+  +storageKey: ?string,
+|};
+
 export type ReaderDefer = {|
   +kind: 'Defer',
   +selections: $ReadOnlyArray<ReaderSelection>,
@@ -189,16 +197,27 @@ export type ReaderStream = {|
   +selections: $ReadOnlyArray<ReaderSelection>,
 |};
 
+export type RequiredFieldAction = 'NONE' | 'LOG' | 'THROW';
+
+export type ReaderRequiredField = {|
+  +kind: 'RequiredField',
+  +field: ReaderField,
+  +action: RequiredFieldAction,
+  +path: string,
+|};
+
 export type ReaderSelection =
   | ReaderCondition
   | ReaderClientExtension
   | ReaderDefer
   | ReaderField
+  | ReaderFlightField
   | ReaderFragmentSpread
   | ReaderInlineDataFragmentSpread
   | ReaderInlineFragment
   | ReaderModuleImport
-  | ReaderStream;
+  | ReaderStream
+  | ReaderRequiredField;
 
 export type ReaderVariableArgument = {|
   +kind: 'Variable',

package/util/RelayConcreteNode.js.flow

@@ -31,6 +31,10 @@ export type ConcreteRequest = {|
   +params: RequestParameters,
 |};
 
+export type NormalizationRootNode =
+  | ConcreteRequest
+  | NormalizationSplitOperation;
+
 /**
  * Contains the parameters required for executing a GraphQL request.
  * The operation can either be provided as a persisted `id` or `text`. If given
@@ -67,6 +71,7 @@ const RelayConcreteNode = {
   CLIENT_EXTENSION: 'ClientExtension',
   DEFER: 'Defer',
   CONNECTION: 'Connection',
+  FLIGHT_FIELD: 'FlightField',
   FRAGMENT: 'Fragment',
   FRAGMENT_SPREAD: 'FragmentSpread',
   INLINE_DATA_FRAGMENT_SPREAD: 'InlineDataFragmentSpread',
@@ -78,6 +83,7 @@ const RelayConcreteNode = {
   LIST_VALUE: 'ListValue',
   LOCAL_ARGUMENT: 'LocalArgument',
   MODULE_IMPORT: 'ModuleImport',
+  REQUIRED_FIELD: 'RequiredField',
   OBJECT_VALUE: 'ObjectValue',
   OPERATION: 'Operation',
   REQUEST: 'Request',

package/util/RelayFeatureFlags.js.flow

@@ -17,14 +17,25 @@ type FeatureFlags = {|
   ENABLE_PARTIAL_RENDERING_DEFAULT: boolean,
   ENABLE_RELAY_CONTAINERS_SUSPENSE: boolean,
   ENABLE_PRECISE_TYPE_REFINEMENT: boolean,
+  ENABLE_REACT_FLIGHT_COMPONENT_FIELD: boolean,
+  ENABLE_REQUIRED_DIRECTIVES: boolean | string,
+  ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean,
+  ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean,
+  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: boolean,
+  ENABLE_LOAD_QUERY_REQUEST_DEDUPING: boolean,
 |};
 
 const RelayFeatureFlags: FeatureFlags = {
-  // T45504512: new connection model
   ENABLE_VARIABLE_CONNECTION_KEY: false,
   ENABLE_PARTIAL_RENDERING_DEFAULT: false,
   ENABLE_RELAY_CONTAINERS_SUSPENSE: false,
   ENABLE_PRECISE_TYPE_REFINEMENT: false,
+  ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,
+  ENABLE_REQUIRED_DIRECTIVES: false,
+  ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
+  ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
+  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: false,
+  ENABLE_LOAD_QUERY_REQUEST_DEDUPING: true,
 };
 
 module.exports = RelayFeatureFlags;

package/util/getFragmentIdentifier.js.flow

@@ -13,6 +13,9 @@
 
 'use strict';
 
+const RelayFeatureFlags = require('./RelayFeatureFlags');
+
+const isEmptyObject = require('./isEmptyObject');
 const stableCopy = require('./stableCopy');
 
 const {
@@ -38,15 +41,36 @@ function getFragmentIdentifier(
         ']';
   const fragmentVariables = getVariablesFromFragment(fragmentNode, fragmentRef);
   const dataIDs = getDataIDsFromFragment(fragmentNode, fragmentRef);
-  return (
-    fragmentOwnerIdentifier +
-    '/' +
-    fragmentNode.name +
-    '/' +
-    JSON.stringify(stableCopy(fragmentVariables)) +
-    '/' +
-    (JSON.stringify(dataIDs) ?? 'missing')
-  );
+
+  if (RelayFeatureFlags.ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION) {
+    return (
+      fragmentOwnerIdentifier +
+      '/' +
+      fragmentNode.name +
+      '/' +
+      (fragmentVariables == null || isEmptyObject(fragmentVariables)
+        ? '{}'
+        : JSON.stringify(stableCopy(fragmentVariables))) +
+      '/' +
+      (typeof dataIDs === 'undefined'
+        ? 'missing'
+        : dataIDs == null
+        ? 'null'
+        : Array.isArray(dataIDs)
+        ? '[' + dataIDs.join(',') + ']'
+        : dataIDs)
+    );
+  } else {
+    return (
+      fragmentOwnerIdentifier +
+      '/' +
+      fragmentNode.name +
+      '/' +
+      JSON.stringify(stableCopy(fragmentVariables)) +
+      '/' +
+      (JSON.stringify(dataIDs) ?? 'missing')
+    );
+  }
 }
 
 module.exports = getFragmentIdentifier;

package/util/getOperation.js.flow

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @emails oncall+relay
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {REQUEST, SPLIT_OPERATION} = require('./RelayConcreteNode');
+
+import type {
+  NormalizationOperation,
+  NormalizationRootNode,
+  NormalizationSplitOperation,
+} from './NormalizationNode';
+
+/**
+ * OperationLoaders can return either a NormalizationSplitOperation or
+ * ConcreteRequest.
+ */
+function getOperation(
+  node: NormalizationRootNode,
+): NormalizationSplitOperation | NormalizationOperation {
+  switch (node.kind) {
+    case REQUEST:
+      return node.operation;
+    case SPLIT_OPERATION:
+    default:
+      return node;
+  }
+}
+
+module.exports = getOperation;

package/util/getRequestIdentifier.js.flow

@@ -18,7 +18,7 @@ const stableCopy = require('./stableCopy');
 import type {RequestParameters} from './RelayConcreteNode';
 import type {Variables} from './RelayRuntimeTypes';
 
-export opaque type RequestIdentifier: string = string;
+export type RequestIdentifier = string;
 
 /**
  * Returns a stable identifier for the given pair of `RequestParameters` +

package/util/isEmptyObject.js.flow

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ * @emails oncall+relay
+ */
+
+'use strict';
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function isEmptyObject(obj: {+[key: string]: mixed}): boolean {
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = isEmptyObject;

package/util/recycleNodesInto.js.flow

@@ -12,6 +12,9 @@
 
 'use strict';
 
+const hasWeakSetDefined = typeof WeakSet !== 'undefined';
+const hasWeakMapDefined = typeof WeakMap !== 'undefined';
+
 /**
  * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.
  */
@@ -19,8 +22,16 @@ function recycleNodesInto<T>(prevData: T, nextData: T): T {
   if (
     prevData === nextData ||
     typeof prevData !== 'object' ||
+    prevData instanceof Set ||
+    prevData instanceof Map ||
+    (hasWeakSetDefined && prevData instanceof WeakSet) ||
+    (hasWeakMapDefined && prevData instanceof WeakMap) ||
     !prevData ||
     typeof nextData !== 'object' ||
+    nextData instanceof Set ||
+    nextData instanceof Map ||
+    (hasWeakSetDefined && nextData instanceof WeakSet) ||
+    (hasWeakMapDefined && nextData instanceof WeakMap) ||
     !nextData
   ) {
     return nextData;

package/util/reportMissingRequiredFields.js.flow

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @emails oncall+relay
+ * @format
+ */
+
+'use strict';
+
+import type {
+  IEnvironment,
+  MissingRequiredFields,
+} from '../store/RelayStoreTypes';
+
+function reportMissingRequiredFields(
+  environment: IEnvironment,
+  missingRequiredFields: MissingRequiredFields,
+) {
+  switch (missingRequiredFields.action) {
+    case 'THROW': {
+      const {path, owner} = missingRequiredFields.field;
+      // This gives the consumer the chance to throw their own error if they so wish.
+      environment.requiredFieldLogger({
+        kind: 'missing_field.throw',
+        owner,
+        fieldPath: path,
+      });
+      throw new Error(
+        `Relay: Missing @required value at path '${path}' in '${owner}'.`,
+      );
+    }
+    case 'LOG':
+      missingRequiredFields.fields.forEach(({path, owner}) => {
+        environment.requiredFieldLogger({
+          kind: 'missing_field.log',
+          owner,
+          fieldPath: path,
+        });
+      });
+      break;
+    default: {
+      (missingRequiredFields.action: empty);
+    }
+  }
+}
+
+module.exports = reportMissingRequiredFields;