relay-runtime 9.0.0 → 10.1.0

package/mutations/RelayDeclarativeMutationConfig.js.flow

@@ -0,0 +1,380 @@
+/**
+ * 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 ConnectionHandler = require('../handlers/connection/ConnectionHandler');
+
+const warning = require('warning');
+
+import type {
+  RecordSourceSelectorProxy,
+  SelectorData,
+  SelectorStoreUpdater,
+} from '../store/RelayStoreTypes';
+import type {ConcreteRequest} from '../util/RelayConcreteNode';
+import type {Variables} from '../util/RelayRuntimeTypes';
+
+const MutationTypes = Object.freeze({
+  RANGE_ADD: 'RANGE_ADD',
+  RANGE_DELETE: 'RANGE_DELETE',
+  NODE_DELETE: 'NODE_DELETE',
+});
+export type MutationType = $Values<typeof MutationTypes>;
+
+const RangeOperations = Object.freeze({
+  APPEND: 'append',
+  PREPEND: 'prepend',
+});
+export type RangeOperation = $Values<typeof RangeOperations>;
+
+type RangeBehaviorsFunction = (connectionArgs: {
+  [name: string]: $FlowFixMe,
+  ...,
+}) => RangeOperation;
+type RangeBehaviorsObject = {[key: string]: RangeOperation, ...};
+export type RangeBehaviors = RangeBehaviorsFunction | RangeBehaviorsObject;
+
+type RangeAddConfig = {|
+  type: 'RANGE_ADD',
+  parentName?: string,
+  parentID?: string,
+  connectionInfo?: Array<{|
+    key: string,
+    filters?: Variables,
+    rangeBehavior: string,
+  |}>,
+  connectionName?: string,
+  edgeName: string,
+  rangeBehaviors?: RangeBehaviors,
+|};
+
+type RangeDeleteConfig = {|
+  type: 'RANGE_DELETE',
+  parentName?: string,
+  parentID?: string,
+  connectionKeys?: Array<{|
+    key: string,
+    filters?: Variables,
+  |}>,
+  connectionName?: string,
+  deletedIDFieldName: string | Array<string>,
+  pathToConnection: Array<string>,
+|};
+
+type NodeDeleteConfig = {|
+  type: 'NODE_DELETE',
+  parentName?: string,
+  parentID?: string,
+  connectionName?: string,
+  deletedIDFieldName: string,
+|};
+
+export type DeclarativeMutationConfig =
+  | RangeAddConfig
+  | RangeDeleteConfig
+  | NodeDeleteConfig;
+
+function convert(
+  configs: Array<DeclarativeMutationConfig>,
+  request: ConcreteRequest,
+  optimisticUpdater?: ?SelectorStoreUpdater,
+  updater?: ?SelectorStoreUpdater,
+): {
+  optimisticUpdater: SelectorStoreUpdater,
+  updater: SelectorStoreUpdater,
+  ...
+} {
+  const configOptimisticUpdates = optimisticUpdater ? [optimisticUpdater] : [];
+  const configUpdates = updater ? [updater] : [];
+  configs.forEach(config => {
+    switch (config.type) {
+      case 'NODE_DELETE':
+        const nodeDeleteResult = nodeDelete(config, request);
+        if (nodeDeleteResult) {
+          configOptimisticUpdates.push(nodeDeleteResult);
+          configUpdates.push(nodeDeleteResult);
+        }
+        break;
+      case 'RANGE_ADD':
+        const rangeAddResult = rangeAdd(config, request);
+        if (rangeAddResult) {
+          configOptimisticUpdates.push(rangeAddResult);
+          configUpdates.push(rangeAddResult);
+        }
+        break;
+      case 'RANGE_DELETE':
+        const rangeDeleteResult = rangeDelete(config, request);
+        if (rangeDeleteResult) {
+          configOptimisticUpdates.push(rangeDeleteResult);
+          configUpdates.push(rangeDeleteResult);
+        }
+        break;
+    }
+  });
+  return {
+    optimisticUpdater: (
+      store: RecordSourceSelectorProxy,
+      data: ?SelectorData,
+    ) => {
+      configOptimisticUpdates.forEach(eachOptimisticUpdater => {
+        eachOptimisticUpdater(store, data);
+      });
+    },
+    updater: (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+      configUpdates.forEach(eachUpdater => {
+        eachUpdater(store, data);
+      });
+    },
+  };
+}
+
+function nodeDelete(
+  config: NodeDeleteConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {deletedIDFieldName} = config;
+  const rootField = getRootField(request);
+  if (!rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    const payload = store.getRootField(rootField);
+    if (!payload) {
+      return;
+    }
+    const deleteID = payload.getValue(deletedIDFieldName);
+    const deleteIDs = Array.isArray(deleteID) ? deleteID : [deleteID];
+    deleteIDs.forEach(id => {
+      if (id && typeof id === 'string') {
+        store.delete(id);
+      }
+    });
+  };
+}
+
+function rangeAdd(
+  config: RangeAddConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {parentID, connectionInfo, edgeName} = config;
+  if (!parentID) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: For mutation config RANGE_ADD ' +
+        'to work you must include a parentID',
+    );
+    return null;
+  }
+  const rootField = getRootField(request);
+  if (!connectionInfo || !rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    const parent = store.get(parentID);
+    if (!parent) {
+      return;
+    }
+    const payload = store.getRootField(rootField);
+    if (!payload) {
+      return;
+    }
+    const serverEdge = payload.getLinkedRecord(edgeName);
+    for (const info of connectionInfo) {
+      if (!serverEdge) {
+        continue;
+      }
+      const connection = ConnectionHandler.getConnection(
+        parent,
+        info.key,
+        info.filters,
+      );
+      if (!connection) {
+        continue;
+      }
+      const clientEdge = ConnectionHandler.buildConnectionEdge(
+        store,
+        connection,
+        serverEdge,
+      );
+      if (!clientEdge) {
+        continue;
+      }
+      switch (info.rangeBehavior) {
+        case 'append':
+          ConnectionHandler.insertEdgeAfter(connection, clientEdge);
+          break;
+        case 'prepend':
+          ConnectionHandler.insertEdgeBefore(connection, clientEdge);
+          break;
+        default:
+          warning(
+            false,
+            'RelayDeclarativeMutationConfig: RANGE_ADD range behavior `%s` ' +
+              'will not work as expected in RelayModern, supported range ' +
+              "behaviors are 'append', 'prepend'.",
+            info.rangeBehavior,
+          );
+          break;
+      }
+    }
+  };
+}
+
+function rangeDelete(
+  config: RangeDeleteConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {
+    parentID,
+    connectionKeys,
+    pathToConnection,
+    deletedIDFieldName,
+  } = config;
+  if (!parentID) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: For mutation config RANGE_DELETE ' +
+        'to work you must include a parentID',
+    );
+    return null;
+  }
+  const rootField = getRootField(request);
+  if (!rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    if (!data) {
+      return;
+    }
+    const deleteIDs = [];
+    let deletedIDField = data[rootField];
+    if (deletedIDField && Array.isArray(deletedIDFieldName)) {
+      for (const eachField of deletedIDFieldName) {
+        if (deletedIDField && typeof deletedIDField === 'object') {
+          deletedIDField = deletedIDField[eachField];
+        }
+      }
+      if (Array.isArray(deletedIDField)) {
+        deletedIDField.forEach(idObject => {
+          if (
+            idObject &&
+            idObject.id &&
+            typeof idObject === 'object' &&
+            typeof idObject.id === 'string'
+          ) {
+            deleteIDs.push(idObject.id);
+          }
+        });
+      } else if (
+        deletedIDField &&
+        deletedIDField.id &&
+        typeof deletedIDField.id === 'string'
+      ) {
+        deleteIDs.push(deletedIDField.id);
+      }
+    } else if (
+      deletedIDField &&
+      typeof deletedIDFieldName === 'string' &&
+      typeof deletedIDField === 'object'
+    ) {
+      deletedIDField = deletedIDField[deletedIDFieldName];
+      if (typeof deletedIDField === 'string') {
+        deleteIDs.push(deletedIDField);
+      } else if (Array.isArray(deletedIDField)) {
+        deletedIDField.forEach(id => {
+          if (typeof id === 'string') {
+            deleteIDs.push(id);
+          }
+        });
+      }
+    }
+    deleteNode(parentID, connectionKeys, pathToConnection, store, deleteIDs);
+  };
+}
+
+function deleteNode(
+  parentID: string,
+  connectionKeys: ?Array<{|
+    key: string,
+    filters?: Variables,
+  |}>,
+  pathToConnection: Array<string>,
+  store: RecordSourceSelectorProxy,
+  deleteIDs: Array<string>,
+): void {
+  warning(
+    connectionKeys != null,
+    'RelayDeclarativeMutationConfig: RANGE_DELETE must provide a ' +
+      'connectionKeys',
+  );
+  const parent = store.get(parentID);
+  if (!parent) {
+    return;
+  }
+  if (pathToConnection.length < 2) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: RANGE_DELETE ' +
+        'pathToConnection must include at least parent and connection',
+    );
+    return;
+  }
+  let recordProxy = parent;
+  for (let i = 1; i < pathToConnection.length - 1; i++) {
+    if (recordProxy) {
+      recordProxy = recordProxy.getLinkedRecord(pathToConnection[i]);
+    }
+  }
+  // Should never enter loop except edge cases
+  if (!connectionKeys || !recordProxy) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: RANGE_DELETE ' +
+        'pathToConnection is incorrect. Unable to find connection with ' +
+        'parentID: %s and path: %s',
+      parentID,
+      pathToConnection.toString(),
+    );
+    return;
+  }
+  for (const key of connectionKeys) {
+    const connection = ConnectionHandler.getConnection(
+      recordProxy,
+      key.key,
+      key.filters,
+    );
+    if (connection) {
+      deleteIDs.forEach(deleteID => {
+        ConnectionHandler.deleteNode(connection, deleteID);
+      });
+    }
+  }
+}
+
+function getRootField(request: ConcreteRequest): ?string {
+  if (
+    request.fragment.selections &&
+    request.fragment.selections.length > 0 &&
+    request.fragment.selections[0].kind === 'LinkedField'
+  ) {
+    return request.fragment.selections[0].name;
+  }
+  return null;
+}
+
+module.exports = {
+  MutationTypes,
+  RangeOperations,
+
+  convert,
+};

package/mutations/RelayRecordProxy.js.flow

@@ -0,0 +1,165 @@
+/**
+ * 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 {generateClientID} = require('../store/ClientID');
+const {getStableStorageKey} = require('../store/RelayStoreUtils');
+
+import type {RecordProxy} from '../store/RelayStoreTypes';
+import type {Arguments} from '../store/RelayStoreUtils';
+import type {DataID} from '../util/RelayRuntimeTypes';
+import type RelayRecordSourceMutator from './RelayRecordSourceMutator';
+import type RelayRecordSourceProxy from './RelayRecordSourceProxy';
+
+/**
+ * @internal
+ *
+ * A helper class for manipulating a given record from a record source via an
+ * imperative/OO-style API.
+ */
+class RelayRecordProxy implements RecordProxy {
+  _dataID: DataID;
+  _mutator: RelayRecordSourceMutator;
+  _source: RelayRecordSourceProxy;
+
+  constructor(
+    source: RelayRecordSourceProxy,
+    mutator: RelayRecordSourceMutator,
+    dataID: DataID,
+  ) {
+    this._dataID = dataID;
+    this._mutator = mutator;
+    this._source = source;
+  }
+
+  copyFieldsFrom(source: RecordProxy): void {
+    this._mutator.copyFields(source.getDataID(), this._dataID);
+  }
+
+  getDataID(): DataID {
+    return this._dataID;
+  }
+
+  getType(): string {
+    const type = this._mutator.getType(this._dataID);
+    invariant(
+      type != null,
+      'RelayRecordProxy: Cannot get the type of deleted record `%s`.',
+      this._dataID,
+    );
+    return type;
+  }
+
+  getValue(name: string, args?: ?Arguments): mixed {
+    const storageKey = getStableStorageKey(name, args);
+    return this._mutator.getValue(this._dataID, storageKey);
+  }
+
+  setValue(value: mixed, name: string, args?: ?Arguments): RecordProxy {
+    invariant(
+      isValidLeafValue(value),
+      'RelayRecordProxy#setValue(): Expected a scalar or array of scalars, ' +
+        'got `%s`.',
+      JSON.stringify(value),
+    );
+    const storageKey = getStableStorageKey(name, args);
+    this._mutator.setValue(this._dataID, storageKey, value);
+    return this;
+  }
+
+  getLinkedRecord(name: string, args?: ?Arguments): ?RecordProxy {
+    const storageKey = getStableStorageKey(name, args);
+    const linkedID = this._mutator.getLinkedRecordID(this._dataID, storageKey);
+    return linkedID != null ? this._source.get(linkedID) : linkedID;
+  }
+
+  setLinkedRecord(
+    record: RecordProxy,
+    name: string,
+    args?: ?Arguments,
+  ): RecordProxy {
+    invariant(
+      record instanceof RelayRecordProxy,
+      'RelayRecordProxy#setLinkedRecord(): Expected a record, got `%s`.',
+      record,
+    );
+    const storageKey = getStableStorageKey(name, args);
+    const linkedID = record.getDataID();
+    this._mutator.setLinkedRecordID(this._dataID, storageKey, linkedID);
+    return this;
+  }
+
+  getOrCreateLinkedRecord(
+    name: string,
+    typeName: string,
+    args?: ?Arguments,
+  ): RecordProxy {
+    let linkedRecord = this.getLinkedRecord(name, args);
+    if (!linkedRecord) {
+      const storageKey = getStableStorageKey(name, args);
+      const clientID = generateClientID(this.getDataID(), storageKey);
+      // NOTE: it's possible that a client record for this field exists
+      // but the field itself was unset.
+      linkedRecord =
+        this._source.get(clientID) ?? this._source.create(clientID, typeName);
+      this.setLinkedRecord(linkedRecord, name, args);
+    }
+    return linkedRecord;
+  }
+
+  getLinkedRecords(name: string, args?: ?Arguments): ?Array<?RecordProxy> {
+    const storageKey = getStableStorageKey(name, args);
+    const linkedIDs = this._mutator.getLinkedRecordIDs(
+      this._dataID,
+      storageKey,
+    );
+    if (linkedIDs == null) {
+      return linkedIDs;
+    }
+    return linkedIDs.map(linkedID => {
+      return linkedID != null ? this._source.get(linkedID) : linkedID;
+    });
+  }
+
+  setLinkedRecords(
+    records: Array<?RecordProxy>,
+    name: string,
+    args?: ?Arguments,
+  ): RecordProxy {
+    invariant(
+      Array.isArray(records),
+      'RelayRecordProxy#setLinkedRecords(): Expected records to be an array, got `%s`.',
+      records,
+    );
+    const storageKey = getStableStorageKey(name, args);
+    const linkedIDs = records.map(record => record && record.getDataID());
+    this._mutator.setLinkedRecordIDs(this._dataID, storageKey, linkedIDs);
+    return this;
+  }
+
+  invalidateRecord(): void {
+    this._source.markIDForInvalidation(this._dataID);
+  }
+}
+
+function isValidLeafValue(value: mixed): boolean {
+  return (
+    value == null ||
+    typeof value !== 'object' ||
+    (Array.isArray(value) && value.every(isValidLeafValue))
+  );
+}
+
+module.exports = RelayRecordProxy;