npm - @salesforce/lds-adapters-uiapi - Versions diffs - 1.170.0 → 1.171.0 - Mend

@salesforce/lds-adapters-uiapi 1.170.0 → 1.171.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (388) hide show

package/sfdc/graphqlAdapters.js CHANGED Viewed

@@ -17,7 +17,7 @@ import { print, visit, parse, astResolver } from 'force/ldsGraphqlParser';
 import { createInstrumentedAdapter, createLDSAdapter, createGraphQLWireAdapterConstructor, createGraphQLImperativeAdapter } from 'force/ldsBindings';
 export { refresh as refreshGraphQL } from 'force/ldsBindings';
 import { buildFieldState, createFragmentMap, serializeFieldArguments, buildQueryTypeStringKey, getOperationFromDocument } from 'force/luvioGraphql';
-import { serializeStructuredKey, StoreKeyMap, deepFreeze, StoreKeySet } from 'force/luvioEngine';
+import { serializeStructuredKey, deepFreeze, StoreKeyMap, StoreKeySet } from 'force/luvioEngine';
 import { createIngestRecordWithFields } from 'force/ldsAdaptersUiapi';
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
@@ -439,10 +439,9 @@ function select$1b(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$12, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$16(astNode, state) {
+function getTypeCacheKeys$16(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$16(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -450,7 +449,6 @@ function getTypeCacheKeys$16(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$16(field) {
     switch (field.name.value) {
@@ -583,10 +581,9 @@ function select$1a(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$11, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$15(astNode, state) {
+function getTypeCacheKeys$15(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$15(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -594,7 +591,6 @@ function getTypeCacheKeys$15(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$15(field) {
     switch (field.name.value) {
@@ -727,10 +723,9 @@ function select$19(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$10, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$14(astNode, state) {
+function getTypeCacheKeys$14(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$14(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -738,7 +733,6 @@ function getTypeCacheKeys$14(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$14(field) {
     switch (field.name.value) {
@@ -895,10 +889,9 @@ function getMinimumSelections$L() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$13(astNode, state) {
+function getTypeCacheKeys$13(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$13(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -920,38 +913,37 @@ function getTypeCacheKeys$13(astNode, state) {
         switch (fieldType.typename) {
             case 'DoubleValue': {
                 const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, avgState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, avgState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'PercentValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$14(requestedField, maxState));
+                getTypeCacheKeys$14(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'PercentValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$14(requestedField, minState));
+                getTypeCacheKeys$14(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'PercentValue': {
                 const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$14(requestedField, sumState));
+                getTypeCacheKeys$14(cacheKeySink, requestedField, sumState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$13(field) {
     switch (field.name.value) {
@@ -1135,10 +1127,9 @@ function select$17(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$_, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$12(astNode, state) {
+function getTypeCacheKeys$12(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$12(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -1146,7 +1137,6 @@ function getTypeCacheKeys$12(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$12(field) {
     switch (field.name.value) {
@@ -1274,10 +1264,9 @@ function select$16(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$Z, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$11(astNode, state) {
+function getTypeCacheKeys$11(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$11(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -1285,7 +1274,6 @@ function getTypeCacheKeys$11(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$11(field) {
     switch (field.name.value) {
@@ -1433,10 +1421,9 @@ function getMinimumSelections$K() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$10(astNode, state) {
+function getTypeCacheKeys$10(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$10(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -1458,33 +1445,32 @@ function getTypeCacheKeys$10(astNode, state) {
         switch (fieldType.typename) {
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'StringValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$11(requestedField, maxState));
+                getTypeCacheKeys$11(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'StringValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$11(requestedField, minState));
+                getTypeCacheKeys$11(cacheKeySink, requestedField, minState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$10(field) {
     switch (field.name.value) {
@@ -1710,10 +1696,9 @@ function getMinimumSelections$I() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$$(astNode, state) {
+function getTypeCacheKeys$$(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$$(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -1721,7 +1706,6 @@ function getTypeCacheKeys$$(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$_(field) {
     switch (field.name.value) {
@@ -1848,10 +1832,9 @@ function select$13(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$W, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$_(astNode, state) {
+function getTypeCacheKeys$_(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$_(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -1859,7 +1842,6 @@ function getTypeCacheKeys$_(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$Z(field) {
     switch (field.name.value) {
@@ -2020,10 +2002,9 @@ function getMinimumSelections$H() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$Z(astNode, state) {
+function getTypeCacheKeys$Z(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$Z(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -2045,88 +2026,87 @@ function getTypeCacheKeys$Z(astNode, state) {
         switch (fieldType.typename) {
             case 'DateFunctionAggregation': {
                 const calendarMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, calendarMonthState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, calendarMonthState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const calendarQuarterState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, calendarQuarterState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, calendarQuarterState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const calendarYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, calendarYearState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, calendarYearState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const dayInMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, dayInMonthState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, dayInMonthState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const dayInWeekState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, dayInWeekState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, dayInWeekState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const dayInYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, dayInYearState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, dayInYearState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const fiscalMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, fiscalMonthState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, fiscalMonthState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const fiscalQuarterState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, fiscalQuarterState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, fiscalQuarterState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const fiscalYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, fiscalYearState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, fiscalYearState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'DateValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$_(requestedField, maxState));
+                getTypeCacheKeys$_(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'DateValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$_(requestedField, minState));
+                getTypeCacheKeys$_(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const weekInMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, weekInMonthState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, weekInMonthState);
                 break;
             }
             case 'DateFunctionAggregation': {
                 const weekInYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, weekInYearState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, weekInYearState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$Y(field) {
     switch (field.name.value) {
@@ -2392,10 +2372,9 @@ function getMinimumSelections$G() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$Y(astNode, state) {
+function getTypeCacheKeys$Y(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$Y(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -2403,7 +2382,6 @@ function getTypeCacheKeys$Y(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$X(field) {
     switch (field.name.value) {
@@ -2580,10 +2558,9 @@ function select$10(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$T, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$X(astNode, state) {
+function getTypeCacheKeys$X(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$X(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -2591,7 +2568,6 @@ function getTypeCacheKeys$X(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$W(field) {
     switch (field.name.value) {
@@ -2729,10 +2705,9 @@ function getMinimumSelections$E() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$W(astNode, state) {
+function getTypeCacheKeys$W(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$W(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -2754,13 +2729,12 @@ function getTypeCacheKeys$W(astNode, state) {
         switch (fieldType.typename) {
             case 'ObjectInfo': {
                 const objectInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$R(requestedField, objectInfoState));
+                getTypeCacheKeys$R(cacheKeySink, requestedField, objectInfoState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$V(field) {
     switch (field.name.value) {
@@ -2919,10 +2893,9 @@ function getMinimumSelections$D() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$V(astNode, state) {
+function getTypeCacheKeys$V(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$V(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -2930,7 +2903,6 @@ function getTypeCacheKeys$V(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$U(field) {
     switch (field.name.value) {
@@ -3065,10 +3037,9 @@ function getMinimumSelections$C() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$U(astNode, state) {
+function getTypeCacheKeys$U(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$U(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -3076,7 +3047,6 @@ function getTypeCacheKeys$U(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$T(field) {
     switch (field.name.value) {
@@ -3244,10 +3214,9 @@ function getMinimumSelections$B() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$T(astNode, state) {
+function getTypeCacheKeys$T(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$T(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -3269,7 +3238,7 @@ function getTypeCacheKeys$T(astNode, state) {
         switch (fieldType.typename) {
             case 'FilteredLookupInfo': {
                 const filteredLookupInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$U(requestedField, filteredLookupInfoState));
+                getTypeCacheKeys$U(cacheKeySink, requestedField, filteredLookupInfoState);
                 break;
             }
             case 'ReferenceToInfo': {
@@ -3285,14 +3254,13 @@ function getTypeCacheKeys$T(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$Q(requestedField, itemState));
+                    getTypeCacheKeys$Q(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$S(field) {
     switch (field.name.value) {
@@ -3610,10 +3578,9 @@ function getMinimumSelections$A() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$S(astNode, state) {
+function getTypeCacheKeys$S(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$S(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -3621,7 +3588,6 @@ function getTypeCacheKeys$S(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$R(field) {
     switch (field.name.value) {
@@ -3782,10 +3748,9 @@ function getMinimumSelections$z() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$R(astNode, state) {
+function getTypeCacheKeys$R(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$R(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -3818,7 +3783,7 @@ function getTypeCacheKeys$R(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$W(requestedField, itemState));
+                    getTypeCacheKeys$W(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
@@ -3835,7 +3800,7 @@ function getTypeCacheKeys$R(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$V(requestedField, itemState));
+                    getTypeCacheKeys$V(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
@@ -3852,7 +3817,7 @@ function getTypeCacheKeys$R(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$T(requestedField, itemState));
+                    getTypeCacheKeys$T(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
@@ -3869,19 +3834,18 @@ function getTypeCacheKeys$R(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$Y(requestedField, itemState));
+                    getTypeCacheKeys$Y(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
             case 'ThemeInfo': {
                 const themeInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$S(requestedField, themeInfoState));
+                getTypeCacheKeys$S(cacheKeySink, requestedField, themeInfoState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$Q(field) {
     switch (field.name.value) {
@@ -4156,10 +4120,9 @@ function getMinimumSelections$y() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$Q(astNode, state) {
+function getTypeCacheKeys$Q(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$Q(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -4181,13 +4144,12 @@ function getTypeCacheKeys$Q(astNode, state) {
         switch (fieldType.typename) {
             case 'ObjectInfo': {
                 const objectInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$R(requestedField, objectInfoState));
+                getTypeCacheKeys$R(cacheKeySink, requestedField, objectInfoState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$P(field) {
     switch (field.name.value) {
@@ -4321,10 +4283,9 @@ function select$U(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$L, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$P(astNode, state) {
+function getTypeCacheKeys$P(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$P(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -4332,7 +4293,6 @@ function getTypeCacheKeys$P(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$O(field) {
     switch (field.name.value) {
@@ -4459,10 +4419,9 @@ function select$T(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$K, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$O(astNode, state) {
+function getTypeCacheKeys$O(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$O(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -4470,7 +4429,6 @@ function getTypeCacheKeys$O(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$N(field) {
     switch (field.name.value) {
@@ -4621,10 +4579,9 @@ function getMinimumSelections$x() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$N(astNode, state) {
+function getTypeCacheKeys$N(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$N(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -4646,43 +4603,42 @@ function getTypeCacheKeys$N(astNode, state) {
         switch (fieldType.typename) {
             case 'DoubleValue': {
                 const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, avgState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, avgState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'LongValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, maxState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'LongValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, minState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'LongValue': {
                 const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, sumState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, sumState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$M(field) {
     switch (field.name.value) {
@@ -4872,10 +4828,9 @@ function select$R(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$I, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$M(astNode, state) {
+function getTypeCacheKeys$M(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$M(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -4883,7 +4838,6 @@ function getTypeCacheKeys$M(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$L(field) {
     switch (field.name.value) {
@@ -5034,10 +4988,9 @@ function getMinimumSelections$w() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$L(astNode, state) {
+function getTypeCacheKeys$L(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$L(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -5059,33 +5012,32 @@ function getTypeCacheKeys$L(astNode, state) {
         switch (fieldType.typename) {
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'PhoneNumberValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$M(requestedField, maxState));
+                getTypeCacheKeys$M(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'PhoneNumberValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$M(requestedField, minState));
+                getTypeCacheKeys$M(cacheKeySink, requestedField, minState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$K(field) {
     switch (field.name.value) {
@@ -5257,10 +5209,9 @@ function select$P(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$G, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$K(astNode, state) {
+function getTypeCacheKeys$K(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$K(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -5268,7 +5219,6 @@ function getTypeCacheKeys$K(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$J(field) {
     switch (field.name.value) {
@@ -5401,10 +5351,9 @@ function select$O(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$F, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$J(astNode, state) {
+function getTypeCacheKeys$J(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$J(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -5412,7 +5361,6 @@ function getTypeCacheKeys$J(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$I(field) {
     switch (field.name.value) {
@@ -5569,10 +5517,9 @@ function getMinimumSelections$v() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$I(astNode, state) {
+function getTypeCacheKeys$I(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$I(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -5594,38 +5541,37 @@ function getTypeCacheKeys$I(astNode, state) {
         switch (fieldType.typename) {
             case 'DoubleValue': {
                 const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, avgState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, avgState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'CurrencyValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$J(requestedField, maxState));
+                getTypeCacheKeys$J(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'CurrencyValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$J(requestedField, minState));
+                getTypeCacheKeys$J(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'CurrencyValue': {
                 const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$J(requestedField, sumState));
+                getTypeCacheKeys$J(cacheKeySink, requestedField, sumState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$H(field) {
     switch (field.name.value) {
@@ -5809,10 +5755,9 @@ function select$M(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$D, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$H(astNode, state) {
+function getTypeCacheKeys$H(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$H(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -5820,7 +5765,6 @@ function getTypeCacheKeys$H(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$G(field) {
     switch (field.name.value) {
@@ -6101,10 +6045,9 @@ function select$L(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$C, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$G(astNode, state) {
+function getTypeCacheKeys$G(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$G(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -6112,7 +6055,6 @@ function getTypeCacheKeys$G(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$E(field) {
     switch (field.name.value) {
@@ -6263,10 +6205,9 @@ function getMinimumSelections$t() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$F(astNode, state) {
+function getTypeCacheKeys$F(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$F(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -6288,33 +6229,32 @@ function getTypeCacheKeys$F(astNode, state) {
         switch (fieldType.typename) {
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'EmailValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$G(requestedField, maxState));
+                getTypeCacheKeys$G(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'EmailValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$G(requestedField, minState));
+                getTypeCacheKeys$G(cacheKeySink, requestedField, minState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$D(field) {
     switch (field.name.value) {
@@ -6486,10 +6426,9 @@ function select$J(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$A, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$E(astNode, state) {
+function getTypeCacheKeys$E(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$E(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -6497,7 +6436,6 @@ function getTypeCacheKeys$E(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$C(field) {
     switch (field.name.value) {
@@ -6624,10 +6562,9 @@ function select$I(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$z, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$D(astNode, state) {
+function getTypeCacheKeys$D(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$D(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -6635,7 +6572,6 @@ function getTypeCacheKeys$D(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$B(field) {
     switch (field.name.value) {
@@ -6784,10 +6720,9 @@ function getMinimumSelections$s() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$C(astNode, state) {
+function getTypeCacheKeys$C(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$C(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -6809,13 +6744,12 @@ function getTypeCacheKeys$C(astNode, state) {
         switch (fieldType.typename) {
             case 'DateFunctionAggregation': {
                 const hourInDayState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$$(requestedField, hourInDayState));
+                getTypeCacheKeys$$(cacheKeySink, requestedField, hourInDayState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$A(field) {
     switch (field.name.value) {
@@ -6959,10 +6893,9 @@ function select$G(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$x, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$B(astNode, state) {
+function getTypeCacheKeys$B(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$B(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -6970,7 +6903,6 @@ function getTypeCacheKeys$B(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$z(field) {
     switch (field.name.value) {
@@ -7121,10 +7053,9 @@ function getMinimumSelections$r() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$A(astNode, state) {
+function getTypeCacheKeys$A(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$A(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -7146,38 +7077,37 @@ function getTypeCacheKeys$A(astNode, state) {
         switch (fieldType.typename) {
             case 'DoubleValue': {
                 const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, avgState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, avgState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'LatitudeValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$B(requestedField, maxState));
+                getTypeCacheKeys$B(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'LatitudeValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$B(requestedField, minState));
+                getTypeCacheKeys$B(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'DoubleValue': {
                 const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, sumState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, sumState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$y(field) {
     switch (field.name.value) {
@@ -7355,10 +7285,9 @@ function select$E(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$v, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$z(astNode, state) {
+function getTypeCacheKeys$z(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$z(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -7366,7 +7295,6 @@ function getTypeCacheKeys$z(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$x(field) {
     switch (field.name.value) {
@@ -7517,10 +7445,9 @@ function getMinimumSelections$q() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$y(astNode, state) {
+function getTypeCacheKeys$y(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$y(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -7542,38 +7469,37 @@ function getTypeCacheKeys$y(astNode, state) {
         switch (fieldType.typename) {
             case 'DoubleValue': {
                 const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, avgState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, avgState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'LongitudeValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$P(requestedField, maxState));
+                getTypeCacheKeys$P(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'LongitudeValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$P(requestedField, minState));
+                getTypeCacheKeys$P(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'DoubleValue': {
                 const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, sumState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, sumState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$w(field) {
     switch (field.name.value) {
@@ -7771,10 +7697,9 @@ function getMinimumSelections$p() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$x(astNode, state) {
+function getTypeCacheKeys$x(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$x(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -7796,38 +7721,37 @@ function getTypeCacheKeys$x(astNode, state) {
         switch (fieldType.typename) {
             case 'DoubleValue': {
                 const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, avgState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, avgState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'DoubleValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, maxState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'DoubleValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, minState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'DoubleValue': {
                 const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, sumState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, sumState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$v(field) {
     switch (field.name.value) {
@@ -8006,10 +7930,9 @@ function select$B(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$s, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$w(astNode, state) {
+function getTypeCacheKeys$w(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$w(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -8017,7 +7940,6 @@ function getTypeCacheKeys$w(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$u(field) {
     switch (field.name.value) {
@@ -8168,10 +8090,9 @@ function getMinimumSelections$o() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$v(astNode, state) {
+function getTypeCacheKeys$v(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$v(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -8193,33 +8114,32 @@ function getTypeCacheKeys$v(astNode, state) {
         switch (fieldType.typename) {
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'IDValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$a(requestedField, maxState));
+                getTypeCacheKeys$a(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'IDValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$a(requestedField, minState));
+                getTypeCacheKeys$a(cacheKeySink, requestedField, minState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$t(field) {
     switch (field.name.value) {
@@ -8415,10 +8335,9 @@ function getMinimumSelections$n() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$u(astNode, state) {
+function getTypeCacheKeys$u(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$u(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -8440,33 +8359,32 @@ function getTypeCacheKeys$u(astNode, state) {
         switch (fieldType.typename) {
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'UrlValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$O(requestedField, maxState));
+                getTypeCacheKeys$O(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'UrlValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$O(requestedField, minState));
+                getTypeCacheKeys$O(cacheKeySink, requestedField, minState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$s(field) {
     switch (field.name.value) {
@@ -8662,10 +8580,9 @@ function getMinimumSelections$m() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$t(astNode, state) {
+function getTypeCacheKeys$t(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$t(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -8687,33 +8604,32 @@ function getTypeCacheKeys$t(astNode, state) {
         switch (fieldType.typename) {
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'TextAreaValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$w(requestedField, maxState));
+                getTypeCacheKeys$w(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'TextAreaValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$w(requestedField, minState));
+                getTypeCacheKeys$w(cacheKeySink, requestedField, minState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$r(field) {
     switch (field.name.value) {
@@ -8885,10 +8801,9 @@ function select$x(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$o, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$s(astNode, state) {
+function getTypeCacheKeys$s(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$s(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -8896,7 +8811,6 @@ function getTypeCacheKeys$s(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$q(field) {
     switch (field.name.value) {
@@ -9053,10 +8967,9 @@ function getMinimumSelections$l() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$r(astNode, state) {
+function getTypeCacheKeys$r(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$r(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -9078,33 +8991,32 @@ function getTypeCacheKeys$r(astNode, state) {
         switch (fieldType.typename) {
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'PicklistValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$K(requestedField, maxState));
+                getTypeCacheKeys$K(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'PicklistValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$K(requestedField, minState));
+                getTypeCacheKeys$K(cacheKeySink, requestedField, minState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$p(field) {
     switch (field.name.value) {
@@ -9306,10 +9218,9 @@ function getMinimumSelections$k() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$q(astNode, state) {
+function getTypeCacheKeys$q(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$q(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -9331,43 +9242,42 @@ function getTypeCacheKeys$q(astNode, state) {
         switch (fieldType.typename) {
             case 'DoubleValue': {
                 const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, avgState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, avgState);
                 break;
             }
             case 'LongValue': {
                 const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countState);
                 break;
             }
             case 'LongValue': {
                 const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, countDistinctState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, countDistinctState);
                 break;
             }
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
             case 'IntValue': {
                 const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, maxState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, maxState);
                 break;
             }
             case 'IntValue': {
                 const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, minState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, minState);
                 break;
             }
             case 'LongValue': {
                 const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, sumState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, sumState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$o(field) {
     switch (field.name.value) {
@@ -9557,10 +9467,9 @@ function select$u(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$l, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$p(astNode, state) {
+function getTypeCacheKeys$p(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$p(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -9568,7 +9477,6 @@ function getTypeCacheKeys$p(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$n(field) {
     switch (field.name.value) {
@@ -9711,10 +9619,9 @@ function getMinimumSelections$j() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$o(astNode, state) {
+function getTypeCacheKeys$o(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$o(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -9736,13 +9643,12 @@ function getTypeCacheKeys$o(astNode, state) {
         switch (fieldType.typename) {
             case 'IntValue': {
                 const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, groupingState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, groupingState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$m(field) {
     switch (field.name.value) {
@@ -9880,10 +9786,9 @@ function select$s(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$j, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$n(astNode, state) {
+function getTypeCacheKeys$n(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$n(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -9891,7 +9796,6 @@ function getTypeCacheKeys$n(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$l(field) {
     switch (field.name.value) {
@@ -10018,10 +9922,9 @@ function select$r(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$i, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$m(astNode, state) {
+function getTypeCacheKeys$m(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$m(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -10029,7 +9932,6 @@ function getTypeCacheKeys$m(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$k(field) {
     switch (field.name.value) {
@@ -10202,10 +10104,9 @@ function getMinimumSelections$h() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$l(astNode, state) {
+function getTypeCacheKeys$l(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$l(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -10213,7 +10114,6 @@ function getTypeCacheKeys$l(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$i(field) {
     switch (field.name.value) {
@@ -10364,10 +10264,9 @@ function getMinimumSelections$g() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$k(astNode, state) {
+function getTypeCacheKeys$k(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$k(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -10375,7 +10274,6 @@ function getTypeCacheKeys$k(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$h(field) {
     switch (field.name.value) {
@@ -10518,10 +10416,9 @@ function getMinimumSelections$f() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$j(astNode, state) {
+function getTypeCacheKeys$j(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$j(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -10554,7 +10451,7 @@ function getTypeCacheKeys$j(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$l(requestedField, itemState));
+                    getTypeCacheKeys$l(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
@@ -10571,14 +10468,13 @@ function getTypeCacheKeys$j(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$k(requestedField, itemState));
+                    getTypeCacheKeys$k(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$g(field) {
     switch (field.name.value) {
@@ -10684,13 +10580,12 @@ function select$n(field, variables, fragments) {
         }
     };
 }
-function getTypeCacheKeys$i(astNode, state) {
+function getTypeCacheKeys$i(cacheKeys, astNode, state) {
     const { path, data } = state;
     const typename = data.__typename;
     if (typename === 'RecordRepresentation') {
-        return getTypeCacheKeys$5(astNode, state);
+        return getTypeCacheKeys$5(cacheKeys, astNode, state);
     }
-    return new StoreKeyMap();
 }
 function getInContextFragmentType$f(fragment, fragmentMap) {
     return sharedGetFragmentType(fragment, fragmentMap);
@@ -11016,10 +10911,9 @@ function getMinimumSelections$d() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$h(astNode, state) {
+function getTypeCacheKeys$h(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$i(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -11041,93 +10935,92 @@ function getTypeCacheKeys$h(astNode, state) {
         switch (fieldType.typename) {
             case 'BooleanAggregate': {
                 const BooleanAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$o(requestedField, BooleanAggregateState));
+                getTypeCacheKeys$o(cacheKeySink, requestedField, BooleanAggregateState);
                 break;
             }
             case 'CurrencyAggregate': {
                 const CurrencyAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$I(requestedField, CurrencyAggregateState));
+                getTypeCacheKeys$I(cacheKeySink, requestedField, CurrencyAggregateState);
                 break;
             }
             case 'DateAggregate': {
                 const DateAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$Z(requestedField, DateAggregateState));
+                getTypeCacheKeys$Z(cacheKeySink, requestedField, DateAggregateState);
                 break;
             }
             case 'DoubleAggregate': {
                 const DoubleAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$x(requestedField, DoubleAggregateState));
+                getTypeCacheKeys$x(cacheKeySink, requestedField, DoubleAggregateState);
                 break;
             }
             case 'EmailAggregate': {
                 const EmailAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$F(requestedField, EmailAggregateState));
+                getTypeCacheKeys$F(cacheKeySink, requestedField, EmailAggregateState);
                 break;
             }
             case 'IDAggregate': {
                 const IDAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$v(requestedField, IDAggregateState));
+                getTypeCacheKeys$v(cacheKeySink, requestedField, IDAggregateState);
                 break;
             }
             case 'IntAggregate': {
                 const IntAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$q(requestedField, IntAggregateState));
+                getTypeCacheKeys$q(cacheKeySink, requestedField, IntAggregateState);
                 break;
             }
             case 'LatitudeAggregate': {
                 const LatitudeAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$A(requestedField, LatitudeAggregateState));
+                getTypeCacheKeys$A(cacheKeySink, requestedField, LatitudeAggregateState);
                 break;
             }
             case 'LongitudeAggregate': {
                 const LongitudeAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$y(requestedField, LongitudeAggregateState));
+                getTypeCacheKeys$y(cacheKeySink, requestedField, LongitudeAggregateState);
                 break;
             }
             case 'LongAggregate': {
                 const LongAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$N(requestedField, LongAggregateState));
+                getTypeCacheKeys$N(cacheKeySink, requestedField, LongAggregateState);
                 break;
             }
             case 'PercentAggregate': {
                 const PercentAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$13(requestedField, PercentAggregateState));
+                getTypeCacheKeys$13(cacheKeySink, requestedField, PercentAggregateState);
                 break;
             }
             case 'PhoneNumberAggregate': {
                 const PhoneNumberAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$L(requestedField, PhoneNumberAggregateState));
+                getTypeCacheKeys$L(cacheKeySink, requestedField, PhoneNumberAggregateState);
                 break;
             }
             case 'PicklistAggregate': {
                 const PicklistAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$r(requestedField, PicklistAggregateState));
+                getTypeCacheKeys$r(cacheKeySink, requestedField, PicklistAggregateState);
                 break;
             }
             case 'StringAggregate': {
                 const StringAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$10(requestedField, StringAggregateState));
+                getTypeCacheKeys$10(cacheKeySink, requestedField, StringAggregateState);
                 break;
             }
             case 'TextAreaAggregate': {
                 const TextAreaAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$t(requestedField, TextAreaAggregateState));
+                getTypeCacheKeys$t(cacheKeySink, requestedField, TextAreaAggregateState);
                 break;
             }
             case 'TimeAggregate': {
                 const TimeAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$C(requestedField, TimeAggregateState));
+                getTypeCacheKeys$C(cacheKeySink, requestedField, TimeAggregateState);
                 break;
             }
             case 'UrlAggregate': {
                 const UrlAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$u(requestedField, UrlAggregateState));
+                getTypeCacheKeys$u(cacheKeySink, requestedField, UrlAggregateState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function ingestFieldByType$d(typename, parentKey, requestedField, sink, fieldKey, fieldData, state) {
     // TODO: add validation logic to only allow nullable fields to be null in the future
@@ -11322,10 +11215,9 @@ function getMinimumSelections$c() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$g(astNode, state) {
+function getTypeCacheKeys$g(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$h(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -11347,13 +11239,12 @@ function getTypeCacheKeys$g(astNode, state) {
         switch (fieldType.typename) {
             case 'RecordAggregate': {
                 const aggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$h(requestedField, aggregateState));
+                getTypeCacheKeys$h(cacheKeySink, requestedField, aggregateState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$d(field) {
     switch (field.name.value) {
@@ -11486,10 +11377,9 @@ function getMinimumSelections$b() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$f(astNode, state) {
+function getTypeCacheKeys$f(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$g(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -11511,13 +11401,12 @@ function getTypeCacheKeys$f(astNode, state) {
         switch (fieldType.typename) {
             case 'RecordResult': {
                 const nodeState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$g(requestedField, nodeState));
+                getTypeCacheKeys$g(cacheKeySink, requestedField, nodeState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$c(field) {
     switch (field.name.value) {
@@ -11657,10 +11546,9 @@ function getMinimumSelections$a() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$e(astNode, state) {
+function getTypeCacheKeys$e(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$f(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -11668,7 +11556,6 @@ function getTypeCacheKeys$e(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$b(field) {
     switch (field.name.value) {
@@ -11885,10 +11772,9 @@ function getMinimumSelections$9() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$d(astNode, state) {
+function getTypeCacheKeys$d(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$e(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -11921,19 +11807,18 @@ function getTypeCacheKeys$d(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$f(requestedField, itemState));
+                    getTypeCacheKeys$f(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
             case 'PageInfo': {
                 const pageInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$e(requestedField, pageInfoState));
+                getTypeCacheKeys$e(cacheKeySink, requestedField, pageInfoState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$a(field) {
     switch (field.name.value) {
@@ -12424,10 +12309,9 @@ function getMinimumSelections$7() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$c(astNode, state) {
+function getTypeCacheKeys$c(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$d(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -12449,13 +12333,12 @@ function getTypeCacheKeys$c(astNode, state) {
         switch (fieldType.typename) {
             case 'RecordAggregateConnection': {
                 const recordQueryAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$d(requestedField, recordQueryAggregateState));
+                getTypeCacheKeys$d(cacheKeySink, requestedField, recordQueryAggregateState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function ingestFieldByType$8(typename, parentKey, requestedField, sink, fieldKey, fieldData, state) {
     // TODO: add validation logic to only allow nullable fields to be null in the future
@@ -12576,10 +12459,9 @@ function getMinimumSelections$6() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$b(astNode, state) {
+function getTypeCacheKeys$b(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$c(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -12587,7 +12469,6 @@ function getTypeCacheKeys$b(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$7(field) {
     switch (field.name.value) {
@@ -13944,10 +13825,9 @@ function select$f(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$6, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$a(astNode, state) {
+function getTypeCacheKeys$a(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$b(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -13955,7 +13835,6 @@ function getTypeCacheKeys$a(astNode, state) {
     });
     // get all cache keys from normalizable fields
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$4(field) {
     switch (field.name.value) {
@@ -14010,8 +13889,7 @@ function getInContextFragmentType$5(fragment, fragmentMap) {
 const VERSION$e = "195d918987a35f45e1aa4dce9a11d8c5";
 const RepresentationType$3 = 'FieldValueRepresentation';
-function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
-    const rootKeySet = new StoreKeyMap();
+function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
@@ -14020,17 +13898,14 @@ function getTypeCacheKeys$9(luvio, input, fullPathFactory) {
         mergeable: false
     });
     if (input.value !== null && typeof input.value === 'object') {
-        const input_value = getTypeCacheKeys$8(luvio, input.value);
-        rootKeySet.merge(input_value);
+        getTypeCacheKeys$8(rootKeySet, luvio, input.value);
     }
-    return rootKeySet;
 }
 const { assign, create, freeze, keys } = Object;
 // we override the generated so we can set "mergeable: true" on the root key
-const getTypeCacheKeys$8 = (luvio, input, _fullPathFactory) => {
-    const rootKeySet = new StoreKeyMap();
+const getTypeCacheKeys$8 = (rootKeySet, luvio, input, _fullPathFactory) => {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = keyBuilderFromType(luvio, input);
     rootKeySet.set(rootKey, {
@@ -14043,23 +13918,20 @@ const getTypeCacheKeys$8 = (luvio, input, _fullPathFactory) => {
     const input_childRelationships_length = input_childRelationships_keys.length;
     for (let i = 0; i < input_childRelationships_length; i++) {
         const key = input_childRelationships_keys[i];
-        const cacheKeys = getTypeCacheKeys$7(luvio, input_childRelationships[key], () => rootKey + '__childRelationships' + '__' + key);
-        rootKeySet.merge(cacheKeys);
+        getTypeCacheKeys$7(rootKeySet, luvio, input_childRelationships[key], () => rootKey + '__childRelationships' + '__' + key);
     }
     const input_fields = input.fields;
     const input_fields_keys = keys(input_fields);
     const input_fields_length = input_fields_keys.length;
     for (let i = 0; i < input_fields_length; i++) {
         const key = input_fields_keys[i];
-        const cacheKeys = getTypeCacheKeys$9(luvio, input_fields[key], () => rootKey + '__fields__' + key);
-        rootKeySet.merge(cacheKeys);
+        getTypeCacheKeys$9(rootKeySet, luvio, input_fields[key], () => rootKey + '__fields__' + key);
     }
     return rootKeySet;
 };
 const RepresentationType$2 = 'RecordCollectionRepresentation';
-function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
-    const rootKeySet = new StoreKeyMap();
+function getTypeCacheKeys$7(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
     const rootKey = fullPathFactory();
     rootKeySet.set(rootKey, {
@@ -14069,9 +13941,8 @@ function getTypeCacheKeys$7(luvio, input, fullPathFactory) {
     });
     const input_records_length = input.records.length;
     for (let i = 0; i < input_records_length; i++) {
-        rootKeySet.merge(getTypeCacheKeys$8(luvio, input.records[i]));
+        getTypeCacheKeys$8(rootKeySet, luvio, input.records[i]);
     }
-    return rootKeySet;
 }
 const VERSION$d = "98c5b18512e48ca8d28727549507e4ba";
@@ -14555,10 +14426,9 @@ function attachMappedData(source, reader) {
     return source;
 }
-function getTypeCacheKeys$6(astNode, state) {
+function getTypeCacheKeys$6(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$7(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -14593,29 +14463,26 @@ function getTypeCacheKeys$6(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$4(requestedField, itemState));
+                    getTypeCacheKeys$4(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
             case 'PageInfo': {
                 // I guess just return the pagination key here since pagination replaced it.
-                const pageInfoCacheKeys = new StoreKeyMap();
-                pageInfoCacheKeys.set(`${rootKey}__pagination`, {
+                cacheKeySink.set(`${rootKey}__pagination`, {
                     namespace: keyPrefix,
                     mergeable: true,
                     representationName: name$a,
                 });
-                cacheKeySink.merge(pageInfoCacheKeys);
                 break;
             }
         }
     }
-    return cacheKeySink;
 }
-function getMappedTypeCacheKeys(astNode, state) {
+function getMappedTypeCacheKeys(cache, astNode, state) {
     const convertedData = convertGraphQLToRaml(astNode, state);
-    return getTypeCacheKeys$8(state.luvio, convertedData.recordRepresentation);
+    getTypeCacheKeys$8(cache, state.luvio, convertedData.recordRepresentation);
 }
 const name$5 = 'RecordRepresentation';
@@ -14798,10 +14665,9 @@ function select$e(field, variables, fragments) {
         return selectCalculateSink(sink, field, buildSelectionForNode$5, source, reader, variables, fragments, parentRecordId);
     };
 }
-function getTypeCacheKeys$5(astNode, state) {
+function getTypeCacheKeys$5(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$9(luvio, path, data);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -14823,164 +14689,163 @@ function getTypeCacheKeys$5(astNode, state) {
         switch (fieldType.typename) {
             case 'IDValue': {
                 const LastModifiedByIdState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$a(requestedField, LastModifiedByIdState));
+                getTypeCacheKeys$a(cacheKeySink, requestedField, LastModifiedByIdState);
                 break;
             }
             case 'DateTimeValue': {
                 const LastModifiedDateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$H(requestedField, LastModifiedDateState));
+                getTypeCacheKeys$H(cacheKeySink, requestedField, LastModifiedDateState);
                 break;
             }
             case 'DateTimeValue': {
                 const SystemModstampState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$H(requestedField, SystemModstampState));
+                getTypeCacheKeys$H(cacheKeySink, requestedField, SystemModstampState);
                 break;
             }
             case 'IDValue': {
                 const RecordTypeIdState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$a(requestedField, RecordTypeIdState));
+                getTypeCacheKeys$a(cacheKeySink, requestedField, RecordTypeIdState);
                 break;
             }
             case 'IntValue': {
                 const IntValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$12(requestedField, IntValueState));
+                getTypeCacheKeys$12(cacheKeySink, requestedField, IntValueState);
                 break;
             }
             case 'StringValue': {
                 const StringValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$11(requestedField, StringValueState));
+                getTypeCacheKeys$11(cacheKeySink, requestedField, StringValueState);
                 break;
             }
             case 'BooleanValue': {
                 const BooleanValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$X(requestedField, BooleanValueState));
+                getTypeCacheKeys$X(cacheKeySink, requestedField, BooleanValueState);
                 break;
             }
             case 'IDValue': {
                 const IDValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$a(requestedField, IDValueState));
+                getTypeCacheKeys$a(cacheKeySink, requestedField, IDValueState);
                 break;
             }
             case 'DateTimeValue': {
                 const DateTimeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$H(requestedField, DateTimeValueState));
+                getTypeCacheKeys$H(cacheKeySink, requestedField, DateTimeValueState);
                 break;
             }
             case 'TimeValue': {
                 const TimeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$s(requestedField, TimeValueState));
+                getTypeCacheKeys$s(cacheKeySink, requestedField, TimeValueState);
                 break;
             }
             case 'DateValue': {
                 const DateValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$_(requestedField, DateValueState));
+                getTypeCacheKeys$_(cacheKeySink, requestedField, DateValueState);
                 break;
             }
             case 'TextAreaValue': {
                 const TextAreaValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$w(requestedField, TextAreaValueState));
+                getTypeCacheKeys$w(cacheKeySink, requestedField, TextAreaValueState);
                 break;
             }
             case 'LongTextAreaValue': {
                 const LongTextAreaValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$z(requestedField, LongTextAreaValueState));
+                getTypeCacheKeys$z(cacheKeySink, requestedField, LongTextAreaValueState);
                 break;
             }
             case 'RichTextAreaValue': {
                 const RichTextAreaValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$E(requestedField, RichTextAreaValueState));
+                getTypeCacheKeys$E(cacheKeySink, requestedField, RichTextAreaValueState);
                 break;
             }
             case 'PhoneNumberValue': {
                 const PhoneNumberValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$M(requestedField, PhoneNumberValueState));
+                getTypeCacheKeys$M(cacheKeySink, requestedField, PhoneNumberValueState);
                 break;
             }
             case 'EmailValue': {
                 const EmailValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$G(requestedField, EmailValueState));
+                getTypeCacheKeys$G(cacheKeySink, requestedField, EmailValueState);
                 break;
             }
             case 'UrlValue': {
                 const UrlValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$O(requestedField, UrlValueState));
+                getTypeCacheKeys$O(cacheKeySink, requestedField, UrlValueState);
                 break;
             }
             case 'EncryptedStringValue': {
                 const EncryptedStringValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$m(requestedField, EncryptedStringValueState));
+                getTypeCacheKeys$m(cacheKeySink, requestedField, EncryptedStringValueState);
                 break;
             }
             case 'CurrencyValue': {
                 const CurrencyValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$J(requestedField, CurrencyValueState));
+                getTypeCacheKeys$J(cacheKeySink, requestedField, CurrencyValueState);
                 break;
             }
             case 'LongitudeValue': {
                 const LongitudeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$P(requestedField, LongitudeValueState));
+                getTypeCacheKeys$P(cacheKeySink, requestedField, LongitudeValueState);
                 break;
             }
             case 'LatitudeValue': {
                 const LatitudeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$B(requestedField, LatitudeValueState));
+                getTypeCacheKeys$B(cacheKeySink, requestedField, LatitudeValueState);
                 break;
             }
             case 'PicklistValue': {
                 const PicklistValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$K(requestedField, PicklistValueState));
+                getTypeCacheKeys$K(cacheKeySink, requestedField, PicklistValueState);
                 break;
             }
             case 'MultiPicklistValue': {
                 const MultiPicklistValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$D(requestedField, MultiPicklistValueState));
+                getTypeCacheKeys$D(cacheKeySink, requestedField, MultiPicklistValueState);
                 break;
             }
             case 'LongValue': {
                 const LongValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$15(requestedField, LongValueState));
+                getTypeCacheKeys$15(cacheKeySink, requestedField, LongValueState);
                 break;
             }
             case 'DoubleValue': {
                 const DoubleValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$16(requestedField, DoubleValueState));
+                getTypeCacheKeys$16(cacheKeySink, requestedField, DoubleValueState);
                 break;
             }
             case 'PercentValue': {
                 const PercentValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$14(requestedField, PercentValueState));
+                getTypeCacheKeys$14(cacheKeySink, requestedField, PercentValueState);
                 break;
             }
             case 'Base64Value': {
                 const Base64ValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$n(requestedField, Base64ValueState));
+                getTypeCacheKeys$n(cacheKeySink, requestedField, Base64ValueState);
                 break;
             }
             case 'JSONValue': {
                 const JSONValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$p(requestedField, JSONValueState));
+                getTypeCacheKeys$p(cacheKeySink, requestedField, JSONValueState);
                 break;
             }
             case 'RecordRepresentation': {
                 const parentRelationshipState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$5(requestedField, parentRelationshipState));
+                getTypeCacheKeys$5(cacheKeySink, requestedField, parentRelationshipState);
                 break;
             }
             case 'PolymorphicParentRelationship': {
                 const polymorphicParentRelationshipState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$i(requestedField, polymorphicParentRelationshipState));
+                getTypeCacheKeys$i(cacheKeySink, requestedField, polymorphicParentRelationshipState);
                 break;
             }
             case 'RecordConnection': {
                 const childRelationshipState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$6(requestedField, childRelationshipState));
+                getTypeCacheKeys$6(cacheKeySink, requestedField, childRelationshipState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    cacheKeySink.merge(getMappedTypeCacheKeys(astNode, state));
-    return cacheKeySink;
+    getMappedTypeCacheKeys(cacheKeySink, astNode, state);
 }
 function ingestFieldByType$5(typename, parentKey, requestedField, sink, fieldKey, fieldData, state) {
     // TODO: add validation logic to only allow nullable fields to be null in the future
@@ -15227,10 +15092,9 @@ function getMinimumSelections$4() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$4(astNode, state) {
+function getTypeCacheKeys$4(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$8(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -15252,13 +15116,12 @@ function getTypeCacheKeys$4(astNode, state) {
         switch (fieldType.typename) {
             case 'RecordRepresentation': {
                 const nodeState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$5(requestedField, nodeState));
+                getTypeCacheKeys$5(cacheKeySink, requestedField, nodeState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$3(field) {
     switch (field.name.value) {
@@ -15617,10 +15480,9 @@ function getMinimumSelections$2() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$3(astNode, state) {
+function getTypeCacheKeys$3(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$6(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -15642,13 +15504,12 @@ function getTypeCacheKeys$3(astNode, state) {
         switch (fieldType.typename) {
             case 'RecordConnection': {
                 const recordQueryState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$6(requestedField, recordQueryState));
+                getTypeCacheKeys$6(cacheKeySink, requestedField, recordQueryState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function ingestFieldByType$2(typename, parentKey, requestedField, sink, fieldKey, fieldData, state) {
     // TODO: add validation logic to only allow nullable fields to be null in the future
@@ -15775,10 +15636,9 @@ function getMinimumSelections$1() {
     ];
     return minimumSelections;
 }
-function getTypeCacheKeys$2(astNode, state) {
+function getTypeCacheKeys$2(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$5(luvio, path);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -15800,12 +15660,12 @@ function getTypeCacheKeys$2(astNode, state) {
         switch (fieldType.typename) {
             case 'RecordQuery': {
                 const queryState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$3(requestedField, queryState));
+                getTypeCacheKeys$3(cacheKeySink, requestedField, queryState);
                 break;
             }
             case 'RecordQueryAggregate': {
                 const aggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$c(requestedField, aggregateState));
+                getTypeCacheKeys$c(cacheKeySink, requestedField, aggregateState);
                 break;
             }
             case 'ObjectInfo': {
@@ -15821,19 +15681,18 @@ function getTypeCacheKeys$2(astNode, state) {
                         },
                         data: item,
                     };
-                    cacheKeySink.merge(getTypeCacheKeys$R(requestedField, itemState));
+                    getTypeCacheKeys$R(cacheKeySink, requestedField, itemState);
                 }
                 break;
             }
             case 'RelatedListInfo': {
                 const relatedListByNameState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$j(requestedField, relatedListByNameState));
+                getTypeCacheKeys$j(cacheKeySink, requestedField, relatedListByNameState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType$1(field) {
     switch (field.name.value) {
@@ -15999,10 +15858,9 @@ function getMinimumSelections() {
     const minimumSelections = [];
     return minimumSelections;
 }
-function getTypeCacheKeys$1(astNode, state) {
+function getTypeCacheKeys$1(cacheKeySink, astNode, state) {
     const { path, data, luvio } = state;
     const rootKey = keyBuilder$4(luvio, astNode, state.variables, state.fragments);
-    const cacheKeySink = new StoreKeyMap();
     cacheKeySink.set(rootKey, {
         namespace: keyPrefix,
         mergeable: true,
@@ -16024,18 +15882,17 @@ function getTypeCacheKeys$1(astNode, state) {
         switch (fieldType.typename) {
             case 'UIAPI': {
                 const uiapiState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$2(requestedField, uiapiState));
+                getTypeCacheKeys$2(cacheKeySink, requestedField, uiapiState);
                 break;
             }
             case 'RateLimit': {
                 const rateLimitState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
-                cacheKeySink.merge(getTypeCacheKeys$b(requestedField, rateLimitState));
+                getTypeCacheKeys$b(cacheKeySink, requestedField, rateLimitState);
                 break;
             }
         }
     }
     // Deal with mapped types' cache keys
-    return cacheKeySink;
 }
 function getFieldType(field) {
     switch (field.name.value) {
@@ -16171,8 +16028,7 @@ const ingest = function GraphQLRepresentationIngest(document, variables, operati
         };
     };
 };
-function getTypeCacheKeys(luvio, document, variables, data, operationName) {
-    const sink = new StoreKeyMap();
+function getTypeCacheKeys(sink, luvio, document, variables, data, operationName) {
     if (data.data) {
         const fragments = createFragmentMap(document);
         const operationToExecute = getOperationFromDocument(document, operationName);
@@ -16188,7 +16044,7 @@ function getTypeCacheKeys(luvio, document, variables, data, operationName) {
                     fullPath: '' // TODO: W-13079691 - Need to take another pass at what we want to do for structured keys
                 }
             };
-            sink.merge(getTypeCacheKeys$1(operationToExecute, state));
+            getTypeCacheKeys$1(sink, operationToExecute, state);
         }
     }
     return sink;
@@ -16207,11 +16063,11 @@ function keyBuilder$3(luvio, params) {
     }
     return `adapters_adapter$45$utils_keyPrefix::GraphQLRepresentation::InvalidOperation`;
 }
-function getResponseCacheKeys$1(luvio, resourceParams, response) {
+function getResponseCacheKeys$1(cacheKeys, luvio, resourceParams, response) {
     const query = resourceParams.body.query;
     const variables = resourceParams.body.variables || {};
     const operationName = resourceParams.body.operationName;
-    return getTypeCacheKeys(luvio, query, variables, response, operationName);
+    getTypeCacheKeys(cacheKeys, luvio, query, variables, response, operationName);
 }
 function ingestSuccess$1(luvio, config, resourceParams, response, snapshotRefresh) {
     const { body } = response;
@@ -16401,7 +16257,11 @@ function buildNetworkSnapshot$1(luvio, config, options) {
         return Promise.reject({ errorType: 'adapterError', error: (_b = response === null || response === void 0 ? void 0 : response.body) === null || _b === void 0 ? void 0 : _b.errors });
     })
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => getResponseCacheKeys$1(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$1(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
     })
         .catch((response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
@@ -16766,8 +16626,7 @@ function keyBuilder$1(luvio, params) {
         params.body.batchQuery +
         ')');
 }
-function getResponseCacheKeys(luvio, resourceParams, response) {
-    let keys = new StoreKeyMap();
+function getResponseCacheKeys(keys, luvio, resourceParams, response) {
     const childEnvelopes = response.results;
     const childResourceParamsArray = createChildResourceParams(resourceParams);
     if (process.env.NODE_ENV !== 'production') {
@@ -16784,8 +16643,7 @@ function getResponseCacheKeys(luvio, resourceParams, response) {
         const childResult = childEnvelopes[index];
         const { statusCode: childStatusCode, result: childBody } = childResult;
         if (childStatusCode === 200) {
-            const childKeys = getResponseCacheKeys$1(luvio, childResourceParams, childBody);
-            ObjectAssign(keys, childKeys);
+            getResponseCacheKeys$1(keys, luvio, childResourceParams, childBody);
         }
         else if (childStatusCode === 404) {
             const childKey = keyBuilder$3(luvio, childResourceParams);
@@ -16796,7 +16654,6 @@ function getResponseCacheKeys(luvio, resourceParams, response) {
             });
         }
     }
-    return keys;
 }
 function ingestSuccessChildResourceParams(luvio, childConfigs, childResourceParamsArray, childEnvelopes) {
     const childSnapshotDataResponses = [];
@@ -17007,7 +16864,11 @@ function buildNetworkSnapshot(luvio, config, options) {
     return luvio
         .dispatchResourceRequest(request, options)
         .then((response) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => getResponseCacheKeys(luvio, resourceParams, response.body));
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
     }, (response) => {
         return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
     });
@@ -17437,4 +17298,4 @@ register({
 });
 export { configurationForGraphQLAdapters as configuration, graphql, factory$1 as graphqlAdapterFactory, graphqlBatch, graphqlBatch_imperative, graphql_imperative };
-// version: 1.170.0-1813b78e7
+// version: 1.171.0-c5e524eba