relay-runtime 21.0.0 → 21.0.1

package/store/RelayPublishQueue.js.flow

@@ -45,18 +45,18 @@ type PendingCommit<TMutation extends MutationParameters> =
   | PendingRecordSource
   | PendingUpdater;
 type PendingRelayPayload<TMutation extends MutationParameters> = {
-  +kind: 'payload',
-  +operation: OperationDescriptor,
-  +payload: RelayResponsePayload,
-  +updater: ?SelectorStoreUpdater<TMutation['response']>,
+  readonly kind: 'payload',
+  readonly operation: OperationDescriptor,
+  readonly payload: RelayResponsePayload,
+  readonly updater: ?SelectorStoreUpdater<TMutation['response']>,
 };
 type PendingRecordSource = {
-  +kind: 'source',
-  +source: RecordSource,
+  readonly kind: 'source',
+  readonly source: RecordSource,
 };
 type PendingUpdater = {
-  +kind: 'updater',
-  +updater: StoreUpdater,
+  readonly kind: 'updater',
+  readonly updater: StoreUpdater,
 };
 
 const _global: typeof global | $FlowFixMe =

package/store/RelayRecordSource.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { DataID } from '../util/RelayRuntimeTypes';
+import { RecordState } from './RelayRecordState';
+import {MutableRecordSource, Record, RecordMap} from './RelayStoreTypes';
+
+export class RelayRecordSource implements MutableRecordSource {
+    constructor(records?: RecordMap);
+
+    static create(records?: RecordMap): MutableRecordSource;
+    get<T extends object = Record<string, unknown>>(dataID: DataID): Record<T> | null | undefined;
+    getRecordIDs(): DataID[];
+    getStatus(dataID: DataID): RecordState;
+    has(dataID: DataID): boolean;
+    size(): number;
+    toJSON(): { [key: string]: Record };
+    clear(): void;
+    delete(dataID: DataID): void;
+    remove(dataID: DataID): void;
+    set(dataID: DataID, record: Record): void;
+}

package/store/RelayRecordState.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+declare enum RelayRecordState {
+    /**
+     * Record exists (either fetched from the server or produced by a local,
+     * optimistic update).
+     */
+    EXISTENT = 'EXISTENT',
+
+    /**
+     * Record is known not to exist (either as the result of a mutation, or
+     * because the server returned `null` when queried for the record).
+     */
+    NONEXISTENT = 'NONEXISTENT',
+
+    /**
+     * Record State is unknown because it has not yet been fetched from the
+     * server.
+     */
+    UNKNOWN = 'UNKNOWN',
+}
+export type RecordState = keyof typeof RelayRecordState;
+export default RelayRecordState;

package/store/RelayResponseNormalizer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { PayloadData } from '../network/RelayNetworkTypes';
+import {MutableRecordSource, NormalizationSelector, RelayResponsePayload, RequestDescriptor} from './RelayStoreTypes';
+
+export type GetDataID = (fieldValue: { [key: string]: any }, typeName: string) => any;
+
+export interface NormalizationOptions {
+    getDataID: GetDataID;
+    path?: readonly string[] | undefined;
+    request: RequestDescriptor;
+}
+
+/**
+ * Normalizes the results of a query and standard GraphQL response, writing the
+ * normalized records/fields into the given MutableRecordSource.
+ */
+export function normalize(
+    recordSource: MutableRecordSource,
+    selector: NormalizationSelector,
+    response: PayloadData,
+    options: NormalizationOptions,
+): RelayResponsePayload;

package/store/RelayResponseNormalizer.js.flow

@@ -70,18 +70,18 @@ const invariant = require('invariant');
 const warning = require('warning');
 
 export type GetDataID = (
-  fieldValue: {+[string]: unknown},
+  fieldValue: {readonly [string]: unknown},
   typeName: string,
 ) => unknown;
 
 export type NormalizationOptions = {
-  +getDataID: GetDataID,
-  +treatMissingFieldsAsNull: boolean,
-  +deferDeduplicatedFields: boolean,
-  +log: ?LogFunction,
-  +path?: ReadonlyArray<string>,
-  +shouldProcessClientComponents?: ?boolean,
-  +actorIdentifier?: ?ActorIdentifier,
+  readonly getDataID: GetDataID,
+  readonly treatMissingFieldsAsNull: boolean,
+  readonly deferDeduplicatedFields: boolean,
+  readonly log: ?LogFunction,
+  readonly path?: ReadonlyArray<string>,
+  readonly shouldProcessClientComponents?: ?boolean,
+  readonly actorIdentifier?: ?ActorIdentifier,
 };
 
 /**