@salesforce/lds-worker-api 1.120.0 → 1.121.1

package/dist/standalone/umd/lds-worker-api.js

@@ -3655,7 +3655,7 @@
             return this.environment.buildStructuredKey(namespace, representationName, idValues);
         }
     }
-    // engine version: 0.137.4-ec6f5c6d
+    // engine version: 0.137.6-aa20c775
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3782,7 +3782,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.120.0-7e4457c5c
+    // version: 1.121.1-ac2ef2013
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15206,7 +15206,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.120.0-7e4457c5c
+    // version: 1.121.1-ac2ef2013
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16119,7 +16119,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.120.0-7e4457c5c
+    // version: 1.121.1-ac2ef2013
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16202,7 +16202,7 @@
     ({
         state: FragmentReadResultState.Missing,
     });
-    // engine version: 0.137.4-ec6f5c6d
+    // engine version: 0.137.6-aa20c775
 
     const { keys: ObjectKeys$3, freeze: ObjectFreeze$3, create: ObjectCreate$3 } = Object;
 
@@ -44353,7 +44353,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.120.0-d7f610c36
+    // version: 1.121.1-7c3b8db1d
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -50732,7 +50732,7 @@
         return new DataLoader(batchRecordQuery);
     }
 
-    function createContext(store, objectInfos, eventEmitter, settings, snapshot) {
+    function createContext(store, objectInfos, eventEmitter, settings, snapshot, draftFunctions) {
         store.query.bind(store);
         const query = (sql, params) => {
             const now = Date.now();
@@ -50759,6 +50759,7 @@
             Record,
             snapshot,
             seenRecordIds: new Set(),
+            draftFunctions,
         };
     }
 
@@ -51144,7 +51145,7 @@
     }
 
     const MultiPickListValueSeparator = ';';
-    function filterToPredicates(where, recordType, alias, objectInfoMap, joins) {
+    function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draftFunctions) {
         if (!where)
             return [];
         let predicates = [];
@@ -51226,38 +51227,52 @@
                 }
             }
             else {
+                //`field` match the filedInfo's apiName
                 for (const [op, value] of entries$2(where[field])) {
                     const operator = operatorToSql(op);
-                    const fieldInfo = objectInfoMap[recordType].fields[field];
-                    const coerceIdNeeded = isCoerceIdNeeded(fieldInfo, field, op);
+                    /**
+                    Two types ID processing might be needed. Draft ID swapping is optional, which depends on DraftFunctions existence.
+                     1. Coercing is needed when query is executed against local db if field is Id field of entity or a reference to an entity. It is OK to use 15 char ID to query agaist server,
+                        so there is no need to coerce the ID in injected AST which is used by luvio to do the network request when necessary.
+                     2. Draft ID swapping is needed when adapter rebuild is triggered. Draft ID swapping also happens in field injection phase when adapter call is invoked. The injected AST node has
+                     the canonical ID and is passed to Luvio
+                    */
+                    const idProcessingNeeded = isIDValueField(fieldInfo);
                     const makePredicate = fieldInfo.dataType === 'MultiPicklist'
                         ? createMultiPicklistPredicate
                         : createSinglePredicate;
-                    predicates.push(makePredicate(coerceIdNeeded ? generateCoercedPredicateValue(value) : value, operator, fieldInfo, alias));
+                    predicates.push(makePredicate(idProcessingNeeded
+                        ? sanitizePredicateIDValue(value, draftFunctions)
+                        : value, operator, fieldInfo, alias));
                 }
             }
         }
         return predicates;
     }
     /**
-     * Coercing is needed when query is executed against local db if field is Id field of entity or a reference to an entity. It is OK to use 15 char ID to query agaist server,
-     * so there is no need to coerce the ID in injected AST which is used by luvio to do the network request when necessary.
+     *
      * @param fieldInfo
-     * @param fieldName
-     * @returns true if coerce is needed
+     * @returns true if field is of IDValue type
      */
-    function isCoerceIdNeeded(fieldInfo, fieldName, op) {
-        return ((fieldName === 'Id' ||
-            (fieldInfo.apiName === fieldName && fieldInfo.referenceToInfos.length > 0)) &&
-            (op === 'eq' || op === 'ne' || op === 'in' || op === 'nin'));
+    function isIDValueField(fieldInfo) {
+        return fieldInfo.apiName === 'Id' || fieldInfo.referenceToInfos.length > 0;
     }
-    function generateCoercedPredicateValue(value) {
+    /**
+     * Coerces and swaps ID if it is a draft ID.
+     * @param value Predicate value which might be a string value like 'John' or a List like ['Acme', 'John']
+     * @param draftFunction optional. If undefined, draft ID swapping does not happen
+     * @returns sanitized previdicate value
+     */
+    function sanitizePredicateIDValue(value, draftFunction) {
         if (isArray$2(value)) {
-            return value.map(generateCoercedPredicateValue);
+            return value.map((singleValue) => sanitizePredicateIDValue(singleValue, draftFunction));
         }
         else {
             const coercedId = getRecordId18(value);
             if (coercedId !== undefined) {
+                if (draftFunction !== undefined && draftFunction.isDraftId(coercedId)) {
+                    return draftFunction.getCanonicalId(coercedId);
+                }
                 return coercedId;
             }
             return value;
@@ -52673,7 +52688,7 @@
     }
     async function connectionEdgeResolver(obj, _args, context) {
         const { parentArgs = {}, parentRecord, currentFieldName } = obj;
-        const { query, objectInfos } = context;
+        const { query, objectInfos, draftFunctions } = context;
         let joins = [];
         let alias = currentFieldName;
         let childRelationshipFieldName = undefined;
@@ -52690,7 +52705,7 @@
         }
         // Alias starts as entity's ApiName
         const predicates = [
-            ...filterToPredicates(parentArgs.where, alias, alias, context.objectInfos, joins),
+            ...filterToPredicates(parentArgs.where, alias, alias, context.objectInfos, joins, draftFunctions),
             ...scopeToPredicates(parentArgs.scope, context.settings),
             ...childRelationshipToPredicates(childRelationshipFieldName, parentRecord.id),
         ];
@@ -53252,7 +53267,7 @@
         return addResolversToSchema(schema, polyFieldTypeNames);
     }
 
-    async function evaluate(config, observers, settings, objectInfos, store, snapshot) {
+    async function evaluate(config, observers, settings, objectInfos, store, snapshot, draftFunctions) {
         const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE, observers);
         // this is only wrapped in a try to execute the event after the result was returned
         try {
@@ -53285,7 +53300,7 @@
             eventEmitter({ type: 'graphql-preconditions-met' });
             // create the resolver request context, runtime values and functions for
             // resolvers to do their job.
-            const contextValue = createContext(store, objectInfos, eventEmitter, settings, snapshot);
+            const contextValue = createContext(store, objectInfos, eventEmitter, settings, snapshot, draftFunctions);
             // We're building this from scratch from each request.  If this becomes a
             // hotspot we can pull it up and memoize it later
             const schema = createSchema(objectInfos);
@@ -56611,11 +56626,11 @@
             let internalRequestContext = {
                 ...requestContext,
             };
+            const draftFunctions = {
+                isDraftId,
+                getCanonicalId,
+            };
             try {
-                const draftFunctions = {
-                    isDraftId,
-                    getCanonicalId,
-                };
                 ({
                     modifiedAST: injectedAST,
                     objectInfos: objectInfoNeeded,
@@ -56698,7 +56713,7 @@
                 let { result: rebuildResult, seenRecordIds } = await evaluate({
                     ...config,
                     query: injectedAST,
-                }, observers, { userId }, objectInfoNeeded, store, originalSnapshot);
+                }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, draftFunctions);
                 if (!rebuildResult.errors) {
                     rebuildResult = removeSyntheticFields(rebuildResult, config.query);
                 }
@@ -59868,7 +59883,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.120.0-7e4457c5c
+    // version: 1.121.1-ac2ef2013
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -65215,7 +65230,6 @@
         });
     }
     function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-        var _a, _b, _c, _d, _e;
         if (fieldData === null) {
             reader.assignScalar(key, sink, fieldData);
             return sink;
@@ -65234,673 +65248,111 @@
                 break;
             }
             case 'IDValue': {
-                const LastModifiedByIdResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$L
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (LastModifiedByIdResolvedLink.data !== undefined) {
-                    const result = select$L(sel, variables, fragments)(LastModifiedByIdResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$L, select$L, false);
                 break;
             }
             case 'DateTimeValue': {
-                const LastModifiedDateResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$K
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (LastModifiedDateResolvedLink.data !== undefined) {
-                    const result = select$K(sel, variables, fragments)(LastModifiedDateResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$K, select$K, false);
                 break;
             }
             case 'IntValue': {
-                const IntValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$N
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (IntValueResolvedLink.data !== undefined) {
-                    const result = select$N(sel, variables, fragments)(IntValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$N, select$N, false);
                 break;
             }
             case 'StringValue': {
-                const StringValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$M
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (StringValueResolvedLink.data !== undefined) {
-                    const result = select$M(sel, variables, fragments)(StringValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$M, select$M, false);
                 break;
             }
             case 'BooleanValue': {
-                const BooleanValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$J
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (BooleanValueResolvedLink.data !== undefined) {
-                    const result = select$J(sel, variables, fragments)(BooleanValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$J, select$J, false);
                 break;
             }
             case 'TimeValue': {
-                const TimeValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$I
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (TimeValueResolvedLink.data !== undefined) {
-                    const result = select$I(sel, variables, fragments)(TimeValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$I, select$I, false);
                 break;
             }
             case 'DateValue': {
-                const DateValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$H
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (DateValueResolvedLink.data !== undefined) {
-                    const result = select$H(sel, variables, fragments)(DateValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$H, select$H, false);
                 break;
             }
             case 'TextAreaValue': {
-                const TextAreaValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$G
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (TextAreaValueResolvedLink.data !== undefined) {
-                    const result = select$G(sel, variables, fragments)(TextAreaValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$G, select$G, false);
                 break;
             }
             case 'LongTextAreaValue': {
-                const LongTextAreaValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$F
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (LongTextAreaValueResolvedLink.data !== undefined) {
-                    const result = select$F(sel, variables, fragments)(LongTextAreaValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$F, select$F, false);
                 break;
             }
             case 'RichTextAreaValue': {
-                const RichTextAreaValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$E
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (RichTextAreaValueResolvedLink.data !== undefined) {
-                    const result = select$E(sel, variables, fragments)(RichTextAreaValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$E, select$E, false);
                 break;
             }
             case 'PhoneNumberValue': {
-                const PhoneNumberValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$D
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (PhoneNumberValueResolvedLink.data !== undefined) {
-                    const result = select$D(sel, variables, fragments)(PhoneNumberValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$D, select$D, false);
                 break;
             }
             case 'EmailValue': {
-                const EmailValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$C
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (EmailValueResolvedLink.data !== undefined) {
-                    const result = select$C(sel, variables, fragments)(EmailValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$C, select$C, false);
                 break;
             }
             case 'UrlValue': {
-                const UrlValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$B
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (UrlValueResolvedLink.data !== undefined) {
-                    const result = select$B(sel, variables, fragments)(UrlValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$B, select$B, false);
                 break;
             }
             case 'EncryptedStringValue': {
-                const EncryptedStringValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$A
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (EncryptedStringValueResolvedLink.data !== undefined) {
-                    const result = select$A(sel, variables, fragments)(EncryptedStringValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$A, select$A, false);
                 break;
             }
             case 'CurrencyValue': {
-                const CurrencyValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$z
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (CurrencyValueResolvedLink.data !== undefined) {
-                    const result = select$z(sel, variables, fragments)(CurrencyValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$z, select$z, false);
                 break;
             }
             case 'LongitudeValue': {
-                const LongitudeValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$y
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (LongitudeValueResolvedLink.data !== undefined) {
-                    const result = select$y(sel, variables, fragments)(LongitudeValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$y, select$y, false);
                 break;
             }
             case 'LatitudeValue': {
-                const LatitudeValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$x
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (LatitudeValueResolvedLink.data !== undefined) {
-                    const result = select$x(sel, variables, fragments)(LatitudeValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$x, select$x, false);
                 break;
             }
             case 'PicklistValue': {
-                const PicklistValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$w
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (PicklistValueResolvedLink.data !== undefined) {
-                    const result = select$w(sel, variables, fragments)(PicklistValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$w, select$w, false);
                 break;
             }
             case 'MultiPicklistValue': {
-                const MultiPicklistValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$v
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (MultiPicklistValueResolvedLink.data !== undefined) {
-                    const result = select$v(sel, variables, fragments)(MultiPicklistValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$v, select$v, false);
                 break;
             }
             case 'LongValue': {
-                const LongValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$P
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (LongValueResolvedLink.data !== undefined) {
-                    const result = select$P(sel, variables, fragments)(LongValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$P, select$P, false);
                 break;
             }
             case 'DoubleValue': {
-                const DoubleValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$Q
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (DoubleValueResolvedLink.data !== undefined) {
-                    const result = select$Q(sel, variables, fragments)(DoubleValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$Q, select$Q, false);
                 break;
             }
             case 'PercentValue': {
-                const PercentValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$O
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (PercentValueResolvedLink.data !== undefined) {
-                    const result = select$O(sel, variables, fragments)(PercentValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$O, select$O, false);
                 break;
             }
             case 'Base64Value': {
-                const Base64ValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$u
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (Base64ValueResolvedLink.data !== undefined) {
-                    const result = select$u(sel, variables, fragments)(Base64ValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$u, select$u, false);
                 break;
             }
             case 'JSONValue': {
-                const JSONValueResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$t
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (JSONValueResolvedLink.data !== undefined) {
-                    const result = select$t(sel, variables, fragments)(JSONValueResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$t, select$t, false);
                 break;
             }
             case 'RecordRepresentation': {
-                const parentRelationshipResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$o
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (parentRelationshipResolvedLink.data !== undefined) {
-                    const result = select$q(sel, variables, fragments)(parentRelationshipResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$o, select$q, false);
                 break;
             }
             case 'PolymorphicParentRelationship': {
-                const polymorphicParentRelationshipResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$s
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (polymorphicParentRelationshipResolvedLink.data !== undefined) {
-                    const result = select$s(sel, variables, fragments)(polymorphicParentRelationshipResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$s, select$s, false);
                 break;
             }
             case 'RecordConnection': {
-                const childRelationshipResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$m
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (childRelationshipResolvedLink.data !== undefined) {
-                    const source = childRelationshipResolvedLink.data.data;
-                    const totalEdges = source.edges !== undefined ? source.edges.length : 0;
-                    const metadata = reader.resolveMetadata(source, PAGINATION_VERSION);
-                    const firstArg = (_a = sel.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => { return argument.name.value === 'first'; });
-                    const firstArgVal = evaluateArgumentValue(firstArg, 'IntValue', variables);
-                    const pageSize = firstArgVal !== undefined ? firstArgVal : totalEdges;
-                    const afterArg = (_b = sel.arguments) === null || _b === void 0 ? void 0 : _b.find(argument => { return argument.name.value === 'after'; });
-                    const afterArgVal = evaluateArgumentValue(afterArg, 'StringValue', variables);
-                    const paginationParams = {
-                        pageSize: parseInt(pageSize, 10),
-                        token: afterArgVal
-                    };
-                    let { startOffset, endOffset } = getPageMetadata(metadata, paginationParams);
-                    const listIsComplete = ((metadata === null || metadata === void 0 ? void 0 : metadata.__END__) !== undefined);
-                    let trimmedEdges = [];
-                    let maxOffset = undefined;
-                    if (totalEdges === 0 && listIsComplete) {
-                        // We have an empty edge list
-                        // If after token was specified, it will never be a good cursor, so defer to a cache miss
-                        if (afterArgVal !== undefined) {
-                            reader.markMissingLink(fieldData.__ref);
-                            reader.markMissing();
-                            return;
-                        }
-                    }
-                    else {
-                        if (metadata === undefined || startOffset === undefined || endOffset === undefined) {
-                            reader.markMissingLink(fieldData.__ref);
-                            reader.markMissing();
-                            return;
-                        }
-                        // gql paging semantics is "after" the requested cursor, so shift the offsets provided a valid cursor is provided
-                        if (afterArgVal !== undefined) {
-                            startOffset++;
-                            // if the "first" argument was not provided then the endOffset
-                            // is already set to the index of the last edge.
-                            // if the "first" argument was provided then we need to increment the endOffset
-                            // however we still need to make sure the endOffset doesn't go past totalEdges
-                            // if the list is already complete and we can't fetch any more edges
-                            if (firstArgVal !== undefined && (!listIsComplete || endOffset < totalEdges)) {
-                                endOffset++;
-                            }
-                        }
-                        if (startOffset >= totalEdges && listIsComplete) {
-                            // Data after the last page was requested, return empty set
-                            startOffset = undefined;
-                            endOffset = undefined;
-                        }
-                        else {
-                            trimmedEdges = trimEdges(source.edges, startOffset, endOffset);
-                            maxOffset = findMaxOffset(metadata);
-                            const listHasEnoughItems = (endOffset - 1 <= maxOffset);
-                            if (trimmedEdges === undefined || !listHasEnoughItems) {
-                                reader.markMissingLink(fieldData.__ref);
-                                reader.markMissing();
-                                // optimize pagination when "first" and "after" args are part of the variable
-                                if (((_c = firstArg === null || firstArg === void 0 ? void 0 : firstArg.value) === null || _c === void 0 ? void 0 : _c.kind) === 'Variable' && ((_d = afterArg === null || afterArg === void 0 ? void 0 : afterArg.value) === null || _d === void 0 ? void 0 : _d.kind) === 'Variable') {
-                                    optimizePagination(metadata, firstArg.value.name.value, afterArg.value.name.value, variables);
-                                }
-                                return;
-                            }
-                        }
-                    }
-                    const paginatedData = {
-                        data: {
-                            ...source,
-                            edges: ObjectFreeze(trimmedEdges),
-                        }
-                    };
-                    const result = select$o(sel, variables, fragments)(paginatedData, reader);
-                    const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
-                    if (pageInfo !== undefined) {
-                        const selectedPageInfo = selectPageInfo$1((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
-                        if (selectedPageInfo !== undefined) {
-                            reader.assignNonScalar(result, 'pageInfo', selectedPageInfo);
-                        }
-                    }
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$m, select$o, true);
                 break;
             }
         }
@@ -65937,38 +65389,6 @@
             return sink;
         };
     }
-    function selectPageInfo$1(selections, fragments, pageInfo) {
-        var _a;
-        const pageInfoSelection = getSelectionNode$1(selections, fragments, 'pageInfo');
-        if (pageInfo === undefined || pageInfoSelection === undefined || pageInfoSelection.kind !== 'Field')
-            return undefined;
-        const pageInfoSelections = (_a = pageInfoSelection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections;
-        const selectedPageInfo = Object.assign({}, pageInfo);
-        Object.keys(pageInfo).forEach((fieldName) => {
-            if (getSelectionNode$1(pageInfoSelections, fragments, fieldName) === undefined) {
-                delete selectedPageInfo[fieldName];
-            }
-        });
-        return selectedPageInfo;
-    }
-    function getSelectionNode$1(selections, fragments, fieldName) {
-        if (selections === undefined)
-            return undefined;
-        for (let i = 0; i < selections.length; i++) {
-            const selection = selections[i];
-            if (selection.kind === 'Field' && selection.name.value === fieldName) {
-                return selection;
-            }
-            else if (selection.kind === 'FragmentSpread') {
-                const fragment = fragments[selection.name.value];
-                return getSelectionNode$1(fragment === null || fragment === void 0 ? void 0 : fragment.selectionSet.selections, fragments, fieldName);
-            }
-            else if (selection.kind === 'InlineFragment') {
-                return getSelectionNode$1(selection.selectionSet.selections, fragments, fieldName);
-            }
-        }
-        return undefined;
-    }
     function getTypeCacheKeys$h(astNode, state) {
         const { path, data, luvio } = state;
         const rootKey = keyBuilder$l(luvio, path, data);
@@ -66830,25 +66250,7 @@
                 break;
             }
             case 'RecordRepresentation': {
-                const nodeResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$o
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (nodeResolvedLink.data !== undefined) {
-                    const result = select$q(sel, variables, fragments)(nodeResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$o, select$q, false);
                 break;
             }
         }
@@ -67096,47 +66498,11 @@
                 break;
             }
             case 'RecordEdge': {
-                const edgesResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$n
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (edgesResolvedLink.data !== undefined) {
-                    const result = select$p(sel, variables, fragments)(edgesResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$n, select$p, false);
                 break;
             }
             case 'PageInfo': {
-                const pageInfoResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$p
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (pageInfoResolvedLink.data !== undefined) {
-                    const result = select$r(sel, variables, fragments)(pageInfoResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$p, select$r, false);
                 break;
             }
             case 'Int': {
@@ -67336,7 +66702,6 @@
         }
     }
     function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-        var _a, _b, _c, _d, _e;
         if (fieldData === null) {
             reader.assignScalar(key, sink, fieldData);
             return sink;
@@ -67347,101 +66712,7 @@
                 break;
             }
             case 'RecordConnection': {
-                const recordQueryResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$m
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (recordQueryResolvedLink.data !== undefined) {
-                    const source = recordQueryResolvedLink.data.data;
-                    const totalEdges = source.edges !== undefined ? source.edges.length : 0;
-                    const metadata = reader.resolveMetadata(source, PAGINATION_VERSION);
-                    const firstArg = (_a = sel.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => { return argument.name.value === 'first'; });
-                    const firstArgVal = evaluateArgumentValue(firstArg, 'IntValue', variables);
-                    const pageSize = firstArgVal !== undefined ? firstArgVal : totalEdges;
-                    const afterArg = (_b = sel.arguments) === null || _b === void 0 ? void 0 : _b.find(argument => { return argument.name.value === 'after'; });
-                    const afterArgVal = evaluateArgumentValue(afterArg, 'StringValue', variables);
-                    const paginationParams = {
-                        pageSize: parseInt(pageSize, 10),
-                        token: afterArgVal
-                    };
-                    let { startOffset, endOffset } = getPageMetadata(metadata, paginationParams);
-                    const listIsComplete = ((metadata === null || metadata === void 0 ? void 0 : metadata.__END__) !== undefined);
-                    let trimmedEdges = [];
-                    let maxOffset = undefined;
-                    if (totalEdges === 0 && listIsComplete) {
-                        // We have an empty edge list
-                        // If after token was specified, it will never be a good cursor, so defer to a cache miss
-                        if (afterArgVal !== undefined) {
-                            reader.markMissingLink(fieldData.__ref);
-                            reader.markMissing();
-                            return;
-                        }
-                    }
-                    else {
-                        if (metadata === undefined || startOffset === undefined || endOffset === undefined) {
-                            reader.markMissingLink(fieldData.__ref);
-                            reader.markMissing();
-                            return;
-                        }
-                        // gql paging semantics is "after" the requested cursor, so shift the offsets provided a valid cursor is provided
-                        if (afterArgVal !== undefined) {
-                            startOffset++;
-                            // if the "first" argument was not provided then the endOffset
-                            // is already set to the index of the last edge.
-                            // if the "first" argument was provided then we need to increment the endOffset
-                            // however we still need to make sure the endOffset doesn't go past totalEdges
-                            // if the list is already complete and we can't fetch any more edges
-                            if (firstArgVal !== undefined && (!listIsComplete || endOffset < totalEdges)) {
-                                endOffset++;
-                            }
-                        }
-                        if (startOffset >= totalEdges && listIsComplete) {
-                            // Data after the last page was requested, return empty set
-                            startOffset = undefined;
-                            endOffset = undefined;
-                        }
-                        else {
-                            trimmedEdges = trimEdges(source.edges, startOffset, endOffset);
-                            maxOffset = findMaxOffset(metadata);
-                            const listHasEnoughItems = (endOffset - 1 <= maxOffset);
-                            if (trimmedEdges === undefined || !listHasEnoughItems) {
-                                reader.markMissingLink(fieldData.__ref);
-                                reader.markMissing();
-                                // optimize pagination when "first" and "after" args are part of the variable
-                                if (((_c = firstArg === null || firstArg === void 0 ? void 0 : firstArg.value) === null || _c === void 0 ? void 0 : _c.kind) === 'Variable' && ((_d = afterArg === null || afterArg === void 0 ? void 0 : afterArg.value) === null || _d === void 0 ? void 0 : _d.kind) === 'Variable') {
-                                    optimizePagination(metadata, firstArg.value.name.value, afterArg.value.name.value, variables);
-                                }
-                                return;
-                            }
-                        }
-                    }
-                    const paginatedData = {
-                        data: {
-                            ...source,
-                            edges: ObjectFreeze(trimmedEdges),
-                        }
-                    };
-                    const result = select$o(sel, variables, fragments)(paginatedData, reader);
-                    const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
-                    if (pageInfo !== undefined) {
-                        const selectedPageInfo = selectPageInfo((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
-                        if (selectedPageInfo !== undefined) {
-                            reader.assignNonScalar(result, 'pageInfo', selectedPageInfo);
-                        }
-                    }
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$m, select$o, true);
                 break;
             }
         }
@@ -67477,38 +66748,6 @@
             return sink;
         };
     }
-    function selectPageInfo(selections, fragments, pageInfo) {
-        var _a;
-        const pageInfoSelection = getSelectionNode(selections, fragments, 'pageInfo');
-        if (pageInfo === undefined || pageInfoSelection === undefined || pageInfoSelection.kind !== 'Field')
-            return undefined;
-        const pageInfoSelections = (_a = pageInfoSelection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections;
-        const selectedPageInfo = Object.assign({}, pageInfo);
-        Object.keys(pageInfo).forEach((fieldName) => {
-            if (getSelectionNode(pageInfoSelections, fragments, fieldName) === undefined) {
-                delete selectedPageInfo[fieldName];
-            }
-        });
-        return selectedPageInfo;
-    }
-    function getSelectionNode(selections, fragments, fieldName) {
-        if (selections === undefined)
-            return undefined;
-        for (let i = 0; i < selections.length; i++) {
-            const selection = selections[i];
-            if (selection.kind === 'Field' && selection.name.value === fieldName) {
-                return selection;
-            }
-            else if (selection.kind === 'FragmentSpread') {
-                const fragment = fragments[selection.name.value];
-                return getSelectionNode(fragment === null || fragment === void 0 ? void 0 : fragment.selectionSet.selections, fragments, fieldName);
-            }
-            else if (selection.kind === 'InlineFragment') {
-                return getSelectionNode(selection.selectionSet.selections, fragments, fieldName);
-            }
-        }
-        return undefined;
-    }
     function getMinimumSelections$A() {
         const minimumSelections = [
             {
@@ -67651,25 +66890,7 @@
                 break;
             }
             case 'ObjectInfo': {
-                const objectInfoResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$d
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (objectInfoResolvedLink.data !== undefined) {
-                    const result = select$f(sel, variables, fragments)(objectInfoResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$d, select$f, false);
                 break;
             }
         }
@@ -68223,25 +67444,7 @@
                 break;
             }
             case 'ObjectInfo': {
-                const objectInfoResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$d
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (objectInfoResolvedLink.data !== undefined) {
-                    const result = select$f(sel, variables, fragments)(objectInfoResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$d, select$f, false);
                 break;
             }
         }
@@ -68461,25 +67664,7 @@
                 break;
             }
             case 'FilteredLookupInfo': {
-                const filteredLookupInfoResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$i
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (filteredLookupInfoResolvedLink.data !== undefined) {
-                    const result = select$k(sel, variables, fragments)(filteredLookupInfoResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$i, select$k, false);
                 break;
             }
             case 'Int': {
@@ -68487,25 +67672,7 @@
                 break;
             }
             case 'ReferenceToInfo': {
-                const referenceToInfosResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$h
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (referenceToInfosResolvedLink.data !== undefined) {
-                    const result = select$j(sel, variables, fragments)(referenceToInfosResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$h, select$j, false);
                 break;
             }
         }
@@ -69264,25 +68431,7 @@
                 break;
             }
             case 'ChildRelationship': {
-                const childRelationshipsResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$k
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (childRelationshipsResolvedLink.data !== undefined) {
-                    const result = select$m(sel, variables, fragments)(childRelationshipsResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$k, select$m, false);
                 break;
             }
             case 'Boolean': {
@@ -69294,91 +68443,19 @@
                 break;
             }
             case 'DependentField': {
-                const dependentFieldsResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$j
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (dependentFieldsResolvedLink.data !== undefined) {
-                    const result = select$l(sel, variables, fragments)(dependentFieldsResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$j, select$l, false);
                 break;
             }
             case 'Field': {
-                const fieldsResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$g
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (fieldsResolvedLink.data !== undefined) {
-                    const result = select$i(sel, variables, fragments)(fieldsResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$g, select$i, false);
                 break;
             }
             case 'RecordTypeInfo': {
-                const recordTypeInfosResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$f
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (recordTypeInfosResolvedLink.data !== undefined) {
-                    const result = select$h(sel, variables, fragments)(recordTypeInfosResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$f, select$h, false);
                 break;
             }
             case 'ThemeInfo': {
-                const themeInfoResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$e
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (themeInfoResolvedLink.data !== undefined) {
-                    const result = select$g(sel, variables, fragments)(themeInfoResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$e, select$g, false);
                 break;
             }
         }
@@ -70159,47 +69236,11 @@
                 break;
             }
             case 'ListColumn': {
-                const displayColumnsResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$c
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (displayColumnsResolvedLink.data !== undefined) {
-                    const result = select$e(sel, variables, fragments)(displayColumnsResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$c, select$e, false);
                 break;
             }
             case 'ListOrder': {
-                const orderedByInfoResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$b
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (orderedByInfoResolvedLink.data !== undefined) {
-                    const result = select$d(sel, variables, fragments)(orderedByInfoResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$b, select$d, false);
                 break;
             }
         }
@@ -70465,69 +69506,15 @@
                 break;
             }
             case 'RecordQuery': {
-                const queryResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$l
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (queryResolvedLink.data !== undefined) {
-                    const result = select$n(sel, variables, fragments)(queryResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$l, select$n, false);
                 break;
             }
             case 'ObjectInfo': {
-                const objectInfosResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$d
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (objectInfosResolvedLink.data !== undefined) {
-                    const result = select$f(sel, variables, fragments)(objectInfosResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$d, select$f, false);
                 break;
             }
             case 'RelatedListInfo': {
-                const relatedListByNameResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$a
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (relatedListByNameResolvedLink.data !== undefined) {
-                    const result = select$c(sel, variables, fragments)(relatedListByNameResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$a, select$c, false);
                 break;
             }
         }
@@ -70976,47 +69963,11 @@
                 break;
             }
             case 'UIAPI': {
-                const uiapiResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$9
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (uiapiResolvedLink.data !== undefined) {
-                    const result = select$b(sel, variables, fragments)(uiapiResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$9, select$b, false);
                 break;
             }
             case 'RateLimit': {
-                const rateLimitResolvedLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$8
-                    },
-                    variables: {}
-                });
-                reader.markSeenId(fieldData.__ref);
-                if (rateLimitResolvedLink.data !== undefined) {
-                    const result = select$a(sel, variables, fragments)(rateLimitResolvedLink.data, reader); // Should probably
-                    reader.assignNonScalar(sink, key, result);
-                }
-                else {
-                    reader.markMissingLink(fieldData.__ref);
-                    reader.markMissing();
-                }
+                selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, VERSION$8, select$a, false);
                 break;
             }
         }
@@ -73176,7 +72127,7 @@
             }
         }
     }
-    function getRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
+    function calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
         const selections = [];
         selectionSet.selections.forEach(selection => {
             if (selection.kind === "Field") {
@@ -73196,6 +72147,21 @@
         });
         return selections;
     }
+    let selectionSetRequestedFieldsWeakMap = new WeakMap();
+    function getRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
+        let cachedRequestedFieldsConfigurations = selectionSetRequestedFieldsWeakMap.get(selectionSet);
+        if (cachedRequestedFieldsConfigurations === undefined) {
+            cachedRequestedFieldsConfigurations = new Map();
+            selectionSetRequestedFieldsWeakMap.set(selectionSet, cachedRequestedFieldsConfigurations);
+        }
+        const cachedRequestedFieldsForType = cachedRequestedFieldsConfigurations.get(typename);
+        if (cachedRequestedFieldsForType !== undefined) {
+            return cachedRequestedFieldsForType;
+        }
+        const selections = calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable);
+        cachedRequestedFieldsConfigurations.set(typename, selections);
+        return selections;
+    }
     function getQueryTransformerForType(typename, fragmentMap) {
         switch (typename) {
             case "PercentAggregate": return {
@@ -73723,6 +72689,145 @@
         }
         reader.exitPath();
         return sink;
+    }
+    function selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, version, selectFn, isCursorConnection) {
+        const resolvedLink = reader.read({
+            recordId: fieldData.__ref,
+            node: {
+                kind: 'Fragment',
+                private: [],
+                opaque: true,
+                version,
+            },
+            variables: {}
+        });
+        reader.markSeenId(fieldData.__ref);
+        if (resolvedLink.data !== undefined) {
+            if (isCursorConnection) {
+                selectTypeLinkWithPagination(resolvedLink, sel, fieldData, reader, key, sink, variables, fragments, selectFn);
+            }
+            else {
+                const result = selectFn(sel, variables, fragments)(resolvedLink.data, reader);
+                reader.assignNonScalar(sink, key, result);
+            }
+        }
+        else {
+            reader.markMissingLink(fieldData.__ref);
+            reader.markMissing();
+        }
+    }
+    function selectTypeLinkWithPagination(resolvedLink, sel, fieldData, reader, key, sink, variables, fragments, selectFn) {
+        var _a, _b, _c, _d, _e;
+        const source = resolvedLink.data.data;
+        const totalEdges = source.edges !== undefined ? source.edges.length : 0;
+        const metadata = reader.resolveMetadata(source, PAGINATION_VERSION);
+        const firstArg = (_a = sel.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => { return argument.name.value === 'first'; });
+        const firstArgVal = evaluateArgumentValue(firstArg, 'IntValue', variables);
+        const pageSize = firstArgVal !== undefined ? firstArgVal : totalEdges;
+        const afterArg = (_b = sel.arguments) === null || _b === void 0 ? void 0 : _b.find(argument => { return argument.name.value === 'after'; });
+        const afterArgVal = evaluateArgumentValue(afterArg, 'StringValue', variables);
+        const paginationParams = {
+            pageSize: parseInt(pageSize, 10),
+            token: afterArgVal
+        };
+        let { startOffset, endOffset } = getPageMetadata(metadata, paginationParams);
+        const listIsComplete = ((metadata === null || metadata === void 0 ? void 0 : metadata.__END__) !== undefined);
+        let trimmedEdges = [];
+        let maxOffset = undefined;
+        if (totalEdges === 0 && listIsComplete) {
+            // We have an empty edge list
+            // If after token was specified, it will never be a good cursor, so defer to a cache miss
+            if (afterArgVal !== undefined) {
+                reader.markMissingLink(fieldData.__ref);
+                reader.markMissing();
+                return;
+            }
+        }
+        else {
+            if (metadata === undefined || startOffset === undefined || endOffset === undefined) {
+                reader.markMissingLink(fieldData.__ref);
+                reader.markMissing();
+                return;
+            }
+            // gql paging semantics is "after" the requested cursor, so shift the offsets provided a valid cursor is provided
+            if (afterArgVal !== undefined) {
+                startOffset++;
+                // if the "first" argument was not provided then the endOffset
+                // is already set to the index of the last edge.
+                // if the "first" argument was provided then we need to increment the endOffset
+                // however we still need to make sure the endOffset doesn't go past totalEdges
+                // if the list is already complete and we can't fetch any more edges
+                if (firstArgVal !== undefined && (!listIsComplete || endOffset < totalEdges)) {
+                    endOffset++;
+                }
+            }
+            if (startOffset >= totalEdges && listIsComplete) {
+                // Data after the last page was requested, return empty set
+                startOffset = undefined;
+                endOffset = undefined;
+            }
+            else {
+                trimmedEdges = trimEdges(source.edges, startOffset, endOffset);
+                maxOffset = findMaxOffset(metadata);
+                const listHasEnoughItems = (endOffset - 1 <= maxOffset);
+                if (trimmedEdges === undefined || !listHasEnoughItems) {
+                    reader.markMissingLink(fieldData.__ref);
+                    reader.markMissing();
+                    // optimize pagination when "first" and "after" args are part of the variable
+                    if (((_c = firstArg === null || firstArg === void 0 ? void 0 : firstArg.value) === null || _c === void 0 ? void 0 : _c.kind) === 'Variable' && ((_d = afterArg === null || afterArg === void 0 ? void 0 : afterArg.value) === null || _d === void 0 ? void 0 : _d.kind) === 'Variable') {
+                        optimizePagination(metadata, firstArg.value.name.value, afterArg.value.name.value, variables);
+                    }
+                    return;
+                }
+            }
+        }
+        const paginatedData = {
+            data: {
+                ...source,
+                edges: ObjectFreeze(trimmedEdges),
+            }
+        };
+        const result = selectFn(sel, variables, fragments)(paginatedData, reader);
+        const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
+        if (pageInfo !== undefined) {
+            const selectedPageInfo = selectPageInfo((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
+            if (selectedPageInfo !== undefined) {
+                reader.assignNonScalar(result, 'pageInfo', selectedPageInfo);
+            }
+        }
+        reader.assignNonScalar(sink, key, result);
+    }
+    function selectPageInfo(selections, fragments, pageInfo) {
+        var _a;
+        const pageInfoSelection = getSelectionNode(selections, fragments, 'pageInfo');
+        if (pageInfo === undefined || pageInfoSelection === undefined || pageInfoSelection.kind !== 'Field')
+            return undefined;
+        const pageInfoSelections = (_a = pageInfoSelection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections;
+        const selectedPageInfo = Object.assign({}, pageInfo);
+        Object.keys(pageInfo).forEach((fieldName) => {
+            if (getSelectionNode(pageInfoSelections, fragments, fieldName) === undefined) {
+                delete selectedPageInfo[fieldName];
+            }
+        });
+        return selectedPageInfo;
+    }
+    function getSelectionNode(selections, fragments, fieldName) {
+        if (selections === undefined)
+            return undefined;
+        for (let i = 0; i < selections.length; i++) {
+            const selection = selections[i];
+            if (selection.kind === 'Field' && selection.name.value === fieldName) {
+                return selection;
+            }
+            else if (selection.kind === 'FragmentSpread') {
+                const fragment = fragments[selection.name.value];
+                return getSelectionNode(fragment === null || fragment === void 0 ? void 0 : fragment.selectionSet.selections, fragments, fieldName);
+            }
+            else if (selection.kind === 'InlineFragment') {
+                return getSelectionNode(selection.selectionSet.selections, fragments, fieldName);
+            }
+        }
+        return undefined;
     }
 
     const TTL = 900000;
@@ -75043,7 +74148,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.120.0-d7f610c36
+    // version: 1.121.1-7c3b8db1d
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -77172,7 +76277,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.120.0-d7f610c36
+    // version: 1.121.1-7c3b8db1d
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -77871,4 +76976,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.120.0-7e4457c5c
+// version: 1.121.1-ac2ef2013