relay-runtime 11.0.2 → 12.0.0

package/subscription/requestSubscription.js.flow

@@ -18,7 +18,6 @@ const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const warning = require('warning');
 
 const {getRequest} = require('../query/GraphQLTag');
-const {generateUniqueClientID} = require('../store/ClientID');
 const {
   createOperationDescriptor,
 } = require('../store/RelayModernOperationDescriptor');
@@ -36,7 +35,24 @@ import type {
   Variables,
 } from '../util/RelayRuntimeTypes';
 
-export type GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
+export type SubscriptionParameters = {|
+  +response: {...},
+  +variables: interface {},
+  +rawResponse?: {...},
+|};
+
+export type GraphQLSubscriptionConfig<T: SubscriptionParameters> = {|
+  configs?: Array<DeclarativeMutationConfig>,
+  cacheConfig?: CacheConfig,
+  subscription: GraphQLTaggedNode,
+  variables: $ElementType<T, 'variables'>,
+  onCompleted?: ?() => void,
+  onError?: ?(error: Error) => void,
+  onNext?: ?(response: ?$ElementType<T, 'response'>) => void,
+  updater?: ?SelectorStoreUpdater,
+|};
+
+export type DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
   configs?: Array<DeclarativeMutationConfig>,
   cacheConfig?: CacheConfig,
   subscription: GraphQLTaggedNode,
@@ -49,7 +65,7 @@ export type GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
 
 function requestSubscription<TSubscriptionPayload>(
   environment: IEnvironment,
-  config: GraphQLSubscriptionConfig<TSubscriptionPayload>,
+  config: DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload>,
 ): Disposable {
   const subscription = getRequest(config.subscription);
   if (subscription.params.operationKind !== 'subscription') {
@@ -67,9 +83,6 @@ function requestSubscription<TSubscriptionPayload>(
     subscription,
     variables,
     cacheConfig,
-    RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT
-      ? generateUniqueClientID()
-      : undefined,
   );
 
   warning(
@@ -91,30 +104,29 @@ function requestSubscription<TSubscriptionPayload>(
       operation,
       updater,
     })
-    .map(responses => {
-      let selector = operation.fragment;
-      if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {
-        let nextID;
-        if (Array.isArray(responses)) {
-          nextID = responses[0]?.extensions?.__relay_subscription_root_id;
-        } else {
-          nextID = responses.extensions?.__relay_subscription_root_id;
-        }
-        if (typeof nextID === 'string') {
-          selector = createReaderSelector(
-            selector.node,
-            nextID,
-            selector.variables,
-            selector.owner,
-          );
-        }
-      }
-      const data = environment.lookup(selector).data;
-      // $FlowFixMe[incompatible-cast]
-      return (data: TSubscriptionPayload);
-    })
     .subscribe({
-      next: onNext,
+      next: responses => {
+        if (onNext != null) {
+          let selector = operation.fragment;
+          let nextID;
+          if (Array.isArray(responses)) {
+            nextID = responses[0]?.extensions?.__relay_subscription_root_id;
+          } else {
+            nextID = responses.extensions?.__relay_subscription_root_id;
+          }
+          if (typeof nextID === 'string') {
+            selector = createReaderSelector(
+              selector.node,
+              nextID,
+              selector.variables,
+              selector.owner,
+            );
+          }
+          const data = environment.lookup(selector).data;
+          // $FlowFixMe[incompatible-cast]
+          onNext((data: TSubscriptionPayload));
+        }
+      },
       error: onError,
       complete: onCompleted,
     });

package/util/NormalizationNode.js.flow

@@ -87,7 +87,7 @@ export type NormalizationInlineFragment = {|
 
 export type NormalizationFragmentSpread = {|
   +kind: 'FragmentSpread',
-  +fragment: NormalizationNode,
+  +fragment: NormalizationSplitOperation,
   +args: ?$ReadOnlyArray<NormalizationArgument>,
 |};
 
@@ -102,7 +102,13 @@ export type NormalizationLinkedField = {|
   +selections: $ReadOnlyArray<NormalizationSelection>,
 |};
 
+export type NormalizationActorChange = {|
+  +kind: 'ActorChange',
+  +linkedField: NormalizationLinkedField,
+|};
+
 export type NormalizationModuleImport = {|
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
   +kind: 'ModuleImport',
   +documentName: string,
   +fragmentPropName: string,
@@ -155,6 +161,7 @@ export type NormalizationFlightField = {|
 |};
 
 export type NormalizationClientComponent = {|
+  +args?: ?$ReadOnlyArray<NormalizationArgument>,
   +kind: 'ClientComponent',
   +fragment: NormalizationNode,
 |};
@@ -176,9 +183,11 @@ export type NormalizationSelection =
   | NormalizationInlineFragment
   | NormalizationModuleImport
   | NormalizationStream
+  | NormalizationActorChange
   | NormalizationTypeDiscriminator;
 
 export type NormalizationSplitOperation = {|
+  +argumentDefinitions?: $ReadOnlyArray<NormalizationLocalArgumentDefinition>,
   +kind: 'SplitOperation',
   +name: string,
   +metadata: ?{+[key: string]: mixed, ...},
@@ -189,8 +198,6 @@ export type NormalizationStream = {|
   +if: string | null,
   +kind: 'Stream',
   +label: string,
-  +useCustomizedBatch: string | null,
-  +metadata: ?{+[key: string]: mixed, ...},
   +selections: $ReadOnlyArray<NormalizationSelection>,
 |};
 

package/util/ReaderNode.js.flow

@@ -108,7 +108,10 @@ export type ReaderClientExtension = {|
   +selections: $ReadOnlyArray<ReaderSelection>,
 |};
 
-export type ReaderField = ReaderScalarField | ReaderLinkedField;
+export type ReaderField =
+  | ReaderScalarField
+  | ReaderLinkedField
+  | ReaderRelayResolver;
 
 export type ReaderRootArgument = {|
   +kind: 'RootArgument',
@@ -133,7 +136,17 @@ export type ReaderLinkedField = {|
   +selections: $ReadOnlyArray<ReaderSelection>,
 |};
 
+export type ReaderActorChange = {|
+  +kind: 'ActorChange',
+  +alias: ?string,
+  +name: string,
+  +storageKey: ?string,
+  +args: ?$ReadOnlyArray<ReaderArgument>,
+  +fragmentSpread: ReaderFragmentSpread,
+|};
+
 export type ReaderModuleImport = {|
+  +args?: ?$ReadOnlyArray<ReaderArgument>,
   +kind: 'ModuleImport',
   +documentName: string,
   +fragmentPropName: string,
@@ -223,6 +236,7 @@ export type ReaderSelection =
   | ReaderClientExtension
   | ReaderDefer
   | ReaderField
+  | ReaderActorChange
   | ReaderFlightField
   | ReaderFragmentSpread
   | ReaderInlineDataFragmentSpread

package/util/RelayConcreteNode.js.flow

@@ -67,6 +67,7 @@ export type GeneratedNode =
   | NormalizationSplitOperation;
 
 const RelayConcreteNode = {
+  ACTOR_CHANGE: 'ActorChange',
   CONDITION: 'Condition',
   CLIENT_COMPONENT: 'ClientComponent',
   CLIENT_EXTENSION: 'ClientExtension',

package/util/RelayFeatureFlags.js.flow

@@ -12,40 +12,38 @@
 
 'use strict';
 
+import type {Disposable} from '../util/RelayRuntimeTypes';
+
 type FeatureFlags = {|
   ENABLE_VARIABLE_CONNECTION_KEY: boolean,
   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_RELAY_RESOLVERS: boolean,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean,
-  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: boolean,
   ENABLE_LOAD_QUERY_REQUEST_DEDUPING: boolean,
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: boolean,
   ENABLE_NOTIFY_SUBSCRIPTION: boolean,
-  ENABLE_UNIQUE_SUBSCRIPTION_ROOT: boolean,
-  ENABLE_BATCHED_STORE_UPDATES: boolean,
+  BATCH_ASYNC_MODULE_UPDATES_FN: ?(() => void) => Disposable,
+  ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT: boolean,
+  ENABLE_QUERY_RENDERER_OFFSCREEN_SUPPORT: boolean,
 |};
 
 const RelayFeatureFlags: FeatureFlags = {
   ENABLE_VARIABLE_CONNECTION_KEY: false,
   ENABLE_PARTIAL_RENDERING_DEFAULT: true,
-  ENABLE_RELAY_CONTAINERS_SUSPENSE: true,
-  ENABLE_PRECISE_TYPE_REFINEMENT: false,
   ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,
   ENABLE_REQUIRED_DIRECTIVES: false,
   ENABLE_RELAY_RESOLVERS: false,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
-  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: false,
   ENABLE_LOAD_QUERY_REQUEST_DEDUPING: true,
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: false,
   ENABLE_NOTIFY_SUBSCRIPTION: false,
-  ENABLE_UNIQUE_SUBSCRIPTION_ROOT: false,
-  ENABLE_BATCHED_STORE_UPDATES: false,
+  BATCH_ASYNC_MODULE_UPDATES_FN: null,
+  ENABLE_CONTAINERS_SUBSCRIBE_ON_COMMIT: false,
+  ENABLE_QUERY_RENDERER_OFFSCREEN_SUPPORT: false,
 };
 
 module.exports = RelayFeatureFlags;

package/util/RelayReplaySubject.js.flow

@@ -42,7 +42,7 @@ class RelayReplaySubject<T> {
   _events: Array<Event<T>> = [];
   _sinks: Set<Sink<T>> = new Set();
   _observable: RelayObservable<T>;
-  _subscription: ?Subscription = null;
+  _subscription: Array<Subscription> = [];
 
   constructor() {
     this._observable = RelayObservable.create(sink => {
@@ -116,15 +116,16 @@ class RelayReplaySubject<T> {
   }
 
   subscribe(observer: Observer<T> | Sink<T>): Subscription {
-    this._subscription = this._observable.subscribe(observer);
-    return this._subscription;
+    const subscription = this._observable.subscribe(observer);
+    this._subscription.push(subscription);
+    return subscription;
   }
 
   unsubscribe() {
-    if (this._subscription) {
-      this._subscription.unsubscribe();
-      this._subscription = null;
+    for (const subscription of this._subscription) {
+      subscription.unsubscribe();
     }
+    this._subscription = [];
   }
 
   getObserverCount(): number {

package/util/getPaginationMetadata.js.flow

@@ -0,0 +1,74 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const getRefetchMetadata = require('./getRefetchMetadata');
+const invariant = require('invariant');
+
+import type {
+  ConcreteRequest,
+  ReaderFragment,
+  ReaderPaginationMetadata,
+} from 'relay-runtime';
+
+function getPaginationMetadata(
+  fragmentNode: ReaderFragment,
+  componentDisplayName: string,
+): {|
+  connectionPathInFragmentData: $ReadOnlyArray<string | number>,
+  identifierField: ?string,
+  paginationRequest: ConcreteRequest,
+  paginationMetadata: ReaderPaginationMetadata,
+  stream: boolean,
+|} {
+  const {
+    refetchableRequest: paginationRequest,
+    refetchMetadata,
+  } = getRefetchMetadata(fragmentNode, componentDisplayName);
+
+  const paginationMetadata = refetchMetadata.connection;
+  invariant(
+    paginationMetadata != null,
+    'Relay: getPaginationMetadata(): Expected fragment `%s` to include a ' +
+      'connection when using `%s`. Did you forget to add a @connection ' +
+      'directive to the connection field in the fragment?',
+    componentDisplayName,
+    fragmentNode.name,
+  );
+  const connectionPathInFragmentData = paginationMetadata.path;
+
+  const connectionMetadata = (fragmentNode.metadata?.connection ?? [])[0];
+  invariant(
+    connectionMetadata != null,
+    'Relay: getPaginationMetadata(): Expected fragment `%s` to include a ' +
+      'connection when using `%s`. Did you forget to add a @connection ' +
+      'directive to the connection field in the fragment?',
+    componentDisplayName,
+    fragmentNode.name,
+  );
+  const identifierField = refetchMetadata.identifierField;
+  invariant(
+    identifierField == null || typeof identifierField === 'string',
+    'Relay: getRefetchMetadata(): Expected `identifierField` to be a string.',
+  );
+  return {
+    connectionPathInFragmentData,
+    identifierField,
+    paginationRequest,
+    paginationMetadata,
+    stream: connectionMetadata.stream === true,
+  };
+}
+
+module.exports = getPaginationMetadata;

package/util/getPaginationVariables.js.flow

@@ -0,0 +1,112 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+const warning = require('warning');
+
+import type {ReaderPaginationMetadata} from './ReaderNode';
+import type {Variables} from './RelayRuntimeTypes';
+
+export type Direction = 'forward' | 'backward';
+
+function getPaginationVariables(
+  direction: Direction,
+  count: number,
+  cursor: ?string,
+  baseVariables: Variables,
+  extraVariables: Variables,
+  paginationMetadata: ReaderPaginationMetadata,
+): {[string]: mixed, ...} {
+  const {
+    backward: backwardMetadata,
+    forward: forwardMetadata,
+  } = paginationMetadata;
+
+  if (direction === 'backward') {
+    invariant(
+      backwardMetadata != null &&
+        backwardMetadata.count != null &&
+        backwardMetadata.cursor != null,
+      'Relay: Expected backward pagination metadata to be available. ' +
+        "If you're seeing this, this is likely a bug in Relay.",
+    );
+    warning(
+      !extraVariables.hasOwnProperty(backwardMetadata.cursor),
+      'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+        'contain cursor variable `%s`. This variable is automatically ' +
+        'determined by Relay.',
+      backwardMetadata.cursor,
+    );
+    warning(
+      !extraVariables.hasOwnProperty(backwardMetadata.count),
+      'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+        'contain count variable `%s`. This variable is automatically ' +
+        'determined by Relay.',
+      backwardMetadata.count,
+    );
+    // $FlowFixMe[cannot-spread-interface]
+    const paginationVariables = {
+      ...baseVariables,
+      ...extraVariables,
+      [backwardMetadata.cursor]: cursor,
+      [backwardMetadata.count]: count,
+    };
+    if (forwardMetadata && forwardMetadata.cursor) {
+      paginationVariables[forwardMetadata.cursor] = null;
+    }
+    if (forwardMetadata && forwardMetadata.count) {
+      paginationVariables[forwardMetadata.count] = null;
+    }
+    return paginationVariables;
+  }
+
+  invariant(
+    forwardMetadata != null &&
+      forwardMetadata.count != null &&
+      forwardMetadata.cursor != null,
+    'Relay: Expected forward pagination metadata to be available. ' +
+      "If you're seeing this, this is likely a bug in Relay.",
+  );
+  warning(
+    !extraVariables.hasOwnProperty(forwardMetadata.cursor),
+    'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+      'contain cursor variable `%s`. This variable is automatically ' +
+      'determined by Relay.',
+    forwardMetadata.cursor,
+  );
+  warning(
+    !extraVariables.hasOwnProperty(forwardMetadata.count),
+    'Relay: `UNSTABLE_extraVariables` provided by caller should not ' +
+      'contain count variable `%s`. This variable is automatically ' +
+      'determined by Relay.',
+    forwardMetadata.count,
+  );
+  // $FlowFixMe[cannot-spread-interface]
+  const paginationVariables = {
+    ...baseVariables,
+    ...extraVariables,
+    [forwardMetadata.cursor]: cursor,
+    [forwardMetadata.count]: count,
+  };
+  if (backwardMetadata && backwardMetadata.cursor) {
+    paginationVariables[backwardMetadata.cursor] = null;
+  }
+  if (backwardMetadata && backwardMetadata.count) {
+    paginationVariables[backwardMetadata.count] = null;
+  }
+  return paginationVariables;
+}
+
+module.exports = getPaginationVariables;

package/util/getPendingOperationsForFragment.js.flow

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {getPromiseForActiveRequest} = require('../query/fetchQueryInternal');
+
+import type {IEnvironment, RequestDescriptor} from '../store/RelayStoreTypes';
+import type {ReaderFragment} from './ReaderNode';
+
+function getPendingOperationsForFragment(
+  environment: IEnvironment,
+  fragmentNode: ReaderFragment,
+  fragmentOwner: RequestDescriptor,
+): {|
+  promise: Promise<void>,
+  pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+|} | null {
+  let pendingOperations: $ReadOnlyArray<RequestDescriptor> = [];
+  let promise = getPromiseForActiveRequest(environment, fragmentOwner);
+
+  if (promise != null) {
+    pendingOperations = [fragmentOwner];
+  } else {
+    const result = environment
+      .getOperationTracker()
+      .getPendingOperationsAffectingOwner(fragmentOwner);
+
+    pendingOperations = result?.pendingOperations ?? [];
+    promise = result?.promise ?? null;
+  }
+
+  if (!promise) {
+    return null;
+  }
+
+  let pendingOperationName =
+    pendingOperations?.map(op => op.node.params.name).join(',') ?? null;
+  if (pendingOperationName == null || pendingOperationName.length === 0) {
+    pendingOperationName = 'Unknown pending operation';
+  }
+  const fragmentName = fragmentNode.name;
+  const promiseDisplayName =
+    pendingOperationName === fragmentName
+      ? `Relay(${pendingOperationName})`
+      : `Relay(${pendingOperationName}:${fragmentName})`;
+  // $FlowExpectedError[prop-missing] Expando to annotate Promises.
+  promise.displayName = promiseDisplayName;
+  return {promise, pendingOperations};
+}
+
+module.exports = getPendingOperationsForFragment;

package/util/getRefetchMetadata.js.flow

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+import type {
+  ConcreteRequest,
+  ReaderFragment,
+  ReaderRefetchMetadata,
+} from 'relay-runtime';
+
+function getRefetchMetadata(
+  fragmentNode: ReaderFragment,
+  componentDisplayName: string,
+): {|
+  fragmentRefPathInResponse: $ReadOnlyArray<string | number>,
+  identifierField: ?string,
+  refetchableRequest: ConcreteRequest,
+  refetchMetadata: ReaderRefetchMetadata,
+|} {
+  invariant(
+    fragmentNode.metadata?.plural !== true,
+    'Relay: getRefetchMetadata(): Expected fragment `%s` not to be plural when using ' +
+      '`%s`. Remove `@relay(plural: true)` from fragment `%s` ' +
+      'in order to use it with `%s`.',
+    fragmentNode.name,
+    componentDisplayName,
+    fragmentNode.name,
+    componentDisplayName,
+  );
+
+  const refetchMetadata = fragmentNode.metadata?.refetch;
+  invariant(
+    refetchMetadata != null,
+    'Relay: getRefetchMetadata(): Expected fragment `%s` to be refetchable when using `%s`. ' +
+      'Did you forget to add a @refetchable directive to the fragment?',
+    componentDisplayName,
+    fragmentNode.name,
+  );
+
+  // handle both commonjs and es modules
+  const refetchableRequest:
+    | ConcreteRequest
+    | string = (refetchMetadata: $FlowFixMe).operation.default
+    ? (refetchMetadata: $FlowFixMe).operation.default
+    : refetchMetadata.operation;
+  const fragmentRefPathInResponse = refetchMetadata.fragmentPathInResult;
+  invariant(
+    typeof refetchableRequest !== 'string',
+    'Relay: getRefetchMetadata(): Expected refetch query to be an ' +
+      "operation and not a string when using `%s`. If you're seeing this, " +
+      'this is likely a bug in Relay.',
+    componentDisplayName,
+  );
+  const identifierField = refetchMetadata.identifierField;
+  invariant(
+    identifierField == null || typeof identifierField === 'string',
+    'Relay: getRefetchMetadata(): Expected `identifierField` to be a string.',
+  );
+  return {
+    fragmentRefPathInResponse,
+    identifierField,
+    refetchableRequest,
+    refetchMetadata,
+  };
+}
+
+module.exports = getRefetchMetadata;

package/util/getValueAtPath.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+function getValueAtPath(
+  data: mixed,
+  path: $ReadOnlyArray<string | number>,
+): mixed {
+  let result = data;
+  for (const key of path) {
+    if (result == null) {
+      return null;
+    }
+    if (typeof key === 'number') {
+      invariant(
+        Array.isArray(result),
+        'Relay: Expected an array when extracting value at path. ' +
+          "If you're seeing this, this is likely a bug in Relay.",
+      );
+      result = result[key];
+    } else {
+      invariant(
+        typeof result === 'object' && !Array.isArray(result),
+        'Relay: Expected an object when extracting value at path. ' +
+          "If you're seeing this, this is likely a bug in Relay.",
+      );
+      result = result[key];
+    }
+  }
+  return result;
+}
+
+module.exports = getValueAtPath;

package/util/isEmptyObject.js.flow

@@ -11,6 +11,7 @@
 
 'use strict';
 
+// $FlowFixMe[method-unbinding] added when improving typing for this parameters
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 function isEmptyObject(obj: interface {+[key: string]: mixed}): boolean {