@salesforce/lds-runtime-mobile 1.247.0 → 1.248.0

package/dist/main.js

@@ -15,7 +15,7 @@ import { withRegistration, register } from '@salesforce/lds-default-luvio';
 import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from '@salesforce/lds-instrumentation';
 import { HttpStatusCode, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, createCustomAdapterEventEmitter, StoreKeyMap, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
 import excludeStaleRecordsGate from '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
-import { parseAndVisit, Kind, visit, execute, buildSchema, isObjectType, defaultFieldResolver } from '@luvio/graphql-parser';
+import { parseAndVisit, Kind, buildSchema, isObjectType, defaultFieldResolver, visit, execute, parse as parse$7, extendSchema, isScalarType } from '@luvio/graphql-parser';
 import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, isStoreKeyRecordViewEntity, getRecordId18, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, RECORD_VIEW_ENTITY_ID_PREFIX, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, keyBuilderObjectInfo, ObjectInfoDirectoryEntryRepresentationType, getRecordsAdapterFactory } from '@salesforce/lds-adapters-uiapi';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
@@ -7077,7 +7077,7 @@ function isArrayLike(x) {
 
 const { create: create$4, keys: keys$4, values: values$2, entries: entries$3, assign: assign$4 } = Object;
 const { stringify: stringify$4, parse: parse$4 } = JSON;
-const { isArray: isArray$2 } = Array;
+const { isArray: isArray$2, from: from$1 } = Array;
 
 function recordLoaderFactory(query) {
     async function batchRecordQuery(ids) {
@@ -9308,25 +9308,6 @@ const additionalSchemaDefinitions = /* GraphQL */ `
     }
 `;
 const baseTypeDefinitions = uiapiSchemaString + additionalSchemaDefinitions;
-/**
- *
- * @param objectInfos
- * @returns Type definition string and entity type names which support polymorphism.
- */
-function generateTypeDefinitions(objectInfos) {
-    if (keys$4(objectInfos).length === 0)
-        return { typeDefs: baseTypeDefinitions, polyFieldTypeNames: [] };
-    const { recordQueries, recordConnections, polyFieldTypeNameArr } = generateRecordQueries(objectInfos);
-    const typeDefs = `
-      ${baseTypeDefinitions}
-  
-      extend type RecordQuery {
-        ${recordQueries}
-      }
-      ${recordConnections}
-    `;
-    return { typeDefs, polyFieldTypeNames: polyFieldTypeNameArr };
-}
 const fieldsStaticallyAdded = [
     'ApiName',
     'DisplayValue',
@@ -9336,99 +9317,340 @@ const fieldsStaticallyAdded = [
     'SystemModstamp',
     'WeakEtag',
 ];
-function generateRecordQueries(objectInfos) {
+class CachedGraphQLSchema {
+    constructor() {
+        this._schema = buildBaseSchema();
+        this._polymorphicFieldTypeNames = [];
+    }
+    getSchema() {
+        return this._schema;
+    }
+    setSchema(value) {
+        this._schema = value;
+    }
+    getPolymorphicFieldTypeNames() {
+        return this._polymorphicFieldTypeNames;
+    }
+    setPolymorphicFieldTypeNames(value) {
+        this._polymorphicFieldTypeNames = value;
+    }
+    set(schema, polymorphicFieldTypeNames) {
+        this._schema = schema;
+        this._polymorphicFieldTypeNames = polymorphicFieldTypeNames;
+    }
+}
+/**
+ * Looks at the injected object info map and checks to see if the existing objects
+ * are within the current schema. It will extend the cached schema if it is not included.
+ * @param objectInfos
+ * @param cache
+ * @returns GraphQLSchema
+ */
+function createSchemaWithCache(objectInfos, cache) {
+    const updatedCache = extendSchemaWithObjectInfos(cache, objectInfos);
+    // set the new values to the passed cached schema & polymorphic field names
+    cache.set(updatedCache.getSchema(), updatedCache.getPolymorphicFieldTypeNames());
+    return cache.getSchema();
+}
+/**
+ * Extends the current GraphQL Schema with new types based on the given object info map
+ *
+ * @param cache the existing cached schema object
+ * @param objectInfoMap map of object info and apiname for key
+ * @returns CachedGraphQLSchema
+ */
+function extendSchemaWithObjectInfos(cache, objectInfoMap) {
+    const { recordQueries, recordConnections, recordExtensions, polyFieldTypeNameArr } = generateRecordQueries(cache.getSchema(), objectInfoMap);
+    const typeDefs = `
+    ${recordQueries}
+    ${recordConnections}
+    ${recordExtensions}
+    `;
+    // if nothing new is added then return the current cache
+    if (typeDefs.trim().length === 0) {
+        return cache;
+    }
+    // parse extensions into DocumentNode to extend the schema
+    const extensions = parse$7(typeDefs);
+    const polymorphicFieldTypeNames = [
+        ...polyFieldTypeNameArr,
+        ...cache.getPolymorphicFieldTypeNames(),
+    ];
+    // extend the schema and add resolvers
+    const schema = addResolversToSchema(extendSchema(cache.getSchema(), extensions), polymorphicFieldTypeNames);
+    cache.setSchema(schema);
+    return cache;
+}
+/**
+ * Builds the base schema from uiapi graphql adapter with resolvers attached
+ * @returns GraphQLSchema
+ */
+function buildBaseSchema() {
+    return addResolversToSchema(buildSchema(baseTypeDefinitions), []);
+}
+/**
+ * Given the existing schema and the object infos it will create a new type for the schema
+ * or extend an existing type to add new fields to it.
+ *
+ * Extends RecordQuery to add new top level queries
+ * extend type RecordQuery {
+ *   Account(predicates): AccountConnection
+ * }
+ * @param schema
+ * @param objectInfoMap
+ * @returns
+ */
+function generateRecordQueries(schema, objectInfoMap) {
     let recordQueries = ``;
     let recordConnections = ``;
-    const polymorphicFieldTypeNames = new Set();
+    let recordExtensions = ``;
+    // use a set to not allow duplicate scalars causing error(s)
+    let addedTypedScalars = new Set();
+    let allPolymorphicFieldTypeNames = new Set();
+    for (const name of keys$4(objectInfoMap)) {
+        const objectInfo = objectInfoMap[name];
+        const { apiName } = objectInfo;
+        const type = schema.getType(apiName);
+        // if type is an ObjectType it exists in the schema
+        if (isObjectType(type)) {
+            const { recordExtension, typedScalars, polymorphicFieldTypeNames } = extendExistingRecordType(schema, type, objectInfo, objectInfoMap);
+            recordExtensions += recordExtension;
+            addedTypedScalars = new Set([...addedTypedScalars, ...typedScalars]);
+            allPolymorphicFieldTypeNames = new Set([
+                ...allPolymorphicFieldTypeNames,
+                ...polymorphicFieldTypeNames,
+            ]);
+        }
+        else {
+            const { recordQueries: newRecordQueries, recordConnections: newRecordConnections, typedScalars, polymorphicFieldTypeNames, } = createNewRecordQuery(schema, objectInfo, objectInfoMap);
+            recordQueries += newRecordQueries;
+            recordConnections += newRecordConnections;
+            addedTypedScalars = new Set([...addedTypedScalars, ...typedScalars]);
+            allPolymorphicFieldTypeNames = new Set([
+                ...allPolymorphicFieldTypeNames,
+                ...polymorphicFieldTypeNames,
+            ]);
+        }
+    }
+    // transform added scalar types into a list of scalars in string
+    const scalars = [...addedTypedScalars].map((scalar) => `scalar ${scalar}`).join('\n');
+    recordConnections += scalars;
+    // return empty string if no recordQueries were extended
+    const extensionWrapper = recordQueries.length > 0
+        ? `
+    extend type RecordQuery {
+        ${recordQueries}
+    }`
+        : '';
+    return {
+        recordQueries: extensionWrapper,
+        recordConnections,
+        recordExtensions,
+        polyFieldTypeNameArr: from$1(allPolymorphicFieldTypeNames),
+    };
+}
+/**
+ * Will create a new record query extension for something that does not already exist in the schema
+ *
+ * generates:
+ *
+ * type {typename} implements Record {
+ *   ...scalar fields
+ *      Id: IDValue
+ *   ...spanning parent records
+ *      User: Parent
+ *   ...spanning children queries
+ *      Accounts(predicates): AccountConnection
+ * }
+ *
+ * scalars SomeAddedScalar
+ *
+ * @param schema
+ * @param objectInfo
+ * @param objectInfoMap
+ * @returns
+ */
+function createNewRecordQuery(schema, objectInfo, objectInfoMap) {
     let typedScalars = new Set();
     let parentRelationshipFields = new Set();
-    for (const objectInfo of values$2(objectInfos)) {
-        const { apiName, childRelationships } = objectInfo;
-        let fields = ``;
-        typedScalars.add(`${apiName}_Filter`);
-        typedScalars.add(`${apiName}_OrderBy`);
-        for (const field of values$2(objectInfo.fields)) {
-            if (!fieldsStaticallyAdded.includes(field.apiName)) {
-                fields += `${field.apiName}: ${dataTypeToType(field.dataType, field.apiName)}\n`;
-            }
-            //handles parent relationship
-            if (field.relationshipName === null) {
-                continue;
+    const { apiName, childRelationships, fields: fieldsRepresentation } = objectInfo;
+    typedScalars.add(`${apiName}_Filter`);
+    typedScalars.add(`${apiName}_OrderBy`);
+    const { fields, polymorphicFieldTypeNames } = makeRecordField(values$2(fieldsRepresentation), objectInfoMap, parentRelationshipFields, 'Missing');
+    // handles child relationship
+    const { spanningRecordConnections, typedScalars: spanningConnectionTypedScalars } = makeSpanningRecordConnections(schema, childRelationships, objectInfoMap, parentRelationshipFields);
+    typedScalars = new Set([...typedScalars, ...spanningConnectionTypedScalars]);
+    const recordQueries = `${apiName}(first: Int, where: ${apiName}_Filter, orderBy: ${apiName}_OrderBy, scope: SupportedScopes): ${apiName}Connection\n`;
+    const isServiceAppointment = apiName === 'ServiceAppointment';
+    const recordConnections = /* GraphQL */ `
+            ${isServiceAppointment ? `scalar ${apiName.toUpperCase()}_SCOPE` : ''}
+    
+            type ${apiName} implements Record {
+            ApiName: String!
+            DisplayValue: String
+            LastModifiedById: IDValue
+            LastModifiedDate: DateTimeValue
+            RecordTypeId(fallback: Boolean): IDValue
+            SystemModstamp: DateTimeValue
+            WeakEtag: Long!
+            _drafts: JSON
+            ${fields}
+            ${spanningRecordConnections}
             }
-            // For spanning parent relationships with no union types
-            if (field.referenceToInfos.length === 1) {
-                const [relation] = field.referenceToInfos;
-                // Only add the relationship if there is relevant objectinfos for it,
-                // otherwise we'd be defining types we cannot satisfy and aren't referenced in
-                // the query.
-                if (objectInfos[relation.apiName] !== undefined) {
-                    parentRelationshipFields.add(field.relationshipName);
-                    fields += `${field.relationshipName}: ${relation.apiName}\n`;
-                }
-                // For polymorphic field, its type is 'Record' inteface. The concrete entity type name is saved for field resolving of next phase
-            }
-            else if (field.referenceToInfos.length > 1) {
-                parentRelationshipFields.add(field.relationshipName);
-                fields += `${field.relationshipName}: Record\n`;
-                for (const relation of field.referenceToInfos) {
-                    if (objectInfos[relation.apiName] !== undefined) {
-                        polymorphicFieldTypeNames.add(relation.apiName);
-                    }
-                }
+    
+            type ${apiName}Connection {
+            edges: [${apiName}Edge]
+            pageInfo: PageInfo!
+            totalCount: Int!
             }
+    
+            type ${apiName}Edge {
+            node: ${apiName}
+            cursor: String!
+            }
+
+        `;
+    return { recordQueries, recordConnections, typedScalars, polymorphicFieldTypeNames };
+}
+/**
+ * Takes the current schema and will extend missing fields to the record.
+ * Assume all scalar fields have already been added, but will extend spanning fields
+ *
+ * extend type Account {
+ *   ...spanning parent records
+ *   User: User
+ *   ...spanning children queries
+ *   Users(predicates): UserConnection
+ * }
+ *
+ * @param schema
+ * @param type
+ * @param objectInfo
+ * @param objectInfoMap
+ * @returns
+ */
+function extendExistingRecordType(schema, type, objectInfo, objectInfoMap) {
+    // use a set to not allow duplicate scalars causing error(s)
+    let typedScalars = new Set();
+    let parentRelationshipFields = new Set();
+    const existingFields = keys$4(type.getFields());
+    const missingFields = values$2(objectInfo.fields).filter((field) => existingFields.includes(field.apiName) === false);
+    const { fields, polymorphicFieldTypeNames } = makeRecordField(missingFields, objectInfoMap, parentRelationshipFields, 'Cached');
+    const { apiName, childRelationships } = objectInfo;
+    // handles child relationship
+    const { spanningRecordConnections, typedScalars: spanningConnectionTypedScalars } = makeSpanningRecordConnections(schema, childRelationships, objectInfoMap, parentRelationshipFields, existingFields);
+    typedScalars = new Set([...typedScalars, ...spanningConnectionTypedScalars]);
+    const hasExtensions = fields.length > 0 || spanningRecordConnections.length > 0;
+    const recordExtension = hasExtensions
+        ? `   
+    extend type ${apiName} {
+        ${fields}
+        ${spanningRecordConnections}
+    }\n`
+        : '';
+    return { recordExtension, typedScalars, polymorphicFieldTypeNames };
+}
+/**
+ * Converts child relationships into spanning record connections to be added to record types
+ *
+ * type Record {
+ *   Generates -> AccountConnection(first: Int, where: Account_Filter, etc...): AccountConnection
+ * }
+ *
+ * will also generate typed scalars if they have not been added to the existing schema for the spanning connection
+ * example: Account_Filter or Account_OrderBy scalars needed to be defined as predicate types
+ * @param schema
+ * @param childRelationships
+ * @param objectInfoMap
+ * @param existingParentRelationships
+ * @param existingFields
+ * @returns
+ */
+function makeSpanningRecordConnections(schema, childRelationships, objectInfoMap, existingParentRelationships, existingFields = []) {
+    let spanningRecordConnections = ``;
+    let typedScalars = new Set();
+    for (const childRelationship of childRelationships) {
+        const { childObjectApiName, relationshipName } = childRelationship;
+        // Only add the relationship if there is relevant objectinfos for it,
+        // otherwise we'd be defining types we cannot satisfy and aren't referenced in
+        // the query.
+        // If one field has both parent relationship and child relationship with the same name, the child relationship is ignored. This is how the server GQL has implemented as date of 08/07/2023
+        if (existingFields.length > 0 && existingFields.includes(relationshipName)) {
+            continue;
         }
-        // handles child relationship
-        for (const childRelationship of childRelationships) {
-            const { childObjectApiName } = childRelationship;
-            // Only add the relationship if there is relevant objectinfos for it,
-            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
-            // the query.
-            // If one field has both parent relationship and child relationship with the same name, the child relationship is ignored. This is how the server GQL has implemented as date of 08/07/2023
-            if (objectInfos[childObjectApiName] !== undefined &&
-                !parentRelationshipFields.has(childRelationship.relationshipName)) {
-                fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
+        if (objectInfoMap[childObjectApiName] !== undefined &&
+            !existingParentRelationships.has(relationshipName)) {
+            spanningRecordConnections += `${relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
+            // if the record type has already been extended then these additional scalars have already been added
+            // to add them again would throw an error
+            const filterScalarType = schema.getType(`${childObjectApiName}_Filter`);
+            if (isScalarType(filterScalarType) === false) {
                 typedScalars.add(`${childObjectApiName}_Filter`);
+            }
+            const orderByScalarType = schema.getType(`${childObjectApiName}_OrderBy`);
+            if (isScalarType(orderByScalarType) === false) {
                 typedScalars.add(`${childObjectApiName}_OrderBy`);
             }
         }
-        recordQueries += `${apiName}(first: Int, where: ${apiName}_Filter, orderBy: ${apiName}_OrderBy, scope: SupportedScopes): ${apiName}Connection\n`;
-        const isServiceAppointment = apiName === 'ServiceAppointment';
-        recordConnections += /* GraphQL */ `
-        ${isServiceAppointment ? `scalar ${apiName.toUpperCase()}_SCOPE` : ''}
-  
-        type ${apiName} implements Record {
-          ApiName: String!
-          DisplayValue: String
-          LastModifiedById: IDValue
-          LastModifiedDate: DateTimeValue
-          RecordTypeId(fallback: Boolean): IDValue
-          SystemModstamp: DateTimeValue
-          WeakEtag: Long!
-          _drafts: JSON
-          ${fields}
-        }
-  
-        type ${apiName}Connection {
-          edges: [${apiName}Edge]
-          pageInfo: PageInfo!
-          totalCount: Int!
-        }
-  
-        type ${apiName}Edge {
-          node: ${apiName}
-          cursor: String!
+    }
+    return { spanningRecordConnections, typedScalars };
+}
+/**
+ * Creates scalar and parent relationship fields for a record type
+ *
+ * type RecordName {
+ *         generates scalar -> Id: IDValue
+ *   generates relationship -> Account: Record
+ * }
+ *
+ * can be used in a type definition or an extension
+ * @param fieldRepresentations
+ * @param objectInfoMap
+ * @param existingParentRelationships
+ * @param recordTypeInSchema
+ * @returns
+ */
+function makeRecordField(fieldRepresentations, objectInfoMap, existingParentRelationships, recordTypeInSchema) {
+    const polymorphicFieldTypeNames = new Set();
+    let fields = ``;
+    for (const field of values$2(fieldRepresentations)) {
+        if (!fieldsStaticallyAdded.includes(field.apiName) && recordTypeInSchema === 'Missing') {
+            fields += `${field.apiName}: ${dataTypeToType(field.dataType, field.apiName)}\n`;
+        }
+        //handles parent relationship
+        if (field.relationshipName === null) {
+            continue;
+        }
+        // For spanning parent relationships with no union types
+        if (field.referenceToInfos.length === 1) {
+            const [relation] = field.referenceToInfos;
+            // Only add the relationship if there is relevant objectinfos for it,
+            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
+            // the query.
+            if (objectInfoMap[relation.apiName] !== undefined) {
+                existingParentRelationships.add(field.relationshipName);
+                fields += `${field.relationshipName}: ${relation.apiName}\n`;
+            }
+            // For polymorphic field, its type is 'Record' inteface. The concrete entity type name is saved for field resolving of next phase
+        }
+        else if (field.referenceToInfos.length > 1) {
+            existingParentRelationships.add(field.relationshipName);
+            fields += `${field.relationshipName}: Record\n`;
+            for (const relation of field.referenceToInfos) {
+                if (objectInfoMap[relation.apiName] !== undefined) {
+                    polymorphicFieldTypeNames.add(relation.apiName);
+                }
+            }
         }
-
-      `;
     }
-    const scalars = [...typedScalars].reduce((accu, typed) => {
-        return accu + `scalar ${typed}\n`;
-    }, ``);
-    recordConnections += scalars;
-    const polyFieldTypeNameArr = [];
-    polymorphicFieldTypeNames.forEach((fieldType) => polyFieldTypeNameArr.push(fieldType));
-    return { recordQueries, recordConnections, polyFieldTypeNameArr };
+    return { fields, polymorphicFieldTypeNames };
 }
+/**
+ * converts the ObjectInfoRepresentation data type into a defined schema scalar type
+ * @param objectInfoDataType
+ * @param apiName
+ * @returns
+ */
 function dataTypeToType(objectInfoDataType, apiName) {
     if (apiName && apiName === 'Id') {
         return `ID!`;
@@ -9470,13 +9692,8 @@ function dataTypeToType(objectInfoDataType, apiName) {
             return 'String';
     }
 }
-function createSchema(objectInfos) {
-    const { typeDefs: typeDefinitions, polyFieldTypeNames } = generateTypeDefinitions(objectInfos);
-    const schema = buildSchema(typeDefinitions);
-    return addResolversToSchema(schema, polyFieldTypeNames);
-}
 
-async function evaluate(config, observers, settings, objectInfos, store, snapshot, draftFunctions) {
+async function evaluate(config, observers, settings, objectInfos, store, snapshot, cache, 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 {
@@ -9517,7 +9734,7 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
         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);
+        const schema = createSchemaWithCache(objectInfos, cache);
         eventEmitter({ type: 'graphql-schema-created' });
         // execute document against schema/context
         let result = (await execute({
@@ -13012,6 +13229,8 @@ const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs)
     }, {});
     return newVariables;
 };
+// create the runtime cache for the graphql schema when the factory creates the adapter
+const graphqlSchemaCache = new CachedGraphQLSchema();
 function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio, isDraftId) {
     const getCanonicalId = (id) => {
         var _a;
@@ -13085,7 +13304,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 ...config,
                 //need to create another copy of the ast for future writes
                 query: parse$3(stringify$3(injectedAST)),
-            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot));
+            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot, graphqlSchemaCache));
         }
         catch (throwable) {
             const error = throwable;
@@ -13114,7 +13333,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             let { result: rebuildResult, seenRecordIds } = await evaluate({
                 ...config,
                 query: injectedAST,
-            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, draftFunctions);
+            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, graphqlSchemaCache, draftFunctions);
             if (!rebuildResult.errors) {
                 rebuildResult = removeSyntheticFields(rebuildResult, config.query);
             }
@@ -17288,4 +17507,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.247.0-4fe38c091
+// version: 1.248.0-1f7f01112

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-mobile",
-    "version": "1.247.0",
+    "version": "1.248.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for mobile/hybrid environments.",
     "main": "dist/main.js",

package/sfdc/main.js

@@ -15,7 +15,7 @@ import { withRegistration, register } from 'native/ldsEngineMobile';
 import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from 'force/ldsInstrumentation';
 import { HttpStatusCode, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, createCustomAdapterEventEmitter, StoreKeyMap, isFileReference, Environment, Luvio, InMemoryStore } from 'force/luvioEngine';
 import excludeStaleRecordsGate from '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
-import { parseAndVisit, Kind, visit, execute, buildSchema, isObjectType, defaultFieldResolver } from 'force/ldsGraphqlParser';
+import { parseAndVisit, Kind, buildSchema, isObjectType, defaultFieldResolver, visit, execute, parse as parse$7, extendSchema, isScalarType } from 'force/ldsGraphqlParser';
 import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, isStoreKeyRecordViewEntity, getRecordId18, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, RECORD_VIEW_ENTITY_ID_PREFIX, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, keyBuilderObjectInfo, ObjectInfoDirectoryEntryRepresentationType, getRecordsAdapterFactory } from 'force/ldsAdaptersUiapi';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
@@ -7077,7 +7077,7 @@ function isArrayLike(x) {
 
 const { create: create$4, keys: keys$4, values: values$2, entries: entries$3, assign: assign$4 } = Object;
 const { stringify: stringify$4, parse: parse$4 } = JSON;
-const { isArray: isArray$2 } = Array;
+const { isArray: isArray$2, from: from$1 } = Array;
 
 function recordLoaderFactory(query) {
     async function batchRecordQuery(ids) {
@@ -9308,25 +9308,6 @@ const additionalSchemaDefinitions = /* GraphQL */ `
     }
 `;
 const baseTypeDefinitions = uiapiSchemaString + additionalSchemaDefinitions;
-/**
- *
- * @param objectInfos
- * @returns Type definition string and entity type names which support polymorphism.
- */
-function generateTypeDefinitions(objectInfos) {
-    if (keys$4(objectInfos).length === 0)
-        return { typeDefs: baseTypeDefinitions, polyFieldTypeNames: [] };
-    const { recordQueries, recordConnections, polyFieldTypeNameArr } = generateRecordQueries(objectInfos);
-    const typeDefs = `
-      ${baseTypeDefinitions}
-  
-      extend type RecordQuery {
-        ${recordQueries}
-      }
-      ${recordConnections}
-    `;
-    return { typeDefs, polyFieldTypeNames: polyFieldTypeNameArr };
-}
 const fieldsStaticallyAdded = [
     'ApiName',
     'DisplayValue',
@@ -9336,99 +9317,340 @@ const fieldsStaticallyAdded = [
     'SystemModstamp',
     'WeakEtag',
 ];
-function generateRecordQueries(objectInfos) {
+class CachedGraphQLSchema {
+    constructor() {
+        this._schema = buildBaseSchema();
+        this._polymorphicFieldTypeNames = [];
+    }
+    getSchema() {
+        return this._schema;
+    }
+    setSchema(value) {
+        this._schema = value;
+    }
+    getPolymorphicFieldTypeNames() {
+        return this._polymorphicFieldTypeNames;
+    }
+    setPolymorphicFieldTypeNames(value) {
+        this._polymorphicFieldTypeNames = value;
+    }
+    set(schema, polymorphicFieldTypeNames) {
+        this._schema = schema;
+        this._polymorphicFieldTypeNames = polymorphicFieldTypeNames;
+    }
+}
+/**
+ * Looks at the injected object info map and checks to see if the existing objects
+ * are within the current schema. It will extend the cached schema if it is not included.
+ * @param objectInfos
+ * @param cache
+ * @returns GraphQLSchema
+ */
+function createSchemaWithCache(objectInfos, cache) {
+    const updatedCache = extendSchemaWithObjectInfos(cache, objectInfos);
+    // set the new values to the passed cached schema & polymorphic field names
+    cache.set(updatedCache.getSchema(), updatedCache.getPolymorphicFieldTypeNames());
+    return cache.getSchema();
+}
+/**
+ * Extends the current GraphQL Schema with new types based on the given object info map
+ *
+ * @param cache the existing cached schema object
+ * @param objectInfoMap map of object info and apiname for key
+ * @returns CachedGraphQLSchema
+ */
+function extendSchemaWithObjectInfos(cache, objectInfoMap) {
+    const { recordQueries, recordConnections, recordExtensions, polyFieldTypeNameArr } = generateRecordQueries(cache.getSchema(), objectInfoMap);
+    const typeDefs = `
+    ${recordQueries}
+    ${recordConnections}
+    ${recordExtensions}
+    `;
+    // if nothing new is added then return the current cache
+    if (typeDefs.trim().length === 0) {
+        return cache;
+    }
+    // parse extensions into DocumentNode to extend the schema
+    const extensions = parse$7(typeDefs);
+    const polymorphicFieldTypeNames = [
+        ...polyFieldTypeNameArr,
+        ...cache.getPolymorphicFieldTypeNames(),
+    ];
+    // extend the schema and add resolvers
+    const schema = addResolversToSchema(extendSchema(cache.getSchema(), extensions), polymorphicFieldTypeNames);
+    cache.setSchema(schema);
+    return cache;
+}
+/**
+ * Builds the base schema from uiapi graphql adapter with resolvers attached
+ * @returns GraphQLSchema
+ */
+function buildBaseSchema() {
+    return addResolversToSchema(buildSchema(baseTypeDefinitions), []);
+}
+/**
+ * Given the existing schema and the object infos it will create a new type for the schema
+ * or extend an existing type to add new fields to it.
+ *
+ * Extends RecordQuery to add new top level queries
+ * extend type RecordQuery {
+ *   Account(predicates): AccountConnection
+ * }
+ * @param schema
+ * @param objectInfoMap
+ * @returns
+ */
+function generateRecordQueries(schema, objectInfoMap) {
     let recordQueries = ``;
     let recordConnections = ``;
-    const polymorphicFieldTypeNames = new Set();
+    let recordExtensions = ``;
+    // use a set to not allow duplicate scalars causing error(s)
+    let addedTypedScalars = new Set();
+    let allPolymorphicFieldTypeNames = new Set();
+    for (const name of keys$4(objectInfoMap)) {
+        const objectInfo = objectInfoMap[name];
+        const { apiName } = objectInfo;
+        const type = schema.getType(apiName);
+        // if type is an ObjectType it exists in the schema
+        if (isObjectType(type)) {
+            const { recordExtension, typedScalars, polymorphicFieldTypeNames } = extendExistingRecordType(schema, type, objectInfo, objectInfoMap);
+            recordExtensions += recordExtension;
+            addedTypedScalars = new Set([...addedTypedScalars, ...typedScalars]);
+            allPolymorphicFieldTypeNames = new Set([
+                ...allPolymorphicFieldTypeNames,
+                ...polymorphicFieldTypeNames,
+            ]);
+        }
+        else {
+            const { recordQueries: newRecordQueries, recordConnections: newRecordConnections, typedScalars, polymorphicFieldTypeNames, } = createNewRecordQuery(schema, objectInfo, objectInfoMap);
+            recordQueries += newRecordQueries;
+            recordConnections += newRecordConnections;
+            addedTypedScalars = new Set([...addedTypedScalars, ...typedScalars]);
+            allPolymorphicFieldTypeNames = new Set([
+                ...allPolymorphicFieldTypeNames,
+                ...polymorphicFieldTypeNames,
+            ]);
+        }
+    }
+    // transform added scalar types into a list of scalars in string
+    const scalars = [...addedTypedScalars].map((scalar) => `scalar ${scalar}`).join('\n');
+    recordConnections += scalars;
+    // return empty string if no recordQueries were extended
+    const extensionWrapper = recordQueries.length > 0
+        ? `
+    extend type RecordQuery {
+        ${recordQueries}
+    }`
+        : '';
+    return {
+        recordQueries: extensionWrapper,
+        recordConnections,
+        recordExtensions,
+        polyFieldTypeNameArr: from$1(allPolymorphicFieldTypeNames),
+    };
+}
+/**
+ * Will create a new record query extension for something that does not already exist in the schema
+ *
+ * generates:
+ *
+ * type {typename} implements Record {
+ *   ...scalar fields
+ *      Id: IDValue
+ *   ...spanning parent records
+ *      User: Parent
+ *   ...spanning children queries
+ *      Accounts(predicates): AccountConnection
+ * }
+ *
+ * scalars SomeAddedScalar
+ *
+ * @param schema
+ * @param objectInfo
+ * @param objectInfoMap
+ * @returns
+ */
+function createNewRecordQuery(schema, objectInfo, objectInfoMap) {
     let typedScalars = new Set();
     let parentRelationshipFields = new Set();
-    for (const objectInfo of values$2(objectInfos)) {
-        const { apiName, childRelationships } = objectInfo;
-        let fields = ``;
-        typedScalars.add(`${apiName}_Filter`);
-        typedScalars.add(`${apiName}_OrderBy`);
-        for (const field of values$2(objectInfo.fields)) {
-            if (!fieldsStaticallyAdded.includes(field.apiName)) {
-                fields += `${field.apiName}: ${dataTypeToType(field.dataType, field.apiName)}\n`;
-            }
-            //handles parent relationship
-            if (field.relationshipName === null) {
-                continue;
+    const { apiName, childRelationships, fields: fieldsRepresentation } = objectInfo;
+    typedScalars.add(`${apiName}_Filter`);
+    typedScalars.add(`${apiName}_OrderBy`);
+    const { fields, polymorphicFieldTypeNames } = makeRecordField(values$2(fieldsRepresentation), objectInfoMap, parentRelationshipFields, 'Missing');
+    // handles child relationship
+    const { spanningRecordConnections, typedScalars: spanningConnectionTypedScalars } = makeSpanningRecordConnections(schema, childRelationships, objectInfoMap, parentRelationshipFields);
+    typedScalars = new Set([...typedScalars, ...spanningConnectionTypedScalars]);
+    const recordQueries = `${apiName}(first: Int, where: ${apiName}_Filter, orderBy: ${apiName}_OrderBy, scope: SupportedScopes): ${apiName}Connection\n`;
+    const isServiceAppointment = apiName === 'ServiceAppointment';
+    const recordConnections = /* GraphQL */ `
+            ${isServiceAppointment ? `scalar ${apiName.toUpperCase()}_SCOPE` : ''}
+    
+            type ${apiName} implements Record {
+            ApiName: String!
+            DisplayValue: String
+            LastModifiedById: IDValue
+            LastModifiedDate: DateTimeValue
+            RecordTypeId(fallback: Boolean): IDValue
+            SystemModstamp: DateTimeValue
+            WeakEtag: Long!
+            _drafts: JSON
+            ${fields}
+            ${spanningRecordConnections}
             }
-            // For spanning parent relationships with no union types
-            if (field.referenceToInfos.length === 1) {
-                const [relation] = field.referenceToInfos;
-                // Only add the relationship if there is relevant objectinfos for it,
-                // otherwise we'd be defining types we cannot satisfy and aren't referenced in
-                // the query.
-                if (objectInfos[relation.apiName] !== undefined) {
-                    parentRelationshipFields.add(field.relationshipName);
-                    fields += `${field.relationshipName}: ${relation.apiName}\n`;
-                }
-                // For polymorphic field, its type is 'Record' inteface. The concrete entity type name is saved for field resolving of next phase
-            }
-            else if (field.referenceToInfos.length > 1) {
-                parentRelationshipFields.add(field.relationshipName);
-                fields += `${field.relationshipName}: Record\n`;
-                for (const relation of field.referenceToInfos) {
-                    if (objectInfos[relation.apiName] !== undefined) {
-                        polymorphicFieldTypeNames.add(relation.apiName);
-                    }
-                }
+    
+            type ${apiName}Connection {
+            edges: [${apiName}Edge]
+            pageInfo: PageInfo!
+            totalCount: Int!
             }
+    
+            type ${apiName}Edge {
+            node: ${apiName}
+            cursor: String!
+            }
+
+        `;
+    return { recordQueries, recordConnections, typedScalars, polymorphicFieldTypeNames };
+}
+/**
+ * Takes the current schema and will extend missing fields to the record.
+ * Assume all scalar fields have already been added, but will extend spanning fields
+ *
+ * extend type Account {
+ *   ...spanning parent records
+ *   User: User
+ *   ...spanning children queries
+ *   Users(predicates): UserConnection
+ * }
+ *
+ * @param schema
+ * @param type
+ * @param objectInfo
+ * @param objectInfoMap
+ * @returns
+ */
+function extendExistingRecordType(schema, type, objectInfo, objectInfoMap) {
+    // use a set to not allow duplicate scalars causing error(s)
+    let typedScalars = new Set();
+    let parentRelationshipFields = new Set();
+    const existingFields = keys$4(type.getFields());
+    const missingFields = values$2(objectInfo.fields).filter((field) => existingFields.includes(field.apiName) === false);
+    const { fields, polymorphicFieldTypeNames } = makeRecordField(missingFields, objectInfoMap, parentRelationshipFields, 'Cached');
+    const { apiName, childRelationships } = objectInfo;
+    // handles child relationship
+    const { spanningRecordConnections, typedScalars: spanningConnectionTypedScalars } = makeSpanningRecordConnections(schema, childRelationships, objectInfoMap, parentRelationshipFields, existingFields);
+    typedScalars = new Set([...typedScalars, ...spanningConnectionTypedScalars]);
+    const hasExtensions = fields.length > 0 || spanningRecordConnections.length > 0;
+    const recordExtension = hasExtensions
+        ? `   
+    extend type ${apiName} {
+        ${fields}
+        ${spanningRecordConnections}
+    }\n`
+        : '';
+    return { recordExtension, typedScalars, polymorphicFieldTypeNames };
+}
+/**
+ * Converts child relationships into spanning record connections to be added to record types
+ *
+ * type Record {
+ *   Generates -> AccountConnection(first: Int, where: Account_Filter, etc...): AccountConnection
+ * }
+ *
+ * will also generate typed scalars if they have not been added to the existing schema for the spanning connection
+ * example: Account_Filter or Account_OrderBy scalars needed to be defined as predicate types
+ * @param schema
+ * @param childRelationships
+ * @param objectInfoMap
+ * @param existingParentRelationships
+ * @param existingFields
+ * @returns
+ */
+function makeSpanningRecordConnections(schema, childRelationships, objectInfoMap, existingParentRelationships, existingFields = []) {
+    let spanningRecordConnections = ``;
+    let typedScalars = new Set();
+    for (const childRelationship of childRelationships) {
+        const { childObjectApiName, relationshipName } = childRelationship;
+        // Only add the relationship if there is relevant objectinfos for it,
+        // otherwise we'd be defining types we cannot satisfy and aren't referenced in
+        // the query.
+        // If one field has both parent relationship and child relationship with the same name, the child relationship is ignored. This is how the server GQL has implemented as date of 08/07/2023
+        if (existingFields.length > 0 && existingFields.includes(relationshipName)) {
+            continue;
         }
-        // handles child relationship
-        for (const childRelationship of childRelationships) {
-            const { childObjectApiName } = childRelationship;
-            // Only add the relationship if there is relevant objectinfos for it,
-            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
-            // the query.
-            // If one field has both parent relationship and child relationship with the same name, the child relationship is ignored. This is how the server GQL has implemented as date of 08/07/2023
-            if (objectInfos[childObjectApiName] !== undefined &&
-                !parentRelationshipFields.has(childRelationship.relationshipName)) {
-                fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
+        if (objectInfoMap[childObjectApiName] !== undefined &&
+            !existingParentRelationships.has(relationshipName)) {
+            spanningRecordConnections += `${relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
+            // if the record type has already been extended then these additional scalars have already been added
+            // to add them again would throw an error
+            const filterScalarType = schema.getType(`${childObjectApiName}_Filter`);
+            if (isScalarType(filterScalarType) === false) {
                 typedScalars.add(`${childObjectApiName}_Filter`);
+            }
+            const orderByScalarType = schema.getType(`${childObjectApiName}_OrderBy`);
+            if (isScalarType(orderByScalarType) === false) {
                 typedScalars.add(`${childObjectApiName}_OrderBy`);
             }
         }
-        recordQueries += `${apiName}(first: Int, where: ${apiName}_Filter, orderBy: ${apiName}_OrderBy, scope: SupportedScopes): ${apiName}Connection\n`;
-        const isServiceAppointment = apiName === 'ServiceAppointment';
-        recordConnections += /* GraphQL */ `
-        ${isServiceAppointment ? `scalar ${apiName.toUpperCase()}_SCOPE` : ''}
-  
-        type ${apiName} implements Record {
-          ApiName: String!
-          DisplayValue: String
-          LastModifiedById: IDValue
-          LastModifiedDate: DateTimeValue
-          RecordTypeId(fallback: Boolean): IDValue
-          SystemModstamp: DateTimeValue
-          WeakEtag: Long!
-          _drafts: JSON
-          ${fields}
-        }
-  
-        type ${apiName}Connection {
-          edges: [${apiName}Edge]
-          pageInfo: PageInfo!
-          totalCount: Int!
-        }
-  
-        type ${apiName}Edge {
-          node: ${apiName}
-          cursor: String!
+    }
+    return { spanningRecordConnections, typedScalars };
+}
+/**
+ * Creates scalar and parent relationship fields for a record type
+ *
+ * type RecordName {
+ *         generates scalar -> Id: IDValue
+ *   generates relationship -> Account: Record
+ * }
+ *
+ * can be used in a type definition or an extension
+ * @param fieldRepresentations
+ * @param objectInfoMap
+ * @param existingParentRelationships
+ * @param recordTypeInSchema
+ * @returns
+ */
+function makeRecordField(fieldRepresentations, objectInfoMap, existingParentRelationships, recordTypeInSchema) {
+    const polymorphicFieldTypeNames = new Set();
+    let fields = ``;
+    for (const field of values$2(fieldRepresentations)) {
+        if (!fieldsStaticallyAdded.includes(field.apiName) && recordTypeInSchema === 'Missing') {
+            fields += `${field.apiName}: ${dataTypeToType(field.dataType, field.apiName)}\n`;
+        }
+        //handles parent relationship
+        if (field.relationshipName === null) {
+            continue;
+        }
+        // For spanning parent relationships with no union types
+        if (field.referenceToInfos.length === 1) {
+            const [relation] = field.referenceToInfos;
+            // Only add the relationship if there is relevant objectinfos for it,
+            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
+            // the query.
+            if (objectInfoMap[relation.apiName] !== undefined) {
+                existingParentRelationships.add(field.relationshipName);
+                fields += `${field.relationshipName}: ${relation.apiName}\n`;
+            }
+            // For polymorphic field, its type is 'Record' inteface. The concrete entity type name is saved for field resolving of next phase
+        }
+        else if (field.referenceToInfos.length > 1) {
+            existingParentRelationships.add(field.relationshipName);
+            fields += `${field.relationshipName}: Record\n`;
+            for (const relation of field.referenceToInfos) {
+                if (objectInfoMap[relation.apiName] !== undefined) {
+                    polymorphicFieldTypeNames.add(relation.apiName);
+                }
+            }
         }
-
-      `;
     }
-    const scalars = [...typedScalars].reduce((accu, typed) => {
-        return accu + `scalar ${typed}\n`;
-    }, ``);
-    recordConnections += scalars;
-    const polyFieldTypeNameArr = [];
-    polymorphicFieldTypeNames.forEach((fieldType) => polyFieldTypeNameArr.push(fieldType));
-    return { recordQueries, recordConnections, polyFieldTypeNameArr };
+    return { fields, polymorphicFieldTypeNames };
 }
+/**
+ * converts the ObjectInfoRepresentation data type into a defined schema scalar type
+ * @param objectInfoDataType
+ * @param apiName
+ * @returns
+ */
 function dataTypeToType(objectInfoDataType, apiName) {
     if (apiName && apiName === 'Id') {
         return `ID!`;
@@ -9470,13 +9692,8 @@ function dataTypeToType(objectInfoDataType, apiName) {
             return 'String';
     }
 }
-function createSchema(objectInfos) {
-    const { typeDefs: typeDefinitions, polyFieldTypeNames } = generateTypeDefinitions(objectInfos);
-    const schema = buildSchema(typeDefinitions);
-    return addResolversToSchema(schema, polyFieldTypeNames);
-}
 
-async function evaluate(config, observers, settings, objectInfos, store, snapshot, draftFunctions) {
+async function evaluate(config, observers, settings, objectInfos, store, snapshot, cache, 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 {
@@ -9517,7 +9734,7 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
         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);
+        const schema = createSchemaWithCache(objectInfos, cache);
         eventEmitter({ type: 'graphql-schema-created' });
         // execute document against schema/context
         let result = (await execute({
@@ -13012,6 +13229,8 @@ const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs)
     }, {});
     return newVariables;
 };
+// create the runtime cache for the graphql schema when the factory creates the adapter
+const graphqlSchemaCache = new CachedGraphQLSchema();
 function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio, isDraftId) {
     const getCanonicalId = (id) => {
         var _a;
@@ -13085,7 +13304,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 ...config,
                 //need to create another copy of the ast for future writes
                 query: parse$3(stringify$3(injectedAST)),
-            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot));
+            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot, graphqlSchemaCache));
         }
         catch (throwable) {
             const error = throwable;
@@ -13114,7 +13333,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             let { result: rebuildResult, seenRecordIds } = await evaluate({
                 ...config,
                 query: injectedAST,
-            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, draftFunctions);
+            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, graphqlSchemaCache, draftFunctions);
             if (!rebuildResult.errors) {
                 rebuildResult = removeSyntheticFields(rebuildResult, config.query);
             }
@@ -17288,4 +17507,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.247.0-4fe38c091
+// version: 1.248.0-1f7f01112