@salesforce/lds-runtime-mobile 1.311.1 → 1.313.0

package/dist/main.js

@@ -17,12 +17,11 @@
  */
 import { withRegistration, register } from '@salesforce/lds-default-luvio';
 import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from '@salesforce/lds-instrumentation';
-import { HttpStatusCode, setBypassDeepFreeze, 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 as Kind$1, buildSchema, isObjectType, defaultFieldResolver, visit, execute, parse as parse$7, extendSchema, isScalarType } from '@luvio/graphql-parser';
-import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, isStoreKeyRecordViewEntity, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, getRecordId18, getRecordsAdapterFactory, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion } from '@salesforce/lds-adapters-uiapi-mobile';
+import { HttpStatusCode, setBypassDeepFreeze, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, StoreKeyMap, createCustomAdapterEventEmitter, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
+import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, isStoreKeyRecordViewEntity, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationVersion, getRecordId18, getRecordsAdapterFactory, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL } from '@salesforce/lds-adapters-uiapi-mobile';
 import ldsIdempotencyWriteDisabled from '@salesforce/gate/lds.idempotencyWriteDisabled';
 import ldsBackdatingEnabled from '@salesforce/gate/lds.backdatingEnabled';
+import { Kind as Kind$1, buildSchema, isObjectType, defaultFieldResolver, visit, execute, parse as parse$7, extendSchema, isScalarType } from '@luvio/graphql-parser';
 import FIRST_DAY_OF_WEEK from '@salesforce/i18n/firstDayOfWeek';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
@@ -54,8 +53,8 @@ import { isStoreKeyRecordViewEntity as isStoreKeyRecordViewEntity$1, RECORD_ID_P
 
 const { parse: parse$6, stringify: stringify$6 } = JSON;
 const { join: join$2, push: push$2, unshift } = Array.prototype;
-const { isArray: isArray$5 } = Array;
-const { entries: entries$6, keys: keys$9 } = Object;
+const { isArray: isArray$4 } = Array;
+const { entries: entries$6, keys: keys$8 } = Object;
 
 const UI_API_BASE_URI = '/services/data/v63.0/ui-api';
 
@@ -120,7 +119,7 @@ function isSpanningRecord$1(fieldValue) {
 function mergeRecordFields$1(first, second) {
     const { fields: targetFields } = first;
     const { fields: sourceFields } = second;
-    const fieldNames = keys$9(sourceFields);
+    const fieldNames = keys$8(sourceFields);
     for (let i = 0, len = fieldNames.length; i < len; i += 1) {
         const fieldName = fieldNames[i];
         const sourceField = sourceFields[fieldName];
@@ -279,7 +278,7 @@ const getRecordDispatcher = (req) => {
         }
     }
     const recordId = urlParams.recordId;
-    const fieldsArray = fields !== undefined && isArray$5(fields) ? fields : [];
+    const fieldsArray = fields !== undefined && isArray$4(fields) ? fields : [];
     const optionalFieldsArray = optionalFields !== undefined && Array.isArray(optionalFields)
         ? optionalFields
         : [];
@@ -537,7 +536,7 @@ const RedirectDurableSegment = 'REDIRECT_KEYS';
 const MessagingDurableSegment = 'MESSAGING';
 const MessageNotifyStoreUpdateAvailable = 'notifyStoreUpdateAvailable';
 
-const { keys: keys$8, create: create$7, assign: assign$7, freeze: freeze$2 } = Object;
+const { keys: keys$7, create: create$7, assign: assign$7, freeze: freeze$2 } = Object;
 
 //Durable store error instrumentation key
 const DURABLE_STORE_ERROR = 'durable-store-error';
@@ -587,7 +586,7 @@ function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
     if (durableRecords === undefined) {
         return { revivedKeys, hadUnexpectedShape };
     }
-    const durableKeys = keys$8(durableRecords);
+    const durableKeys = keys$7(durableRecords);
     if (durableKeys.length === 0) {
         // no records to revive
         return { revivedKeys, hadUnexpectedShape };
@@ -772,7 +771,7 @@ class DurableTTLStore {
                     overrides,
                 };
             }
-            const keys$1 = keys$8(entries);
+            const keys$1 = keys$7(entries);
             for (let i = 0, len = keys$1.length; i < len; i++) {
                 const key = keys$1[i];
                 const entry = entries[key];
@@ -801,7 +800,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     // TODO: W-8909393 Once metadata is stored in its own segment we need to
     // call setEntries for the visitedIds on default segment and call setEntries
     // on the metadata segment for the refreshedIds
-    const keys$1 = keys$8({ ...visitedIds, ...refreshedIds });
+    const keys$1 = keys$7({ ...visitedIds, ...refreshedIds });
     for (let i = 0, len = keys$1.length; i < len; i += 1) {
         const key = keys$1[i];
         const canonicalKey = store.getCanonicalRecordId(key);
@@ -833,7 +832,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
         }
     }
     const durableStoreOperations = additionalDurableStoreOperations;
-    const recordKeys = keys$8(durableRecords);
+    const recordKeys = keys$7(durableRecords);
     if (recordKeys.length > 0) {
         // publishes with data
         durableStoreOperations.push({
@@ -842,7 +841,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
             segment: DefaultDurableSegment,
         });
     }
-    const refreshKeys = keys$8(refreshedDurableRecords);
+    const refreshKeys = keys$7(refreshedDurableRecords);
     if (refreshKeys.length > 0) {
         // publishes with only metadata updates
         durableStoreOperations.push({
@@ -864,7 +863,7 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
         });
     });
     // evicts
-    const evictedKeys = keys$8(evictedRecords);
+    const evictedKeys = keys$7(evictedRecords);
     if (evictedKeys.length > 0) {
         durableStoreOperations.push({
             type: 'evictEntries',
@@ -1122,7 +1121,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
             try {
                 const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
                 if (entries !== undefined) {
-                    const entryKeys = keys$8(entries);
+                    const entryKeys = keys$7(entries);
                     for (let i = 0, len = entryKeys.length; i < len; i++) {
                         const entryKey = entryKeys[i];
                         const entry = entries[entryKey];
@@ -1157,7 +1156,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
             if (filteredKeys.length > 0) {
                 const entries = await durableStore.getMetadata(filteredKeys, DefaultDurableSegment);
                 if (entries !== undefined) {
-                    const entryKeys = keys$8(entries);
+                    const entryKeys = keys$7(entries);
                     for (let i = 0, len = entryKeys.length; i < len; i++) {
                         const entryKey = entryKeys[i];
                         const { metadata } = entries[entryKey];
@@ -1529,7 +1528,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         validateNotDisposed();
         const entryKeys = keys$1.map(serializeStructuredKey);
         const entries = await durableStore.getEntries(entryKeys, DefaultDurableSegment);
-        if (entries === undefined || keys$8(entries).length === 0) {
+        if (entries === undefined || keys$7(entries).length === 0) {
             return environment.notifyStoreUpdateAvailable(keys$1);
         }
         const now = Date.now();
@@ -1541,3369 +1540,101 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
                 const storeEntry = entry;
                 if (storeEntry.metadata !== undefined) {
                     storeEntry.metadata = {
-                        ...storeEntry.metadata,
-                        expirationTimestamp: now,
-                    };
-                }
-                needWriteBack = true;
-            }
-        }
-        if (needWriteBack) {
-            await durableStore.setEntries(entries, DefaultDurableSegment);
-        }
-        // push a notifyStoreUpdateAvailable message with entryKeys as data into messaging segment
-        await durableStore.setEntries({ notifyStoreUpdateAvailable: { data: entryKeys } }, MessagingDurableSegment);
-        return Promise.resolve(undefined);
-    };
-    const reviveSnapshotWrapper = function (unavailableSnapshot, buildL1Snapshot) {
-        let revivingStore = undefined;
-        if (useRevivingStore) {
-            // NOTE: `store` is private, there doesn't seem to be a better,
-            // cleaner way of accessing it from a derived environment.
-            let baseStore = environment.store;
-            // If we're rebuilding during an ingest, the existing staging store should be the base store.
-            if (stagingStore) {
-                baseStore = stagingStore;
-            }
-            let revivingStore = buildRevivingStagingStore(baseStore);
-            revivingStores.add(revivingStore);
-        }
-        return reviveSnapshot(environment, durableStore, unavailableSnapshot, durableStoreErrorHandler, () => {
-            const tempStore = stagingStore;
-            const result = buildL1Snapshot();
-            stagingStore = tempStore;
-            return result;
-        }, revivingStore).finally(() => {
-        });
-    };
-    const expirePossibleStaleRecords = async function (keys$1, config, refresh) {
-        validateNotDisposed();
-        const metadataKeys = keys$1.map(serializeStructuredKey);
-        const now = Date.now();
-        const entries = await durableStore.getMetadata(metadataKeys, DefaultDurableSegment);
-        if (entries === undefined || keys$8(entries).length === 0) {
-            return environment.expirePossibleStaleRecords(keys$1);
-        }
-        let metaDataChanged = false;
-        const metadataEntries = metadataKeys.reduce((accu, key) => {
-            const metadataEntry = entries[key];
-            if (metadataEntry.metadata !== undefined) {
-                const metadata = { ...metadataEntry.metadata, expirationTimestamp: now };
-                accu[key] = { metadata };
-                metaDataChanged = true;
-            }
-            return accu;
-        }, {});
-        if (metaDataChanged) {
-            await durableStore.setMetadata(metadataEntries, DefaultDurableSegment);
-        }
-        if (config !== undefined && refresh !== undefined) {
-            return environment.refreshPossibleStaleRecords(config, refresh);
-        }
-        return Promise.resolve();
-    };
-    // set the default cache policy of the base environment
-    environment.setDefaultCachePolicy({
-        type: 'stale-while-revalidate',
-        staleDurationSeconds: Number.MAX_SAFE_INTEGER,
-    });
-    return create$7(environment, {
-        publishStoreMetadata: { value: publishStoreMetadata },
-        storeIngest: { value: storeIngest },
-        storeIngestError: { value: storeIngestError },
-        storeBroadcast: { value: storeBroadcast },
-        storeLookup: { value: storeLookup },
-        storeEvict: { value: storeEvict },
-        wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
-        getNode: { value: getNode },
-        rebuildSnapshot: { value: rebuildSnapshot },
-        withContext: { value: withContext },
-        storeSetTTLOverride: { value: storeSetTTLOverride },
-        storeSetDefaultTTLOverride: { value: storeSetDefaultTTLOverride },
-        storePublish: { value: storePublish },
-        storeRedirect: { value: storeRedirect },
-        dispose: { value: dispose },
-        publishChangesToDurableStore: { value: publishChangesToDurableStore },
-        getDurableTTLOverrides: { value: getDurableTTLOverrides },
-        dispatchResourceRequest: { value: dispatchResourceRequest },
-        applyCachePolicy: { value: applyCachePolicy },
-        getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
-        getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },
-        getIngestStagingStore: { value: getIngestStagingStore },
-        handleSuccessResponse: { value: handleSuccessResponse },
-        handleErrorResponse: { value: handleErrorResponse },
-        getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
-        notifyStoreUpdateAvailable: { value: notifyStoreUpdateAvailable },
-        expirePossibleStaleRecords: { value: expirePossibleStaleRecords },
-    });
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
-function isStoreKeyRecordId$1(key) {
-    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
-}
-function objectsDeepEqual(lhs, rhs) {
-    if (lhs === rhs)
-        return true;
-    if (typeof lhs !== 'object' || typeof rhs !== 'object' || lhs === null || rhs === null)
-        return false;
-    const lhsKeys = Object.keys(lhs);
-    const rhsKeys = Object.keys(rhs);
-    if (lhsKeys.length !== rhsKeys.length)
-        return false;
-    for (let key of lhsKeys) {
-        if (!rhsKeys.includes(key))
-            return false;
-        if (typeof lhs[key] === 'function' || typeof rhs[key] === 'function') {
-            if (lhs[key].toString() !== rhs[key].toString())
-                return false;
-        }
-        else {
-            if (!objectsDeepEqual(lhs[key], rhs[key]))
-                return false;
-        }
-    }
-    return true;
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
-const GRAPHQL_ROOT_KEY$1 = `GraphQL::graphql`;
-function findIds(json) {
-    const entries = Object.entries(json);
-    let ids = [];
-    for (let index = 0; index < entries.length; index++) {
-        const entry = entries[index];
-        const key = entry[0];
-        const value = entry[1];
-        if (typeof value === 'object' && value !== null) {
-            const childIds = findIds(value);
-            ids.push(...childIds);
-        }
-        else if (key === 'Id' && typeof value === 'string') {
-            ids.push(value);
-        }
-    }
-    return ids;
-}
-function idWithPrefix(id) {
-    return `UiApi::RecordRepresentation:${id}`;
-}
-function createSeenRecords$1(json) {
-    const ids = findIds(json)
-        .map(idWithPrefix)
-        .reduce((acc, curr) => (acc.add(curr), acc), new StoreKeySet());
-    return ids;
-}
-function createStoreEvalSnapshot(data, seenRecords, rebuildWithStoreEval, recordId) {
-    return {
-        recordId,
-        variables: {},
-        seenRecords,
-        select: {
-            recordId: GRAPHQL_ROOT_KEY$1,
-            variables: {},
-            node: {
-                kind: 'Fragment',
-                private: [],
-            },
-        },
-        state: 'Fulfilled',
-        data,
-        rebuildWithStoreEval,
-    };
-}
-
-var PredicateType$1;
-(function (PredicateType) {
-    PredicateType["compound"] = "compound";
-    PredicateType["comparison"] = "comparison";
-    PredicateType["not"] = "not";
-    PredicateType["nullComparison"] = "nullComparison";
-    PredicateType["recordRepresentation"] = "recordRepresentation";
-    PredicateType["exists"] = "exists";
-    PredicateType["between"] = "between";
-    PredicateType["dateFunction"] = "dateFunction";
-})(PredicateType$1 || (PredicateType$1 = {}));
-var DateFunction;
-(function (DateFunction) {
-    DateFunction["dayOfMonth"] = "DAY_OF_MONTH";
-})(DateFunction || (DateFunction = {}));
-var CompoundOperator;
-(function (CompoundOperator) {
-    CompoundOperator["and"] = "and";
-    CompoundOperator["or"] = "or";
-})(CompoundOperator || (CompoundOperator = {}));
-var NullComparisonOperator;
-(function (NullComparisonOperator) {
-    NullComparisonOperator["is"] = "is";
-    NullComparisonOperator["isNot"] = "isNot";
-})(NullComparisonOperator || (NullComparisonOperator = {}));
-var ComparisonOperator;
-(function (ComparisonOperator) {
-    ComparisonOperator["eq"] = "eq";
-    ComparisonOperator["ne"] = "ne";
-    ComparisonOperator["like"] = "like";
-    ComparisonOperator["lt"] = "lt";
-    ComparisonOperator["gt"] = "gt";
-    ComparisonOperator["lte"] = "lte";
-    ComparisonOperator["gte"] = "gte";
-    ComparisonOperator["in"] = "in";
-    ComparisonOperator["nin"] = "nin";
-    ComparisonOperator["excludes"] = "excludes";
-    ComparisonOperator["includes"] = "includes";
-})(ComparisonOperator || (ComparisonOperator = {}));
-var DateEnumType;
-(function (DateEnumType) {
-    DateEnumType[DateEnumType["yesterday"] = 0] = "yesterday";
-    DateEnumType[DateEnumType["today"] = 1] = "today";
-    DateEnumType[DateEnumType["tomorrow"] = 2] = "tomorrow";
-    DateEnumType[DateEnumType["last_week"] = 3] = "last_week";
-    DateEnumType[DateEnumType["this_week"] = 4] = "this_week";
-    DateEnumType[DateEnumType["next_week"] = 5] = "next_week";
-    DateEnumType[DateEnumType["last_month"] = 6] = "last_month";
-    DateEnumType[DateEnumType["this_month"] = 7] = "this_month";
-    DateEnumType[DateEnumType["next_month"] = 8] = "next_month";
-    DateEnumType[DateEnumType["last_quarter"] = 9] = "last_quarter";
-    DateEnumType[DateEnumType["this_quarter"] = 10] = "this_quarter";
-    DateEnumType[DateEnumType["next_quarter"] = 11] = "next_quarter";
-    DateEnumType[DateEnumType["last_90_days"] = 12] = "last_90_days";
-    DateEnumType[DateEnumType["next_90_days"] = 13] = "next_90_days";
-    DateEnumType[DateEnumType["last_year"] = 14] = "last_year";
-    DateEnumType[DateEnumType["this_year"] = 15] = "this_year";
-    DateEnumType[DateEnumType["next_year"] = 16] = "next_year";
-})(DateEnumType || (DateEnumType = {}));
-var DateRangeEnumType;
-(function (DateRangeEnumType) {
-    DateRangeEnumType[DateRangeEnumType["last_n_months"] = 0] = "last_n_months";
-    DateRangeEnumType[DateRangeEnumType["last_n_days"] = 1] = "last_n_days";
-})(DateRangeEnumType || (DateRangeEnumType = {}));
-var FieldType;
-(function (FieldType) {
-    FieldType["Child"] = "ChildField";
-    FieldType["Scalar"] = "ScalarField";
-    FieldType["Spanning"] = "SpanningField";
-    FieldType["Null"] = "NullField";
-})(FieldType || (FieldType = {}));
-var ValueType;
-(function (ValueType) {
-    ValueType["Extract"] = "JsonExtract";
-    ValueType["BooleanLiteral"] = "BooleanLiteral";
-    ValueType["DoubleLiteral"] = "DoubleLiteral";
-    ValueType["IntLiteral"] = "IntLiteral";
-    ValueType["Identifier"] = "Identifier";
-    ValueType["StringLiteral"] = "StringLiteral";
-    ValueType["StringArray"] = "StringArray";
-    ValueType["NumberArray"] = "NumberArray";
-    ValueType["DateEnum"] = "DateEnum";
-    ValueType["DateValue"] = "DateValue";
-    ValueType["DateArray"] = "DateArray";
-    ValueType["DateRange"] = "DateRange";
-    ValueType["DateTimeEnum"] = "DateTimeEnum";
-    ValueType["DateTimeValue"] = "DateTimeValue";
-    ValueType["DateTimeArray"] = "DateTimeArray";
-    ValueType["DateTimeRange"] = "DateTimeRange";
-    ValueType["RelativeDate"] = "RelativeDate";
-    ValueType["NullValue"] = "NullValue";
-    ValueType["MultiPicklistSet"] = "MultiPicklistSet";
-})(ValueType || (ValueType = {}));
-function isCompoundPredicate$1(predicate) {
-    return predicate.type === PredicateType$1.compound;
-}
-function isComparisonPredicate(predicate) {
-    return predicate.type === PredicateType$1.comparison;
-}
-function isBetweenPredicate(predicate) {
-    return predicate.type === PredicateType$1.between;
-}
-function isNullComparisonPredicate(predicate) {
-    return predicate.type === PredicateType$1.nullComparison;
-}
-function isNotPredicate$1(predicate) {
-    return predicate.type === PredicateType$1.not;
-}
-function isExistsPredicate(predicate) {
-    return predicate.type === PredicateType$1.exists;
-}
-function isDateFunctionPredicate(predicate) {
-    return predicate.type === PredicateType$1.dateFunction;
-}
-
-function flatten$1(previous, current) {
-    return previous.concat(current);
-}
-function flatMap(transform) {
-    return (acc, current) => {
-        const mapped = transform(current);
-        return acc.concat(mapped);
-    };
-}
-
-function isExpressionEqual(lh, rh) {
-    if (lh.type === ValueType.StringLiteral && rh.type === ValueType.StringLiteral) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.DoubleLiteral && rh.type === ValueType.DoubleLiteral) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.IntLiteral && rh.type === ValueType.IntLiteral) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.BooleanLiteral && rh.type === ValueType.BooleanLiteral) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.StringArray && rh.type === ValueType.StringArray) {
-        return isArrayEqual(lh.value, rh.value, isStrictEqual);
-    }
-    if (lh.type === ValueType.NumberArray && rh.type === ValueType.NumberArray) {
-        return isArrayEqual(lh.value, rh.value, isStrictEqual);
-    }
-    if (lh.type === ValueType.DateValue && rh.type === ValueType.DateValue) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.DateEnum && rh.type === ValueType.DateEnum) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.DateTimeValue && rh.type === ValueType.DateTimeValue) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.DateTimeEnum && rh.type === ValueType.DateTimeEnum) {
-        return lh.value === rh.value;
-    }
-    if (lh.type === ValueType.RelativeDate && rh.type === ValueType.RelativeDate) {
-        return (lh.amount === rh.amount &&
-            lh.hasTime === rh.hasTime &&
-            lh.offset === rh.offset &&
-            lh.unit === rh.unit);
-    }
-    if (lh.type === ValueType.NullValue && rh.type === ValueType.NullValue) {
-        return true;
-    }
-    if (lh.type === ValueType.DateArray && rh.type === ValueType.DateArray) {
-        return isArrayEqual(lh.value, rh.value, isExpressionEqual);
-    }
-    if (lh.type === ValueType.DateTimeArray && rh.type === ValueType.DateTimeArray) {
-        return isArrayEqual(lh.value, rh.value, isExpressionEqual);
-    }
-    if (lh.type === ValueType.Extract && rh.type === ValueType.Extract) {
-        return (lh.field === rh.field && lh.jsonAlias === rh.jsonAlias && lh.subfield === rh.subfield);
-    }
-    return false;
-}
-function isStrictEqual(l, r) {
-    return l === r;
-}
-function isArrayEqual(lh, rh, compare) {
-    if (lh.length !== rh.length) {
-        return false;
-    }
-    for (let index = 0; index < rh.length; index++) {
-        const r = rh[index];
-        const l = lh[index];
-        if (compare(l, r) === false) {
-            return false;
-        }
-    }
-    return true;
-}
-function isPredicateEqual(lh, rh) {
-    if (lh === undefined) {
-        return lh === rh;
-    }
-    if (rh === undefined) {
-        return rh === lh;
-    }
-    const { nullComparison, not, comparison, compound, between } = PredicateType$1;
-    if (rh.type === nullComparison && lh.type === nullComparison) {
-        return rh.operator === lh.operator && isExpressionEqual(rh.left, lh.left);
-    }
-    if (rh.type === not && lh.type === not) {
-        return isPredicateEqual(rh.child, lh.child);
-    }
-    if (rh.type === comparison && lh.type === comparison) {
-        return (rh.operator === lh.operator &&
-            isExpressionEqual(rh.left, lh.left) &&
-            isExpressionEqual(rh.right, lh.right));
-    }
-    if (rh.type === between && lh.type === between) {
-        return (isExpressionEqual(rh.compareDate, lh.compareDate) &&
-            isExpressionEqual(rh.start, lh.start) &&
-            isExpressionEqual(rh.end, lh.end));
-    }
-    if (rh.type === compound && lh.type === compound) {
-        const lChildren = lh.children;
-        const rChildren = rh.children;
-        return isArrayEqual(lChildren, rChildren, isPredicateEqual);
-    }
-    return false;
-}
-function containsPredicate(predicates, predicate) {
-    for (let index = 0; index < predicates.length; index++) {
-        const element = predicates[index];
-        if (isPredicateEqual(predicate, element)) {
-            return true;
-        }
-    }
-    return false;
-}
-function removeDuplicatePredicates(predicates) {
-    return predicates.reduce(function (acc, b) {
-        if (containsPredicate(acc, b) === false) {
-            acc.push(b);
-        }
-        return acc;
-    }, []);
-}
-function isOrderByEqual(lh, rh) {
-    if (lh === undefined) {
-        return lh === rh;
-    }
-    if (rh === undefined) {
-        return lh === rh;
-    }
-    return (lh.asc === rh.asc &&
-        isExpressionEqual(lh.extract, rh.extract) &&
-        lh.nullsFirst === rh.nullsFirst);
-}
-function isRecordQueryEqual(lh, rh) {
-    return (lh.alias === rh.alias &&
-        isArrayEqual(lh.fields, rh.fields, isFieldEqual) &&
-        lh.first === rh.first &&
-        isArrayEqual(lh.joins, rh.joins, isStrictEqual) &&
-        isArrayEqual(lh.orderBy, rh.orderBy, isOrderByEqual) &&
-        isPredicateEqual(lh.predicate, rh.predicate));
-}
-function isFieldEqual(lh, rh) {
-    if (rh.type === FieldType.Child && lh.type === FieldType.Child) {
-        return isRecordQueryEqual(lh.connection, rh.connection) && lh.path === rh.path;
-    }
-    if (rh.type === FieldType.Scalar && lh.type === FieldType.Scalar) {
-        return isExpressionEqual(lh.extract, rh.extract) && lh.path === rh.path;
-    }
-    return false;
-}
-function containsField(fields, field) {
-    for (let index = 0; index < fields.length; index++) {
-        const element = fields[index];
-        if (isFieldEqual(field, element)) {
-            return true;
-        }
-    }
-    return false;
-}
-function removeDuplicateFields(fields) {
-    return fields.reduce(function (acc, b) {
-        if (containsField(acc, b) === false) {
-            acc.push(b);
-        }
-        return acc;
-    }, []);
-}
-
-function message(message) {
-    return { type: 'MessageError', message };
-}
-function missingObjectInfo(object) {
-    return { type: 'MissingObjectInfoError', object };
-}
-function concatenatePredicateErrors(errors) {
-    const messages = errors.reduce((accu, error) => {
-        if (error.type === 'MessageError') {
-            accu.push(error.message);
-        }
-        else if (error.type === 'MissingObjectInfoError') {
-            accu.push(`Missing object info for type ${error.object}`);
-        }
-        return accu;
-    }, []);
-    return new Error(messages.join(', '));
-}
-
-function success(value) {
-    return {
-        value,
-        isSuccess: true,
-        map: (f) => success(f(value)),
-        flatMap: (f) => f(value),
-        mapError: (_) => success(value),
-    };
-}
-function failure(error) {
-    return {
-        error,
-        isSuccess: false,
-        map: (_) => failure(error),
-        flatMap: (_) => failure(error),
-        mapError: (f) => failure(f(error)),
-    };
-}
-function isSuccess(result) {
-    return result.isSuccess;
-}
-function isFailure(result) {
-    return result.isSuccess === false;
-}
-function errors(result) {
-    return result.error;
-}
-function values$5(result) {
-    return result.value;
-}
-function flattenResults(results) {
-    const fails = results.filter(isFailure).map(errors);
-    if (fails.length > 0) {
-        return failure(fails);
-    }
-    return success(results.filter(isSuccess).map(values$5));
-}
-
-function getFieldInfo(apiName, fieldName, infoMap) {
-    const objInfo = infoMap[apiName];
-    if (objInfo === undefined) {
-        return failure(missingObjectInfo(apiName));
-    }
-    // Special casing for WeakEtag which is represented in the GraphQL schema but
-    // has no ObjectInfo representation
-    if (fieldName === 'WeakEtag') {
-        return success({
-            apiName: 'WeakEtag',
-            dataType: 'WeakEtag',
-        });
-    }
-    const fieldInfo = Object.values(objInfo.fields).find((field) => field.apiName === fieldName ||
-        (field.dataType === 'Reference' && field.relationshipName === fieldName));
-    return success(fieldInfo);
-}
-function getRelationshipInfo(apiName, fieldName, infoMap) {
-    const objInfo = infoMap[apiName];
-    if (objInfo === undefined) {
-        return failure(missingObjectInfo(apiName));
-    }
-    return success(objInfo.childRelationships.find((relationship) => relationship.relationshipName === fieldName));
-}
-function stringLiteral(value, safe = false, isCaseSensitive = false) {
-    return { type: ValueType.StringLiteral, value, safe, isCaseSensitive };
-}
-function isStringLiteral(expression) {
-    return expression.type === ValueType.StringLiteral;
-}
-function isStringArray(expression) {
-    return expression.type === ValueType.StringArray;
-}
-function comparison(left, operator, right) {
-    return { type: PredicateType$1.comparison, left, right, operator };
-}
-function compoundOrSelf(children, operator) {
-    if (children.length === 1) {
-        return children[0];
-    }
-    return { type: PredicateType$1.compound, operator, children };
-}
-function isEmptyPredicate(predicate) {
-    return isCompoundPredicate$1(predicate) ? predicate.children.length === 0 : false;
-}
-/**
- * Flattens the contents of child predicates of the same type as the new parent compound predicate.
- * Removes duplicate predicates found within the same compound predicate.
- *
- * @param predicates
- * @param operator
- * @returns
- */
-function combinePredicates(predicates, operator) {
-    //compound predicates with a different type (and, or) than operator
-    const otherCompoundPredicates = predicates
-        .filter(isCompoundPredicate$1)
-        .filter((pred) => pred.operator !== operator);
-    const flattened = predicates
-        .filter(isCompoundPredicate$1)
-        .filter((pred) => pred.operator === operator)
-        .map((pred) => pred.children)
-        .reduce(flatten$1, []);
-    const compares = predicates.filter((pred) => isComparisonPredicate(pred) ||
-        isNullComparisonPredicate(pred) ||
-        isExistsPredicate(pred) ||
-        isDateFunctionPredicate(pred) ||
-        isBetweenPredicate(pred) ||
-        isNotPredicate$1(pred));
-    const children = [...compares, ...flattened, ...otherCompoundPredicates];
-    const uniques = removeDuplicatePredicates(children);
-    return compoundOrSelf(uniques, operator);
-}
-function referencePredicate(fromAlias, toAlias, referenceKey) {
-    return comparison({ type: ValueType.Extract, jsonAlias: fromAlias, field: referenceKey }, ComparisonOperator.eq, {
-        type: ValueType.Extract,
-        jsonAlias: toAlias,
-        field: 'Id',
-    });
-}
-function extractPath(fieldName, subfield = undefined) {
-    switch (fieldName) {
-        case 'Id':
-            return 'id';
-        case 'ApiName':
-            return 'apiName';
-        case 'drafts':
-            return 'drafts';
-        case 'RecordTypeId':
-            return 'recordTypeId';
-        case 'WeakEtag':
-            return 'weakEtag';
-        default: {
-            const sub = subfield !== undefined ? subfield : 'value';
-            return `fields.${fieldName}.${sub}`;
-        }
-    }
-}
-function removeAllQuotations(s) {
-    return s.replace(/['"]+/g, '');
-}
-function removeQuotationsFromKeys(s) {
-    return s.replace(/"([^"]+)":/g, '$1:');
-}
-// Turns a single dimensional array into a 2 dimensional array, where
-// the internal array "chunks" are of length `chunkSize`.  The last
-// chunk will have any remainder and may be less than `chunkSize`
-function chunkArr(arr, chunkSize) {
-    const res = [];
-    for (let i = 0; i < arr.length; i += chunkSize) {
-        const chunk = arr.slice(i, i + chunkSize);
-        res.push(chunk);
-    }
-    return res;
-}
-
-const TODAY_RANGE$1 = {
-    lowerBound: `date('now')`,
-    upperBound: `date('now', '+1 day', '-0.001 seconds')`,
-};
-const TOMORROW_RANGE$1 = {
-    lowerBound: `date('now', '+1 day')`,
-    upperBound: `date('now', '+2 day', '-0.001 seconds')`,
-};
-const YESTERDAY_RANGE$1 = {
-    lowerBound: `date('now', '-1 day')`,
-    upperBound: `date('now', '-0.001 seconds')`,
-};
-const THIS_WEEK_RANGE$1 = {
-    lowerBound: `date('now', 'weekday 0', '-7 days')`,
-    upperBound: `date('now', 'weekday 0', '-1 day')`,
-};
-const LAST_WEEK_RANGE$1 = {
-    lowerBound: `date('now', 'weekday 0', '-14 days')`,
-    upperBound: `date('now', 'weekday 0', '-8 days')`,
-};
-const NEXT_WEEK_RANGE$1 = {
-    lowerBound: `date('now', 'weekday 0')`,
-    upperBound: `date('now', 'weekday 0', '+6 days')`,
-};
-const THIS_MONTH_RANGE$1 = {
-    lowerBound: `date('now', 'start of month')`,
-    upperBound: `date('now', 'start of month', '1 month', '-1 day')`,
-};
-const LAST_MONTH_RANGE$1 = {
-    lowerBound: `date('now', 'start of month', '-1 month')`,
-    upperBound: `date('now', 'start of month', '-1 day')`,
-};
-const NEXT_MONTH_RANGE$1 = {
-    lowerBound: `date('now', 'start of month', '+1 month')`,
-    // -1 day is the day before the end of the month
-    // this needs to be 0 day
-    upperBound: `date('now', 'start of month', '+2 month', '0 day')`,
-};
-const THIS_QUARTER_RANGE$1 = computeQuarterDateRange$1(DateEnumType.this_quarter);
-const LAST_QUARTER_RANGE$1 = computeQuarterDateRange$1(DateEnumType.last_quarter);
-const NEXT_QUARTER_RANGE$1 = computeQuarterDateRange$1(DateEnumType.next_quarter);
-const THIS_YEAR_RANGE$1 = {
-    lowerBound: `date('now', 'start of year')`,
-    upperBound: `date('now', 'start of month', '1 year', '-1 day')`,
-};
-const LAST_YEAR_RANGE$1 = {
-    lowerBound: `date('now', 'start of year', '-1 year')`,
-    upperBound: `date('now', 'start of year', '-1 day')`,
-};
-const NEXT_YEAR_RANGE$1 = {
-    lowerBound: `date('now', 'start of year', '+1 year')`,
-    upperBound: `date('now', 'start of year', '+2 years', '-1 day')`,
-};
-const LAST_90_DAYS_RANGE$1 = {
-    lowerBound: `date('now', '-90 days')`,
-    upperBound: `date('now')`,
-};
-const NEXT_90_DAYS_RANGE$1 = {
-    lowerBound: `date('now', '+1 day')`,
-    upperBound: `date('now', '+90 days')`,
-};
-const dateRanges = initDateRanges();
-function initDateRanges() {
-    const dateRanges = {};
-    dateRanges[DateEnumType.today] = TODAY_RANGE$1;
-    dateRanges[DateEnumType.yesterday] = YESTERDAY_RANGE$1;
-    dateRanges[DateEnumType.tomorrow] = TOMORROW_RANGE$1;
-    dateRanges[DateEnumType.this_week] = THIS_WEEK_RANGE$1;
-    dateRanges[DateEnumType.last_week] = LAST_WEEK_RANGE$1;
-    dateRanges[DateEnumType.next_week] = NEXT_WEEK_RANGE$1;
-    dateRanges[DateEnumType.this_month] = THIS_MONTH_RANGE$1;
-    dateRanges[DateEnumType.last_month] = LAST_MONTH_RANGE$1;
-    dateRanges[DateEnumType.next_month] = NEXT_MONTH_RANGE$1;
-    dateRanges[DateEnumType.this_year] = THIS_YEAR_RANGE$1;
-    dateRanges[DateEnumType.last_year] = LAST_YEAR_RANGE$1;
-    dateRanges[DateEnumType.next_year] = NEXT_YEAR_RANGE$1;
-    dateRanges[DateEnumType.this_quarter] = THIS_QUARTER_RANGE$1;
-    dateRanges[DateEnumType.last_quarter] = LAST_QUARTER_RANGE$1;
-    dateRanges[DateEnumType.next_quarter] = NEXT_QUARTER_RANGE$1;
-    dateRanges[DateEnumType.last_90_days] = LAST_90_DAYS_RANGE$1;
-    dateRanges[DateEnumType.next_90_days] = NEXT_90_DAYS_RANGE$1;
-    return dateRanges;
-}
-function computeQuarterDateRange$1(enumType) {
-    const curQuarterStart = quarterStart$1(new Date());
-    switch (enumType) {
-        case DateEnumType.last_quarter:
-            return {
-                lowerBound: `date('${curQuarterStart}', '-3 months')`,
-                upperBound: `date('${curQuarterStart}', '-1 day')`,
-            };
-        case DateEnumType.this_quarter:
-            return {
-                lowerBound: `date('${curQuarterStart}')`,
-                // -1 days would set the day before the end of the quarter
-                // 0 days sets it to the end of the month
-                upperBound: `date('${curQuarterStart}', '3 months', '0 days')`,
-            };
-        case DateEnumType.next_quarter:
-            return {
-                lowerBound: `date('${curQuarterStart}', '+3 months')`,
-                // -1 days would set the day before the end of the quarter
-                // 0 days sets it to the end of the month
-                upperBound: `date('${curQuarterStart}', '+6 months', '0 days')`,
-            };
-    }
-}
-// querter start date in UTC
-function quarterStart$1(date) {
-    let month = Math.floor(date.getUTCMonth() / 3) * 3 + 1;
-    const year = date.getUTCFullYear();
-    return month === 10 ? `${year}-${month}-01` : `${year}-0${month}-01`;
-}
-function comparisonDateRightExpressionToSql(operator, dateEnum) {
-    let dateRange = dateRanges[dateEnum];
-    if (dateEnum === DateEnumType.last_quarter ||
-        dateEnum === DateEnumType.this_quarter ||
-        dateEnum === DateEnumType.next_quarter) {
-        const latestQuarterRange = computeQuarterDateRange$1(dateEnum);
-        if (latestQuarterRange.lowerBound !== dateRange.lowerBound) {
-            dateRanges[dateEnum] = latestQuarterRange;
-            dateRange = latestQuarterRange;
-        }
-    }
-    const isDiscreteDate = dateRange.lowerBound === dateRange.upperBound;
-    switch (operator) {
-        case ComparisonOperator.eq:
-            if (isDiscreteDate) {
-                return `= ` + dateRange.lowerBound;
-            }
-            else {
-                return `between ` + dateRange.lowerBound + ` and ` + dateRange.upperBound;
-            }
-        case ComparisonOperator.ne:
-            if (isDiscreteDate) {
-                return `!= ` + dateRange.lowerBound;
-            }
-            else {
-                return `not between ` + dateRange.lowerBound + ` and ` + dateRange.upperBound;
-            }
-        case ComparisonOperator.gt:
-            return `> ` + dateRange.upperBound;
-        case ComparisonOperator.gte:
-            return `>= ` + dateRange.lowerBound;
-        case ComparisonOperator.lt:
-            return `< ` + dateRange.lowerBound;
-        case ComparisonOperator.lte:
-            return `<= ` + dateRange.upperBound;
-        default:
-            return ``;
-    }
-}
-function useInOrNinOperator(dateInput) {
-    let useInOrNin = true;
-    dateInput.value.forEach((element) => {
-        if (element.type === ValueType.DateEnum || element.type === ValueType.DateTimeEnum) {
-            if (element.value !== DateEnumType.yesterday &&
-                element.value !== DateEnumType.today &&
-                element.value !== DateEnumType.tomorrow) {
-                useInOrNin = false;
-            }
-            return;
-        }
-        if (element.type !== ValueType.DateValue &&
-            element.type !== ValueType.DateTimeValue &&
-            element.type !== ValueType.NullValue) {
-            useInOrNin = false;
-        }
-    });
-    return useInOrNin;
-}
-function comparisonOperatorToSql(operator) {
-    switch (operator) {
-        case ComparisonOperator.eq:
-            return '=';
-        case ComparisonOperator.ne:
-            return 'IS NOT';
-        case ComparisonOperator.gt:
-            return '>';
-        case ComparisonOperator.gte:
-            return '>=';
-        case ComparisonOperator.lt:
-            return '<';
-        case ComparisonOperator.lte:
-            return '<=';
-        case ComparisonOperator.like:
-            return 'like';
-        case ComparisonOperator.in:
-            return 'IN';
-        case ComparisonOperator.nin:
-            return 'NOT IN';
-        case ComparisonOperator.includes:
-            return 'LIKE';
-        case ComparisonOperator.excludes:
-            return 'NOT LIKE';
-    }
-}
-// Supports the date literal within the 'in' and 'nin' expressions. Literals is limited to 'TODAY', 'TOMORROW' and 'YESTERDAY'
-function discreteDateEnumToSql(dateEnum) {
-    switch (dateEnum) {
-        case DateEnumType.yesterday:
-            return `date('now', '-1 day')`;
-        case DateEnumType.today:
-            return `date('now')`;
-        case DateEnumType.tomorrow:
-            return `date('now', '+1 day')`;
-        default:
-            return '';
-    }
-}
-
-const recordPrefix = '.data.uiapi.query';
-const recordSuffix = 'edges';
-const pathPrefix = '$';
-const recordsCTE = 'recordsCTE';
-const MultiPickListValueSeparator$1 = ';';
-const recordCTESQL = excludeStaleRecordsGate.isOpen({ fallback: false })
-    ? `WITH ${recordsCTE} AS NOT materialized ` +
-        `(select data, metadata from lds_data where key like 'UiApi::RecordRepresentation:%')`
-    : `WITH ${recordsCTE} AS NOT materialized ` +
-        `(select data from lds_data where key like 'UiApi::RecordRepresentation:%')`;
-function cteSql() {
-    return recordCTESQL;
-}
-function computeSql(rootQuery) {
-    const fields = rootQuery.connections.map((connection) => {
-        const { sql: recordQuerySql, bindings } = recordQueryToSql(connection);
-        return {
-            sql: `'${pathPrefix}${recordPrefix}.${connection.alias}.${recordSuffix}', (${recordQuerySql})`,
-            bindings,
-        };
-    });
-    const fieldSql = fields.map((v) => v.sql).join(`, `);
-    const bindings = fields.map((v) => v.bindings).reduce(flatten$1);
-    return { sql: `${cteSql()} SELECT json_set('{}', ${fieldSql} ) as json`, bindings };
-}
-function fieldToSql(field) {
-    const { path } = field;
-    if (field.type === FieldType.Child) {
-        const { sql, bindings } = recordQueryToSql(field.connection);
-        return { sql: `'${pathPrefix}.${path}', (${sql})`, bindings };
-    }
-    if (field.type === FieldType.Null) {
-        return { sql: `'${pathPrefix}.${path}', null`, bindings: [] };
-    }
-    const { sql, bindings } = expressionToSql(field.extract, field.targetDataType);
-    return { sql: `'${pathPrefix}.${path}', (${sql})`, bindings };
-}
-function recordQueryToSql(recordQuery) {
-    const { predicate, first, orderBy, fields: recordFields, joins, alias: name } = recordQuery;
-    const fields = recordFields.map((f) => fieldToSql(f));
-    const fieldBindings = fields.map((v) => v.bindings).reduce(flatten$1);
-    const { sql: select, bindings: selectBindings } = selectSql(predicate, name, first, orderBy, joins);
-    // In W-12058909, we learned that 63 fields was the upper bound of the json_set approach
-    // before we ran into sqlite errors.  Backing off that threshold a bit in case there are
-    // other unknown-unknowns.  Lower thresholds will have the effect of more json_set nesting
-    // which may be more computationally expensive for the DB to produce.
-    const chunks = chunkArr(fields, 60);
-    // Recursively builds a nested string, where each "chunk" of fields gets added
-    // to a json_set, and embedded in the next json_set to work around a sqlite function arg
-    // limit for GraphQL queries that compute to large numbers of json_sets
-    const nestJsonSets = (sql) => {
-        // take a batch of fields
-        const fields = chunks.shift();
-        // exit when there are no more batches of fields
-        if (!fields)
-            return sql;
-        // Wrap the chunk of fields in a new json_set until exhaustion
-        // eslint-disable-next-line no-param-reassign
-        sql = `json_set(${sql || "'{}'"}, ${fields.map((field) => field.sql).join(`, `)} )`;
-        return nestJsonSets(sql);
-    };
-    const jsonSets = nestJsonSets('');
-    return {
-        sql: `SELECT json_group_array(${jsonSets}) FROM ${select}`,
-        bindings: fieldBindings.concat(selectBindings),
-    };
-}
-function selectSql(predicate, name, first, orderBy, joins) {
-    const { sql: joinString, bindings: joinBindings } = joinsToSql(joins);
-    const columns = columnsSql(joins.map((join) => join.name).concat(name));
-    let predicateString = '';
-    let predicateBindings = [];
-    if (predicate !== undefined) {
-        const { sql: predicateSql, bindings } = predicateToSql(predicate);
-        predicateBindings = bindings;
-        predicateString = `WHERE ${predicateSql}`;
-    }
-    const limitString = first !== undefined ? `LIMIT ${first}` : '';
-    const { sql: orderBySql, bindings: orderByBindings } = orderbyToSql(orderBy);
-    const sql = `(SELECT ${columns} FROM ${recordsCTE} as '${name}' ` +
-        `${joinString} ${predicateString} ${orderBySql}${limitString})`;
-    const bindings = joinBindings.concat(predicateBindings).concat(orderByBindings);
-    return { sql, bindings };
-}
-function orderbyToSql(orderBy = []) {
-    if (orderBy.length === 0) {
-        return { sql: '', bindings: [] };
-    }
-    const clauses = orderBy.map((clause) => {
-        const { sql: extractSql, bindings } = expressionToSql(clause.extract);
-        const order = clause.asc ? 'ASC' : 'DESC';
-        const nullsOrder = clause.nullsFirst ? 'DESC' : 'ASC';
-        //As of fall 2021 most devices don't have NULLS FIRST|LAST support which was added to sqlite in 2019,
-        //so we use a CASE expression and sort by an "is null" column and then by the actual column order.
-        return {
-            sql: `CASE WHEN ${extractSql} IS NULL THEN 1 ELSE 0 END ${nullsOrder}, ${extractSql} ${order} `,
-            bindings,
-        };
-    });
-    const clausesSql = clauses.map((v) => v.sql).join(`, `);
-    const bindings = clauses.map((v) => v.bindings).reduce(flatten$1);
-    return { sql: `ORDER BY ${clausesSql}`, bindings };
-}
-function columnsSql(names) {
-    return names.map((name) => `'${name}'.data as '${name}.JSON'`).join(', ');
-}
-function joinsToSql(joins) {
-    const allBindings = [];
-    const sql = joins.reduce((joinAccumulator, join) => {
-        const conditionSQL = join.conditions.reduce((conditionAccumalator, condition) => {
-            const { sql, bindings } = predicateToSql(condition);
-            const conditionSQL = `${conditionAccumalator}${conditionAccumalator.length === 0 ? '' : ' AND '}${sql}`;
-            allBindings.push(...bindings);
-            return conditionSQL;
-        }, '');
-        const joinSQL = `${joinAccumulator}${joinAccumulator.length === 0 ? '' : ' '}${join.type} JOIN ${recordsCTE} as '${join.name}' ${conditionSQL.length === 0 ? '' : 'ON ' + conditionSQL}`;
-        return joinSQL;
-    }, '');
-    return { sql, bindings: allBindings };
-    //return joins.map((join) => `${join.type} join ${recordsCTE} as '${join.name}'`).join(' ');
-}
-function predicateToSql(predicate, isNotOperator = false) {
-    if (isCompoundPredicate$1(predicate)) {
-        return compoundPredicateToSql(predicate, isNotOperator);
-    }
-    if (isComparisonPredicate(predicate)) {
-        return isNotOperator
-            ? comparisonIsAlsoNotNullToSql(predicate)
-            : comparisonPredicateToSql(predicate);
-    }
-    if (isNullComparisonPredicate(predicate)) {
-        return nullComparisonPredicateToSql(predicate);
-    }
-    if (isExistsPredicate(predicate)) {
-        return existsPredicateToSql(predicate);
-    }
-    if (isDateFunctionPredicate(predicate)) {
-        return dateFunctionPredicateToSql(predicate);
-    }
-    if (isBetweenPredicate(predicate)) {
-        return betweenPredicateToSql(predicate);
-    }
-    return notPredicateToSql$1(predicate);
-}
-function compoundPredicateToSql(predicate, isNotOperator = false) {
-    const operatorString = compoundOperatorToSql(predicate.operator);
-    const results = predicate.children.map((child) => predicateToSql(child, isNotOperator));
-    const statementSql = results.map((v) => v.sql).join(` ${operatorString} `);
-    const bindings = results.map((v) => v.bindings).reduce(flatten$1);
-    return { sql: `( ${statementSql} )`, bindings };
-}
-function dateFunctionPredicateToSql(predicate) {
-    const operator = comparisonOperatorToSql(predicate.operator);
-    const { sql: extract, bindings: extractBindings } = expressionToSql(predicate.extract);
-    switch (predicate.function) {
-        case DateFunction.dayOfMonth: {
-            const day = String(predicate.value).padStart(2, '0');
-            const bindings = extractBindings.concat(`'${day}'`);
-            return { sql: `strftime('%d', ${extract}) ${operator} ?`, bindings };
-        }
-    }
-}
-// This is useful for the 'scope' filter
-function existsPredicateToSql(exists) {
-    const { predicate, joinNames, alias } = exists;
-    const joins = joinNames.map((joinName) => {
-        return {
-            name: joinName,
-            type: 'INNER',
-            conditions: [],
-        };
-    });
-    const { sql: select, bindings } = selectSql(predicate, alias, undefined, undefined, joins);
-    return { sql: `EXISTS ${select}`, bindings };
-}
-function comparisonPredicateToSql(predicate) {
-    const operator = comparisonOperatorToSql(predicate.operator);
-    let { sql: left, bindings: leftBindings } = expressionToSql(predicate.left, undefined, predicate.operator);
-    if (predicate.right.type === ValueType.DateEnum ||
-        predicate.right.type === ValueType.DateTimeEnum ||
-        predicate.right.type === ValueType.DateArray ||
-        predicate.right.type === ValueType.DateTimeArray ||
-        predicate.right.type === ValueType.DateValue ||
-        predicate.right.type === ValueType.DateTimeValue) {
-        const dateFunction = predicate.right.type === ValueType.DateTimeEnum ||
-            predicate.right.type === ValueType.DateTimeArray ||
-            predicate.right.type === ValueType.DateTimeValue
-            ? 'datetime'
-            : 'date';
-        const fieldDateValue = `${dateFunction}(${left})`;
-        return comparisonDateLiteralToSql(fieldDateValue, predicate.operator, predicate.right);
-    }
-    if (predicate.right.type === ValueType.RelativeDate) {
-        const dateFunc = predicate.right.hasTime ? 'datetime' : 'date';
-        left = `${dateFunc}(${left})`;
-    }
-    const { sql: right, bindings: rightBindings } = expressionToSql(predicate.right, undefined, predicate.operator);
-    let bindings = leftBindings.concat(rightBindings);
-    if (predicate.operator === ComparisonOperator.eq &&
-        predicate.right.type === ValueType.StringLiteral &&
-        predicate.right.isCaseSensitive === false) {
-        return { sql: `${left} ${operator} ${right} COLLATE NOCASE`, bindings };
-    }
-    if (predicate.operator === ComparisonOperator.in &&
-        predicate.right.type === ValueType.StringArray &&
-        predicate.right.isCaseSensitive === false) {
-        // If an explicit collating sequence is required on an IN operator it should be applied to the left operand,
-        // like this: "x COLLATE nocase IN (y,z, ...)".
-        return { sql: `${left} COLLATE NOCASE ${operator} ${right}`, bindings };
-    }
-    return { sql: `${left} ${operator} ${right}`, bindings };
-}
-function betweenPredicateToSql(predicate) {
-    const { sql: compareDateSql, bindings: compareBindings } = expressionToSql(predicate.compareDate);
-    const { sql: startSql, bindings: startBindings } = expressionToSql(predicate.start);
-    const { sql: endSql, bindings: endBindings } = expressionToSql(predicate.end);
-    const bindings = compareBindings.concat(startBindings).concat(endBindings);
-    return { sql: `${compareDateSql} BETWEEN ${startSql} AND ${endSql}`, bindings };
-}
-/**
- * used to make a sql statement that also checks if that field is not null
- * @param predicate
- * @returns
- */
-function comparisonIsAlsoNotNullToSql(predicate) {
-    const { sql, bindings } = predicateToSql(predicate);
-    const isNotNullPredicate = {
-        left: predicate.left,
-        operator: NullComparisonOperator.isNot,
-        type: PredicateType$1.nullComparison,
-    };
-    const { sql: notNullSql, bindings: notNullBindings } = predicateToSql(isNotNullPredicate);
-    return {
-        sql: `${sql} AND ${notNullSql}`,
-        bindings: bindings.concat(notNullBindings),
-    };
-}
-function notPredicateToSql$1(predicate) {
-    if (predicate.child === undefined) {
-        return { sql: '', bindings: [] };
-    }
-    if (isComparisonPredicate(predicate.child)) {
-        const { sql, bindings } = comparisonIsAlsoNotNullToSql(predicate.child);
-        return {
-            sql: `NOT (${sql})`,
-            bindings,
-        };
-    }
-    else if (isCompoundPredicate$1(predicate.child)) {
-        const createCompoundNots = (p) => {
-            if (isComparisonPredicate(p)) {
-                return comparisonIsAlsoNotNullToSql(p);
-            }
-            else {
-                return predicateToSql(p, true);
-            }
-        };
-        const compoundNot = predicate.child.children.map(createCompoundNots);
-        const operatorString = compoundOperatorToSql(predicate.child.operator);
-        const statementSql = compoundNot.map((v) => `(${v.sql})`).join(` ${operatorString} `);
-        const bindings = compoundNot.map((v) => v.bindings).reduce(flatten$1);
-        return { sql: `NOT ( ${statementSql} )`, bindings };
-    }
-    else {
-        const { sql, bindings } = predicateToSql(predicate.child);
-        return { sql: `NOT (${sql})`, bindings };
-    }
-}
-function nullComparisonPredicateToSql(predicate) {
-    const operator = predicate.operator === NullComparisonOperator.is ? 'IS' : 'IS NOT';
-    const { sql: leftSql, bindings } = expressionToSql(predicate.left);
-    return { sql: `${leftSql} ${operator} NULL`, bindings };
-}
-function coerceToTargetDataType(initialSql, targetDataType) {
-    if (targetDataType === 'Boolean') {
-        return `case when ${initialSql} = 1 then json('true') else json('false') end`;
-    }
-    else {
-        return initialSql;
-    }
-}
-function expressionToSql(expression, targetDataType, operator) {
-    switch (expression.type) {
-        case ValueType.Extract: {
-            // displayValue's for Booleans are special, they return null
-            if (expression.subfield === 'displayValue' && targetDataType === 'Boolean') {
-                return { sql: 'null', bindings: [] };
-            }
-            // metadata extract is somewhat different than a data extract
-            if (expression.metadata === true) {
-                let sql = `json_extract("${expression.jsonAlias}".metadata, '${pathPrefix}.${expression.field}')`;
-                if (targetDataType !== undefined) {
-                    sql = coerceToTargetDataType(sql, targetDataType);
-                }
-                return { sql, bindings: [] };
-            }
-            let path = extractPath(expression.field, expression.subfield);
-            // For multiple picklist includes/excluding filtering, we need to prefix and suffix the field value with ';'
-            // to make the match safe.
-            // sample:  field value: 'item12;item123', input value is 'item1'; they need to be converted to
-            // ';item12;item123;' and '%;item1;%' first, then do sqlite like operation.
-            let sql = operator === ComparisonOperator.includes || operator === ComparisonOperator.excludes
-                ? `'${MultiPickListValueSeparator$1}' || json_extract("${expression.jsonAlias}.JSON", '${pathPrefix}.${path}') || '${MultiPickListValueSeparator$1}'`
-                : `json_extract("${expression.jsonAlias}.JSON", '${pathPrefix}.${path}')`;
-            if (targetDataType !== undefined) {
-                sql = coerceToTargetDataType(sql, targetDataType);
-            }
-            return {
-                sql,
-                bindings: [],
-            };
-        }
-        case ValueType.BooleanLiteral:
-            // SQLite does not have a boolean type, instead use number 0 or 1
-            return { sql: '?', bindings: [expression.value.valueOf() ? 1 : 0] };
-        case ValueType.DoubleLiteral:
-        case ValueType.IntLiteral:
-            return { sql: '?', bindings: [expression.value] };
-        case ValueType.StringArray:
-            return expressionArrayToSql(expression.value, (e) => ({
-                sql: '?',
-                bindings: [e],
-            }));
-        case ValueType.NumberArray:
-            return expressionArrayToSql(expression.value, (e) => ({
-                sql: '?',
-                bindings: [e],
-            }));
-        case ValueType.NullValue:
-            return { sql: 'null', bindings: [] };
-        case ValueType.DateEnum:
-            return { sql: dateEnumToSql(expression.value), bindings: [] };
-        case ValueType.DateTimeEnum:
-            return { sql: dateTimeEnumToSql(expression.value), bindings: [] };
-        case ValueType.DateTimeArray:
-            return expressionArrayToSql(expression.value, expressionToSql);
-        case ValueType.DateArray:
-            return expressionArrayToSql(expression.value, expressionToSql);
-        case ValueType.DateRange:
-        case ValueType.DateTimeRange:
-            //not used
-            return { sql: '', bindings: [] };
-        case ValueType.RelativeDate:
-            return relativeDateToSql(expression);
-        case ValueType.DateValue:
-        case ValueType.DateTimeValue:
-            return { sql: '?', bindings: [`'${expression.value}'`] };
-        case ValueType.StringLiteral:
-            return stringLiteralToSql(expression);
-        case ValueType.MultiPicklistSet:
-            return multiPicklistToSql$1(expression, operator);
-    }
-}
-function stringLiteralToSql(string) {
-    const { safe, value } = string;
-    if (safe === true) {
-        return { sql: `'${value}'`, bindings: [] };
-    }
-    return { sql: '?', bindings: [value] };
-}
-function expressionArrayToSql(expressions, toSql) {
-    const results = expressions.map(toSql);
-    const sql = `(${results.map((v) => v.sql).join(', ')})`;
-    const bindings = results.length > 0 ? results.map((v) => v.bindings).reduce(flatten$1) : [];
-    return { sql, bindings };
-}
-function multiPicklistToSql$1({ value }, operator) {
-    // Individual multipicklist terms that delimited by semicolon are stored server-side
-    // as lexically sorted strings and treated like logical ANDs. We can approximate this
-    // behavior in SQL with wildcarded `LIKE` SQL operators.  Terms with no delimiter can
-    // be treated as string literals.  Multiple terms are logically OR'd together to
-    // match the behavior described in SOQL documentation (https://sfdc.co/c9j0r)
-    // To make sure the match is safe for includes/excludes. the value is prefix and
-    // suffix with ';', like 'abc' to '%;abc;%'.  raw value for eq and ne.
-    const sql = '?';
-    const binding = operator === ComparisonOperator.includes || operator === ComparisonOperator.excludes
-        ? `%${MultiPickListValueSeparator$1}${value}${MultiPickListValueSeparator$1}%`
-        : value;
-    return { sql, bindings: [binding] };
-}
-function relativeDateToSql(expression) {
-    const funcName = expression.hasTime ? 'datetime' : 'date';
-    switch (expression.unit) {
-        case 'month':
-            if (expression.offset === 'end') {
-                return {
-                    sql: `${funcName}('now', 'start of month', ?, '-1 day')`,
-                    bindings: [`${expression.amount + 1} months`],
-                };
-            }
-            return {
-                sql: `${funcName}('now', 'start of month', ?)`,
-                bindings: [`${expression.amount} months`],
-            };
-        case 'day':
-            return { sql: `${funcName}('now', ?)`, bindings: [`${expression.amount} days`] };
-    }
-}
-function comparisonDateLiteralToSql(leftOperand, operator, dateInput) {
-    if (dateInput.type === ValueType.DateEnum || dateInput.type === ValueType.DateTimeEnum) {
-        return {
-            sql: `${leftOperand} ${comparisonDateRightExpressionToSql(operator, dateInput.value)}`,
-            bindings: [],
-        };
-    }
-    if (dateInput.type === ValueType.DateTimeArray || dateInput.type === ValueType.DateArray) {
-        // Only discrete date could use 'in' keyword in SQL
-        if (useInOrNinOperator(dateInput)) {
-            const sectionResults = dateInput.value.map((element) => {
-                if (element.type === ValueType.DateEnum ||
-                    element.type === ValueType.DateTimeEnum) {
-                    return { sql: discreteDateEnumToSql(element.value), bindings: [] };
-                }
-                else if (element.type === ValueType.DateValue ||
-                    element.type === ValueType.DateTimeValue) {
-                    return { sql: '?', bindings: [`'${element.value}'`] };
-                }
-                return { sql: 'null', bindings: [] };
-            });
-            if (operator === 'in' || operator === 'nin') {
-                const sectionSQL = sectionResults.map((v) => v.sql).join(', ');
-                const sectionBinding = sectionResults
-                    .map((v) => v.bindings)
-                    .reduce(flatten$1);
-                const transformedOperator = operator === 'in' ? 'IN' : 'NOT IN';
-                return {
-                    sql: `${leftOperand} ${transformedOperator} (${sectionSQL})`,
-                    bindings: sectionBinding,
-                };
-            }
-            return { sql: '', bindings: [] };
-        }
-        const sectionResults = dateInput.value.map((scalerDateInput) => comparisonDateLiteralToSql(leftOperand, ComparisonOperator.eq, scalerDateInput));
-        const sectionBinding = sectionResults.map((v) => v.bindings).reduce(flatten$1);
-        if (operator === 'in') {
-            return {
-                sql: `(` + sectionResults.map((v) => v.sql).join(' or ') + `)`,
-                bindings: sectionBinding,
-            };
-        }
-        else if (operator === 'nin') {
-            return {
-                sql: `not (` + sectionResults.map((v) => v.sql).join(' or ') + `)`,
-                bindings: sectionBinding,
-            };
-        }
-    }
-    if (dateInput.type === ValueType.DateValue || dateInput.type === ValueType.DateTimeValue) {
-        const dateFunction = dateInput.type === ValueType.DateTimeValue ? 'datetime' : 'date';
-        const compOperator = comparisonOperatorToSql(operator);
-        return {
-            sql: leftOperand + ` ${compOperator} ` + `${dateFunction}(?)`,
-            bindings: [`${dateInput.value}`],
-        };
-    }
-    return { sql: '', bindings: [] };
-}
-function dateTimeEnumToSql(dateEnum) {
-    switch (dateEnum) {
-        case DateEnumType.today:
-            return `datetime('now')`;
-        case DateEnumType.tomorrow:
-            return `datetime('now', '+1 day')`;
-        // TODO [W-1109312]: apply the date filter [W-1109312]
-        default:
-            return ``;
-    }
-}
-function dateEnumToSql(dateEnum) {
-    switch (dateEnum) {
-        case DateEnumType.today:
-            return `date('now')`;
-        case DateEnumType.tomorrow:
-            return `date('now', '+1 day')`;
-        // TODO [W-1109312]: apply the date filter [W-1109312]
-        default:
-            return ``;
-    }
-}
-function compoundOperatorToSql(operator) {
-    switch (operator) {
-        case CompoundOperator.and:
-            return 'AND';
-        case CompoundOperator.or:
-            return 'OR';
-    }
-}
-
-const { isArray: isArray$4 } = Array;
-const { keys: keys$7 } = Object;
-
-function isListValueNode(node) {
-    return node.kind === 'ListValue';
-}
-function isObjectFieldSelection(node) {
-    return node !== undefined && node.kind === 'ObjectFieldSelection';
-}
-function isCustomFieldNode(node) {
-    return node !== undefined && node.kind === 'CustomFieldSelection';
-}
-function isScalarFieldNode(node) {
-    return node !== undefined && node.kind === 'ScalarFieldSelection';
-}
-function isOperationDefinition(node) {
-    return node.kind === 'OperationDefinition';
-}
-function isObjectValueNode$1(node) {
-    return node.kind === 'ObjectValue';
-}
-function is(node, kind) {
-    return node.kind === kind;
-}
-function isDefined(item) {
-    return item !== undefined;
-}
-function isCompoundOperator(value) {
-    let values = [CompoundOperator.and, CompoundOperator.or];
-    return values.includes(value);
-}
-function isScalarDataType(type) {
-    return [
-        'Boolean',
-        'String',
-        'Double',
-        'Date',
-        'DateTime',
-        'Int',
-        'WeakEtag',
-        'Picklist',
-        'Currency',
-        'MultiPicklist',
-        'Time',
-        'Phone',
-        'Url',
-        'Email',
-        'TextArea',
-        'Percent',
-        'EncryptedString',
-    ].includes(type);
-}
-
-const NotOperator = 'not';
-const { eq, ne, gt, gte, lt, lte, nin, like, includes, excludes } = ComparisonOperator;
-const inOp = ComparisonOperator.in;
-function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperator = CompoundOperator.and, joins, draftFunctions) {
-    const results = fieldValues
-        .map((value) => {
-        if (!isObjectValueNode$1(value)) {
-            return [failure([message('Parent filter node should be an object.')])];
-        }
-        return Object.entries(value.fields).map(([key, value]) => filter(key, value, joinAlias, apiName, input, joins, draftFunctions));
-    })
-        .reduce(flatten$1, []);
-    const failures = results.filter(isFailure).reduce(flatMap(errors), []);
-    if (failures.length > 0) {
-        return failure(failures);
-    }
-    const containers = results.filter(isSuccess).map(values$5);
-    const predicates = [];
-    containers.forEach((c) => {
-        if (c.predicate !== undefined) {
-            predicates.push(c.predicate);
-        }
-    });
-    // it is possible its subfields return nothing; for example the first 'CreateBy' within 'where: { CreatedBy: { CreatedBy: { Email: { eq: "xyz" } } } '
-    if (predicates.length === 0) {
-        return success({ predicate: undefined });
-    }
-    const resolvedPredicate = combinePredicates(predicates, compoundOperator);
-    return success({ predicate: resolvedPredicate });
-}
-//{where: {Field: ... | and: ... | or: ... | not: ...}}
-function recordFilter(where, joinAlias, apiName, input, joins, draftFunctions) {
-    if (where === undefined) {
-        return success(undefined);
-    }
-    // when 'recordFilter' starts, there is no 'NotPredicated'
-    return fieldsToFilters([where.value], joinAlias, apiName, input, CompoundOperator.and, joins, draftFunctions).map((result) => result.predicate === undefined || isEmptyPredicate(result.predicate) ? undefined : result);
-}
-function filter(name, value, tableAlias, apiName, input, joins, draftFunctions) {
-    if (isCompoundOperator(name)) {
-        if (!isListValueNode(value)) {
-            return failure([message(`Value for ${name} node must be a list.`)]);
-        }
-        return compoundPredicate(name, value, tableAlias, apiName, input, joins, draftFunctions);
-    }
-    if (name === NotOperator) {
-        const children = fieldsToFilters([value], tableAlias, apiName, input, CompoundOperator.and, joins, draftFunctions);
-        // take the children of a not predicate
-        // and wrap them all inside it
-        return children.flatMap((container) => {
-            if (container.predicate !== undefined) {
-                return success({
-                    predicate: {
-                        type: PredicateType$1.not,
-                        child: container.predicate,
-                    },
-                });
-            }
-            return failure([message('Unable to create not predicate.')]);
-        });
-    }
-    if (!isObjectValueNode$1(value)) {
-        return failure([message('Filter node must be an object or list.')]);
-    }
-    return fieldFilter(name, value, tableAlias, apiName, input, joins, draftFunctions);
-}
-function compoundPredicate(operator, list, joinAlias, apiName, input, joins, draftFunctions) {
-    return fieldsToFilters(list.values, joinAlias, apiName, input, operator, joins, draftFunctions);
-}
-/**
- * spans a FieldNode with its ObjectValueNode is passed. All the predicates is added into the 'join' array.
- * @param fieldInfo
- * @param fieldNode
- * @param alias
- * @param input
- * @param joins
- * @returns undefined predicate
- */
-function spanningFilter(fieldInfo, fieldNode, alias, input, joins, draftFunctions) {
-    const { apiName: fieldName, referenceToInfos, relationshipName } = fieldInfo;
-    const referenceInfo = referenceToInfos[0];
-    const jsonAlias = `${alias}.${relationshipName}`;
-    const joinPredicate = referencePredicate(alias, jsonAlias, fieldName);
-    if (referenceInfo === undefined) {
-        return failure([message(`No reference info found for ${fieldName}`)]);
-    }
-    const { apiName } = referenceInfo;
-    const conditions = [joinPredicate];
-    const join = {
-        name: jsonAlias,
-        type: 'LEFT',
-        to: alias,
-        conditions,
-    };
-    joins.push(join);
-    // moves constraint predicate to where
-    const constraintPredicates = [];
-    const filterResult = fieldsToFilters([fieldNode], jsonAlias, apiName, input, CompoundOperator.and, joins, draftFunctions);
-    if (filterResult.isSuccess === false) {
-        return filterResult;
-    }
-    filterResult.map((container) => {
-        const { predicate } = container;
-        if (predicate !== undefined) {
-            constraintPredicates.push(predicate);
-        }
-    });
-    return success({ predicate: combinePredicates(constraintPredicates, CompoundOperator.and) });
-}
-function isIDValueField$1(fieldInfo) {
-    return (fieldInfo.apiName === 'Id' ||
-        (fieldInfo.referenceToInfos !== undefined && fieldInfo.referenceToInfos.length > 0));
-}
-function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins, draftFunctions) {
-    const fieldInfoResult = getFieldInfo(apiName, fieldName, input);
-    if (fieldInfoResult.isSuccess === false) {
-        return failure([fieldInfoResult.error]);
-    }
-    const fieldInfo = fieldInfoResult.value;
-    if (fieldInfo === undefined) {
-        return failure([message(`Field ${fieldName} for type ${apiName} not found.`)]);
-    }
-    if (fieldInfo.dataType === 'Reference' && fieldInfo.relationshipName === fieldName) {
-        return spanningFilter(fieldInfo, fieldNode, alias, input, joins, draftFunctions);
-    }
-    const idProcessingNeeded = isIDValueField$1(fieldInfo);
-    const extract = {
-        type: ValueType.Extract,
-        jsonAlias: alias,
-        field: fieldName,
-    };
-    const dateFunction = dateFunctions(fieldNode, extract, fieldInfo.dataType);
-    //It's possible for a field to have more than one comparison operator which
-    //should combine into compound predicate with 'and'
-    const operators = fieldOperators(fieldNode, fieldInfo.dataType);
-    if (dateFunction.isSuccess === false) {
-        return failure(dateFunction.error);
-    }
-    if (operators.isSuccess === false) {
-        return failure(operators.error);
-    }
-    let comparisons = operators.value.map((op) => {
-        if (op.type === 'NullOperator') {
-            return { type: PredicateType$1.nullComparison, left: extract, operator: op.operator };
-        }
-        if (op.type === 'DateOperator' && op.value.type === ValueType.DateRange) {
-            return dateRangeComparison(op.value, op.operator, extract);
-        }
-        if (op.type === 'DateTimeOperator' && op.value.type === ValueType.DateTimeRange) {
-            return dateRangeComparison(op.value, op.operator, extract);
-        }
-        if (op.type === 'MultiPicklistSetOperator') {
-            const operator = op.operator === ComparisonOperator.includes
-                ? CompoundOperator.or
-                : CompoundOperator.and;
-            const children = [];
-            const length = op.value.value.length;
-            for (let i = 0; i < length; i++) {
-                const term = op.value.value[i];
-                if (term !== null) {
-                    const splittedValue = term
-                        .split(MultiPickListValueSeparator$1)
-                        .map((v) => v.trim())
-                        .filter((v) => v.length > 0);
-                    if (splittedValue.length === 1) {
-                        children.push(comparison(extract, op.operator, {
-                            type: ValueType.MultiPicklistSet,
-                            value: term,
-                        }));
-                    }
-                    else {
-                        children.push({
-                            type: PredicateType$1.compound,
-                            operator: op.operator === ComparisonOperator.includes
-                                ? CompoundOperator.and
-                                : CompoundOperator.or,
-                            children: splittedValue.map((singleValue) => {
-                                return comparison(extract, op.operator, {
-                                    type: ValueType.MultiPicklistSet,
-                                    value: singleValue,
-                                });
-                            }),
-                        });
-                    }
-                }
-            }
-            return {
-                type: PredicateType$1.compound,
-                operator,
-                children,
-            };
-        }
-        if (op.type === 'StringSetOperator' && op.value.value.includes(null)) {
-            const children = [
-                {
-                    type: PredicateType$1.nullComparison,
-                    left: extract,
-                    operator: op.operator === 'in'
-                        ? NullComparisonOperator.is
-                        : NullComparisonOperator.isNot,
-                },
-            ];
-            if (op.value.value.length > 1) {
-                children.push(comparison(extract, op.operator, {
-                    type: ValueType.StringArray,
-                    safe: false,
-                    isCaseSensitive: false,
-                    value: op.value.value.filter((val) => val !== null),
-                }));
-            }
-            return {
-                type: PredicateType$1.compound,
-                operator: op.operator === 'in' ? CompoundOperator.or : CompoundOperator.and,
-                children,
-            };
-        }
-        const rightOperand = op.value;
-        if (idProcessingNeeded) {
-            if (isStringLiteral(rightOperand)) {
-                if (rightOperand.value !== null) {
-                    if (draftFunctions.isDraftId(rightOperand.value)) {
-                        rightOperand.value = draftFunctions.getCanonicalId(rightOperand.value);
-                    }
-                }
-            }
-            else if (isStringArray(rightOperand)) {
-                if (rightOperand.value !== null) {
-                    rightOperand.value = rightOperand.value.map((originalId) => {
-                        if (originalId !== null) {
-                            if (draftFunctions.isDraftId(originalId)) {
-                                return draftFunctions.getCanonicalId(originalId);
-                            }
-                        }
-                        return originalId;
-                    });
-                }
-            }
-        }
-        return comparison(extract, op.operator, rightOperand);
-    });
-    const combined = combinePredicates(comparisons.concat(...dateFunction.value), CompoundOperator.and);
-    const container = {
-        predicate: combined,
-    };
-    return success(container);
-}
-function dateRangeComparison(dateRange, operator, compareDate) {
-    switch (operator) {
-        case eq:
-            return {
-                type: PredicateType$1.between,
-                compareDate,
-                start: dateRange.start,
-                end: dateRange.end,
-            };
-        case ne:
-            return {
-                type: PredicateType$1.not,
-                child: {
-                    type: PredicateType$1.between,
-                    compareDate,
-                    start: dateRange.start,
-                    end: dateRange.end,
-                },
-            };
-        case lt:
-            return comparison(compareDate, lt, dateRange.start);
-        case lte:
-            return comparison(compareDate, lte, dateRange.end);
-        case gt:
-            return comparison(compareDate, gt, dateRange.end);
-        case gte:
-            return comparison(compareDate, gte, dateRange.start);
-    }
-}
-function dateFunctions(operatorNode, extract, dataType) {
-    if (dataType !== 'Date' && dataType !== 'DateTime') {
-        return success([]);
-    }
-    const results = Object.entries(operatorNode.fields).map(([key, valueNode]) => {
-        if (isFilterFunction(key) === false) {
-            return success([]);
-        }
-        if (!isObjectValueNode$1(valueNode)) {
-            return failure([message('Date function expects an object node.')]);
-        }
-        const [opKey, opValue] = Object.entries(valueNode.fields)[0];
-        const result = operatorWithValue(opKey, opValue, 'Int')
-            .flatMap((op) => {
-            if (op.type !== 'IntOperator') {
-                return failure([message('Date function expects Int values')]);
-            }
-            const predicate = {
-                type: PredicateType$1.dateFunction,
-                operator: op.operator,
-                function: DateFunction.dayOfMonth,
-                value: op.value.value,
-                extract,
-            };
-            return success(predicate);
-        })
-            .map((r) => [r]);
-        return result;
-    });
-    const fails = results.filter(isFailure).reduce(flatMap(errors), []);
-    if (fails.length > 0) {
-        return failure(fails);
-    }
-    const vals = results.filter(isSuccess).reduce(flatMap(values$5), []);
-    return success(vals);
-}
-function isFilterFunction(name) {
-    return name === 'DAY_OF_MONTH';
-}
-function fieldOperators(operatorNode, dataType) {
-    const results = Object.entries(operatorNode.fields)
-        .filter(([key, _]) => isFilterFunction(key) === false)
-        .map(([key, value]) => operatorWithValue(key, value, dataType));
-    const _values = results.filter(isSuccess).map(values$5);
-    const fails = results.filter(isFailure).reduce(flatMap(errors), []);
-    if (fails.length > 0) {
-        return failure(fails);
-    }
-    return success(_values);
-}
-function isSetOperatorType(value) {
-    let values = [inOp, nin];
-    return values.includes(value);
-}
-function isMultiPicklistSetOperatorType(value) {
-    let values = [excludes, includes];
-    return values.includes(value);
-}
-function isScalarOperatorType(value) {
-    let values = [eq, ne, lt, gt, lte, gte];
-    return values.includes(value);
-}
-function isBooleanOperatorType(value) {
-    return value === eq || value === ne;
-}
-function nullOperatorTypeFrom(value) {
-    switch (value) {
-        case eq:
-            return NullComparisonOperator.is;
-        case ne:
-            return NullComparisonOperator.isNot;
-    }
-}
-function isStringOperatorType(value) {
-    return isScalarOperatorType(value) || value === like;
-}
-function isPicklistOperatorType(value) {
-    let values = [eq, ne, like, lt, gt, lte, gte];
-    return values.includes(value);
-}
-function isCurrencyOperatorType(value) {
-    return isScalarOperatorType(value);
-}
-function isMultiPicklistOperatorType(value) {
-    let values = [eq, ne];
-    return values.includes(value);
-}
-function listNodeToTypeArray(list, kind) {
-    const typeAssert = (node) => is(node, kind);
-    const badValue = list.values.filter((n) => !typeAssert(n))[0];
-    if (badValue !== undefined) {
-        return failure(message(`${JSON.stringify(badValue)} is not a valid value in list of ${kind}.`));
-    }
-    const values = list.values.filter(typeAssert).map((u) => u.value);
-    return success(values);
-}
-function operatorWithValue(operator, valueNode, objectInfoDataType) {
-    if (is(valueNode, 'NullValue')) {
-        return parseNullValue(operator).mapError((e) => [e]);
-    }
-    if (['String', 'Reference', 'Phone', 'Url', 'Email', 'TextArea'].includes(objectInfoDataType)) {
-        if (isStringOperatorType(operator)) {
-            return is(valueNode, 'StringValue')
-                ? success({
-                    type: `StringOperator`,
-                    operator,
-                    value: stringLiteral(valueNode.value),
-                })
-                : failure([message(`Comparison value must be a ${objectInfoDataType}.`)]);
-        }
-        if (isSetOperatorType(operator)) {
-            if (!is(valueNode, 'ListValue')) {
-                return failure([
-                    message(`Comparison value must be a ${objectInfoDataType} array.`),
-                ]);
-            }
-            const listValues = [];
-            for (const node of valueNode.values) {
-                switch (node.kind) {
-                    case 'NullValue':
-                        listValues.push(null);
-                        break;
-                    case 'StringValue':
-                        listValues.push(node.value);
-                        break;
-                    default:
-                        continue;
-                }
-            }
-            return success({
-                operator,
-                type: 'StringSetOperator',
-                value: {
-                    type: ValueType.StringArray,
-                    value: listValues,
-                    safe: false,
-                    isCaseSensitive: false,
-                },
-            });
-        }
-    }
-    if (objectInfoDataType === 'Int') {
-        if (isScalarOperatorType(operator)) {
-            return is(valueNode, 'IntValue')
-                ? success({
-                    type: 'IntOperator',
-                    operator,
-                    value: { type: ValueType.IntLiteral, value: parseInt(valueNode.value) },
-                })
-                : failure([message(`Comparison value must be an int.`)]);
-        }
-        if (isSetOperatorType(operator)) {
-            return is(valueNode, 'ListValue')
-                ? listNodeToTypeArray(valueNode, 'IntValue')
-                    .map((strings) => {
-                    return {
-                        operator,
-                        type: 'IntSetOperator',
-                        value: {
-                            type: ValueType.NumberArray,
-                            value: strings.map((s) => parseInt(s)),
-                        },
-                    };
-                })
-                    .mapError((e) => [e])
-                : failure([message(`Comparison value must be an int array.`)]);
-        }
-    }
-    if (objectInfoDataType === 'Double') {
-        if (isScalarOperatorType(operator)) {
-            // allow a float/double value to be passed
-            // also allow an integer to be passed to a double, but not a double to an integer
-            const isFloatOrInt = is(valueNode, 'FloatValue') ||
-                is(valueNode, 'IntValue');
-            return isFloatOrInt
-                ? success({
-                    type: 'DoubleOperator',
-                    operator,
-                    value: { type: ValueType.DoubleLiteral, value: parseFloat(valueNode.value) },
-                })
-                : failure([message(`Comparison value must be a double.`)]);
-        }
-        if (isSetOperatorType(operator)) {
-            return is(valueNode, 'ListValue')
-                ? listNodeToTypeArray(valueNode, 'FloatValue')
-                    .map((strings) => {
-                    return {
-                        operator,
-                        type: 'DoubleSetOperator',
-                        value: {
-                            type: ValueType.NumberArray,
-                            value: strings.map(parseFloat),
-                        },
-                    };
-                })
-                    .mapError((e) => [e])
-                : failure([message(`Comparison value must be a double array.`)]);
-        }
-    }
-    if (objectInfoDataType === 'Percent') {
-        if (isScalarOperatorType(operator)) {
-            // Percents are documented as being Double-like, but in practice the UIAPI GraphQL
-            // API will accent Integer (50) and Float (50.0) inputs and treat them equally
-            const isPercentLike = (is(valueNode, 'FloatValue') ||
-                is(valueNode, 'IntValue')) &&
-                !isNaN(parseFloat(valueNode.value));
-            if (isPercentLike) {
-                return success({
-                    type: 'DoubleOperator',
-                    operator,
-                    value: { type: ValueType.DoubleLiteral, value: parseFloat(valueNode.value) },
-                });
-            }
-            else {
-                return failure([message(`Comparison value must be a ${objectInfoDataType}.`)]);
-            }
-        }
-        if (isSetOperatorType(operator)) {
-            if (is(valueNode, 'ListValue')) {
-                const typeErrors = [];
-                const values = [];
-                for (const node of valueNode.values) {
-                    if (is(node, 'FloatValue') ||
-                        is(node, 'IntValue')) {
-                        values.push(parseFloat(node.value));
-                    }
-                    else {
-                        typeErrors.push(message(`Comparison value must be a ${objectInfoDataType} array.`));
-                    }
-                }
-                if (typeErrors.length) {
-                    return failure(typeErrors);
-                }
-                return success({
-                    operator,
-                    type: 'DoubleSetOperator',
-                    value: {
-                        type: ValueType.NumberArray,
-                        value: values,
-                    },
-                });
-            }
-            else {
-                return failure([
-                    message(`Comparison value must be a ${objectInfoDataType} array.`),
-                ]);
-            }
-        }
-    }
-    if (objectInfoDataType === 'Boolean') {
-        if (isBooleanOperatorType(operator)) {
-            return is(valueNode, 'BooleanValue')
-                ? success({
-                    type: 'BooleanOperator',
-                    operator,
-                    value: { type: ValueType.BooleanLiteral, value: valueNode.value },
-                })
-                : failure([message(`Comparison value must be a boolean.`)]);
-        }
-    }
-    if (objectInfoDataType === 'Date') {
-        if (isScalarOperatorType(operator)) {
-            const result = dateInput(valueNode).mapError((e) => [e]);
-            if (result.isSuccess === false) {
-                return failure(result.error);
-            }
-            const { value: input } = result;
-            if (input.type === ValueType.NullValue) {
-                return parseNullValue(operator).mapError((e) => [e]);
-            }
-            return success({ type: 'DateOperator', operator, value: input });
-        }
-        if (isSetOperatorType(operator)) {
-            if (is(valueNode, 'ListValue')) {
-                return flattenResults(valueNode.values.map(dateInput)).map((value) => {
-                    return {
-                        type: 'DateSetOperator',
-                        operator,
-                        value: { type: ValueType.DateArray, value },
-                    };
-                });
-            }
-            return failure([message('Comparison value must be a date array.')]);
-        }
-    }
-    if (objectInfoDataType === 'DateTime') {
-        if (isScalarOperatorType(operator)) {
-            const result = dateTimeInput(valueNode).mapError((e) => [e]);
-            if (result.isSuccess === false) {
-                return failure(result.error);
-            }
-            const { value: input } = result;
-            if (input.type === ValueType.NullValue) {
-                return parseNullValue(operator).mapError((e) => [e]);
-            }
-            return success({ type: 'DateTimeOperator', operator, value: input });
-        }
-        if (isSetOperatorType(operator)) {
-            if (is(valueNode, 'ListValue')) {
-                return flattenResults(valueNode.values.map(dateTimeInput)).map((value) => {
-                    return {
-                        type: 'DateTimeSetOperator',
-                        operator,
-                        value: { type: ValueType.DateTimeArray, value },
-                    };
-                });
-            }
-            return failure([message('Comparison value must be a date time array.')]);
-        }
-    }
-    if (objectInfoDataType === 'Picklist') {
-        if (isPicklistOperatorType(operator)) {
-            return is(valueNode, 'StringValue')
-                ? success({
-                    type: 'PicklistOperator',
-                    operator,
-                    value: stringLiteral(valueNode.value),
-                })
-                : failure([message(`Comparison value must be a Picklist.`)]);
-        }
-        if (isSetOperatorType(operator)) {
-            return is(valueNode, 'ListValue')
-                ? listNodeToTypeArray(valueNode, 'StringValue')
-                    .map((value) => {
-                    return {
-                        operator,
-                        type: 'PicklistSetOperator',
-                        value: {
-                            type: ValueType.StringArray,
-                            value,
-                            safe: false,
-                            isCaseSensitive: false,
-                        },
-                    };
-                })
-                    .mapError((e) => [e])
-                : failure([message(`Comparison value must be a Picklist array.`)]);
-        }
-    }
-    if (objectInfoDataType === 'Currency') {
-        if (isCurrencyOperatorType(operator)) {
-            return is(valueNode, 'FloatValue')
-                ? success({
-                    type: 'CurrencyOperator',
-                    operator,
-                    value: { type: ValueType.DoubleLiteral, value: parseFloat(valueNode.value) },
-                })
-                : failure([message(`Comparison value must be a Currency.`)]);
-        }
-        if (isSetOperatorType(operator)) {
-            return is(valueNode, 'ListValue')
-                ? listNodeToTypeArray(valueNode, 'FloatValue')
-                    .map((strings) => {
-                    return {
-                        operator,
-                        type: 'CurrencySetOperator',
-                        value: {
-                            type: ValueType.NumberArray,
-                            value: strings.map(parseFloat),
-                        },
-                    };
-                })
-                    .mapError((e) => [e])
-                : failure([message(`Comparison value must be a Currency array.`)]);
-        }
-    }
-    if (objectInfoDataType === 'MultiPicklist') {
-        if (isMultiPicklistOperatorType(operator)) {
-            if (is(valueNode, 'StringValue')) {
-                // The raw value could be ';;a; b;;', clean it up to 'a;b'
-                const welformatedValue = valueNode.value
-                    .split(MultiPickListValueSeparator$1)
-                    .map((v) => v.trim())
-                    .filter((v) => v.length > 0)
-                    .join(MultiPickListValueSeparator$1);
-                return success({
-                    type: 'MultiPicklistOperator',
-                    operator,
-                    value: stringLiteral(welformatedValue),
-                });
-            }
-            return failure([message(`Comparison value must be a MultiPicklist`)]);
-        }
-        if (isMultiPicklistSetOperatorType(operator)) {
-            if (is(valueNode, 'ListValue')) {
-                return listNodeToTypeArray(valueNode, 'StringValue')
-                    .map((val) => {
-                    return {
-                        operator,
-                        type: 'MultiPicklistSetOperator',
-                        value: {
-                            type: ValueType.StringArray,
-                            value: val,
-                            safe: false,
-                            isCaseSensitive: true,
-                        },
-                    };
-                })
-                    .mapError((e) => [e]);
-            }
-            else {
-                return failure([message(`Comparison value must be a MultiPicklist array.`)]);
-            }
-        }
-    }
-    if (objectInfoDataType === 'Time') {
-        if (isScalarOperatorType(operator)) {
-            return is(valueNode, 'StringValue')
-                ? success({
-                    type: 'TimeOperator',
-                    operator,
-                    value: stringLiteral(valueNode.value),
-                })
-                : failure([message(`Comparison value must be a Time`)]);
-        }
-        if (isSetOperatorType(operator)) {
-            return is(valueNode, 'ListValue')
-                ? listNodeToTypeArray(valueNode, 'StringValue')
-                    .map((value) => {
-                    return {
-                        operator,
-                        type: 'TimeSetOperator',
-                        value: {
-                            type: ValueType.StringArray,
-                            value,
-                            isCaseSensitive: true,
-                            safe: false,
-                        },
-                    };
-                })
-                    .mapError((e) => [e])
-                : failure([message(`Comparison value must be a Time array.`)]);
-        }
-    }
-    return failure([
-        message(`Comparison operator ${operator} is not supported for type ${objectInfoDataType}.`),
-    ]);
-}
-function isValidDate(value) {
-    return isNaN(Date.parse(value)) === false;
-}
-function dateInput(node) {
-    return parseDateNode(node, false, 'YYYY-MM-DD', isValidDate).map((result) => {
-        switch (result.type) {
-            case ValueType.NullValue:
-                return result;
-            case ValueType.StringLiteral:
-                return { type: ValueType.DateValue, value: result.value };
-            case 'range':
-                return { type: ValueType.DateRange, start: result.start, end: result.end };
-            case 'enum':
-                return { type: ValueType.DateEnum, value: result.value };
-        }
-    });
-}
-function dateTimeInput(node) {
-    return parseDateNode(node, true, 'YYYY-MM-DDTHH:MM:SS.SSSZ, YYYY-MM-DDTHH:MM:SSZ, YYYY-MM-DDTHH:MM:SS.SSS+|-HH:MM, or YYYY-MM-DDTHH:MM:SS+|-HH:MM', isValidDate).map((result) => {
-        switch (result.type) {
-            case ValueType.NullValue:
-                return result;
-            case ValueType.StringLiteral: {
-                let dateString = result.value;
-                if (dateString !== null && dateString.indexOf('.') === -1) {
-                    dateString = dateString.substring(0, dateString.length - 1) + '.000Z';
-                }
-                return { type: ValueType.DateTimeValue, value: dateString };
-            }
-            case 'range':
-                return { type: ValueType.DateTimeRange, start: result.start, end: result.end };
-            case 'enum':
-                return { type: ValueType.DateTimeEnum, value: result.value };
-        }
-    });
-}
-function parseNullValue(op) {
-    const operator = nullOperatorTypeFrom(op);
-    if (operator !== undefined) {
-        return success({ type: 'NullOperator', operator });
-    }
-    return failure(message(`Null can not be compared with ${op}`));
-}
-function parseDateNode(node, hasTime, dateFormat, isValidDate) {
-    const typeName = hasTime ? 'DateTime' : 'Date';
-    if (!isObjectValueNode$1(node)) {
-        return failure(message(`Comparison value must be a ${typeName} input.`));
-    }
-    const valueField = node.fields.value;
-    if (valueField !== undefined) {
-        if (is(valueField, 'StringValue')) {
-            // check the date is valid
-            // then make sure if it isnt suppose to contain time stamps that it doesnt
-            // and if it should have a timestamp it should contain it
-            const includesTimeStamp = valueField.value.includes('T');
-            if (isValidDate(valueField.value) &&
-                ((hasTime && includesTimeStamp) || (!hasTime && !includesTimeStamp))) {
-                return success(stringLiteral(valueField.value));
-            }
-            return failure(message(`${typeName} format must be ${dateFormat}.`));
-        }
-        if (is(valueField, 'NullValue')) {
-            return success({ type: ValueType.NullValue });
-        }
-        return failure(message(`${typeName} input value field must be a string.`));
-    }
-    const literalField = node.fields['literal'];
-    if (literalField !== undefined) {
-        if (is(literalField, 'EnumValue')) {
-            switch (literalField.value) {
-                case 'TODAY':
-                    return success({ type: 'enum', value: DateEnumType.today });
-                case 'TOMORROW':
-                    return success({ type: 'enum', value: DateEnumType.tomorrow });
-                case 'YESTERDAY':
-                    return success({ type: 'enum', value: DateEnumType.yesterday });
-                case 'LAST_WEEK':
-                    return success({ type: 'enum', value: DateEnumType.last_week });
-                case 'THIS_WEEK':
-                    return success({ type: 'enum', value: DateEnumType.this_week });
-                case 'NEXT_WEEK':
-                    return success({ type: 'enum', value: DateEnumType.next_week });
-                case 'LAST_MONTH':
-                    return success({ type: 'enum', value: DateEnumType.last_month });
-                case 'THIS_MONTH':
-                    return success({ type: 'enum', value: DateEnumType.this_month });
-                case 'NEXT_MONTH':
-                    return success({ type: 'enum', value: DateEnumType.next_month });
-                case 'LAST_90_DAYS':
-                    return success({ type: 'enum', value: DateEnumType.last_90_days });
-                case 'NEXT_90_DAYS':
-                    return success({ type: 'enum', value: DateEnumType.next_90_days });
-                case 'LAST_QUARTER':
-                    return success({ type: 'enum', value: DateEnumType.last_quarter });
-                case 'THIS_QUARTER':
-                    return success({ type: 'enum', value: DateEnumType.this_quarter });
-                case 'NEXT_QUARTER':
-                    return success({ type: 'enum', value: DateEnumType.next_quarter });
-                case 'LAST_YEAR':
-                    return success({ type: 'enum', value: DateEnumType.last_year });
-                case 'THIS_YEAR':
-                    return success({ type: 'enum', value: DateEnumType.this_year });
-                case 'NEXT_YEAR':
-                    return success({ type: 'enum', value: DateEnumType.next_year });
-                default:
-                    return failure(message(`Unknown ${typeName} literal ${literalField.value}.`));
-            }
-        }
-        return failure(message(`${typeName} input literal field must be an enum.`));
-    }
-    const rangeField = node.fields['range'];
-    if (rangeField !== undefined) {
-        if (is(rangeField, 'ObjectValue')) {
-            const fieldsField = rangeField.fields;
-            const last_n_months = fieldsField['last_n_months'];
-            if (last_n_months !== undefined) {
-                if (is(last_n_months, 'IntValue')) {
-                    const amount = -parseInt(last_n_months.value);
-                    const start = {
-                        type: ValueType.RelativeDate,
-                        unit: 'month',
-                        amount,
-                        offset: 'start',
-                        hasTime,
-                    };
-                    const end = {
-                        type: ValueType.RelativeDate,
-                        unit: 'month',
-                        amount: -1,
-                        offset: 'end',
-                        hasTime,
-                    };
-                    return success({ type: 'range', start, end });
-                }
-            }
-            const next_n_months = fieldsField['next_n_months'];
-            if (next_n_months !== undefined) {
-                if (is(next_n_months, 'IntValue')) {
-                    const amount = parseInt(next_n_months.value);
-                    const start = {
-                        type: ValueType.RelativeDate,
-                        unit: 'month',
-                        amount: 1,
-                        offset: 'start',
-                        hasTime,
-                    };
-                    const end = {
-                        type: ValueType.RelativeDate,
-                        unit: 'month',
-                        amount,
-                        offset: 'end',
-                        hasTime,
-                    };
-                    return success({ type: 'range', start, end });
-                }
-            }
-            const last_n_days = fieldsField['last_n_days'];
-            if (last_n_days !== undefined) {
-                if (is(last_n_days, 'IntValue')) {
-                    const amount = -parseInt(last_n_days.value);
-                    const start = {
-                        type: ValueType.RelativeDate,
-                        unit: 'day',
-                        amount,
-                        offset: undefined,
-                        hasTime,
-                    };
-                    const end = {
-                        type: ValueType.RelativeDate,
-                        unit: 'day',
-                        amount: 0,
-                        offset: undefined,
-                        hasTime,
-                    };
-                    return success({ type: 'range', start, end });
-                }
-            }
-            const next_n_days = fieldsField['next_n_days'];
-            if (next_n_days !== undefined) {
-                if (is(next_n_days, 'IntValue')) {
-                    const amount = parseInt(next_n_days.value);
-                    const start = {
-                        type: ValueType.RelativeDate,
-                        unit: 'day',
-                        amount: 1,
-                        offset: undefined,
-                        hasTime,
-                    };
-                    const end = {
-                        type: ValueType.RelativeDate,
-                        unit: 'day',
-                        amount,
-                        offset: undefined,
-                        hasTime,
-                    };
-                    return success({ type: 'range', start, end });
-                }
-            }
-            return failure(message(`invalid date range name`));
-        }
-        return failure(message(`${typeName} range must be an object.`));
-    }
-    return failure(message(`${typeName} input must include a value or literal field.`));
-}
-
-function fieldsToOrderBy(fieldValues, joinAlias, apiName, input, joins) {
-    const [node] = fieldValues;
-    if (!isObjectValueNode$1(node)) {
-        return failure([
-            message('Parent OrderBy node should be an object.'),
-        ]);
-    }
-    const orderByContainers = [];
-    const errors = [];
-    const orderByResults = Object.entries(node.fields).map(([key, value]) => orderBy(key, value, joinAlias, apiName, input, joins));
-    for (const result of orderByResults) {
-        if (isSuccess(result)) {
-            orderByContainers.push(result.value);
-        }
-        else {
-            errors.push(result.error);
-        }
-    }
-    if (errors.length) {
-        return failure(errors);
-    }
-    return success(orderByContainers);
-}
-function orderBy(name, value, tableAlias, apiName, input, joins) {
-    if (!isObjectValueNode$1(value)) {
-        return failure(message('OrderBy node must be an object.'));
-    }
-    return fieldsOrderBy(name, value, tableAlias, apiName, input, joins);
-}
-function spanningOrderBy(fieldInfo, fieldNode, alias, input, joins) {
-    const { apiName: fieldName, referenceToInfos, relationshipName } = fieldInfo;
-    const referenceInfo = referenceToInfos[0];
-    const jsonAlias = `${alias}.${relationshipName}`;
-    const joinPredicate = referencePredicate(alias, jsonAlias, fieldName);
-    if (referenceInfo === undefined) {
-        return failure(message(`No reference info found for ${fieldName}`));
-    }
-    const { apiName } = referenceInfo;
-    const join = {
-        name: jsonAlias,
-        to: alias,
-        type: 'LEFT',
-        conditions: [joinPredicate],
-    };
-    joins.push(join);
-    const result = fieldsToOrderBy([fieldNode], jsonAlias, apiName, input, joins);
-    if (!result.isSuccess) {
-        return failure(result.error[0]);
-    }
-    const [container] = result.value;
-    const { orderBy } = container;
-    return success({ orderBy });
-}
-function fieldsOrderBy(fieldName, fieldNode, alias, apiName, input, joins) {
-    const fieldInfoResult = getFieldInfo(apiName, fieldName, input);
-    if (fieldInfoResult.isSuccess === false) {
-        return failure(fieldInfoResult.error);
-    }
-    const fieldInfo = fieldInfoResult.value;
-    if (fieldInfo === undefined) {
-        return failure(message(`Field ${fieldName} for type ${apiName} not found.`));
-    }
-    if (fieldInfo.dataType === 'Reference' && fieldInfo.relationshipName === fieldName) {
-        return spanningOrderBy(fieldInfo, fieldNode, alias, input, joins);
-    }
-    const result = orderByDetails(fieldNode, alias, fieldName);
-    if (!result.isSuccess) {
-        return failure(result.error);
-    }
-    return success({ orderBy: result.value });
-}
-function orderByDetails(fieldNode, jsonAlias, path) {
-    const extract = { type: ValueType.Extract, jsonAlias, field: path };
-    const orderField = fieldNode.fields['order'];
-    const nullsField = fieldNode.fields['nulls'];
-    const asc = isAsc(orderField);
-    const nulls = nullsFirst(nullsField);
-    if (asc.isSuccess === false) {
-        return failure(asc.error);
-    }
-    if (nulls.isSuccess === false) {
-        return failure(nulls.error);
-    }
-    return success({ asc: asc.value, extract, nullsFirst: nulls.value });
-}
-function isAsc(field) {
-    if (field !== undefined) {
-        if (is(field, 'EnumValue')) {
-            switch (field.value) {
-                case 'ASC':
-                    return success(true);
-                case 'DESC':
-                    return success(false);
-                default:
-                    return failure(message(`Unknown order enum ${field.value}.`));
-            }
-        }
-        return failure(message(`OrderBy order field must be an enum.`));
-    }
-    return success(true);
-}
-function nullsFirst(field) {
-    if (field !== undefined) {
-        if (is(field, 'EnumValue')) {
-            switch (field.value) {
-                case 'FIRST':
-                    return success(true);
-                case 'LAST':
-                    return success(false);
-                default:
-                    return failure(message(`Unknown nulls enum ${field.value}.`));
-            }
-        }
-        return failure(message(`OrderBy nulls field must be an enum.`));
-    }
-    return success(false);
-}
-function parseOrderBy(orderByArg, joinAlias, apiName, input, joins) {
-    if (orderByArg === undefined) {
-        return success([]);
-    }
-    return fieldsToOrderBy([orderByArg.value], joinAlias, apiName, input, joins);
-}
-
-function scopeFilter(scopeArg, jsonAlias, apiName, input, joins) {
-    if (scopeArg === undefined) {
-        return success(undefined);
-    }
-    const value = scopeArg.value;
-    if (value.kind !== 'EnumValue') {
-        return failure(message('Scope type should be an EnumValueNode.'));
-    }
-    const scope = value.value;
-    if (scope === 'MINE') {
-        const fieldInfoResult = getFieldInfo(apiName, 'OwnerId', input.objectInfoMap);
-        if (fieldInfoResult.isSuccess === false) {
-            return failure(fieldInfoResult.error);
-        }
-        const fieldInfo = fieldInfoResult.value;
-        if (fieldInfo === undefined) {
-            return failure(message('Scope MINE requires the entity type to have an OwnerId field.'));
-        }
-        return success({
-            type: PredicateType$1.comparison,
-            left: {
-                type: ValueType.Extract,
-                jsonAlias,
-                field: fieldInfo.apiName,
-            },
-            operator: ComparisonOperator.eq,
-            right: stringLiteral(input.userId),
-        });
-    }
-    if (scope === 'ASSIGNEDTOME') {
-        if (apiName !== 'ServiceAppointment') {
-            return failure(message('ASSIGNEDTOME can only be used with ServiceAppointment'));
-        }
-        return success(assignedToMe(input, jsonAlias, joins));
-    }
-    return failure(message(`Scope '${scope} is not supported.`));
-}
-/**
- * generates predicates and joins for 'assignToMe' scope
- * @param input
- * @param parentAlias it would be 'ServiceAppointment' if scope belongs to a top level record query.
- * @param joins it would be populated with joins
- * @returns a compound predicates which contains its api type predicates.
- */
-function assignedToMe(input, parentAlias, joins) {
-    const srApiName = 'ServiceResource';
-    const arApiName = 'AssignedResource';
-    const assignedResourceAlias = `${parentAlias}.${arApiName}`;
-    const serviceResourceAlias = `${assignedResourceAlias}.${srApiName}`;
-    const serviceAppointmentIdPredicate = comparison({
-        type: ValueType.Extract,
-        jsonAlias: assignedResourceAlias,
-        field: 'ServiceAppointmentId',
-    }, ComparisonOperator.eq, { type: ValueType.Extract, jsonAlias: parentAlias, field: 'Id' });
-    // Uses 'inner join' instead of 'left join', otherwise the query plan tries to scan 'lds_data' table, which might be due to the fact that 'AssignedResource is child of both 'ServiceAppointment' and
-    // 'ServiceResource'. It is fine to use like this since its sole purpose is to identify the 'ServiceAppointment'. It won't have the missing result behavior
-    // since alias 'ServiceAppointment.AssignedResource' and 'ServiceAppointment.AssignedResource.ServiceResource' are crafted in the way that they will not collide with any other relationship.
-    const assignedResourceToServiceAppointmentJoin = {
-        name: assignedResourceAlias,
-        to: parentAlias,
-        conditions: [serviceAppointmentIdPredicate],
-        type: 'INNER',
-    };
-    joins.push(assignedResourceToServiceAppointmentJoin);
-    const serviceResourceIdPredicate = comparison({ type: ValueType.Extract, jsonAlias: assignedResourceAlias, field: 'ServiceResourceId' }, ComparisonOperator.eq, { type: ValueType.Extract, jsonAlias: serviceResourceAlias, field: 'Id' });
-    const serviceResourceToAssignedResourceJoin = {
-        name: serviceResourceAlias,
-        to: assignedResourceAlias,
-        conditions: [serviceResourceIdPredicate],
-        type: 'INNER',
-    };
-    joins.push(serviceResourceToAssignedResourceJoin);
-    const userIdPredicate = comparison({ type: ValueType.Extract, jsonAlias: serviceResourceAlias, field: 'RelatedRecordId' }, ComparisonOperator.eq, stringLiteral(input.userId));
-    return userIdPredicate;
-}
-
-const REFERENCE_NAME_KEY = 'Reference';
-const API_NAME_KEY = 'ApiName';
-const { Extract } = ValueType;
-function isSpanningField(value) {
-    return value.type === FieldType.Spanning;
-}
-function luvioSelections(node) {
-    return node.luvioSelections === undefined ? [] : node.luvioSelections;
-}
-function hasArguments(node) {
-    return node.arguments !== undefined;
-}
-function named(name) {
-    return (node) => node.name === name;
-}
-function spanningField(node, fieldInfo, names, parentAlias, input, joins) {
-    const parentQuery = spanningRecordQuery(node, fieldInfo, names, parentAlias, input, joins);
-    if (parentQuery.isSuccess === false) {
-        return failure(parentQuery.error);
-    }
-    const field = {
-        type: FieldType.Spanning,
-        path: '',
-        spanning: parentQuery.value,
-    };
-    return success(field);
-}
-function scalarField(node, names, jsonAlias, targetDataType) {
-    const outputNames = names.concat(node.name);
-    return [node]
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isScalarFieldNode)
-        .map((field) => {
-        const outputPath = outputNames.concat(field.name).join('.');
-        const extract = {
-            type: Extract,
-            jsonAlias,
-            field: node.name,
-            subfield: field.name,
-        };
-        return { type: FieldType.Scalar, extract, path: outputPath, targetDataType };
-    });
-}
-function selectionToQueryField(node, names, parentApiName, parentAlias, input, joins) {
-    if (!isObjectFieldSelection(node) && !isCustomFieldNode(node) && !isScalarFieldNode(node)) {
-        return failure([message(`Node type ${node.kind} is not a valid record field type.`)]);
-    }
-    // The following graphql fields are root properties on the record representation, rather
-    // than fields found in the `fields` bag, so they need special handling.
-    const rootPropertyFields = ['ApiName', 'Id', 'WeakEtag'];
-    if (rootPropertyFields.includes(node.name)) {
-        const outputPath = names.concat(node.name).join('.');
-        const extract = {
-            type: Extract,
-            jsonAlias: parentAlias,
-            field: node.name,
-        };
-        return success([{ type: FieldType.Scalar, extract, path: outputPath }]);
-    }
-    // RecordTypeId is special field that is pulled from the root properties of record rep
-    // but is not returned as a scalar value.
-    if (node.name === 'RecordTypeId') {
-        return success(scalarField({ ...node, kind: 'ObjectFieldSelection' }, names, parentAlias, 'String'));
-    }
-    const fieldInfoResult = getFieldInfo(parentApiName, node.name, input.objectInfoMap);
-    const relationshipInfoResult = getRelationshipInfo(parentApiName, node.name, input.objectInfoMap);
-    if (fieldInfoResult.isSuccess === false) {
-        return failure([fieldInfoResult.error]);
-    }
-    if (relationshipInfoResult.isSuccess === false) {
-        return failure([relationshipInfoResult.error]);
-    }
-    const fieldInfo = fieldInfoResult.value;
-    const relationshipInfo = relationshipInfoResult.value;
-    if (fieldInfo === undefined && relationshipInfo === undefined) {
-        return failure([message(`Field ${node.name} for type ${parentApiName} not found.`)]);
-    }
-    if (fieldInfo !== undefined) {
-        //This is a spanning field
-        if (fieldInfo.dataType === REFERENCE_NAME_KEY) {
-            if (!isObjectFieldSelection(node) && !isCustomFieldNode(node)) {
-                return failure([
-                    message(`Node type ${node.kind} is not a valid reference field type.`),
-                ]);
-            }
-            const selection = { ...node, kind: 'ObjectFieldSelection' };
-            if (fieldInfo.relationshipName === node.name) {
-                return spanningField(selection, fieldInfo, names, parentAlias, input, joins).map((field) => [field]);
-            }
-            return success(scalarField(selection, names, parentAlias, fieldInfo.dataType));
-        }
-        //Scalar field
-        if (isScalarDataType(fieldInfo.dataType)) {
-            if (!isObjectFieldSelection(node)) {
-                return failure([
-                    message(`Node type ${node.kind} is not a valid scalar field type.`),
-                ]);
-            }
-            return success(scalarField(node, names, parentAlias, fieldInfo.dataType));
-        }
-        // If we've gotten this far, we're looking at a scalar field with a datatype
-        // that we haven't otherwise identified
-        return failure([
-            message(`Field with datatype ${fieldInfo.dataType} is not a valid scalar field type.`),
-        ]);
-    }
-    if (relationshipInfo === undefined) {
-        return failure([message(`Relationship ${node.name} for type ${parentApiName} not found.`)]);
-    }
-    //Field is a connection to a child record type
-    if (!isCustomFieldNode(node)) {
-        return failure([message(`Node type ${node.kind} is not a valid child field type.`)]);
-    }
-    const fieldPath = names.concat(node.name);
-    const edgePath = fieldPath.concat('edges');
-    return childRecordQuery(node, relationshipInfo, parentAlias, input).map((query) => {
-        return [{ type: FieldType.Child, path: edgePath.join('.'), connection: query }];
-    });
-}
-function recordFields(luvioSelections, names, parentApiName, parentAlias, input, joins) {
-    const results = luvioSelections.map((selection) => selectionToQueryField(selection, names, parentApiName, parentAlias, input, joins));
-    const fields = results.filter(isSuccess).reduce(flatMap(values$5), []);
-    const fails = results.filter(isFailure).reduce(flatMap(errors), []);
-    if (fails.length > 0) {
-        return failure(fails);
-    }
-    return success(fields);
-}
-function queryContainer(inputFields, jsonAlias, apiName, additionalPredicates) {
-    if (inputFields.isSuccess === false) {
-        return failure(inputFields.error);
-    }
-    const extract = {
-        type: Extract,
-        jsonAlias,
-        field: API_NAME_KEY,
-    };
-    //query's type predicate
-    const typePredicate = comparison(extract, ComparisonOperator.eq, stringLiteral(apiName, true, true));
-    const typePredicates = [];
-    typePredicates.push(typePredicate);
-    // puts 'typePredicate' in front so that 'apiName' predicate is always in the front of the SQL
-    const fields = inputFields.value
-        .map((field) => {
-        if (isSpanningField(field)) {
-            return field.spanning.fields;
-        }
-        else
-            return [field];
-    })
-        .reduce(flatten$1, []);
-    const predicates = typePredicates.concat(additionalPredicates);
-    return success({ fields, predicates });
-}
-//A field or fields from a parent record
-function spanningRecordQuery(selection, fieldInfo, names, parentAlias, input, joins) {
-    const { apiName: fieldName, referenceToInfos: referenceInfos, relationshipName } = fieldInfo;
-    if (relationshipName === null) {
-        return failure([message(`Relationship name is missing for ${fieldName}`)]);
-    }
-    const alias = `${parentAlias}.${relationshipName}`;
-    const selections = selection.luvioSelections || [];
-    const outPathNames = names.concat(relationshipName);
-    const referenceToInfo = referenceInfos[0];
-    if (referenceToInfo === undefined) {
-        return failure([message(`No reference info found for ${fieldName}`)]);
-    }
-    const { apiName } = referenceToInfo;
-    const joinPredicate = referencePredicate(parentAlias, alias, fieldName);
-    const join = {
-        name: alias,
-        type: 'LEFT',
-        to: parentAlias,
-        conditions: [joinPredicate],
-    };
-    joins.push(join);
-    // pushes the join in order
-    const internalFields = recordFields(selections, outPathNames, apiName, alias, input, joins);
-    if (internalFields.isSuccess === false) {
-        return failure(internalFields.error);
-    }
-    const fields = internalFields.value
-        .map((field) => {
-        // add child predicates as part of its own predicates
-        if (isSpanningField(field)) {
-            return field.spanning.fields;
-        }
-        else
-            return [field];
-    })
-        .reduce(flatten$1, []);
-    return success({
-        type: 'spanning',
-        apiName,
-        fields,
-        alias,
-    });
-}
-function childRecordQuery(selection, relationshipInfo, parentAlias, input) {
-    const { relationshipName, childObjectApiName, fieldName } = relationshipInfo;
-    const alias = `${parentAlias}.${relationshipName}`;
-    const apiName = childObjectApiName;
-    //parent predicate
-    let additionalPredicates = [referencePredicate(alias, parentAlias, fieldName)];
-    return recordQuery(selection, apiName, alias, additionalPredicates, input);
-}
-function parseFirst(arg) {
-    if (arg === undefined) {
-        return success(undefined);
-    }
-    if (arg.value.kind !== 'IntValue') {
-        return failure(message('first type should be an IntValue.'));
-    }
-    return success(parseInt(arg.value.value));
-}
-function recordQuery(selection, apiName, alias, predicates, input) {
-    const args = selection.arguments || [];
-    const whereArg = args.filter(named('where'))[0];
-    const scopeArg = args.filter(named('scope'))[0];
-    const orderByArg = args.filter(named('orderBy'))[0];
-    const firstArg = args.filter(named('first'))[0];
-    const joinsGroup = [];
-    const firstResult = parseFirst(firstArg);
-    const orderByJoins = [];
-    const orderByResult = parseOrderBy(orderByArg, alias, apiName, input.objectInfoMap, orderByJoins);
-    const filterJoins = [];
-    const whereResult = recordFilter(whereArg, alias, apiName, input.objectInfoMap, filterJoins, input.draftFunctions);
-    const scopeJoins = [];
-    const scopeResult = scopeFilter(scopeArg, alias, apiName, input, scopeJoins);
-    let additionalPredicates = [];
-    if (orderByResult.isSuccess === false) {
-        return failure(orderByResult.error);
-    }
-    if (whereResult.isSuccess === false) {
-        return failure(whereResult.error);
-    }
-    if (scopeResult.isSuccess === false) {
-        return failure([scopeResult.error]);
-    }
-    if (firstResult.isSuccess === false) {
-        return failure([firstResult.error]);
-    }
-    if (scopeResult.value !== undefined) {
-        additionalPredicates.push(scopeResult.value);
-    }
-    if (whereResult.value !== undefined) {
-        const { predicate } = whereResult.value;
-        //it is possible that all the predicates falls into 'joins'
-        if (predicate !== undefined) {
-            additionalPredicates.push(predicate);
-        }
-    }
-    //make our way down to the field-containing ast node
-    const node = [selection]
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isObjectFieldSelection)
-        .filter(named('edges'))
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isCustomFieldNode)
-        .filter(named('node'))[0];
-    const queryJoins = [];
-    //look for scalar fields, parent fields or children
-    const internalFields = recordFields(node.luvioSelections || [], ['node'], apiName, alias, input, queryJoins);
-    joinsGroup.push(filterJoins);
-    joinsGroup.push(orderByJoins);
-    joinsGroup.push(queryJoins);
-    joinsGroup.push(scopeJoins);
-    const allJoins = joinsGroup.reduce((accumulatedJoins, curJoins) => {
-        return mergeJoins(accumulatedJoins, curJoins);
-    }, []);
-    const extract = { type: ValueType.Extract, jsonAlias: alias, field: 'drafts' };
-    const draftsField = { type: FieldType.Scalar, extract, path: 'node._drafts' };
-    const idExtract = { type: ValueType.Extract, jsonAlias: alias, field: 'Id' };
-    const idField = { type: FieldType.Scalar, extract: idExtract, path: 'node.Id' };
-    // When the exclude stale records gate is open and there is a root timestamp
-    // in the parser input, inject an additional predicate to limit the search
-    // to records that either have drafts associated to them or were ingested at
-    // least as recently as the query.
-    if (excludeStaleRecordsGate.isOpen({ fallback: false }) && input.rootTimestamp !== undefined) {
-        const timestampCheck = {
-            type: PredicateType$1.comparison,
-            left: {
-                type: ValueType.Extract,
-                jsonAlias: alias,
-                field: 'ingestionTimestamp',
-                metadata: true,
-            },
-            operator: ComparisonOperator.gte,
-            right: { type: ValueType.IntLiteral, value: input.rootTimestamp },
-        };
-        const isDraft = {
-            type: PredicateType$1.nullComparison,
-            left: { type: ValueType.Extract, jsonAlias: alias, field: 'drafts' },
-            operator: NullComparisonOperator.isNot,
-        };
-        predicates.push({
-            type: PredicateType$1.compound,
-            operator: CompoundOperator.or,
-            children: [timestampCheck, isDraft],
-        });
-    }
-    return queryContainer(internalFields, alias, apiName, predicates).map((result) => {
-        const { fields, predicates } = result;
-        const allFields = removeDuplicateFields(fields.concat(...[draftsField, idField]));
-        // predicate for the top level 'recordQuery'
-        const predicate = combinePredicates([...additionalPredicates, ...predicates].filter(isDefined), CompoundOperator.and);
-        const first = firstResult.value;
-        const orderBy = orderByResult.value === undefined
-            ? []
-            : orderByResult.value.map((result) => result.orderBy);
-        return {
-            fields: allFields,
-            first,
-            orderBy,
-            apiName,
-            alias,
-            predicate,
-            joins: allJoins,
-        };
-    });
-}
-// merge 2 joins. it honors join type from the 2nd param.
-function mergeJoins(lJoins, rJoins) {
-    const mergedJoins = [...lJoins];
-    for (const join of rJoins) {
-        const existingJoin = mergedJoins.find((newJoin) => join.name === newJoin.name && join.to === newJoin.to);
-        if (existingJoin !== undefined) {
-            const existingConditions = existingJoin.conditions;
-            const allCondition = [...existingConditions, ...join.conditions];
-            const mergedJoin = {
-                name: join.name,
-                to: join.to,
-                type: join.type,
-                conditions: removeDuplicatePredicates(allCondition),
-            };
-            mergedJoins.splice(mergedJoins.indexOf(existingJoin), 1, mergedJoin);
-        }
-        else {
-            mergedJoins.push(join);
-        }
-    }
-    return mergedJoins;
-}
-function rootRecordQuery(selection, input) {
-    const alias = selection.name;
-    const apiName = selection.name;
-    if (input.objectInfoMap[alias] === undefined) {
-        return failure([missingObjectInfo(apiName)]);
-    }
-    // When the exclude stale records gate is open and the query has an
-    // ingestion timestamp in its cache metadata, associate that with the input
-    // so it can later be used to limit the search to records were ingested at
-    // least as recently as the query.
-    if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
-        const key = input.connectionKeyBuilder(selection, input.config.variables);
-        const queryMetadata = input.metadata[key];
-        // If there is no metadata for this query or it somehow lacks a timestamp
-        // skip setting the root timestamp
-        if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
-            const timestamp = Number(queryMetadata.ingestionTimestamp);
-            if (!isNaN(timestamp)) {
-                input.rootTimestamp = timestamp;
-            }
-        }
-    }
-    return recordQuery(selection, alias, apiName, [], input);
-}
-function rootQuery(recordNodes, input) {
-    const results = recordNodes.map((record) => rootRecordQuery(record, input));
-    const connections = results.filter(isSuccess).map(values$5);
-    const fails = results.filter(isFailure).reduce(flatMap(errors), []);
-    if (fails.length > 0) {
-        return failure(fails);
-    }
-    return success({ type: 'root', connections, queryKeys: input.queryKeys });
-}
-/**
- * Given a connection array of LuvioSelectionCustomFieldNode
- * it will go through to find a nested connection and check that it has arguments
- * if it has no arguments or no luvioSelections it will return the next level as an empty arrray
- * @param  {LuvioSelectionCustomFieldNode[]} previousLevel
- * @returns LuvioSelectionCustomFieldNode[]
- */
-function getNextLevelOfArguments(previousLevel) {
-    return previousLevel
-        .map((node) => {
-        if (node.luvioSelections) {
-            const records = node.luvioSelections
-                .filter(isObjectFieldSelection)
-                .reduce(flatMap(luvioSelections), [])
-                .filter(isCustomFieldNode)
-                .reduce(flatMap(luvioSelections), [])
-                .filter(isCustomFieldNode)
-                .filter(hasArguments);
-            return records;
-        }
-        return [];
-    })
-        .reduce(flatten$1);
-}
-/**
- * Return all LuvioSelectionCustomFieldNodes that have arguments on them
- * @param  {LuvioDocumentNode} document
- * @returns LuvioSelectionCustomFieldNode[]
- */
-function findAllRecordsThatHaveArugments(document) {
-    const topLevelRecords = findRecordsWithVariableArguments(document);
-    let allRecordsWithVariables = [topLevelRecords];
-    let lastLevel = topLevelRecords;
-    while (lastLevel.length > 0) {
-        lastLevel = getNextLevelOfArguments(lastLevel);
-        if (lastLevel.length > 0) {
-            allRecordsWithVariables.push(lastLevel);
-        }
-    }
-    return allRecordsWithVariables.reduce(flatten$1);
-}
-/**
- * Given an AST Document and GQL Variables it will transform the argument nodes
- * and the variables listed in them to a parseable gql string that can be ran throug
- * @param  {LuvioDocumentNode} document
- * @param  {Record<string, any>} variables
- * @returns string
- */
-function generateVariableGQLQuery(document, variables) {
-    return (findAllRecordsThatHaveArugments(document)
-        .map((node) => {
-        const gqlArguments = node.arguments
-            ? node.arguments
-                .map((args) => {
-                const { value, name } = args;
-                //The variable is on the top level, for example `where: ${filter}`
-                if (is(value, 'Variable')) {
-                    return generateVariableNodeQuery(value, name, name, variables);
-                }
-                else if (isObjectValueNode$1(value)) {
-                    return generateVariableSubQuery(value, name, name, variables);
-                }
-            })
-                .filter(Boolean)
-            : undefined;
-        return gqlArguments
-            ? `${node.name} ${gqlArguments.length > 0 ? '(' + gqlArguments.join(',') + ')' : ''} { Id }`
-            : '';
-    })
-        //remove empty strings
-        .filter(Boolean)
-        //insert record qurries into brackets
-        .reduce((accu, query) => {
-        const length = accu.length;
-        return [accu.slice(0, 1), query, accu.slice(1, length)].join('');
-    }, '{ }'));
-}
-/**
- * Given a  LuvioValueNode, generates a sql with its variable node replaced with actual value.
- * @param valueNode G
- * @param name
- * @param type
- * @param variables
- * @returns
- */
-function generateVariableSubQuery(valueNode, name, type, variables) {
-    switch (valueNode.kind) {
-        case Kind$1.OBJECT: {
-            // For example, `{ Id: { eq: $draftId } }` is a `ObjectValueNode`, which has field keys 'Id'
-            const resultQuery = keys$7(valueNode.fields)
-                .map((key) => generateVariableSubQuery(valueNode.fields[key], key, type, variables))
-                .filter((subquery) => subquery.length > 0)
-                .join(',');
-            if (resultQuery.length > 0) {
-                return `${name}: {${resultQuery}}`;
-            }
-            return resultQuery;
-        }
-        case Kind$1.VARIABLE:
-            return generateVariableNodeQuery(valueNode, name, type, variables);
-        default:
-            return '';
-    }
-}
-// Generate a sql for the variable node with its actual value.
-function generateVariableNodeQuery(value, name, type, variables) {
-    const variable = variables[value.name];
-    if (variable) {
-        const jsonString = JSON.stringify(variable);
-        const buildRecordQueryString = (name, query, transform) => {
-            return `${name}: ${transform(query)}`;
-        };
-        switch (type) {
-            case 'scope':
-            case 'orderBy':
-                return buildRecordQueryString(name, jsonString, removeAllQuotations);
-            default:
-                return buildRecordQueryString(name, jsonString, removeQuotationsFromKeys);
-        }
-    }
-    return '';
-}
-/**
- * Given an AST with variables
- * Swap out the LuvioArgumentNodes on the original AST with ones generated from its variables.
- * @param  {LuvioDocumentNode} document
- * @param  {Record<string, any>} variables
- */
-function swapVariableArguments(document, variables) {
-    // dont run if no variables exist
-    if (Object.keys(variables).length > 0) {
-        const variablesGqlString = generateVariableGQLQuery(document, variables);
-        const gqlParsedVariables = parseAndVisit(variablesGqlString);
-        const variableNodes = findTopLevelVariableDocuments(gqlParsedVariables);
-        const allArgumentRecords = findAllRecordsThatHaveArugments(document);
-        // replace each variable argument node with the generated one of the same name
-        variableNodes.forEach((node) => {
-            const { name } = node;
-            const first = allArgumentRecords.find((n) => n.name === name);
-            if (first) {
-                const swappedArgments = swapArgumentWithVariableNodes(node.arguments, first.arguments);
-                first.arguments = swappedArgments ? swappedArgments : [];
-            }
-        });
-    }
-}
-// Replaces the variable node  in original LuvioArgumentNode with the actual value in the swapped node with the same path.
-function swapArgumentWithVariableNodes(swapped, original) {
-    if (swapped === undefined || original === undefined) {
-        return original;
-    }
-    return original.map((x) => {
-        const targetNode = swapped.find((y) => y.name === x.name);
-        if (targetNode === undefined) {
-            return x;
-        }
-        if (x.value.kind === 'Variable') {
-            return targetNode;
-        }
-        swapValueNodeWithVariableNodes(x.value, targetNode.value);
-        return x;
-    });
-}
-function swapValueNodeWithVariableNodes(original, swapped) {
-    if (original.kind === Kind$1.OBJECT) {
-        for (const key of keys$7(original.fields)) {
-            if (isObjectValueNode$1(swapped) && swapped.fields[key]) {
-                if (is(original.fields[key], 'Variable')) {
-                    original.fields[key] = swapped.fields[key];
-                }
-                else {
-                    swapValueNodeWithVariableNodes(original.fields[key], swapped.fields[key]);
-                }
-            }
-        }
-    }
-}
-//find top level record queries
-function findRecordSelections(document) {
-    return document.definitions
-        .filter(isOperationDefinition)
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isObjectFieldSelection)
-        .filter(named('uiapi'))
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isObjectFieldSelection)
-        .filter(named('query'))
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isCustomFieldNode);
-}
-function findRecordsWithVariableArguments(document) {
-    return findRecordSelections(document).filter(hasArguments);
-}
-function findTopLevelVariableDocuments(document) {
-    return document.definitions
-        .filter(isOperationDefinition)
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isObjectFieldSelection);
-}
-function transform(document, input) {
-    const recordNodes = findRecordSelections(document);
-    return rootQuery(recordNodes, input);
-}
-
-class StoreEvalPreconditioner {
-    /**
-     * Given an AST, a mechanism to discover missing object info references and a required userId,
-     * produce an intermediate representation that can be successfully transformed to SQL for evaluation.
-     * Missing object info records triggers the objectInfoService (same instance shared with Drafts code), to
-     * use the getObjectInfos adapter to efficiently fetch the necessary records.
-     */
-    async createRootQuery(config, objectInfoService, userId, draftFunctions, connectionKeyBuilder, sqliteStore) {
-        const { query: ast, variables } = config;
-        swapVariableArguments(ast, variables);
-        // Parse out top-level record queries types we know we will need, since spanning fields will
-        // require at least this top level record present to resolve relationship lookups
-        const recordSelections = findRecordSelections(ast);
-        let metadata = {};
-        const queryKeys = recordSelections.map((rs) => connectionKeyBuilder(rs, variables));
-        if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
-            let sqlResult = await sqliteStore.query(`select key, metadata from lds_data where key in (${queryKeys
-                .map(() => '?')
-                .join(',')})`, queryKeys);
-            metadata = sqlResult.rows.reduce((metadata, row) => {
-                metadata[row[0]] = JSON.parse(row[1]);
-                return metadata;
-            }, {});
-        }
-        const topLevelNeededRecords = recordSelections.map((selection) => selection.name);
-        // Seed the initial list of things to fetch
-        const neededObjectInfos = new Set(topLevelNeededRecords);
-        // Seed the list of things we've _tried_ to fetch.  As we iterate and
-        // continue to find things we know we need, we're keeping track of things we've tried
-        // to make sure that a query with unknown types (from the server's perspective) don't
-        // trigger an infinite loop of ObjectInfo record lookups.
-        const objectInfoAttemptedFetches = new Set(topLevelNeededRecords);
-        // We'll build up this dictionary along the way with the necessary ObjectInfo records
-        // we discovery
-        let objectInfoMap = {};
-        // Captures query parsing success/fail
-        let astTransformResult;
-        // Guarding against unknown unknowns that could (theoretically) get stuck in an infinite loop while
-        // resolving ObjectInfo records.
-        let depthGuard = 0;
-        // Most of the depths we'll see for real use cases are on the order 2-8
-        const depthLimit = 50;
-        // The idea here is to keep attempting to parse the AST into something offline
-        // eval understands until we've fetched all the necessary types and are successful or we
-        // have irrecoverable errors.
-        while (neededObjectInfos.size > 0) {
-            // safety net in case there are 🐲's
-            if (depthGuard++ > depthLimit) {
-                // eslint-disable-next-line
-                throw new Error('Maximum ObjectInfo fetching depth exceeded');
-            }
-            // Fetch the current list of needed records
-            const fetchedObjectInfos = await objectInfoService.getObjectInfos([
-                ...neededObjectInfos,
-            ]);
-            // Clear the list of records needed; this will get rebuilt with each iteration
-            neededObjectInfos.clear();
-            // Enrich the dictionary with the new information
-            objectInfoMap = {
-                ...objectInfoMap,
-                ...fetchedObjectInfos,
-            };
-            // Attempt to parse the AST given what we know already...
-            astTransformResult = transform(ast, {
-                config,
-                userId,
-                objectInfoMap,
-                draftFunctions,
-                connectionKeyBuilder,
-                metadata,
-                queryKeys,
-            });
-            if (astTransformResult.isSuccess === false) {
-                for (const error of astTransformResult.error) {
-                    // The only kind of error we can recover from is missing object info, so
-                    // if something else is wrong, bail early.
-                    if (error.type !== 'MissingObjectInfoError')
-                        throw concatenatePredicateErrors(astTransformResult.error);
-                    // If we've tried to fetch this before and failed, don't re-add it to the
-                    // list of things to try and fetch
-                    if (objectInfoAttemptedFetches.has(error.object))
-                        continue;
-                    // If there are errors specifically about missing object info, add the
-                    // newly discovered necessity to the list of things to fetch...
-                    neededObjectInfos.add(error.object);
-                    // and track the attempt
-                    objectInfoAttemptedFetches.add(error.object);
+                        ...storeEntry.metadata,
+                        expirationTimestamp: now,
+                    };
                 }
+                needWriteBack = true;
             }
         }
-        // The only way this is undefined is if we're processing GraphQL queries that aren't Record queries.
-        // At this point in time Record queries are all we support, so for now this is an error state.  In
-        // the future when we support non-record queries (related list metadata queries?), we'll adjust for this
-        if (astTransformResult === undefined) {
-            // eslint-disable-next-line
-            throw new Error('Unable to transform AST to intermediate representation');
-        }
-        else if (astTransformResult.isSuccess === false) {
-            // After we've exhausted the errors related to missing records, if we still have errors
-            // we'll throw to exit early, otherwise we can proceed to evaluate
-            throw concatenatePredicateErrors(astTransformResult.error);
-        }
-        else {
-            return astTransformResult.value;
-        }
-    }
-}
-
-/**
- * Checks a GraphQL-shaped network response for errors, returning true if it does
- * and false otherwise
- */
-function hasGraphQlErrors$1(response) {
-    return (response !== undefined &&
-        response.errors !== undefined &&
-        isArray$4(response.errors) &&
-        response.errors.length > 0);
-}
-
-const GRAPHQL_EVAL_NAMESPACE$1 = 'graphql-eval';
-
-function isStoreEvalSnapshot(snapshot) {
-    return 'rebuildWithStoreEval' in snapshot;
-}
-/**
- * Evaluates the SQL.  Assumes all preconditions are met.  NOTE: this function
- * will throw if it fails to evaluate the SQL, callers should protect against that.
- */
-async function evaluateSqlite(query, eventEmitter, store) {
-    const { sql, bindings } = computeSql(query);
-    const start = Date.now();
-    const result = await store.query(sql, bindings);
-    const rawValue = result.rows[0][0];
-    eventEmitter({ type: 'graphql-db-read', sql, bindings, duration: Date.now() - start });
-    const data = JSON.parse(rawValue);
-    const seenRecords = createSeenRecords$1(data);
-    if (query.queryKeys) {
-        for (const queryKey of query.queryKeys) {
-            seenRecords.add(queryKey);
+        if (needWriteBack) {
+            await durableStore.setEntries(entries, DefaultDurableSegment);
         }
-    }
-    return { data, seenRecords };
-}
-const wrapStartEndEvents = (storeEval) => {
-    return async (config, nonEvaluatedSnapshotOrPromise, observers, connectionKeyBuilder) => {
-        const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE$1, observers);
-        eventEmitter({ type: 'graphql-eval-start' });
-        const snapshot = await storeEval(config, nonEvaluatedSnapshotOrPromise, observers, connectionKeyBuilder);
-        eventEmitter({ type: 'graphql-eval-end' });
-        return snapshot;
+        // push a notifyStoreUpdateAvailable message with entryKeys as data into messaging segment
+        await durableStore.setEntries({ notifyStoreUpdateAvailable: { data: entryKeys } }, MessagingDurableSegment);
+        return Promise.resolve(undefined);
     };
-};
-function sqliteStoreEvalFactory(userId, sqliteStore, objectInfoService, draftFunctions) {
-    // if the store does not support eval then use the noop version
-    if (sqliteStore.isEvalSupported() === false) {
-        return noopStoreEval;
-    }
-    const preconditioner = new StoreEvalPreconditioner();
-    return makeStoreEval(preconditioner, objectInfoService, userId, async () => {
-        return undefined;
-    }, (query, _context, eventEmitter) => evaluateSqlite(query, eventEmitter, sqliteStore), draftFunctions, sqliteStore);
-}
-async function noopStoreEval(_config, nonEvaluatedSnapshotOrPromise, _observers) {
-    return nonEvaluatedSnapshotOrPromise;
-}
-/**
- * If we can't reach the server or if we get back a 504 (which means only-if-cached
- * cache policy was used but this query hasn't been cached) then we still want to
- * attempt an eval.  All other errors should be returned to caller.
- */
-function isErrorSnapshotThatShouldGetReturnedToCaller$1(snapshot) {
-    return ((snapshot.state === 'Error' &&
-        snapshot.error.errorType === 'fetchResponse' &&
-        snapshot.error.status !== 504) ||
-        hasGraphQlErrors$1(snapshot.data));
-}
-function generateUniqueRecordId$1() {
-    return `${GRAPHQL_ROOT_KEY$1}${Date.now() + Math.random().toFixed(5).split('.')[1]}`;
-}
-function makeStoreEval(preconditioner, objectInfoService, userId, contextProvider, queryEvaluator, draftFunctions, sqliteStore) {
-    const storeEval = async (config, nonEvaluatedSnapshotOrPromise, observers, connectionKeyBuilder) => {
-        const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE$1, observers);
-        // the non-eval'ed input could either be a snapshot or promise of one so
-        // await it here to normalize the input to a snapshot
-        const nonEvaluatedSnapshot = await nonEvaluatedSnapshotOrPromise;
-        // if the non-eval result has errors we want to return to caller
-        const nonEvaluatedGQLSnapshot = nonEvaluatedSnapshot;
-        if (isErrorSnapshotThatShouldGetReturnedToCaller$1(nonEvaluatedGQLSnapshot)) {
-            const { data: gqlData } = nonEvaluatedGQLSnapshot;
-            if (hasGraphQlErrors$1(gqlData) && gqlData !== undefined) {
-                return {
-                    ...nonEvaluatedSnapshot,
-                    data: undefined,
-                    state: 'Error',
-                    error: {
-                        errorType: 'adapterError',
-                        error: gqlData.errors,
-                    },
-                };
+    const reviveSnapshotWrapper = function (unavailableSnapshot, buildL1Snapshot) {
+        let revivingStore = undefined;
+        if (useRevivingStore) {
+            // NOTE: `store` is private, there doesn't seem to be a better,
+            // cleaner way of accessing it from a derived environment.
+            let baseStore = environment.store;
+            // If we're rebuilding during an ingest, the existing staging store should be the base store.
+            if (stagingStore) {
+                baseStore = stagingStore;
             }
-            return nonEvaluatedSnapshot;
+            let revivingStore = buildRevivingStagingStore(baseStore);
+            revivingStores.add(revivingStore);
         }
-        let rootQuery;
-        let context;
-        // pre-conditions try block
-        try {
-            context = await contextProvider();
-            // Ensures ObjectInfo metadata is available for the request.  Sourcing records from L1/L2/Network
-            // is delegated to the getObjectInfo adapter via objectInfoService
-            rootQuery = await preconditioner.createRootQuery(config, objectInfoService, userId, draftFunctions, connectionKeyBuilder, sqliteStore);
+        return reviveSnapshot(environment, durableStore, unavailableSnapshot, durableStoreErrorHandler, () => {
+            const tempStore = stagingStore;
+            const result = buildL1Snapshot();
+            stagingStore = tempStore;
+            return result;
+        }, revivingStore).finally(() => {
+        });
+    };
+    const expirePossibleStaleRecords = async function (keys$1, config, refresh) {
+        validateNotDisposed();
+        const metadataKeys = keys$1.map(serializeStructuredKey);
+        const now = Date.now();
+        const entries = await durableStore.getMetadata(metadataKeys, DefaultDurableSegment);
+        if (entries === undefined || keys$7(entries).length === 0) {
+            return environment.expirePossibleStaleRecords(keys$1);
         }
-        catch (error) {
-            eventEmitter({
-                type: 'graphql-eval-precondition-error',
-                error,
-            });
-            if (error instanceof Error) {
-                return {
-                    ...nonEvaluatedSnapshot,
-                    data: undefined,
-                    state: 'Error',
-                    error: {
-                        status: 500,
-                        statusText: 'PRECONDITIONER_ERROR',
-                        body: {
-                            message: error.message,
-                        },
-                        errorType: 'fetchResponse',
-                        headers: {},
-                        ok: false,
-                    },
-                };
+        let metaDataChanged = false;
+        const metadataEntries = metadataKeys.reduce((accu, key) => {
+            const metadataEntry = entries[key];
+            if (metadataEntry.metadata !== undefined) {
+                const metadata = { ...metadataEntry.metadata, expirationTimestamp: now };
+                accu[key] = { metadata };
+                metaDataChanged = true;
             }
-            return nonEvaluatedSnapshot;
-        }
-        eventEmitter({ type: 'graphql-eval-preconditions-met' });
-        // all pre-conditions met, now we can eval
-        try {
-            const { data, seenRecords } = await queryEvaluator(rootQuery, context, eventEmitter);
-            const rebuildWithStoreEval = ((originalSnapshot) => {
-                return storeEval(config, originalSnapshot, observers, connectionKeyBuilder).then((rebuiltSnapshot) => {
-                    return objectsDeepEqual(originalSnapshot.data, rebuiltSnapshot.data)
-                        ? originalSnapshot
-                        : rebuiltSnapshot;
-                });
-            });
-            const recordId = generateUniqueRecordId$1();
-            // if the non-eval'ed snapshot was an error then we return a synthetic
-            // Fulfilled snapshot (this only happens in this code path if
-            // the error is network error or 504), otherwise we spread over
-            // the non-eval'ed snapshot (which will be either Fulfilled or Stale)
-            return nonEvaluatedSnapshot.state === 'Error'
-                ? createStoreEvalSnapshot(data, seenRecords, rebuildWithStoreEval, recordId)
-                : {
-                    ...nonEvaluatedSnapshot,
-                    data: data,
-                    recordId,
-                    seenRecords: seenRecords,
-                    rebuildWithStoreEval,
-                };
+            return accu;
+        }, {});
+        if (metaDataChanged) {
+            await durableStore.setMetadata(metadataEntries, DefaultDurableSegment);
         }
-        catch (error) {
-            eventEmitter({
-                type: 'graphql-create-snapshot-error',
-                error,
-            });
-            return nonEvaluatedSnapshot;
+        if (config !== undefined && refresh !== undefined) {
+            return environment.refreshPossibleStaleRecords(config, refresh);
         }
+        return Promise.resolve();
     };
-    return wrapStartEndEvents(storeEval);
+    // set the default cache policy of the base environment
+    environment.setDefaultCachePolicy({
+        type: 'stale-while-revalidate',
+        staleDurationSeconds: Number.MAX_SAFE_INTEGER,
+    });
+    return create$7(environment, {
+        publishStoreMetadata: { value: publishStoreMetadata },
+        storeIngest: { value: storeIngest },
+        storeIngestError: { value: storeIngestError },
+        storeBroadcast: { value: storeBroadcast },
+        storeLookup: { value: storeLookup },
+        storeEvict: { value: storeEvict },
+        wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
+        getNode: { value: getNode },
+        rebuildSnapshot: { value: rebuildSnapshot },
+        withContext: { value: withContext },
+        storeSetTTLOverride: { value: storeSetTTLOverride },
+        storeSetDefaultTTLOverride: { value: storeSetDefaultTTLOverride },
+        storePublish: { value: storePublish },
+        storeRedirect: { value: storeRedirect },
+        dispose: { value: dispose },
+        publishChangesToDurableStore: { value: publishChangesToDurableStore },
+        getDurableTTLOverrides: { value: getDurableTTLOverrides },
+        dispatchResourceRequest: { value: dispatchResourceRequest },
+        applyCachePolicy: { value: applyCachePolicy },
+        getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
+        getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },
+        getIngestStagingStore: { value: getIngestStagingStore },
+        handleSuccessResponse: { value: handleSuccessResponse },
+        handleErrorResponse: { value: handleErrorResponse },
+        getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
+        notifyStoreUpdateAvailable: { value: notifyStoreUpdateAvailable },
+        expirePossibleStaleRecords: { value: expirePossibleStaleRecords },
+    });
 }
 
 /**
@@ -5262,7 +1993,7 @@ function getRetryAfterInMs(headers) {
     return delayUntilDateTime - Date.now();
 }
 
-function buildLuvioOverrideForDraftAdapters(luvio, handler, extractTargetIdFromCacheKey, options = {}) {
+function buildLuvioOverrideForDraftAdapters(luvio, handler, extractTargetIdFromCacheKey) {
     // override this to create and enqueue a new draft action, and return synthetic response
     const dispatchResourceRequest = async function (resourceRequest, _context) {
         const resourceRequestCopy = clone$1(resourceRequest);
@@ -5270,13 +2001,6 @@ function buildLuvioOverrideForDraftAdapters(luvio, handler, extractTargetIdFromC
         if (handler.hasIdempotencySupport()) {
             resourceRequestCopy.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
         }
-        // enable return extra fields for record creation and record update http call
-        if (typeof resourceRequest.basePath === 'string' &&
-            resourceRequest.basePath.startsWith('/ui-api/records') &&
-            (resourceRequest.method === 'post' || resourceRequest.method === 'patch')) {
-            resourceRequestCopy.queryParams = resourceRequestCopy.queryParams || {};
-            resourceRequestCopy.queryParams['includeFieldsInBody'] = true;
-        }
         const { data } = await handler.enqueue(resourceRequestCopy).catch((err) => {
             throw transformErrorToDraftSynthesisError(err);
         });
@@ -5297,24 +2021,6 @@ function buildLuvioOverrideForDraftAdapters(luvio, handler, extractTargetIdFromC
             ttl: Number.MAX_SAFE_INTEGER,
         });
     };
-    if (options.forDeleteAdapter === true) {
-        // delete adapters attempt to evict the record on successful network response,
-        // since draft-aware delete adapters do soft-delete (record stays in cache
-        // with a "drafts.deleted" property) we just want to let the environment know so it can
-        // decrement its ref count for the record
-        const storeEvict = function (key) {
-            const softEvict = luvio.environment.softEvict;
-            if (softEvict === undefined) {
-                throw Error('DraftAwareEnvironment not configured correctly');
-            }
-            softEvict(key);
-        };
-        return create$6(luvio, {
-            dispatchResourceRequest: { value: dispatchResourceRequest },
-            publishStoreMetadata: { value: publishStoreMetadata },
-            storeEvict: { value: storeEvict },
-        });
-    }
     return create$6(luvio, {
         dispatchResourceRequest: { value: dispatchResourceRequest },
         publishStoreMetadata: { value: publishStoreMetadata },
@@ -6333,14 +3039,7 @@ class AbstractResourceRequestActionHandler {
             version: '242.0.0',
         };
     }
-    async handleActionEnqueued(action) {
-        const { method } = action.data;
-        // delete adapters don't get a value back to ingest so
-        // we ingest it for them here
-        if (method === 'delete') {
-            await this.reingestRecord(action);
-        }
-    }
+    async handleActionEnqueued(_action) { }
     handleActionRemoved(action) {
         return this.reingestRecord(action);
     }
@@ -7090,6 +3789,40 @@ function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueu
  */
 
 
+function isStoreKeyRecordId$1(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
+}
+function objectsDeepEqual(lhs, rhs) {
+    if (lhs === rhs)
+        return true;
+    if (typeof lhs !== 'object' || typeof rhs !== 'object' || lhs === null || rhs === null)
+        return false;
+    const lhsKeys = Object.keys(lhs);
+    const rhsKeys = Object.keys(rhs);
+    if (lhsKeys.length !== rhsKeys.length)
+        return false;
+    for (let key of lhsKeys) {
+        if (!rhsKeys.includes(key))
+            return false;
+        if (typeof lhs[key] === 'function' || typeof rhs[key] === 'function') {
+            if (lhs[key].toString() !== rhs[key].toString())
+                return false;
+        }
+        else {
+            if (!objectsDeepEqual(lhs[key], rhs[key]))
+                return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
 const { keys: keys$5, values: values$3, create: create$5, assign: assign$5, freeze: freeze$1, entries: entries$5 } = Object;
 const { stringify: stringify$4, parse: parse$4 } = JSON;
 const { shift } = Array.prototype;
@@ -7113,7 +3846,6 @@ function getDenormalizedRecord(recordKey, durableStore) {
         if (denormalizedEntry === undefined) {
             return undefined;
         }
-        // don't include link information
         const denormalizedRecord = denormalizedEntry.data;
         if (isStoreRecordError(denormalizedRecord)) {
             return undefined;
@@ -7212,6 +3944,11 @@ function filterOutReferenceNonScalarFields(record) {
     delete filteredRecords.links;
     return filteredRecords;
 }
+function filterOutPrivateProperties(record) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { eTag, weakEtag, ...rest } = record;
+    return rest;
+}
 
 /**
  * Checks if a resource request is a GET method on the record endpoint
@@ -8119,6 +4856,9 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         }
         return super.handleActionCompleted(completedAction, queueOperations, allHandlers);
     }
+    async handleActionEnqueued(action) {
+        await this.reingestRecord(action);
+    }
     async fetchReferenceRecord(referenceFields) {
         const promises = referenceFields.map(async (referenceFieldInfo) => {
             const apiName = await this.identifyApiName(referenceFieldInfo.id, referenceFieldInfo.field);
@@ -8631,6 +5371,15 @@ class UiApiDraftRecordService {
         const luvio = this.getLuvio();
         const key = keyBuilderFromTypeRecordRepresentation(luvio, record);
         luvio.storeIngest(key, ingestRecord, record);
+        if (record.drafts && record.drafts.created) {
+            luvio.publishStoreMetadata(key, {
+                namespace: 'UiApi',
+                representationName: 'RecordRepresentation',
+                ttl: Number.MAX_SAFE_INTEGER,
+                version: RecordRepresentationVersion,
+                ingestionTimestamp: Date.now(),
+            });
+        }
     }
     getUserId() {
         return this.userId;
@@ -9421,10 +6170,23 @@ function getDescriptionFromResourceRequest(request) {
  * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
  *        register it with the DraftQueue, runtime should set that up
  */
-function createRecordDraftAdapterFactory(luvio, actionHandler) {
-    const luvioWithDraftOverrides = buildLuvioOverrideForDraftAdapters(luvio, actionHandler, extractRecordIdFromStoreKey);
-    return function createRecordDraftAdapter(config, buildNetworkSnapshot) {
-        return buildNetworkSnapshot(luvioWithDraftOverrides, config);
+function createRecordDraftAdapterFactory(actionHandler, durableStore) {
+    return async function createRecordDraftAdapter(config, createResourceRequest) {
+        const request = createResourceRequest(config);
+        request.headers['Idempotency-Key'] = uuidv4();
+        request.queryParams = request.queryParams || {};
+        request.queryParams['includeFieldsInBody'] = true;
+        const result = await actionHandler.enqueue(request).catch((err) => {
+            throw transformErrorToDraftSynthesisError(err);
+        });
+        const record = await getDenormalizedRecord(result.action.tag, durableStore);
+        if (record) {
+            return {
+                state: 'Fulfilled',
+                data: filterOutPrivateProperties(filterOutReferenceNonScalarFields(record)),
+            };
+        }
+        throw createDraftSynthesisErrorResponse();
     };
 }
 
@@ -9434,10 +6196,23 @@ function createRecordDraftAdapterFactory(luvio, actionHandler) {
  * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
  *        register it with the DraftQueue, runtime should set that up
  */
-function updateRecordDraftAdapterFactory(luvio, actionHandler) {
-    const luvioWithDraftOverrides = buildLuvioOverrideForDraftAdapters(luvio, actionHandler, extractRecordIdFromStoreKey);
-    return function updateRecordDraftAdapter(config, buildNetworkSnapshot) {
-        return buildNetworkSnapshot(luvioWithDraftOverrides, config);
+function updateRecordDraftAdapterFactory(actionHandler, durableStore) {
+    return async function createRecordDraftAdapter(config, createResourceRequest) {
+        const request = createResourceRequest(config);
+        request.headers['Idempotency-Key'] = uuidv4();
+        request.queryParams = request.queryParams || {};
+        request.queryParams['includeFieldsInBody'] = true;
+        const result = await actionHandler.enqueue(request).catch((err) => {
+            throw transformErrorToDraftSynthesisError(err);
+        });
+        const record = await getDenormalizedRecord(result.action.tag, durableStore);
+        if (record) {
+            return {
+                state: 'Fulfilled',
+                data: filterOutPrivateProperties(filterOutReferenceNonScalarFields(record)),
+            };
+        }
+        throw createDraftSynthesisErrorResponse();
     };
 }
 
@@ -9447,10 +6222,9 @@ function updateRecordDraftAdapterFactory(luvio, actionHandler) {
  * @param actionHandler The UIAPI Record action handler. NOTE: this adapter doesn't
  *        register it with the DraftQueue, runtime should set that up
  */
-function deleteRecordDraftAdapterFactory(luvio, actionHandler) {
-    const luvioWithDraftOverrides = buildLuvioOverrideForDraftAdapters(luvio, actionHandler, extractRecordIdFromStoreKey, { forDeleteAdapter: true });
-    return function deleteRecordDraftAdapter(config, buildNetworkSnapshot) {
-        return buildNetworkSnapshot(luvioWithDraftOverrides, config);
+function deleteRecordDraftAdapterFactory(actionHandler) {
+    return async function deleteRecordDraftAdapter(config, buildResourceRequest) {
+        await actionHandler.enqueue(buildResourceRequest(config));
     };
 }
 
@@ -10841,7 +7615,14 @@ function singlePredicateToSql(predicate, defaultAlias, isChildNotPredicate = fal
             // SQLite is case sensitive by default, SOQL is case in-sensitive by default
             // For pick list includes or excludeds, prefix and suffix the field value with ';' to guarantee the query accuracy.
             if (dataType === 'MultiPicklist' && (operator === 'LIKE' || operator === 'NOT LIKE')) {
-                sql = `'${MultiPickListValueSeparator}' || json_extract("${alias}".data, '${leftPath}') || '${MultiPickListValueSeparator}' ${operator} ${questionSql} COLLATE NOCASE`;
+                // to include nulls in NOT LIKE operators we need to still return a value for NULL
+                // calling the COALESCE function with the extracted value and empty string will make it an empty string
+                // instead of NULL in the function return and can be compared
+                const coalesce = (sql) => {
+                    return `COALESCE(${sql}, '')`;
+                };
+                const extract = `json_extract("${alias}".data, '${leftPath}')`;
+                sql = `'${MultiPickListValueSeparator}' || ${operator === 'NOT LIKE' ? coalesce(extract) : extract} || '${MultiPickListValueSeparator}' ${operator} ${questionSql} COLLATE NOCASE`;
             }
             else {
                 sql = `json_extract("${alias}".data, '${leftPath}') ${operator} ${questionSql}${isCaseSensitive === true ? '' : ` COLLATE NOCASE`}`;
@@ -17571,12 +14352,6 @@ function isUnfulfilledSnapshot(cachedSnapshotResult) {
 function makeEnvironmentGraphqlAware(environment) {
     //TODO: [W-12734162] - rebuild non-evaluated snapshot when graph rebuild is triggered. The dependency work on luvio needs to be done.
     const rebuildSnapshot = function (snapshot, onRebuild) {
-        if (isStoreEvalSnapshot(snapshot)) {
-            snapshot.rebuildWithStoreEval(snapshot).then((rebuilt) => {
-                onRebuild(rebuilt);
-            });
-            return;
-        }
         if (isLocalEvalSnapshot(snapshot)) {
             snapshot.rebuildWithLocalEval(snapshot).then((rebuilt) => {
                 onRebuild(rebuilt);
@@ -18164,7 +14939,13 @@ class PrimingSession extends EventEmitter {
     processFetchedRecords(result, abortController) {
         if (result.ok === false) {
             const { error } = result;
-            const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
+            let primingError = 'unknown';
+            if (error === 'service-protection-error') {
+                primingError = 'service-protection-error';
+            }
+            else if (error === 'network-error') {
+                primingError = 'service-unavailable';
+            }
             this.emit('error', {
                 ids: result.missingIds,
                 code: primingError,
@@ -18300,6 +15081,17 @@ class PrimingSession extends EventEmitter {
     }
 }
 
+class PrimingNetworkError extends Error {
+    constructor(message, httpCode) {
+        super(message);
+        this.httpCode = httpCode;
+    }
+    isServiceProtectionError() {
+        // When CSP kicks-in, we get 429/503 errors back - https://salesforce.quip.com/20HZA5BN5xgx
+        return this.httpCode === 429 || this.httpCode === 503;
+    }
+}
+
 const requiredPrefix = `required_`;
 const requiredFieldMap = {
     ApiName: 'ApiName',
@@ -18321,12 +15113,22 @@ class RecordLoaderGraphQL {
             return this.generateFetchResult(rep, batch);
         }
         catch (e) {
-            return {
-                ok: false,
-                error: 'network-error',
-                messages: ['Network Error'],
-                missingIds: batch.ids,
-            };
+            if (e instanceof PrimingNetworkError && e.isServiceProtectionError()) {
+                return {
+                    ok: false,
+                    error: 'service-protection-error',
+                    messages: ['Service Protection Error'],
+                    missingIds: batch.ids,
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    error: 'network-error',
+                    messages: ['Network Error'],
+                    missingIds: batch.ids,
+                };
+            }
         }
     }
     async batchFetchRecordData(batchs, abortController) {
@@ -18342,14 +15144,26 @@ class RecordLoaderGraphQL {
             const missingIds = batchs
                 .map((batch) => batch.ids)
                 .reduce((prev, curr) => prev.concat(curr), []);
-            return [
-                {
-                    ok: false,
-                    error: 'network-error',
-                    messages: ['Network Error'],
-                    missingIds,
-                },
-            ];
+            if (e instanceof PrimingNetworkError && e.isServiceProtectionError()) {
+                return [
+                    {
+                        ok: false,
+                        error: 'service-protection-error',
+                        messages: [e.message],
+                        missingIds,
+                    },
+                ];
+            }
+            else {
+                return [
+                    {
+                        ok: false,
+                        error: 'network-error',
+                        messages: ['Network Error'],
+                        missingIds,
+                    },
+                ];
+            }
         }
     }
     generateFetchResult(repResult, batchInput) {
@@ -18560,13 +15374,16 @@ class NimbusPrimingNetworkAdapter {
                 body: JSON.stringify({
                     batchQuery: configs,
                 }),
-                headers: {},
+                headers: {
+                    // This header is needed to get back 429/503 error code when CSP kicks-in - https://salesforce.quip.com/20HZA5BN5xgx
+                    Cos: '0x04',
+                },
                 queryParams: {},
                 priority: 'background',
                 observabilityContext: {},
             }, abortController, (response) => {
                 if (response.status < 200 || response.status > 299) {
-                    reject(new Error(response.body || 'Network error'));
+                    reject(new PrimingNetworkError(response.body || 'Network error', response.status));
                     return;
                 }
                 try {
@@ -18606,7 +15423,7 @@ class NimbusPrimingNetworkAdapter {
                 observabilityContext: {},
             }, abortController, (response) => {
                 if (response.status < 200 || response.status > 299) {
-                    reject(new Error(response.body || 'Network error'));
+                    reject(new PrimingNetworkError(response.body || 'Network error', response.status));
                     return;
                 }
                 try {
@@ -18638,7 +15455,7 @@ class NimbusPrimingNetworkAdapter {
                 observabilityContext: {},
             }, abortController, (response) => {
                 if (response.status < 200 || response.status > 299) {
-                    reject(new Error(response.body || 'Network error'));
+                    reject(new PrimingNetworkError(response.body || 'Network error', response.status));
                     return;
                 }
                 try {
@@ -18674,7 +15491,7 @@ class NimbusPrimingNetworkAdapter {
                 observabilityContext: {},
             }, abortController, (response) => {
                 if (response.status < 200 || response.status > 299) {
-                    reject(new Error(response.body || 'Network error'));
+                    reject(new PrimingNetworkError(response.body || 'Network error', response.status));
                     return;
                 }
                 try {
@@ -19131,20 +15948,6 @@ function getRuntime() {
         setupMobileInstrumentation(lazyLuvio, store);
         // If the observer nimbus plugin is configured, observation is enabled otherwise this is a no-op
         setupObserver();
-        // set storeEval function for lds-adapters-graghql to use
-        withRegistration('@salesforce/lds-adapters-graphql', (registration) => {
-            const { configuration: { setStoreEval, setDraftFunctions }, } = registration;
-            const getCanonicalId = (id) => {
-                var _a;
-                return ((_a = extractRecordIdFromStoreKey(lazyLuvio.storeGetCanonicalKey(RECORD_ID_PREFIX + id))) !== null && _a !== void 0 ? _a : id);
-            };
-            const draftFuncs = {
-                isDraftId: isGenerated,
-                getCanonicalId,
-            };
-            setStoreEval(sqliteStoreEvalFactory(userId, lazyDurableStore, lazyObjectInfoService, draftFuncs));
-            setDraftFunctions(draftFuncs);
-        });
         // on core the graphql configuration is split so we need to set configureUIAPIGraphQL both in the
         // graphql registration and the uiapi for off core
         const configureUIAPIGraphQL = (registration) => {
@@ -19163,9 +15966,9 @@ function getRuntime() {
             setEnvironmentAwareGraphQLBatchAdapter(environmentAwareGraphQLBatchAdapter);
         };
         const draftAwareCreateContentDocumentAndVersionAdapter = createContentDocumentAndVersionDraftAdapterFactory(lazyLuvio, NimbusBinaryStore, contentDocumentCompositeActionHandler);
-        const draftAwareCreateRecord = createRecordDraftAdapterFactory(lazyLuvio, uiApiRecordHandler);
-        const draftAwareUpdateRecord = updateRecordDraftAdapterFactory(lazyLuvio, uiApiRecordHandler);
-        const draftAwareDeleteRecord = deleteRecordDraftAdapterFactory(lazyLuvio, uiApiRecordHandler);
+        const draftAwareCreateRecord = createRecordDraftAdapterFactory(uiApiRecordHandler, lazyDurableStore);
+        const draftAwareUpdateRecord = updateRecordDraftAdapterFactory(uiApiRecordHandler, lazyDurableStore);
+        const draftAwareDeleteRecord = deleteRecordDraftAdapterFactory(uiApiRecordHandler);
         withRegistration('@salesforce/lds-adapters-uiapi-mobile', (registration) => {
             setLdsAdaptersUiapiInstrumentation(registration);
             registration.configuration.setDraftAwareCreateContentDocumentAndVersionAdapter(draftAwareCreateContentDocumentAndVersionAdapter);
@@ -19209,4 +16012,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.311.1-73c3329af5
+// version: 1.313.0-bf88d762e3