@salesforce/lds-runtime-mobile 1.247.0 → 1.249.0

package/dist/main.js

@@ -15,8 +15,9 @@ 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 { 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 { 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, getRecordsAdapterFactory } from '@salesforce/lds-adapters-uiapi';
+import ldsIdempotencyWriteDisabled from '@salesforce/gate/lds.idempotencyWriteDisabled';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
 import ldsUseShortUrlGate from '@salesforce/gate/lds.useShortUrl';
@@ -1237,12 +1238,12 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         }
         return environment.getNode(key, stagingStore);
     };
-    const wrapNormalizedGraphNode = function (normalized) {
+    const wrapNormalizedGraphNode = function (normalized, key) {
         validateNotDisposed();
         if (stagingStore === null) {
             stagingStore = buildIngestStagingStore(environment);
         }
-        return environment.wrapNormalizedGraphNode(normalized, stagingStore);
+        return environment.wrapNormalizedGraphNode(normalized, key, stagingStore);
     };
     const rebuildSnapshot = function (snapshot, onRebuild) {
         validateNotDisposed();
@@ -4950,6 +4951,21 @@ class AsyncWorkerPool {
     }
 }
 
+/**
+Use Math.random to generate v4 RFC4122 compliant uuid
+ */
+function uuidv4() {
+    const uuid = [];
+    for (let i = 0; i < 32; i++) {
+        const random = (Math.random() * 16) | 0;
+        if (i === 8 || i === 12 || i === 16 || i === 20) {
+            uuid.push('-');
+        }
+        uuid.push((i === 12 ? 4 : i === 16 ? (random & 3) | 8 : random).toString(16));
+    }
+    return uuid.join('');
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -5163,20 +5179,6 @@ function generateUniqueDraftActionId(existingIds) {
     }
     return newId.toString();
 }
-/**
-Use Math.random to generate v4 RFC4122 compliant uuid
- */
-function uuidv4() {
-    const uuid = [];
-    for (let i = 0; i < 32; i++) {
-        const random = (Math.random() * 16) | 0;
-        if (i === 8 || i === 12 || i === 16 || i === 20) {
-            uuid.push('-');
-        }
-        uuid.push((i === 12 ? 4 : i === 16 ? (random & 3) | 8 : random).toString(16));
-    }
-    return uuid.join('');
-}
 
 const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
 const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
@@ -6053,7 +6055,12 @@ class AbstractResourceRequestActionHandler {
         // the luvio store redirect table, during which a new draft might be enqueued
         // which would not see a necessary mapping.
         this.ephemeralRedirects = {};
+        // determined by Server setup.
         this.isIdempotencySupported = true;
+        // idempotency write flag set by lds
+        this.isLdsIdempotencyWriteDisabled = ldsIdempotencyWriteDisabled.isOpen({
+            fallback: false,
+        });
     }
     enqueue(data) {
         return this.draftQueue.enqueue(this.handlerId, data);
@@ -6410,7 +6417,7 @@ class AbstractResourceRequestActionHandler {
         return [action.targetId];
     }
     hasIdempotencySupport() {
-        return this.isIdempotencySupported;
+        return this.isIdempotencySupported && !this.isLdsIdempotencyWriteDisabled;
     }
     async ingestResponses(responses, action) {
         const luvio = this.getLuvio();
@@ -6948,14 +6955,20 @@ function buildQueryTypeStringKey(args) {
  */
 
 
+const MAX_BATCH_SIZE = 2000;
 class DataLoader {
-    constructor(batchLoadFn) {
+    constructor(batchLoadFn, options) {
         this._batchLoadFn = batchLoadFn;
         this._batch = null;
         this._batchScheduleFn = function (fn) {
             setTimeout(fn, 0);
         };
         this._cacheMap = new Map();
+        this._maxBatchSize = MAX_BATCH_SIZE;
+        if (options !== undefined) {
+            const { maxBatchSize } = options;
+            this._maxBatchSize = maxBatchSize || MAX_BATCH_SIZE;
+        }
     }
     load(key) {
         if (key === null || key === undefined) {
@@ -6985,7 +6998,9 @@ class DataLoader {
         // If there is an existing batch which has not yet dispatched and is within
         // the limit of the batch size, then return it.
         const existingBatch = this._batch;
-        if (existingBatch !== null && !existingBatch.hasDispatched && !existingBatch.cacheHits) {
+        if (existingBatch !== null &&
+            !existingBatch.hasDispatched &&
+            existingBatch.keys.length < this._maxBatchSize) {
             return existingBatch;
         }
         // Otherwise, create a new batch for this loader.
@@ -7077,7 +7092,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 +9323,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 +9332,347 @@ 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);
+    const polymorphicFieldTypeNamesSet = new Set(polymorphicFieldTypeNames);
+    cache.setSchema(schema);
+    cache.setPolymorphicFieldTypeNames([...polymorphicFieldTypeNamesSet]);
+    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
+    
+            type ${apiName}Connection {
+            edges: [${apiName}Edge]
+            pageInfo: PageInfo!
+            totalCount: Int!
             }
-            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}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) => {
+        return (existingFields.includes(field.apiName) === false ||
+            (field.relationshipName !== null && field.referenceToInfos.length > 1));
+    });
+    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;
+        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`);
+            }
+        }
+    }
+    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 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`;
-                typedScalars.add(`${childObjectApiName}_Filter`);
-                typedScalars.add(`${childObjectApiName}_OrderBy`);
+            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
         }
-        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!
+        else if (field.referenceToInfos.length > 1) {
+            if (recordTypeInSchema === 'Missing') {
+                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 +9714,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 +9756,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({
@@ -11867,34 +12106,42 @@ function applyReferenceLinksToDraft(record, draftMetadata) {
         }
         const { dataType, relationshipName, referenceToInfos } = fieldInfo;
         const draftFieldValue = record.fields[draftField].value;
-        if (dataType === 'Reference' && relationshipName !== null && draftFieldValue !== null) {
-            if (typeof draftFieldValue !== 'string') {
-                throw Error('reference field value is not a string');
+        if (dataType === 'Reference' && relationshipName !== null) {
+            if (draftFieldValue === null) {
+                recordFields[relationshipName] = {
+                    displayValue: null,
+                    value: null,
+                };
             }
-            const key = getRecordKeyForId(luvio, draftFieldValue);
-            const referencedRecord = referencedRecords.get(key);
-            recordFields[relationshipName] = {
-                displayValue: null,
-                value: createLink(key),
-            };
-            // for custom objects, we select the 'Name' field
-            // otherwise we check the object info for name fields.
-            //if there are multiple we select 'Name' if it exists, otherwise the first one
-            if (referencedRecord !== undefined && referenceToInfos.length > 0) {
-                let nameField;
-                const referenceToInfo = referenceToInfos[0];
-                const nameFields = referenceToInfo.nameFields;
-                if (nameFields.length !== 0) {
-                    nameField = nameFields.find((x) => x === 'Name');
-                    if (nameField === undefined) {
-                        nameField = nameFields[0];
-                    }
+            else {
+                if (typeof draftFieldValue !== 'string') {
+                    throw Error('reference field value is not a string');
                 }
-                if (nameField !== undefined) {
-                    const nameFieldRef = referencedRecord.fields[nameField];
-                    if (nameFieldRef) {
-                        recordFields[relationshipName].displayValue =
-                            (_a = nameFieldRef.displayValue) !== null && _a !== void 0 ? _a : nameFieldRef.value;
+                const key = getRecordKeyForId(luvio, draftFieldValue);
+                const referencedRecord = referencedRecords.get(key);
+                recordFields[relationshipName] = {
+                    displayValue: null,
+                    value: createLink(key),
+                };
+                // for custom objects, we select the 'Name' field
+                // otherwise we check the object info for name fields.
+                //if there are multiple we select 'Name' if it exists, otherwise the first one
+                if (referencedRecord !== undefined && referenceToInfos.length > 0) {
+                    let nameField;
+                    const referenceToInfo = referenceToInfos[0];
+                    const nameFields = referenceToInfo.nameFields;
+                    if (nameFields.length !== 0) {
+                        nameField = nameFields.find((x) => x === 'Name');
+                        if (nameField === undefined) {
+                            nameField = nameFields[0];
+                        }
+                    }
+                    if (nameField !== undefined) {
+                        const nameFieldRef = referencedRecord.fields[nameField];
+                        if (nameFieldRef) {
+                            recordFields[relationshipName].displayValue =
+                                (_a = nameFieldRef.displayValue) !== null && _a !== void 0 ? _a : nameFieldRef.value;
+                        }
                     }
                 }
             }
@@ -12187,17 +12434,8 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         };
         for (const fieldName of keys$3(recordWithSpanningRefLinks.fields)) {
             const fieldKey = buildRecordFieldStoreKey(key, fieldName);
-            if (this.collectedFields[fieldKey] !== undefined) {
-                const fieldData = recordWithSpanningRefLinks.fields[fieldName];
-                normalizedRecord.fields[fieldName] = { __ref: fieldKey };
-                publishData(fieldKey, fieldData);
-            }
-            else if (recordWithSpanningRefLinks.fields[fieldName] &&
-                recordWithSpanningRefLinks.fields[fieldName].value &&
-                recordWithSpanningRefLinks.fields[fieldName].value.__ref !== undefined) {
-                normalizedRecord.fields[fieldName] = { __ref: fieldKey };
-                publishData(fieldKey, recordWithSpanningRefLinks.fields[fieldName]);
-            }
+            normalizedRecord.fields[fieldName] = { __ref: fieldKey };
+            publishData(fieldKey, recordWithSpanningRefLinks.fields[fieldName]);
         }
         // publish the normalized record
         publishData(key, normalizedRecord);
@@ -13012,6 +13250,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 +13325,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 +13354,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);
             }
@@ -15156,6 +15396,14 @@ class ObjectInfoService {
                 return this.updateObjectInfoMapping(keyPrefix, apiName);
             }
         };
+        this.getCachedObjectInfoStatus = async () => {
+            const infos = await this.readObjectInfoDataFromDurableStore();
+            const map = new Map();
+            infos.forEach(({ apiName, expirationTimestamp }) => {
+                map.set(apiName, { expiration: expirationTimestamp });
+            });
+            return map;
+        };
         this.isObjectInfoInDurableStore = async (apiName) => {
             if (this.apiNameToKeyPrefixMemoryCache[apiName] !== undefined) {
                 return Promise.resolve(true);
@@ -15164,12 +15412,10 @@ class ObjectInfoService {
             return this.apiNameToKeyPrefixMemoryCache[apiName] !== undefined;
         };
         this.loadObjectInfoMaps = async () => {
-            const rows = (await this.durableStore.query(`SELECT json_extract(data, '$.apiName') as ApiName, json_extract(data, '$.keyPrefix') as keyPrefix from lds_data where key like '%ObjectInfoRepresentation%'`, [])).rows;
-            for (const row of rows) {
-                const apiName = row[0];
-                const keyPrefix = row[1];
+            const infos = await this.readObjectInfoDataFromDurableStore();
+            infos.forEach(({ keyPrefix, apiName }) => {
                 this.updateObjectInfoMapping(keyPrefix, apiName);
-            }
+            });
         };
         this.updateObjectInfoMapping = (keyPrefix, apiName) => {
             this.apiNameToKeyPrefixMemoryCache[apiName] = keyPrefix;
@@ -15213,6 +15459,24 @@ class ObjectInfoService {
         }
         return snapshot.data;
     }
+    async readObjectInfoDataFromDurableStore() {
+        const rows = (await this.durableStore.query(`
+            SELECT
+                json_extract(data, '$.apiName') as ApiName,
+                json_extract(data, '$.keyPrefix') as keyPrefix,
+                JSON_EXTRACT(metadata, '$.expirationTimestamp') AS expirationTimestamp
+            from
+                lds_data
+            where
+                key like '%ObjectInfoRepresentation%'`, [])).rows;
+        return rows.map((row) => {
+            return {
+                apiName: row[0],
+                keyPrefix: row[1],
+                expirationTimestamp: row[2],
+            };
+        });
+    }
 }
 
 function instrumentGraphQLEval(adapter) {
@@ -16311,7 +16575,7 @@ class ConflictPool {
     }
 }
 
-const DEFAULT_BATCH_SIZE = 500;
+const DEFAULT_BATCH_SIZE$1 = 500;
 const DEFAULT_CONCURRENCY = 6;
 const DEFAULT_GQL_QUERY_BATCH_SIZE = 5;
 class PrimingSession extends EventEmitter {
@@ -16319,7 +16583,7 @@ class PrimingSession extends EventEmitter {
         var _a, _b;
         super();
         this.useBatchGQL = false;
-        this.batchSize = (_a = config.batchSize) !== null && _a !== void 0 ? _a : DEFAULT_BATCH_SIZE;
+        this.batchSize = (_a = config.batchSize) !== null && _a !== void 0 ? _a : DEFAULT_BATCH_SIZE$1;
         this.concurrency = (_b = config.concurrency) !== null && _b !== void 0 ? _b : DEFAULT_CONCURRENCY;
         this.recordLoader = config.recordLoader;
         this.recordIngestor = config.recordIngestor;
@@ -16940,10 +17204,6 @@ class NimbusPrimingNetworkAdapter {
 // ref: https://gnome.pages.gitlab.gnome.org/tracker/docs/developer/limits.html?gi-language=c
 const SQLITE_MAX_VARIABLE_NUMBER = 999;
 const PARAMS_PER_RECORD = 3;
-/**
- * No key builder (or adapter) exists for the object info directory, we need to build the key manually
- */
-const ObjectInfoDirectoryKey = `${UiApiNamespace}::${ObjectInfoDirectoryEntryRepresentationType}:`;
 // We need to batch the records to avoid hitting the SQLITE_MAX_VARIABLE_NUMBER limit. Each record has 3 parameters
 const BATCH_SIZE = Math.floor(SQLITE_MAX_VARIABLE_NUMBER / PARAMS_PER_RECORD);
 class SqlitePrimingStore {
@@ -17008,44 +17268,6 @@ class SqlitePrimingStore {
             };
         }
     }
-    async readObjectInfoDirectory() {
-        const sql = 'SELECT data FROM lds_data WHERE key = ?';
-        const params = [ObjectInfoDirectoryKey];
-        const result = await this.store.query(sql, params);
-        if (result.rows.length === 1) {
-            return JSON.parse(result.rows[0][0]);
-        }
-        return undefined;
-    }
-    async readObjectApiNames() {
-        const sql = 'SELECT key FROM lds_data WHERE key like ?';
-        const params = [`%${ObjectInfoRepresentationType}%`];
-        const result = await this.store.query(sql, params);
-        const apiNames = new Set();
-        result.rows.forEach((row) => {
-            const key = row[0];
-            const parts = key.split(':');
-            apiNames.add(parts[parts.length - 1]);
-        });
-        return apiNames;
-    }
-    writeObjectInfoDirectory(directory) {
-        const sql = 'INSERT or IGNORE into lds_data (key, data) values (?, ?)';
-        const params = [ObjectInfoDirectoryKey, JSON.stringify(directory)];
-        return this.store.query(sql, params).then(() => { });
-    }
-    writeObjectInfos(objectInfos) {
-        const sql = `INSERT or IGNORE into lds_data (key, data) values ${objectInfos
-            .map(() => '(?, ?)')
-            .join(',')};`;
-        const params = [];
-        objectInfos.forEach((objectInfo) => {
-            const key = keyBuilderObjectInfo(this.getLuvio(), { apiName: objectInfo.apiName });
-            params.push(key);
-            params.push(JSON.stringify(objectInfo));
-        });
-        return this.store.query(sql, params).then(() => { });
-    }
 }
 function batchArray(arr, batchSize = BATCH_SIZE) {
     const batches = [];
@@ -17120,9 +17342,7 @@ function primingSessionFactory(config) {
         recordLoader,
         recordIngestor,
         store: primingStore,
-        objectInfoLoader: {
-            getObjectInfos: objectInfoService.getObjectInfos.bind(objectInfoService),
-        },
+        objectInfoLoader: objectInfoService,
         concurrency: config.concurrency,
         batchSize: config.batchSize,
         ldsRecordRefresher: new LdsPrimingRecordRefresher(config.getRecords),
@@ -17288,4 +17508,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.247.0-4fe38c091
+// version: 1.249.0-11c3e1ed5