relay-runtime 9.0.0 → 10.1.0

package/util/getRelayHandleKey.js.flow

@@ -0,0 +1,41 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+const {DEFAULT_HANDLE_KEY} = require('./RelayDefaultHandleKey');
+
+/**
+ * @internal
+ *
+ * Helper to create a unique name for a handle field based on the handle name, handle key and
+ * source field.
+ */
+function getRelayHandleKey(
+  handleName: string,
+  key: ?string,
+  fieldName: ?string,
+): string {
+  if (key && key !== DEFAULT_HANDLE_KEY) {
+    return `__${key}_${handleName}`;
+  }
+
+  invariant(
+    fieldName != null,
+    'getRelayHandleKey: Expected either `fieldName` or `key` in `handle` to be provided',
+  );
+  return `__${fieldName}_${handleName}`;
+}
+
+module.exports = getRelayHandleKey;

package/util/getRequestIdentifier.js.flow

@@ -0,0 +1,42 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+const stableCopy = require('./stableCopy');
+
+import type {RequestParameters} from './RelayConcreteNode';
+import type {Variables} from './RelayRuntimeTypes';
+
+export opaque type RequestIdentifier: string = string;
+
+/**
+ * Returns a stable identifier for the given pair of `RequestParameters` +
+ * variables.
+ */
+function getRequestIdentifier(
+  parameters: RequestParameters,
+  variables: Variables,
+): RequestIdentifier {
+  const requestID =
+    parameters.cacheID != null ? parameters.cacheID : parameters.id;
+  invariant(
+    requestID != null,
+    'getRequestIdentifier: Expected request `%s` to have either a ' +
+      'valid `id` or `cacheID` property',
+    parameters.name,
+  );
+  return requestID + JSON.stringify(stableCopy(variables));
+}
+
+module.exports = getRequestIdentifier;

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/isPromise.js.flow

@@ -0,0 +1,21 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+declare function isPromise(p: mixed): boolean %checks(p instanceof Promise);
+
+function isPromise(p: $FlowFixMe): boolean {
+  return !!p && typeof p.then === 'function';
+}
+
+module.exports = isPromise;

package/util/isScalarAndEqual.js.flow

@@ -0,0 +1,26 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * A fast test to determine if two values are equal scalars:
+ * - compares scalars such as booleans, strings, numbers by value
+ * - compares functions by identity
+ * - returns false for complex values, since these cannot be cheaply tested for
+ *   equality (use `areEquals` instead)
+ */
+function isScalarAndEqual(valueA: mixed, valueB: mixed): boolean {
+  return valueA === valueB && (valueA === null || typeof valueA !== 'object');
+}
+
+module.exports = isScalarAndEqual;

package/util/recycleNodesInto.js.flow

@@ -0,0 +1,87 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const hasWeakSetDefined = typeof WeakSet !== 'undefined';
+const hasWeakMapDefined = typeof WeakMap !== 'undefined';
+
+/**
+ * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.
+ */
+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;
+  }
+  let canRecycle = false;
+
+  // Assign local variables to preserve Flow type refinement.
+  const prevArray = Array.isArray(prevData) ? prevData : null;
+  const nextArray = Array.isArray(nextData) ? nextData : null;
+  if (prevArray && nextArray) {
+    canRecycle =
+      nextArray.reduce((wasEqual, nextItem, ii) => {
+        const prevValue = prevArray[ii];
+        const nextValue = recycleNodesInto(prevValue, nextItem);
+        if (nextValue !== nextArray[ii]) {
+          if (__DEV__) {
+            if (!Object.isFrozen(nextArray)) {
+              nextArray[ii] = nextValue;
+            }
+          } else {
+            nextArray[ii] = nextValue;
+          }
+        }
+        return wasEqual && nextValue === prevArray[ii];
+      }, true) && prevArray.length === nextArray.length;
+  } else if (!prevArray && !nextArray) {
+    // Assign local variables to preserve Flow type refinement.
+    const prevObject = prevData;
+    const nextObject = nextData;
+    const prevKeys = Object.keys(prevObject);
+    const nextKeys = Object.keys(nextObject);
+    canRecycle =
+      nextKeys.reduce((wasEqual, key) => {
+        const prevValue = prevObject[key];
+        const nextValue = recycleNodesInto(prevValue, nextObject[key]);
+        if (nextValue !== nextObject[key]) {
+          if (__DEV__) {
+            if (!Object.isFrozen(nextObject)) {
+              // $FlowFixMe[cannot-write]
+              nextObject[key] = nextValue;
+            }
+          } else {
+            // $FlowFixMe[cannot-write]
+            nextObject[key] = nextValue;
+          }
+        }
+        return wasEqual && nextValue === prevObject[key];
+      }, true) && prevKeys.length === nextKeys.length;
+  }
+  return canRecycle ? prevData : nextData;
+}
+
+module.exports = recycleNodesInto;

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;

package/util/resolveImmediate.js.flow

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+var resolvedPromise = Promise.resolve();
+
+/**
+ * An alternative to setImmediate based on Promise.
+ */
+function resolveImmediate(callback: () => void) {
+  resolvedPromise.then(callback).catch(throwNext);
+}
+
+function throwNext(error) {
+  setTimeout(() => {
+    throw error;
+  }, 0);
+}
+
+module.exports = resolveImmediate;

package/util/stableCopy.js.flow

@@ -0,0 +1,35 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+/**
+ * Creates a copy of the provided value, ensuring any nested objects have their
+ * keys sorted such that equivalent values would have identical JSON.stringify
+ * results.
+ */
+function stableCopy<T: mixed>(value: T): T {
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(stableCopy);
+  }
+  const keys = Object.keys(value).sort();
+  const stable = {};
+  for (let i = 0; i < keys.length; i++) {
+    stable[keys[i]] = stableCopy(value[keys[i]]);
+  }
+  return (stable: any);
+}
+
+module.exports = stableCopy;