@apollo/client 4.3.0-alpha.1 → 4.3.0-alpha.10

package/cache/inmemory/helpers.d.ts

@@ -7,7 +7,15 @@ import type { KeyFieldsContext } from "./policies.js";
 import type { InMemoryCacheConfig, NormalizedCache } from "./types.js";
 export declare const hasOwn: (v: PropertyKey) => boolean;
 export declare function defaultDataIdFromObject({ __typename, id, _id }: Readonly<StoreObject>, context?: KeyFieldsContext): string | undefined;
-export declare function normalizeConfig(config: InMemoryCacheConfig): InMemoryCacheConfig;
+export declare function normalizeConfig(config: InMemoryCacheConfig): import("./types.js").ApolloReducerConfig & {
+    resultCaching?: boolean;
+    possibleTypes?: import("./policies.js").PossibleTypesMap;
+    typePolicies?: import("./policies.js").TypePolicies;
+    fragments?: FragmentRegistryAPI;
+    inputObjects?: import("./types.js").InputObjectsOption;
+} & {
+    scalars?: import("@apollo/client").InMemoryCache.ScalarsOption;
+};
 export declare function getTypenameFromStoreObject(store: NormalizedCache, objectOrReference: StoreObject | Reference): string | undefined;
 export declare const TypeOrFieldNameRegExp: RegExp;
 export declare function fieldNameFromStoreName(storeFieldName: string): string;

package/cache/inmemory/inMemoryCache.d.ts

@@ -1,13 +1,31 @@
-import type { DocumentNode, FragmentDefinitionNode, InlineFragmentNode } from "graphql";
-import type { OperationVariables } from "@apollo/client";
+import type { DocumentNode, FragmentDefinitionNode, InlineFragmentNode, OperationTypeNode } from "graphql";
+import type { OperationVariables, TypedDocumentNode } from "@apollo/client";
 import type { DeepPartial, Reference, StoreObject } from "@apollo/client/utilities";
+import type { handleIncrementalSymbol, IsLooselyEqual, NoInfer } from "@apollo/client/utilities/internal";
 import { getInMemoryCacheMemoryInternals } from "@apollo/client/utilities/internal";
 import { ApolloCache } from "../core/cache.js";
+import type { Scalar } from "../core/Scalar.js";
 import type { Cache } from "../core/types/Cache.js";
 import { Policies } from "./policies.js";
 import { makeVar } from "./reactiveVars.js";
-import type { InMemoryCacheConfig, NormalizedCacheObject } from "./types.js";
+import type { DiffIncrementalInfo, InMemoryCacheConfig, KnownScalars, NormalizedCacheObject } from "./types.js";
 type BroadcastOptions = Pick<Cache.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;
+export declare namespace InMemoryCache {
+    type ScalarsOption = {
+        [ScalarName in keyof KnownScalars as IsLooselyEqual<KnownScalars[ScalarName]["serialized"], KnownScalars[ScalarName]["parsed"]> extends true ? ScalarName : never]?: KnownScalars[ScalarName] extends ({
+            serialized: infer TSerialized;
+            parsed: infer TParsed;
+        }) ? Scalar<TSerialized, TParsed> : never;
+    } & {
+        [ScalarName in keyof KnownScalars as IsLooselyEqual<KnownScalars[ScalarName]["serialized"], KnownScalars[ScalarName]["parsed"]> extends true ? never : ScalarName]: KnownScalars[ScalarName] extends ({
+            serialized: infer TSerialized;
+            parsed: infer TParsed;
+        }) ? Scalar<TSerialized, TParsed> : never;
+    } & (ApolloCache.Scalars extends (Record<string, {
+        serialized: infer TSerialized;
+        parsed: infer TParsed;
+    }>) ? Record<string, Scalar<TSerialized, TParsed>> : {});
+}
 export declare class InMemoryCache extends ApolloCache {
     private data;
     private optimisticData;
@@ -20,9 +38,27 @@ export declare class InMemoryCache extends ApolloCache {
     readonly assumeImmutableResults = true;
     readonly policies: Policies;
     readonly makeVar: typeof makeVar;
-    constructor(config?: InMemoryCacheConfig);
+    constructor(...args: {} extends InMemoryCache.ScalarsOption ? [
+        config?: InMemoryCacheConfig
+    ] : [config: InMemoryCacheConfig]);
     private init;
     private resetResultCache;
+    getRootTypename(operation: OperationTypeNode): string;
+    getScalar<TKey extends keyof ApolloCache.Scalars>(key: TKey): ApolloCache.GetScalarType<TKey> extends (Scalar<infer TSerialized, infer TParsed>) ? IsLooselyEqual<TSerialized, TParsed> extends true ? ApolloCache.GetScalarType<TKey> | undefined : ApolloCache.GetScalarType<TKey> : never;
+    /** Get a scalar instance for a field in a type */
+    getScalarForField<TSerialized = unknown, TParsed = unknown>(typename: string, fieldName: string): Scalar<TSerialized, TParsed> | undefined;
+    configuresScalars(): boolean;
+    /**
+    * Serializes scalar values in the variables object
+    */
+    serializeVariables<TVariables extends OperationVariables = OperationVariables>(document: DocumentNode | TypedDocumentNode<any, TVariables>, variables: NoInfer<TVariables>): TVariables;
+    /**
+    * Serializes scalar values in the variables object
+    */
+    serializeVariables<TVariables extends OperationVariables = OperationVariables>(document: DocumentNode | TypedDocumentNode<any, TVariables>, variables: NoInfer<TVariables> | undefined): TVariables | undefined;
+    private serializeVariablesValue;
+    private serializeInputArray;
+    private serializeInputObject;
     restore(data: NormalizedCacheObject): this;
     extract(optimistic?: boolean): NormalizedCacheObject;
     read<TData = unknown>(options: Cache.ReadOptions<TData, OperationVariables> & {
@@ -31,7 +67,10 @@ export declare class InMemoryCache extends ApolloCache {
     read<TData = unknown>(options: Cache.ReadOptions<TData, OperationVariables>): TData | null;
     write<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.WriteOptions<TData, TVariables>): Reference | undefined;
     modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache.ModifyOptions<Entity>): boolean;
-    diff<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: Cache.DiffOptions<TData, TVariables>): Cache.DiffResult<TData>;
+    diff<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: Cache.DiffOptions<TData, TVariables> & {
+        [handleIncrementalSymbol]: DiffIncrementalInfo | undefined;
+    }): Cache.InternalDiffResultWithDataState<TData>;
+    diff<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: Cache.DiffOptions<TData, TVariables>): Cache.DiffResult<TData>;
     watch<TData = unknown, TVariables extends OperationVariables = OperationVariables>(watch: Cache.WatchOptions<TData, TVariables>): () => void;
     gc(options?: {
         resetResultCache?: boolean;

package/cache/inmemory/inMemoryCache.js

@@ -2,7 +2,7 @@ import { equal } from "@wry/equality";
 import { wrap } from "optimism";
 import { addTypenameToDocument, cacheSizes, canonicalStringify, DocumentTransform, isReference, print, } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { getInMemoryCacheMemoryInternals } from "@apollo/client/utilities/internal";
+import { getInMemoryCacheMemoryInternals, getOperationDefinition, getUnwrappedType, isPlainObject, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { ApolloCache } from "../core/cache.js";
 import { EntityStore, supportsResultCaching } from "./entityStore.js";
@@ -28,9 +28,9 @@ export class InMemoryCache extends ApolloCache {
     // cache.policies.addPossibletypes.
     policies;
     makeVar = makeVar;
-    constructor(config = {}) {
+    constructor(...args) {
         super();
-        this.config = normalizeConfig(config);
+        this.config = normalizeConfig(args[0] ?? {});
         this.policies = new Policies({
             cache: this,
             dataIdFromObject: this.config.dataIdFromObject,
@@ -90,6 +90,78 @@ export class InMemoryCache extends ApolloCache {
         // all CacheGroup dependency information.
         new Set([this.data.group, this.optimisticData.group]).forEach((group) => group.resetCaching());
     }
+    getRootTypename(operation) {
+        return this.policies.rootTypenamesById[`ROOT_${operation.toUpperCase()}`];
+    }
+    getScalar(key) {
+        return this.config.scalars?.[key];
+    }
+    /** Get a scalar instance for a field in a type */
+    getScalarForField(typename, fieldName) {
+        return this.policies.getScalarForField(typename, fieldName);
+    }
+    configuresScalars() {
+        return !!this.config.scalars;
+    }
+    serializeVariables(document, variables) {
+        if (!variables ||
+            Object.keys(variables).length === 0 ||
+            (!this.config.scalars && !this.config.inputObjects)) {
+            return variables;
+        }
+        const variableTypes = getOperationDefinition(document)?.variableDefinitions?.reduce((memo, node) => {
+            memo[node.variable.name.value] = getUnwrappedType(node.type);
+            return memo;
+        }, {});
+        if (!variableTypes || Object.keys(variableTypes).length === 0) {
+            return variables;
+        }
+        return this.serializeVariablesValue(variables, variableTypes);
+    }
+    serializeVariablesValue(value, variableTypes, scalar) {
+        if (Array.isArray(value)) {
+            return this.serializeInputArray(value, variableTypes, scalar);
+        }
+        if (scalar && value != null) {
+            return scalar.coerceToSerialized(value);
+        }
+        if (isPlainObject(value)) {
+            return this.serializeInputObject(value, variableTypes);
+        }
+        return value;
+    }
+    serializeInputArray(value, variableTypes, scalar) {
+        let changed = false;
+        const newValue = value.map((item) => {
+            const newItem = this.serializeVariablesValue(item, variableTypes, scalar);
+            changed ||= newItem !== item;
+            return newItem;
+        });
+        return changed ? newValue : value;
+    }
+    serializeInputObject(value, variableTypes) {
+        let changed = false;
+        const entries = Object.entries(value).map(([name, value]) => {
+            const type = variableTypes[name];
+            if (!type) {
+                return [name, value];
+            }
+            const inputObject = this.config.inputObjects?.[type];
+            if (inputObject) {
+                const newValue = this.serializeVariablesValue(value, inputObject.fields);
+                changed ||= newValue !== value;
+                return [name, newValue];
+            }
+            const scalar = this.getScalar(type);
+            if (scalar) {
+                const newValue = this.serializeVariablesValue(value, variableTypes, scalar);
+                changed ||= newValue !== value;
+                return [name, newValue];
+            }
+            return [name, value];
+        });
+        return changed ? Object.fromEntries(entries) : value;
+    }
     restore(data) {
         this.init();
         // Since calling this.init() discards/replaces the entire StoreReader, along
@@ -103,7 +175,7 @@ export class InMemoryCache extends ApolloCache {
         return (optimistic ? this.optimisticData : this.data).extract();
     }
     read(options) {
-        const { 
+        const { query, variables, 
         // Since read returns data or null, without any additional metadata
         // about whether/where there might have been missing fields, the
         // default behavior cannot be returnPartialData = true (like it is
@@ -114,15 +186,20 @@ export class InMemoryCache extends ApolloCache {
         returnPartialData = false, } = options;
         return this.storeReader.diffQueryAgainstStore({
             ...options,
+            variables: this.serializeVariables(query, variables),
             store: options.optimistic ? this.optimisticData : this.data,
             config: this.config,
             returnPartialData,
         }).result;
     }
     write(options) {
+        const { query, variables } = options;
         try {
             ++this.txCount;
-            return this.storeWriter.writeToStore(this.data, options);
+            return this.storeWriter.writeToStore(this.data, {
+                ...options,
+                variables: this.serializeVariables(query, variables),
+            });
         }
         finally {
             if (!--this.txCount && options.broadcast !== false) {
@@ -158,8 +235,10 @@ export class InMemoryCache extends ApolloCache {
         }
     }
     diff(options) {
+        const { variables } = options;
         return this.storeReader.diffQueryAgainstStore({
             ...options,
+            variables: this.serializeVariables(options.query, variables),
             store: options.optimistic ? this.optimisticData : this.data,
             rootId: options.id || "ROOT_QUERY",
             config: this.config,