@apollo/client 4.3.0-alpha.0 → 4.3.0-alpha.2

package/__cjs/cache/inmemory/entityStore.d.cts

@@ -23,6 +23,8 @@ export declare abstract class EntityStore implements NormalizedCache {
     evict(options: Cache.EvictOptions, limit: EntityStore): boolean;
     clear(): void;
     extract(): NormalizedCacheObject;
+    private coerceStoreObject;
+    private coerceValue;
     replace(newData: NormalizedCacheObject | null): void;
     abstract getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
     private rootIds;

package/__cjs/cache/inmemory/helpers.d.cts

@@ -7,7 +7,15 @@ import type { KeyFieldsContext } from "./policies.cjs";
 import type { InMemoryCacheConfig, NormalizedCache } from "./types.cjs";
 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.cjs").ApolloReducerConfig & {
+    resultCaching?: boolean;
+    possibleTypes?: import("./policies.cjs").PossibleTypesMap;
+    typePolicies?: import("./policies.cjs").TypePolicies;
+    fragments?: FragmentRegistryAPI;
+    inputObjects?: import("./types.cjs").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/__cjs/cache/inmemory/inMemoryCache.cjs

@@ -35,9 +35,9 @@ class InMemoryCache extends cache_js_1.ApolloCache {
     // cache.policies.addPossibletypes.
     policies;
     makeVar = reactiveVars_js_1.makeVar;
-    constructor(config = {}) {
+    constructor(...args) {
         super();
-        this.config = (0, helpers_js_1.normalizeConfig)(config);
+        this.config = (0, helpers_js_1.normalizeConfig)(args[0] ?? {});
         this.policies = new policies_js_1.Policies({
             cache: this,
             dataIdFromObject: this.config.dataIdFromObject,
@@ -97,6 +97,68 @@ class InMemoryCache extends cache_js_1.ApolloCache {
         // all CacheGroup dependency information.
         new Set([this.data.group, this.optimisticData.group]).forEach((group) => group.resetCaching());
     }
+    getScalar(key) {
+        return this.config.scalars?.[key];
+    }
+    serializeVariables(document, variables) {
+        if (!variables ||
+            Object.keys(variables).length === 0 ||
+            (!this.config.scalars && !this.config.inputObjects)) {
+            return variables;
+        }
+        const variableTypes = (0, internal_1.getOperationDefinition)(document)?.variableDefinitions?.reduce((memo, node) => {
+            memo[node.variable.name.value] = (0, internal_1.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 ((0, internal_1.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
@@ -110,7 +172,7 @@ class InMemoryCache extends cache_js_1.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
@@ -121,15 +183,20 @@ class InMemoryCache extends cache_js_1.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) {
@@ -165,8 +232,10 @@ class InMemoryCache extends cache_js_1.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,