@salesforce/lds-adapters-graphql 1.124.1 → 1.124.3

package/dist/umd/es5/graphql-service.js

@@ -1,2182 +0,0 @@
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine'), require('@salesforce/lds-default-luvio'), require('@luvio/graphql-parser'), require('@salesforce/lds-adapters-uiapi'), require('@salesforce/lds-adapters-uiapi')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine', '@salesforce/lds-default-luvio', '@luvio/graphql-parser', '@salesforce/lds-adapters-uiapi', '@salesforce/lds-adapters-uiapi'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.graphqlService = {}, global.engine, global.ldsDefaultLuvio, global.graphqlParser, global.graphql, global.ldsAdaptersUiapi));
-})(this, (function (exports, engine, ldsDefaultLuvio, graphqlParser, graphql, ldsAdaptersUiapi) { 'use strict';
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __spreadArray(to, from, pack) {
-        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-            if (ar || !(i in from)) {
-                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-            }
-        }
-        return to.concat(ar || Array.prototype.slice.call(from));
-    }
-
-    var isArray = Array.isArray;
-    var keys = Object.keys, freeze = Object.freeze;
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-    var parse = JSON.parse, stringify = JSON.stringify;
-
-    function sortAndCopyUsingObjectKey(arr, key) {
-        return __spreadArray([], arr, true).sort(function (a, b) {
-            var aKey = a[key];
-            var bKey = b[key];
-            if (aKey < bKey) {
-                return -1;
-            }
-            if (aKey > bKey) {
-                return 1;
-            }
-            return 0;
-        });
-    }
-
-    function untrustedIsObject(untrusted) {
-        return typeof untrusted === 'object' && untrusted !== null && isArray(untrusted) === false;
-    }
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (var i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            var keys$1 = keys(value);
-            for (var i = 0, len = keys$1.length; i < len; i += 1) {
-                var v = value[keys$1[i]];
-                deepFreeze(v);
-            }
-        }
-        return freeze(value);
-    }
-    /**
-     * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
-     * This is needed because insertion order for JSON.stringify(object) affects output:
-     * JSON.stringify({a: 1, b: 2})
-     *      "{"a":1,"b":2}"
-     * JSON.stringify({b: 2, a: 1})
-     *      "{"b":2,"a":1}"
-     * @param data Data to be JSON-stringified.
-     * @returns JSON.stringified value with consistent ordering of keys.
-     */
-    function stableJSONStringify(node) {
-        // This is for Date values.
-        if (node && node.toJSON && typeof node.toJSON === 'function') {
-            // eslint-disable-next-line no-param-reassign
-            node = node.toJSON();
-        }
-        if (node === undefined) {
-            return '';
-        }
-        if (typeof node === 'number') {
-            return isFinite(node) ? '' + node : 'null';
-        }
-        if (typeof node !== 'object') {
-            return stringify(node);
-        }
-        var i;
-        var out;
-        if (isArray(node)) {
-            node.sort();
-            out = '[';
-            for (i = 0; i < node.length; i++) {
-                if (i) {
-                    out += ',';
-                }
-                out += stableJSONStringify(node[i]) || 'null';
-            }
-            return out + ']';
-        }
-        if (node === null) {
-            return 'null';
-        }
-        var keys$1 = keys(node).sort();
-        out = '';
-        for (i = 0; i < keys$1.length; i++) {
-            var key = keys$1[i];
-            var value = stableJSONStringify(node[key]);
-            if (!value) {
-                continue;
-            }
-            if (out) {
-                out += ',';
-            }
-            out += key + ':' + value;
-        }
-        return '{' + out + '}';
-    }
-    var namespace = 'GraphQL';
-    var representationName = 'graphql';
-
-    function serialize$1(args) {
-        return serializeArgs(args, { render: false });
-    }
-    function render$1(args, variables) {
-        return serializeArgs(args, { render: true, variables: variables });
-    }
-    function serializeArgs(args, option) {
-        var sortedArgs = option.render === true ? sortAndCopyUsingObjectKey(args, 'name') : args;
-        var str = '';
-        for (var i = 0, len = sortedArgs.length; i < len; i += 1) {
-            str = "".concat(str).concat(serializeArgumentNode(sortedArgs[i], option));
-            if (len > 1 && i < len - 1) {
-                str = "".concat(str, ",");
-            }
-        }
-        return str;
-    }
-    function serializeArgumentValueNode(valueDefinition, option) {
-        var kind = valueDefinition.kind;
-        switch (kind) {
-            case 'ObjectValue':
-                return serializeAndSortObjectValueNode(valueDefinition, option);
-            case 'ListValue':
-                return serializeAndSortListValueNode(valueDefinition, option);
-            case 'Variable':
-                return serializeVariableNode$1(valueDefinition, option);
-            default:
-                return serializeValueNode(valueDefinition);
-        }
-    }
-    function serializeVariableNode$1(literalValueNode, option) {
-        if (option.render === false) {
-            return "$".concat(literalValueNode.name);
-        }
-        return "".concat(serializeVariableValue(option.variables[literalValueNode.name]));
-    }
-    function serializeVariableValue(value) {
-        return stableJSONStringify(value);
-    }
-    function serializeAndSortListValueNode(objectValueDefinition, option) {
-        var values = objectValueDefinition.values;
-        var str = [];
-        var sorted = option.render === true ? sortAndCopyUsingObjectKey(values, 'value') : values;
-        for (var i = 0, len = sorted.length; i < len; i += 1) {
-            str.push(serializeArgumentValueNode(sorted[i], option));
-        }
-        return "[".concat(str.join(','), "]");
-    }
-    function serializeAndSortObjectValueNode(objectValueDefinition, option) {
-        var fields = objectValueDefinition.fields;
-        var str = '';
-        var fieldKeys = keys(fields).sort();
-        for (var i = 0, len = fieldKeys.length; i < len; i += 1) {
-            var fieldKey = fieldKeys[i];
-            str = "".concat(str).concat(fieldKey, ":").concat(serializeArgumentValueNode(fields[fieldKey], option));
-            if (len > 1 && i < len - 1) {
-                str = "".concat(str, ",");
-            }
-        }
-        return "{".concat(str, "}");
-    }
-    function serializeArgumentNode(arg, option) {
-        var name = arg.name, value = arg.value;
-        return "".concat(name, ":").concat(serializeArgumentValueNode(value, option));
-    }
-
-    function render(sel, variables) {
-        return serializeField(sel, { render: true, variables: variables });
-    }
-    function serializeField(sel, option) {
-        var fieldName = sel.name;
-        if (sel.kind === 'ScalarFieldSelection') {
-            return fieldName;
-        }
-        var selectionArguments = sel.arguments;
-        if (selectionArguments === undefined || selectionArguments.length === 0) {
-            return fieldName;
-        }
-        return "".concat(fieldName, "(").concat(option.render === true
-            ? render$1(selectionArguments, option.variables)
-            : serialize$1(selectionArguments), ")");
-    }
-
-    function readScalarFieldSelection(builder, source, fieldName, sink) {
-        var gqlData = source[fieldName];
-        if (gqlData !== undefined && gqlData !== null && gqlData.__ref !== undefined) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error("Scalar requested at \"".concat(fieldName, "\" but is instead an object at \"").concat(gqlData.__ref, "\""));
-            }
-        }
-        builder.readScalar(fieldName, source, sink);
-    }
-
-    var CUSTOM_FIELD_NODE_TYPE = 'Record';
-    var RECORD_DEFAULT_FIELD_VALUES = ['value', 'displayValue'];
-    function collectObjectFieldSelection(data) {
-        return {
-            value: data.value,
-            displayValue: data.displayValue,
-        };
-    }
-    function childTypeIsChildRelationships(sel, _data) {
-        return sel.type === CONNECTION_NODE_TYPE;
-    }
-    function childTypeIsSpanningGqlRecord(sel, _data) {
-        return sel.type === CUSTOM_FIELD_NODE_TYPE;
-    }
-    function convertAstToTrie(ast) {
-        var selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-        var children = {};
-        var trie = {
-            name: ast.name,
-            children: children,
-        };
-        for (var i = 0, len = selections.length; i < len; i += 1) {
-            var sel = getLuvioFieldNodeSelection(selections[i]);
-            var selName = sel.name, kind = sel.kind;
-            switch (kind) {
-                case 'ObjectFieldSelection': {
-                    children[selName] = {
-                        name: selName,
-                        children: {},
-                    };
-                    break;
-                }
-                case 'CustomFieldSelection': {
-                    children[selName] = convertAstToTrie(sel);
-                    break;
-                }
-            }
-        }
-        return trie;
-    }
-    function formatSpanningCustomFieldSelection(sel, data) {
-        if (data === null) {
-            return {
-                value: {
-                    displayValue: null,
-                    value: null,
-                },
-                trie: convertAstToTrie(sel),
-            };
-        }
-        var _a = convertToRecordRepresentation(sel, data), recordRepresentation = _a.recordRepresentation, fieldsTrie = _a.fieldsTrie;
-        return {
-            trie: fieldsTrie,
-            value: {
-                displayValue: data.DisplayValue,
-                value: recordRepresentation,
-            },
-        };
-    }
-    function convertToRecordRepresentation(ast, record) {
-        var Id = record.Id, WeakEtag = record.WeakEtag, ApiName = record.ApiName, LastModifiedById = record.LastModifiedById, LastModifiedDate = record.LastModifiedDate, SystemModstamp = record.SystemModstamp, ldsRecordTypeId = record.ldsRecordTypeId;
-        var luvioSelections = ast.luvioSelections;
-        if (luvioSelections === undefined) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Undefined selections');
-        }
-        var trieChildren = {};
-        var trie = {
-            name: ApiName,
-            children: trieChildren,
-        };
-        var childRelationships = {};
-        var fieldsBag = {};
-        for (var i = 0, len = luvioSelections.length; i < len; i += 1) {
-            var sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-            var fieldName = sel.name, alias = sel.alias;
-            var propertyName = alias === undefined ? fieldName : alias;
-            var data = record[propertyName];
-            switch (sel.kind) {
-                case 'ObjectFieldSelection': {
-                    trieChildren[fieldName] = {
-                        name: fieldName,
-                        children: {},
-                    };
-                    fieldsBag[fieldName] = collectObjectFieldSelection(data);
-                    break;
-                }
-                case 'CustomFieldSelection': {
-                    if (childTypeIsSpanningGqlRecord(sel)) {
-                        var _a = formatSpanningCustomFieldSelection(sel, data), value = _a.value, trie_1 = _a.trie;
-                        trieChildren[fieldName] = trie_1;
-                        fieldsBag[fieldName] = value;
-                    }
-                    else if (childTypeIsChildRelationships(sel)) {
-                        childRelationships[fieldName] = {
-                            ast: sel,
-                            data: data,
-                        };
-                    }
-                    break;
-                }
-            }
-        }
-        var rep = {
-            apiName: ApiName,
-            eTag: '',
-            lastModifiedById: LastModifiedById.value,
-            lastModifiedDate: LastModifiedDate.value,
-            systemModstamp: SystemModstamp.value,
-            recordTypeId: ldsRecordTypeId === null ? null : ldsRecordTypeId.value,
-            recordTypeInfo: null,
-            childRelationships: {},
-            id: Id,
-            weakEtag: WeakEtag,
-            fields: fieldsBag,
-        };
-        return {
-            recordRepresentation: rep,
-            fieldsTrie: trie,
-            childRelationships: childRelationships,
-        };
-    }
-    var defaultRecordFieldsFragmentName = 'defaultRecordFields';
-    var defaultRecordFieldsFragment = "fragment ".concat(defaultRecordFieldsFragmentName, " on Record { __typename, ApiName, WeakEtag, Id, DisplayValue, SystemModstamp { value } LastModifiedById { value } LastModifiedDate { value } ldsRecordTypeId: RecordTypeId(fallback: true) { value } }");
-    function getChildRelationshipsKey(recordKey, propertyName) {
-        return "".concat(recordKey, "__childRelationships__").concat(propertyName);
-    }
-    var createIngest$4 = function (ast, variables) {
-        return function (data, path, luvio, store, timestamp) {
-            var _a = convertToRecordRepresentation(ast, data), recordRepresentation = _a.recordRepresentation, fieldsTrie = _a.fieldsTrie, childRelationships = _a.childRelationships;
-            var ingestRecord = ldsAdaptersUiapi.createIngestRecordWithFields(fieldsTrie, {
-                name: recordRepresentation.apiName,
-                children: {},
-            });
-            var recordIngest = ingestRecord(recordRepresentation, path, luvio, store, timestamp);
-            var recordKey = recordIngest.__ref;
-            var childRelationshipKeys = Object.keys(childRelationships);
-            for (var i = 0, len = childRelationshipKeys.length; i < len; i += 1) {
-                var propertyName = childRelationshipKeys[i];
-                var childRelationship = childRelationships[propertyName];
-                var childRelationshipAst = childRelationship.ast, childRelationshipData = childRelationship.data;
-                var fullPath = getChildRelationshipsKey(recordKey, propertyName);
-                createIngest$1(childRelationshipAst, fullPath, variables)(childRelationshipData, {
-                    parent: {
-                        data: data,
-                        key: recordKey,
-                        existing: undefined,
-                    },
-                    fullPath: fullPath,
-                    propertyName: propertyName,
-                }, luvio, store, timestamp);
-            }
-            return recordIngest;
-        };
-    };
-    var recordProperties = {
-        Id: {
-            propertyName: 'id',
-        },
-        ApiName: {
-            propertyName: 'apiName',
-        },
-    };
-    function getNonSpanningField(sel, builder, source) {
-        var sink = {};
-        var luvioSelections = sel.luvioSelections;
-        if (luvioSelections === undefined) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Empty selections not supported');
-        }
-        for (var i = 0, len = luvioSelections.length; i < len; i += 1) {
-            var sel_1 = getLuvioFieldNodeSelection(luvioSelections[i]);
-            var kind = sel_1.kind;
-            var name_1 = sel_1.name;
-            builder.enterPath(name_1);
-            if (kind !== 'ScalarFieldSelection') {
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error("Unexpected kind \"".concat(kind, "\""));
-                }
-            }
-            builder.assignScalar(name_1, sink, source[name_1]);
-            builder.exitPath();
-        }
-        return sink;
-    }
-    function getCustomSelection(luvio, selection, builder, options, variables) {
-        var type = selection.type;
-        switch (type) {
-            case 'Record':
-                return readRecordRepresentation(luvio, selection, builder, options, variables);
-        }
-    }
-    function getScalarValue(selectionName, state) {
-        if (selectionName === 'DisplayValue') {
-            var parentFieldValue = state.parentFieldValue;
-            if (parentFieldValue === undefined) {
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error('Unable to calculate DisplayValue');
-                }
-                else {
-                    return undefined;
-                }
-            }
-            return parentFieldValue.displayValue;
-        }
-        var assignment = recordProperties[selectionName];
-        if (assignment === undefined) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error("Unknown assignment for ScalarFieldSelection at property \"".concat(selectionName, "\""));
-            }
-        }
-        return state.source[assignment.propertyName];
-    }
-    function assignConnectionSelection(luvio, builder, sink, sel, recordKey, propertyName, variables) {
-        var key = getChildRelationshipsKey(recordKey, propertyName);
-        var resolved = resolveKey(builder, key);
-        if (resolved === undefined) {
-            return;
-        }
-        var data = createRead$2(luvio, sel, variables)(resolved.value, builder);
-        builder.assignNonScalar(sink, propertyName, data);
-    }
-    function assignSelection(luvio, selection, builder, state, variables) {
-        var sel = getLuvioFieldNodeSelection(selection);
-        var selectionName = sel.name, kind = sel.kind, alias = sel.alias;
-        var propertyName = alias === undefined ? selectionName : alias;
-        var source = state.source, sink = state.sink;
-        var fields = source.fields;
-        builder.enterPath(selectionName);
-        switch (kind) {
-            case 'ScalarFieldSelection': {
-                builder.assignScalar(propertyName, sink, getScalarValue(selectionName, state));
-                break;
-            }
-            case 'ObjectFieldSelection': {
-                // regular field, not spanning
-                var field = propertyLookup(builder, selectionName, fields);
-                if (field.state === PropertyLookupResultState.Missing) {
-                    break;
-                }
-                var resolved = resolveLink(builder, field.value);
-                if (resolved === undefined) {
-                    break;
-                }
-                var data = getNonSpanningField(sel, builder, resolved.value);
-                builder.assignNonScalar(sink, propertyName, data);
-                break;
-            }
-            case 'CustomFieldSelection': {
-                if (sel.type === 'Connection') {
-                    var recordKey = ldsAdaptersUiapi.keyBuilderRecord(luvio, {
-                        recordId: state.source.id,
-                    });
-                    assignConnectionSelection(luvio, builder, sink, sel, recordKey, propertyName, variables);
-                }
-                else {
-                    var field = fields[selectionName];
-                    var resolvedParentFieldValue = resolveLink(builder, field);
-                    if (resolvedParentFieldValue === undefined) {
-                        break;
-                    }
-                    var spanningFieldResult = resolvedParentFieldValue.value;
-                    var spanningFieldValue = spanningFieldResult.value;
-                    if (spanningFieldValue === null || typeof spanningFieldValue !== 'object') {
-                        sink[propertyName] = null;
-                        break;
-                    }
-                    var resolvedSpanningRecordValue = resolveLink(builder, spanningFieldValue);
-                    if (resolvedSpanningRecordValue === undefined) {
-                        break;
-                    }
-                    var data = getCustomSelection(luvio, sel, builder, {
-                        source: resolvedSpanningRecordValue.value,
-                        parentFieldValue: spanningFieldResult,
-                    }, variables);
-                    builder.assignNonScalar(sink, propertyName, data);
-                }
-            }
-        }
-        builder.exitPath();
-    }
-    function readRecordRepresentation(luvio, ast, builder, options, variables) {
-        var luvioSelections = ast.luvioSelections;
-        if (luvioSelections === undefined) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('Empty selections not supported');
-        }
-        var sink = {};
-        var state = {
-            source: options.source,
-            sink: sink,
-            parentFieldValue: options.parentFieldValue,
-        };
-        for (var i = 0, len = luvioSelections.length; i < len; i += 1) {
-            assignSelection(luvio, luvioSelections[i], builder, state, variables);
-        }
-        return sink;
-    }
-    var createRead$3 = function (luvio, ast, variables) {
-        return function (data, builder) {
-            return readRecordRepresentation(luvio, ast, builder, {
-                source: data,
-                parentFieldValue: undefined,
-            }, variables);
-        };
-    };
-
-    var createIngest$3 = function (ast, variables) {
-        var type = ast.type;
-        switch (type) {
-            case CUSTOM_FIELD_NODE_TYPE:
-                return createIngest$4(ast, variables);
-            case CONNECTION_NODE_TYPE:
-                return createIngest$1(ast, keyBuilder(ast, variables), variables);
-        }
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error("Unsupported type: \"".concat(type, "\""));
-    };
-
-    function merge(existing, incoming) {
-        if (existing === undefined) {
-            return incoming;
-        }
-        // Merge existing and incoming values together
-        return __assign(__assign({}, existing), incoming);
-    }
-
-    function resolveValue(ast, variables, source) {
-        var alias = ast.alias;
-        var propertyName = render(ast, variables);
-        if (process.env.NODE_ENV !== 'production') {
-            if (alias !== undefined && alias in source) {
-                throw new Error("Invalid alias \"".concat(alias, "\" passed to \"equal\" function. All aliases need to be normalized before calling equal"));
-            }
-        }
-        return source[propertyName];
-    }
-    function linkEquals(ast, variables, existing, incoming) {
-        var value = resolveValue(ast, variables, existing);
-        if (value === undefined) {
-            return false;
-        }
-        var incomingLink = resolveValue(ast, variables, incoming);
-        if (process.env.NODE_ENV !== 'production') {
-            if (incomingLink === undefined) {
-                throw new Error('Unexpected undefined link');
-            }
-        }
-        return value.__ref === incomingLink.__ref;
-    }
-    function scalarFieldEquals(ast, variables, existing, incoming) {
-        var name = ast.name;
-        var value = existing[name];
-        if (value === undefined) {
-            return false;
-        }
-        return value === resolveValue(ast, variables, incoming);
-    }
-    function equals(ast, variables, existing, incoming) {
-        var selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-        for (var i = 0, len = selections.length; i < len; i += 1) {
-            var sel = getLuvioFieldNodeSelection(selections[i]);
-            if (sel.kind === 'ScalarFieldSelection') {
-                if (scalarFieldEquals(sel, variables, existing, incoming) === false) {
-                    return false;
-                }
-            }
-            else {
-                if (linkEquals(sel, variables, existing, incoming) === false) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-
-    var DEFAULT_GRAPHQL_TTL = 30000;
-    var GRAPHQL_INGEST_VERSION = 'GRAPHQL_INGEST_VERSION_1';
-    function createIngest$2(ast, variables) {
-        if (ast.kind === 'CustomFieldSelection') {
-            return createIngest$3(ast, variables);
-        }
-        return genericCreateIngest(ast, variables);
-    }
-    function publishDataIfChanged(params) {
-        var store = params.store, key = params.key, ast = params.ast, incoming = params.incoming, luvio = params.luvio, variables = params.variables;
-        var existing = store.readEntry(key);
-        if (existing === undefined || equals(ast, variables, existing, incoming) === false) {
-            var newData = merge(existing, incoming);
-            luvio.storePublish(key, newData);
-        }
-    }
-    function genericCreateIngest(ast, variables) {
-        var selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-        return function (data, path, luvio, store, timestamp) {
-            var fullPath = path.fullPath;
-            for (var i = 0, len = selections.length; i < len; i += 1) {
-                var sel = getLuvioFieldNodeSelection(selections[i]);
-                if (sel.kind === 'ScalarFieldSelection') {
-                    continue;
-                }
-                var fieldName = sel.name, alias = sel.alias;
-                var readPropertyName = alias === undefined ? fieldName : alias;
-                var propertyFullPath = "".concat(fullPath, "__").concat(fieldName);
-                var writePropertyName = render(sel, variables);
-                var childPath = {
-                    parent: {
-                        existing: null,
-                        key: fullPath,
-                        data: data,
-                    },
-                    propertyName: readPropertyName,
-                    fullPath: propertyFullPath,
-                };
-                data[writePropertyName] = createIngest$2(sel, variables)(data[readPropertyName], childPath, luvio, store, timestamp);
-                if (writePropertyName !== readPropertyName && data[readPropertyName] !== undefined) {
-                    delete data[readPropertyName];
-                }
-            }
-            publishDataIfChanged({
-                ast: ast,
-                luvio: luvio,
-                store: store,
-                key: fullPath,
-                variables: {},
-                incoming: data,
-            });
-            if (data && data.__typename !== undefined) {
-                luvio.publishStoreMetadata(fullPath, {
-                    representationName: data.__typename,
-                    namespace: namespace,
-                    ttl: DEFAULT_GRAPHQL_TTL,
-                    version: GRAPHQL_INGEST_VERSION,
-                });
-            }
-            return {
-                __ref: fullPath,
-            };
-        };
-    }
-
-    var CONNECTION_NODE_TYPE = 'Connection';
-    var TYPENAME_FIELD$1 = '__typename';
-    var PAGE_INFO_REQUIRED_FIELDS = ['hasNextPage', 'hasPreviousPage'];
-    var EDGE_REQUIRED_FIELDS = ['cursor'];
-    var PROPERTY_NAME_EDGES = 'edges';
-    var PROPERTY_NAME_PAGE_INFO = 'pageInfo';
-    var PROPERTY_NAME_TOTAL_COUNT = 'totalCount';
-    function keyBuilder(ast, variables) {
-        var args = ast.arguments, name = ast.name;
-        if (args === undefined) {
-            return "".concat(namespace, "::").concat(CONNECTION_NODE_TYPE, ":").concat(name, "()");
-        }
-        var serialized = render$1(args, variables);
-        return "".concat(namespace, "::").concat(CONNECTION_NODE_TYPE, ":").concat(name, "(").concat(serialized, ")");
-    }
-    function selectEdges(luvio, builder, ast, links, variables) {
-        var sink = [];
-        for (var i = 0, len = links.length; i < len; i += 1) {
-            builder.enterPath(i);
-            var link = links[i];
-            var resolved = followLink(luvio, ast, builder, link, variables);
-            builder.assignNonScalar(sink, i, resolved);
-            builder.exitPath();
-        }
-        return sink;
-    }
-    var createRead$2 = function (luvio, ast, variables) {
-        var selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-        return function (source, builder) {
-            var sink = {};
-            for (var i = 0, len = selections.length; i < len; i += 1) {
-                var sel = getLuvioFieldNodeSelection(selections[i]);
-                var name_1 = sel.name, kind = sel.kind;
-                if (kind === 'ScalarFieldSelection') {
-                    readScalarFieldSelection(builder, source, name_1, sink);
-                    continue;
-                }
-                var readPropertyName = render(sel, variables);
-                builder.enterPath(readPropertyName);
-                var edges = resolveLink(builder, source[readPropertyName]);
-                if (edges === undefined) {
-                    builder.exitPath();
-                    break;
-                }
-                if (readPropertyName === PROPERTY_NAME_EDGES) {
-                    var data = selectEdges(luvio, builder, sel, edges.value, variables);
-                    builder.assignNonScalar(sink, readPropertyName, data);
-                }
-                else {
-                    if (process.env.NODE_ENV !== 'production') {
-                        throw new Error('Not supported');
-                    }
-                }
-                builder.exitPath();
-            }
-            return sink;
-        };
-    };
-    function ingestConnectionProperty(sel, data, path, luvio, store, timestamp, variables) {
-        var propertyName = sel.name;
-        switch (propertyName) {
-            case PROPERTY_NAME_EDGES:
-                return ingestConnectionEdges(sel, data, path, luvio, store, timestamp, variables);
-        }
-    }
-    function ingestConnectionEdges(sel, data, path, luvio, store, timestamp, variables) {
-        var key = path.fullPath;
-        var existing = store.readEntry(key);
-        var hasChanges = existing === undefined || data.length !== existing.length;
-        for (var i = 0, len = data.length; i < len; i += 1) {
-            var incomingItem = (data[i] = createIngest$2(sel, variables)(data[i], {
-                parent: {
-                    data: data,
-                    existing: null,
-                    key: key,
-                },
-                propertyName: i,
-                fullPath: "".concat(key, "__").concat(i),
-            }, luvio, store, timestamp));
-            var existingItem = existing !== undefined ? existing[i] : undefined;
-            if (existingItem === undefined || existingItem.__ref !== incomingItem.__ref) {
-                hasChanges = true;
-            }
-        }
-        if (hasChanges === true) {
-            luvio.storePublish(key, data);
-        }
-        luvio.publishStoreMetadata(key, {
-            representationName: CONNECTION_NODE_TYPE,
-            namespace: namespace,
-            ttl: DEFAULT_GRAPHQL_TTL,
-            version: GRAPHQL_INGEST_VERSION,
-        });
-        return {
-            __ref: key,
-        };
-    }
-    var createIngest$1 = function (ast, key, variables) {
-        var luvioSelections = ast.luvioSelections;
-        var selections = luvioSelections === undefined ? [] : luvioSelections;
-        return function (data, path, luvio, store, timestamp) {
-            for (var i = 0, len = selections.length; i < len; i += 1) {
-                var sel = getLuvioFieldNodeSelection(selections[i]);
-                var kind = sel.kind;
-                var propertyName = sel.name;
-                if (kind !== 'ObjectFieldSelection') {
-                    continue;
-                }
-                data[propertyName] = ingestConnectionProperty(sel, data[propertyName], {
-                    parent: {
-                        existing: null,
-                        key: key,
-                        data: data,
-                    },
-                    fullPath: "".concat(key, "__").concat(propertyName),
-                    propertyName: propertyName,
-                }, luvio, store, timestamp, variables);
-            }
-            publishDataIfChanged({
-                key: key,
-                luvio: luvio,
-                store: store,
-                incoming: data,
-                variables: {},
-                ast: ast,
-            });
-            var typeName = data.__typename;
-            luvio.publishStoreMetadata(key, {
-                representationName: typeName,
-                namespace: namespace,
-                ttl: DEFAULT_GRAPHQL_TTL,
-                version: GRAPHQL_INGEST_VERSION,
-            });
-            return {
-                __ref: key,
-            };
-        };
-    };
-    function serialize(def, state) {
-        var luvioSelections = def.luvioSelections, args = def.arguments;
-        if (luvioSelections === undefined) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('Connection field node must have selections');
-            }
-            return '';
-        }
-        var argsString = args === undefined || args.length === 0 ? '' : "(".concat(serializeArguments(args), ")");
-        var seenFields = {};
-        var serializedFields = [];
-        for (var i = 0; i < luvioSelections.length; i++) {
-            var sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-            var fieldName = sel.name;
-            seenFields[fieldName] = true;
-            if (fieldName === PROPERTY_NAME_PAGE_INFO) {
-                serializedFields.push(serializePageInfo(sel, state));
-            }
-            else if (fieldName === PROPERTY_NAME_EDGES) {
-                serializedFields.push(serializeEdges(sel, state));
-            }
-            else {
-                serializedFields.push(serializeFieldNode(sel, state));
-            }
-        }
-        appendRequiredConnectionFields(seenFields, serializedFields);
-        return "".concat(serializeFieldNodeName(def)).concat(argsString, " { ").concat(serializedFields.join(' '), " }");
-    }
-    function serializeEdges(node, state) {
-        if (!isLuvioFieldNodeObjectFieldNode(node)) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('PageInfo must be an ObjectFieldNode');
-            }
-            return '';
-        }
-        var luvioSelections = node.luvioSelections;
-        if (luvioSelections === undefined)
-            return '';
-        var seenFields = {};
-        var serializedFields = [];
-        for (var i = 0; i < luvioSelections.length; i++) {
-            var sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-            seenFields[sel.name] = true;
-            serializedFields.push(serializeFieldNode(sel, state));
-        }
-        appendRequiredFields(EDGE_REQUIRED_FIELDS, seenFields, serializedFields);
-        insertTypeName(seenFields, serializedFields);
-        return "".concat(serializeFieldNodeName(node), " { ").concat(serializedFields.join(' '), " }");
-    }
-    function serializePageInfo(node, state) {
-        if (!isLuvioFieldNodeObjectFieldNode(node)) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('PageInfo must be an ObjectFieldNode');
-            }
-            return '';
-        }
-        var luvioSelections = node.luvioSelections;
-        if (luvioSelections === undefined)
-            return '';
-        var seenFields = {};
-        var serializedFields = [];
-        for (var i = 0; i < luvioSelections.length; i++) {
-            var sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-            seenFields[sel.name] = true;
-            serializedFields.push(serializeFieldNode(sel, state));
-        }
-        appendRequiredFields(PAGE_INFO_REQUIRED_FIELDS, seenFields, serializedFields);
-        return "".concat(serializeFieldNodeName(node), " { ").concat(serializedFields.join(' '), " }");
-    }
-    function appendRequiredFields(requiredFields, seenFields, result) {
-        for (var i = 0; i < requiredFields.length; i++) {
-            var fieldName = requiredFields[i];
-            if (seenFields[fieldName] !== true) {
-                result.push(fieldName);
-            }
-        }
-    }
-    function appendRequiredConnectionFields(seenFields, result) {
-        if (seenFields[PROPERTY_NAME_PAGE_INFO] !== true) {
-            result.push('pageInfo { hasNextPage hasPreviousPage }');
-        }
-        if (seenFields[PROPERTY_NAME_TOTAL_COUNT] !== true) {
-            result.push(PROPERTY_NAME_TOTAL_COUNT);
-        }
-        insertTypeName(seenFields, result);
-    }
-    function insertTypeName(seenFields, result) {
-        if (seenFields[TYPENAME_FIELD$1] !== true) {
-            result.unshift(TYPENAME_FIELD$1);
-        }
-    }
-
-    function createCustomFieldRead(luvio, sel, variables) {
-        if (sel.type === 'Connection') {
-            return createRead$2(luvio, sel, variables);
-        }
-        return createRead$3(luvio, sel, variables);
-    }
-    function createRead$1(luvio, ast, variables) {
-        if (ast.kind === 'CustomFieldSelection') {
-            return createCustomFieldRead(luvio, ast, variables);
-        }
-        if (ast.kind === 'FragmentSpread' ||
-            ast.kind === 'InlineFragment' ||
-            ast.kind === 'ScalarFieldSelection') {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('"FragmentSpread" and "InlineFragment" currently not supported');
-        }
-        return genericCreateRead(luvio, ast, variables);
-    }
-    var genericCreateRead = function (luvio, ast, variables) {
-        var selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-        return function (source, builder) {
-            var sink = {};
-            for (var i = 0, len = selections.length; i < len; i += 1) {
-                var sel = getLuvioFieldNodeSelection(selections[i]);
-                var fieldName = sel.name, alias = sel.alias;
-                var propertyName = alias === undefined ? fieldName : alias;
-                builder.enterPath(fieldName);
-                switch (sel.kind) {
-                    case 'ScalarFieldSelection':
-                        readScalarFieldSelection(builder, source, fieldName, sink);
-                        break;
-                    default: {
-                        var data = followLink(luvio, sel, builder, source[render(sel, variables)], variables);
-                        builder.assignNonScalar(sink, propertyName, data);
-                    }
-                }
-                builder.exitPath();
-            }
-            return sink;
-        };
-    };
-
-    var PropertyLookupResultState;
-    (function (PropertyLookupResultState) {
-        PropertyLookupResultState[PropertyLookupResultState["Missing"] = 0] = "Missing";
-        PropertyLookupResultState[PropertyLookupResultState["Present"] = 1] = "Present";
-    })(PropertyLookupResultState || (PropertyLookupResultState = {}));
-    var objectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty;
-    function propertyLookup(builder, key, source) {
-        if (objectPrototypeHasOwnProperty.call(source, key) === false) {
-            builder.markMissing();
-            return {
-                state: PropertyLookupResultState.Missing,
-            };
-        }
-        return {
-            state: PropertyLookupResultState.Present,
-            value: source[key],
-        };
-    }
-    function markStoreResolveResultSeen(builder, state) {
-        var redirects = state.redirects, resolvedKey = state.resolvedKey;
-        builder.markSeenId(resolvedKey);
-        var len = redirects.length;
-        if (len === 0) {
-            return;
-        }
-        for (var i = 0; i < len; i += 1) {
-            builder.markSeenId(redirects[i]);
-        }
-    }
-    function resolveKey(builder, key) {
-        var StoreResolveResultState = builder.StoreResolveResultState;
-        var lookup = builder.storeLookup(key);
-        markStoreResolveResultSeen(builder, lookup);
-        switch (lookup.state) {
-            case StoreResolveResultState.NotPresent:
-                builder.markMissingLink(key);
-                return;
-            case StoreResolveResultState.Stale:
-                builder.markStale();
-                return lookup;
-            case StoreResolveResultState.Error:
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error('TODO: Implement error links');
-                }
-                else {
-                    return;
-                }
-        }
-        return lookup;
-    }
-    function resolveLink(builder, storeLink) {
-        var StoreLinkStateValues = builder.StoreLinkStateValues;
-        var linkState = builder.getLinkState(storeLink);
-        switch (linkState.state) {
-            case StoreLinkStateValues.RefNotPresent:
-            case StoreLinkStateValues.NotPresent:
-            case StoreLinkStateValues.Missing:
-                builder.markMissing();
-                return;
-            case StoreLinkStateValues.Pending:
-                builder.markPending();
-                return;
-            case StoreLinkStateValues.Null:
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error("TODO: Invalid Link State. Link on \"".concat(builder.currentPath.fullPath, "\""));
-                }
-                else {
-                    return;
-                }
-        }
-        var __ref = linkState.key;
-        return resolveKey(builder, __ref);
-    }
-    function followLink(luvio, sel, builder, storeLink, variables) {
-        var linkState = resolveLink(builder, storeLink);
-        if (linkState === undefined) {
-            return;
-        }
-        var value = linkState.value;
-        return createRead$1(luvio, sel, variables)(value, builder);
-    }
-    function getLuvioFieldNodeSelection(ast) {
-        var kind = ast.kind;
-        if (kind === 'FragmentSpread' || kind === 'InlineFragment') {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('"FragmentSpread" and "InlineFragment" currently not supported');
-            }
-        }
-        return ast;
-    }
-
-    var TYPENAME_FIELD = '__typename';
-    var KIND_OBJECT_FIELD_SELECTION = 'ObjectFieldSelection';
-    function serializeFieldNodeName(node) {
-        var name = node.name, alias = node.alias;
-        return alias === undefined ? "".concat(name) : "".concat(alias, ": ").concat(name);
-    }
-    function serializeSelections(selections, state) {
-        if (selections === undefined) {
-            return '';
-        }
-        var str = '';
-        for (var i = 0, len = selections.length; i < len; i += 1) {
-            var def = serializeFieldNode(selections[i], state);
-            str = "".concat(str).concat(def);
-        }
-        return str;
-    }
-    function serializeFieldNode(def, state) {
-        var kind = def.kind;
-        switch (kind) {
-            case 'ObjectFieldSelection':
-                return serializeObjectFieldNode(def, state);
-            case 'CustomFieldSelection':
-                return serializeCustomFieldNode(def, state);
-            case 'ScalarFieldSelection':
-                return serializeScalarFieldNode(def);
-        }
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error("Unable to serialize graphql query, unsupported field node \"".concat(kind, "\""));
-        }
-        return '';
-    }
-    function serializeObjectFieldNode(def, state) {
-        var luvioSelections = def.luvioSelections, defArgs = def.arguments;
-        var args = defArgs === undefined ? '' : "(".concat(serializeArguments(defArgs), ")");
-        return "".concat(serializeFieldNodeName(def)).concat(args, " { ").concat(TYPENAME_FIELD, " ").concat(serializeSelections(luvioSelections, state), " }");
-    }
-    function serializeCustomFieldNode(def, state) {
-        var type = def.type;
-        switch (type) {
-            case 'Connection':
-                return serialize(def, state);
-            case 'Record':
-                return serializeCustomFieldRecord(def, state);
-        }
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error("Unable to serialize graphql query, unsupported CustomField type \"".concat(type, "\""));
-        }
-        return '';
-    }
-    function serializeScalarFieldNode(def) {
-        return "".concat(serializeFieldNodeName(def), ", ");
-    }
-    function serializeRecordSelections(selections, state) {
-        if (selections === undefined) {
-            return '';
-        }
-        var str = '';
-        for (var i = 0, len = selections.length; i < len; i += 1) {
-            var sel = getLuvioFieldNodeSelection(selections[i]);
-            sel.name;
-            var def = isLuvioFieldNodeObjectFieldNode(sel)
-                ? serializeObjectFieldNodeUnderRecord(sel)
-                : serializeFieldNode(sel, state);
-            str = "".concat(str).concat(def);
-        }
-        return str;
-    }
-    function isLuvioFieldNodeObjectFieldNode(node) {
-        return node.kind === KIND_OBJECT_FIELD_SELECTION;
-    }
-    function serializeObjectFieldNodeUnderRecord(node) {
-        var luvioSelections = node.luvioSelections, nodeArgs = node.arguments, nodeName = node.name;
-        var fields = {};
-        var result = "";
-        if (luvioSelections === undefined) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('selection should not be empty for ObjectFieldNodeUnderRecord');
-        }
-        var luvioSelectionsLength = luvioSelections.length;
-        for (var i = 0; i < luvioSelectionsLength; i++) {
-            var sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-            var name_2 = sel.name;
-            if (sel.kind !== 'ScalarFieldSelection') {
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error("Invalid selection for ".concat(nodeName, ". ").concat(nodeName, " appears to be a Record, but is missing @resource(type: \"Record\")"));
-                }
-            }
-            if (RECORD_DEFAULT_FIELD_VALUES.indexOf(name_2) === -1) {
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error("Invalid selection for \"".concat(nodeName, ".").concat(name_2, "\". Only ").concat(RECORD_DEFAULT_FIELD_VALUES.join(', '), " are supported. If \"").concat(nodeName, "\" is a spanning Record, please include @resource(type: \"Record\") directive."));
-                }
-            }
-            fields[name_2] = true;
-            result = "".concat(result).concat(serializeScalarFieldNode(sel));
-        }
-        result = appendRecordDefaultFieldValues(result, fields);
-        var args = nodeArgs === undefined ? '' : "(".concat(serializeArguments(nodeArgs), ")");
-        return "".concat(serializeFieldNodeName(node)).concat(args, " { ").concat(TYPENAME_FIELD, " ").concat(result, " }");
-    }
-    function appendRecordDefaultFieldValues(fieldValues, fieldValuesMap) {
-        var str = fieldValues;
-        for (var i = 0, len = RECORD_DEFAULT_FIELD_VALUES.length; i < len; i++) {
-            var defaultField = RECORD_DEFAULT_FIELD_VALUES[i];
-            if (fieldValuesMap[defaultField] !== true) {
-                str = "".concat(str).concat(defaultField, ", ");
-            }
-        }
-        return str;
-    }
-    function appendSpanningRecordIds(luvioSelections) {
-        if (luvioSelections === undefined) {
-            return undefined;
-        }
-        //add record ref ids
-        var spanningRecordIdFields = [];
-        var selections = luvioSelections;
-        //Find all fields with a record type declaration and add the corresponding
-        //reference ID.
-        // TODO [W-11342283]:  This approach uses a naming pattern that is brittle and not
-        // guaranteed to work in the long run.  A more correct approach is to thread through
-        // ObjectInfo schemas and use its mapping definitions.
-        for (var i = 0; i < selections.length; i++) {
-            var selection = selections[i];
-            if (selection.kind === 'CustomFieldSelection' && selection.type === 'Record') {
-                var customFieldMatches = selection.name.match(/(.*__)r$/);
-                if (customFieldMatches) {
-                    // For `FSL__Related_Service__r {...}`, inject `FSL__Related_Service__c { value } as a peer field`
-                    var captureGroup = customFieldMatches[1];
-                    spanningRecordIdFields.push("".concat(captureGroup, "c"));
-                }
-                else {
-                    // For `Owner {...}`, inject `OwnerId { value } as a peer field`
-                    spanningRecordIdFields.push("".concat(selection.name, "Id"));
-                }
-            }
-        }
-        var _loop_1 = function (i) {
-            var idField = spanningRecordIdFields[i];
-            if (selections.findIndex(function (e) { return e.kind === 'ObjectFieldSelection' && e.name === idField; }) >
-                -1) {
-                return "continue";
-            }
-            selections.push({
-                kind: 'ObjectFieldSelection',
-                name: idField,
-                luvioSelections: [{ kind: 'ScalarFieldSelection', name: 'value' }],
-            });
-        };
-        //Add all missing reference IDs to the set of selections
-        for (var i = 0; i < spanningRecordIdFields.length; i++) {
-            _loop_1(i);
-        }
-        return selections;
-    }
-    function serializeCustomFieldRecord(def, state) {
-        var luvioSelections = def.luvioSelections;
-        if (state.fragments[defaultRecordFieldsFragmentName] === undefined) {
-            state.fragments[defaultRecordFieldsFragmentName] = defaultRecordFieldsFragment;
-        }
-        var selections = appendSpanningRecordIds(luvioSelections);
-        return "".concat(serializeFieldNodeName(def), " { ").concat(serializeRecordSelections(selections, state), " ...").concat(defaultRecordFieldsFragmentName, " }");
-    }
-    function serializeArguments(argDefinitions) {
-        if (argDefinitions === undefined) {
-            return '';
-        }
-        var str = '';
-        for (var i = 0, len = argDefinitions.length; i < len; i += 1) {
-            var def = serializeArgument(argDefinitions[i]);
-            if (i !== 0) {
-                def = " ".concat(def);
-            }
-            str = "".concat(str).concat(def);
-        }
-        return str;
-    }
-    function serializeArgument(argDefinition) {
-        var name = argDefinition.name, value = argDefinition.value;
-        return "".concat(name, ": ").concat(serializeValueNode(value));
-    }
-
-    function serializeValueNode(valueDefinition) {
-        var kind = valueDefinition.kind;
-        switch (kind) {
-            case 'ObjectValue':
-                return serializeObjectValueNode(valueDefinition);
-            case 'StringValue':
-                return serializeStringValueNode(valueDefinition);
-            case 'NullValue':
-                return 'null';
-            case 'FloatValue':
-            case 'IntValue':
-            case 'BooleanValue':
-            case 'EnumValue':
-                return valueDefinition.value;
-            case 'Variable':
-                return serializeVariableNode(valueDefinition);
-            case 'ListValue':
-                return serializeListValueNode(valueDefinition);
-        }
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error("Unable to serialize graphql query, unsupported value node \"".concat(kind, "\""));
-        }
-    }
-    function serializeVariableNode(variableNode) {
-        return "$".concat(variableNode.name);
-    }
-    function serializeListValueNode(listNode) {
-        var values = listNode.values;
-        if (values.length === 0) {
-            return '';
-        }
-        var str = '';
-        for (var i = 0, len = values.length; i < len; i += 1) {
-            str = "".concat(str).concat(serializeValueNode(values[i]), ", ");
-        }
-        return "[".concat(str.substring(0, str.length - 2), "]");
-    }
-    function serializeStringValueNode(literalValueNode) {
-        return "\"".concat(literalValueNode.value, "\"");
-    }
-    function serializeObjectValueNode(objectValueDefinition) {
-        var fields = objectValueDefinition.fields;
-        var str = [];
-        var fieldKeys = keys(fields);
-        for (var i = 0, len = fieldKeys.length; i < len; i += 1) {
-            var fieldKey = fieldKeys[i];
-            str.push("".concat(fieldKey, ": ").concat(serializeValueNode(fields[fieldKey])));
-        }
-        return "{ ".concat(str.join(', '), " }");
-    }
-    function serializeVariableDefinitions(definitons) {
-        if (definitons === undefined || definitons.length === 0) {
-            return '';
-        }
-        var str = '';
-        for (var i = 0, len = definitons.length; i < len; i += 1) {
-            var def = serializeVariableDefinitionNode(definitons[i]);
-            str = "".concat(str).concat(def, ", ");
-        }
-        return " (".concat(str.substring(0, str.length - 2), ")");
-    }
-    function serializeVariableDefinitionNode(def) {
-        var variable = def.variable, type = def.type, defaultValue = def.defaultValue;
-        return defaultValue === undefined
-            ? "$".concat(variable.name, ": ").concat(serializeTypeNode(type))
-            : "$".concat(variable.name, ": ").concat(serializeTypeNode(type), " = ").concat(serializeValueNode(defaultValue));
-    }
-    function serializeTypeNode(type) {
-        var kind = type.kind;
-        switch (kind) {
-            case 'NamedType':
-                return serializeNamedTypeNode(type);
-            case 'ListType':
-                return serializeListTypeNode(type);
-        }
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error("Unable to serialize graphql query, unsupported variable definition type node \"".concat(type.kind, "\""));
-        }
-        return '';
-    }
-    function serializeNamedTypeNode(type) {
-        return type.name;
-    }
-    function serializeListTypeNode(type) {
-        return "[".concat(serializeTypeNode(type.type), "]");
-    }
-    function serializeOperationNode(def, state) {
-        var kind = def.kind;
-        switch (kind) {
-            case 'OperationDefinition':
-                return serializeOperationDefinition(def, state);
-        }
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error("Unable to serialize graphql query, unsupported OperationDefinition type \"".concat(kind, "\""));
-        }
-    }
-    function serializeOperationDefinition(def, state) {
-        var operation = def.operation, luvioSelections = def.luvioSelections, name = def.name, variableDefinitions = def.variableDefinitions;
-        var nameStr = name === undefined ? ' ' : " ".concat(name, " ");
-        return "".concat(operation).concat(nameStr).concat(serializeVariableDefinitions(variableDefinitions), "{ ").concat(TYPENAME_FIELD, " ").concat(serializeSelections(luvioSelections, state), " }");
-    }
-    function applyFragments(str, fragments) {
-        var appliedString = str;
-        var fragmentNames = Object.keys(fragments);
-        for (var i = 0, len = fragmentNames.length; i < len; i += 1) {
-            var name_1 = fragmentNames[i];
-            appliedString = "".concat(appliedString, " ").concat(fragments[name_1]);
-        }
-        return appliedString;
-    }
-    function astToString(ast) {
-        var definitions = ast.definitions;
-        var state = {
-            fragments: {},
-        };
-        var str = '';
-        for (var i = 0, len = definitions.length; i < len; i += 1) {
-            var def = serializeOperationNode(definitions[i], state);
-            str = "".concat(str).concat(def);
-        }
-        return applyFragments(str, state.fragments);
-    }
-
-    function isGraphQLVariables(unknown) {
-        return untrustedIsObject(unknown);
-    }
-    function validateVariableDefinitions(definitons, variables) {
-        var errors = [];
-        for (var i = 0, len = definitons.length; i < len; i += 1) {
-            var _a = definitons[i], variable = _a.variable, type = _a.type, defaultValue = _a.defaultValue;
-            var value = getVariableValue(variable.name, variables, defaultValue);
-            if (value === undefined) {
-                errors.push("Variable $".concat(variable.name, " has an undefined value provided for it."));
-            }
-            if (type.kind === 'NonNullType' && value === null) {
-                errors.push("Expected a non-null value to be provided as value for $".concat(variable.name));
-            }
-            if (type.kind === 'ListType' && value !== null && !Array.isArray(value)) {
-                errors.push("Expected a list to be provided as value for $".concat(variable.name));
-            }
-        }
-        return errors;
-    }
-    function getVariableValue(name, variables, defaultValue) {
-        if (name in variables) {
-            return variables[name];
-        }
-        if (defaultValue === undefined) {
-            return null;
-        }
-        return defaultValue;
-    }
-
-    function validate$1(ast, variables) {
-        var variableDefinitions = ast.variableDefinitions;
-        var errors = [];
-        if (variableDefinitions !== undefined) {
-            errors.push.apply(errors, validateVariableDefinitions(variableDefinitions, variables));
-        }
-        return errors;
-    }
-
-    function isLuvioDocumentNode(unknown) {
-        if (untrustedIsObject(unknown) === true &&
-            hasOwnProperty.call(unknown, 'kind') === true &&
-            hasOwnProperty.call(unknown, 'definitions') === true) {
-            return (typeof unknown.kind === 'string' &&
-                isArray(unknown.definitions));
-        }
-        return false;
-    }
-    var createRead = function (luvio, ast, variables) {
-        var definitions = ast.definitions === undefined ? [] : ast.definitions;
-        return function (source, builder) {
-            builder.enterPath('data');
-            var sink = {};
-            for (var i = 0, len = definitions.length; i < len; i += 1) {
-                var def = definitions[i];
-                if (def.kind !== 'OperationDefinition') {
-                    // eslint-disable-next-line @salesforce/lds/no-error-in-production
-                    throw new Error("Unsupported document definition \"".concat(def.kind, "\""));
-                }
-                var data = createRead$1(luvio, def, variables)(source, builder);
-                sink = __assign(__assign({}, sink), data);
-            }
-            var gqlData = {};
-            builder.assignNonScalar(gqlData, 'data', sink);
-            builder.exitPath();
-            builder.enterPath('errors');
-            builder.assignNonScalar(gqlData, 'errors', []);
-            builder.exitPath();
-            return gqlData;
-        };
-    };
-    function createIngest(ast, variables) {
-        var definitions = ast.definitions === undefined ? [] : ast.definitions;
-        return function (data, path, luvio, store, timestamp) {
-            var key = path.fullPath;
-            for (var i = 0, len = definitions.length; i < len; i += 1) {
-                var def = definitions[i];
-                if (def.kind !== 'OperationDefinition') {
-                    // eslint-disable-next-line @salesforce/lds/no-error-in-production
-                    throw new Error("Unsupported document definition \"".concat(def.kind, "\""));
-                }
-                createIngest$2(def, variables)(data, {
-                    parent: null,
-                    fullPath: key,
-                    propertyName: null,
-                }, luvio, store, timestamp);
-            }
-            return {
-                __ref: key,
-            };
-        };
-    }
-    function validate(ast, variables) {
-        var errors = [];
-        var definitions = ast.definitions;
-        for (var i = 0, len = definitions.length; i < len; i += 1) {
-            var def = definitions[i];
-            if (def.kind !== 'OperationDefinition') {
-                errors.push("Unsupported document definition \"".concat(def.kind, "\""));
-            }
-            else {
-                errors.push.apply(errors, validate$1(def, variables));
-            }
-        }
-        return errors;
-    }
-
-    var storeEval = undefined;
-    var configuration = {
-        setStoreEval: function (storeEvalArg) {
-            storeEval = storeEvalArg;
-        },
-    };
-
-    var assignedToMe = {
-        kind: 'CustomFieldSelection',
-        name: 'ServiceResources',
-        type: 'Connection',
-        luvioSelections: [
-            {
-                kind: 'ObjectFieldSelection',
-                name: 'edges',
-                luvioSelections: [
-                    {
-                        kind: 'CustomFieldSelection',
-                        name: 'node',
-                        type: 'Record',
-                        luvioSelections: [
-                            {
-                                kind: 'ObjectFieldSelection',
-                                name: 'ServiceResourceId',
-                                luvioSelections: [
-                                    {
-                                        kind: 'ScalarFieldSelection',
-                                        name: 'value',
-                                    },
-                                ],
-                            },
-                            {
-                                kind: 'ObjectFieldSelection',
-                                name: 'ServiceAppointmentId',
-                                luvioSelections: [
-                                    {
-                                        kind: 'ScalarFieldSelection',
-                                        name: 'value',
-                                    },
-                                ],
-                            },
-                            {
-                                kind: 'CustomFieldSelection',
-                                name: 'ServiceResource',
-                                type: 'Record',
-                                luvioSelections: [
-                                    {
-                                        kind: 'ScalarFieldSelection',
-                                        name: 'Id',
-                                    },
-                                    {
-                                        kind: 'ObjectFieldSelection',
-                                        name: 'RelatedRecordId',
-                                        luvioSelections: [
-                                            {
-                                                kind: 'ScalarFieldSelection',
-                                                name: 'value',
-                                            },
-                                        ],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            },
-        ],
-    };
-    function shouldInjectFields(ast) {
-        var injectScope = false;
-        var recordNodes = findRecordSelections(ast);
-        if (recordNodes !== undefined && recordNodes.length > 0) {
-            for (var _i = 0, recordNodes_1 = recordNodes; _i < recordNodes_1.length; _i++) {
-                var recordNode = recordNodes_1[_i];
-                if (recordNode.arguments !== undefined) {
-                    for (var _a = 0, _b = recordNode.arguments; _a < _b.length; _a++) {
-                        var argument = _b[_a];
-                        if (argument.name === 'scope' &&
-                            argument.value.kind === 'EnumValue' &&
-                            argument.value.value === 'ASSIGNEDTOME') {
-                            injectScope = true;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        return injectScope;
-    }
-    function injectFieldsGQL(ast) {
-        return injectScopeFields(ast);
-    }
-    function injectScopeFields(ast) {
-        var _a;
-        var modifiedDocumentNode = {
-            kind: 'Document',
-            definitions: [
-                {
-                    kind: 'OperationDefinition',
-                    operation: 'query',
-                    luvioSelections: [
-                        {
-                            kind: 'ObjectFieldSelection',
-                            name: 'uiapi',
-                            luvioSelections: [
-                                {
-                                    kind: 'ObjectFieldSelection',
-                                    name: 'query',
-                                    luvioSelections: [],
-                                },
-                            ],
-                        },
-                    ],
-                },
-            ],
-        };
-        var modifiedSelections = [];
-        var recordNodes = findRecordSelections(ast);
-        if (recordNodes !== undefined && recordNodes.length > 0) {
-            // each record node represent a connection
-            for (var _i = 0, recordNodes_2 = recordNodes; _i < recordNodes_2.length; _i++) {
-                var recordNode = recordNodes_2[_i];
-                modifiedSelections.push(injectConnectionForScope(recordNode));
-            }
-        }
-        var queryNode = modifiedDocumentNode.definitions
-            .filter(isOperationDefinition)
-            .reduce(flatMap(luvioSelections), [])
-            .filter(isObjectFieldSelection)
-            .filter(named('uiapi'))
-            .reduce(flatMap(luvioSelections), [])
-            .filter(isObjectFieldSelection)
-            .filter(named('query'))[0];
-        (_a = queryNode.luvioSelections).push.apply(_a, modifiedSelections);
-        return ast;
-    }
-    function injectConnectionForScope(connectionNode) {
-        if (connectionNode.name === 'ServiceAppointment') {
-            if (connectionNode.arguments !== undefined) {
-                for (var _i = 0, _a = connectionNode.arguments; _i < _a.length; _i++) {
-                    var argument = _a[_i];
-                    if (argument.name === 'scope' &&
-                        argument.value.kind === 'EnumValue' &&
-                        argument.value.value === 'ASSIGNEDTOME') {
-                        var injectedConnctionNode = __assign({}, connectionNode);
-                        if (injectedConnctionNode.luvioSelections !== undefined) {
-                            var injectedNodes = injectedConnctionNode.luvioSelections
-                                .filter(isObjectFieldSelection)
-                                .filter(named('edges'))
-                                .reduce(flatMap(luvioSelections), [])
-                                .filter(isCustomFieldNode)
-                                .filter(named('node'));
-                            if (injectedNodes !== undefined && injectedNodes.length > 0) {
-                                var injectedNode = injectedNodes[0];
-                                if (injectedNode.luvioSelections !== undefined) {
-                                    injectedNode.luvioSelections = mergeSelectionNodes(injectedNode.luvioSelections, [assignedToMe]);
-                                }
-                            }
-                        }
-                        return injectedConnctionNode;
-                    }
-                }
-            }
-        }
-        return __assign({}, connectionNode);
-    }
-    function mergeSelectionNodes(group1, group2) {
-        var sameFields1 = [];
-        var sameFields2 = [];
-        var results = [];
-        var _loop_1 = function (node2) {
-            if (isCustomFieldNode(node2)) {
-                var nodes1SameLevel = group1
-                    .filter(isCustomFieldNode)
-                    .filter(function (node1) { return node1.name === node2.name && node1.type === node2.type; });
-                if (nodes1SameLevel.length > 0) {
-                    sameFields1.push.apply(sameFields1, nodes1SameLevel);
-                    sameFields2.push(node2);
-                    var mergedNode = nodes1SameLevel.reduce(function (accu, cur) { return mergeCustomFieldNodes(accu, cur); }, node2);
-                    results.push(mergedNode);
-                }
-            }
-            else if (isObjectFieldSelection(node2)) {
-                var nodes1SameLevel = group1
-                    .filter(isObjectFieldSelection)
-                    .filter(function (node1) { return node1.name === node2.name; });
-                if (nodes1SameLevel.length > 0) {
-                    sameFields1.push.apply(sameFields1, nodes1SameLevel);
-                    sameFields2.push(node2);
-                    var mergedNode = nodes1SameLevel.reduce(function (accu, cur) { return mergeObjectFieldNodes(accu, cur); }, node2);
-                    results.push(mergedNode);
-                }
-            }
-        };
-        for (var _i = 0, group2_1 = group2; _i < group2_1.length; _i++) {
-            var node2 = group2_1[_i];
-            _loop_1(node2);
-        }
-        if (sameFields1.length > 0) {
-            var differentNodes1 = group1.filter(function (node) { return !sameFields1.includes(node); });
-            results.push.apply(results, differentNodes1);
-            var differentNodes2 = group2.filter(function (node) { return !sameFields2.includes(node); });
-            results.push.apply(results, differentNodes2);
-        }
-        else {
-            return group1.concat(group2);
-        }
-        return results;
-    }
-    function mergeCustomFieldNodes(node1, node2) {
-        var result = node1;
-        if (node1.name === node2.name && node1.kind === node2.kind && node1.type === node2.type) {
-            result = {
-                kind: node1.kind,
-                name: node1.name,
-                type: node1.type,
-                luvioSelections: [],
-            };
-            var selections_1 = [];
-            var sameCustomFields1_1 = [];
-            var sameCustomFields2_1 = [];
-            var sameObjectFields1_1 = [];
-            var sameObjectFields2_1 = [];
-            var sameScalarFields1_1 = [];
-            var sameScalarFields2_1 = [];
-            if (node1.luvioSelections && node2.luvioSelections) {
-                sameCustomFields1_1 = node1.luvioSelections
-                    .filter(isCustomFieldNode)
-                    .filter(function (childNode1) {
-                    if (node2.luvioSelections) {
-                        var sames = node2.luvioSelections
-                            .filter(isCustomFieldNode)
-                            .filter(function (childNode2) { return childNode2.name === childNode1.name; });
-                        if (sames.length > 0) {
-                            var mergedNode = sames.reduce(function (accu, cur) { return mergeCustomFieldNodes(accu, cur); }, childNode1);
-                            selections_1.push(mergedNode);
-                            result = __assign(__assign({}, result), { luvioSelections: selections_1 });
-                            sameCustomFields2_1.push.apply(sameCustomFields2_1, sames);
-                            return true;
-                        }
-                    }
-                    return false;
-                });
-                sameObjectFields1_1 = node1.luvioSelections
-                    .filter(isObjectFieldSelection)
-                    .filter(function (childNode1) {
-                    if (node2.luvioSelections) {
-                        var sames = node2.luvioSelections
-                            .filter(isObjectFieldSelection)
-                            .filter(function (childNode2) { return childNode2.name === childNode1.name; });
-                        if (sames.length > 0) {
-                            var mergedNode = sames.reduce(function (accu, cur) { return mergeObjectFieldNodes(accu, cur); }, childNode1);
-                            selections_1.push(mergedNode);
-                            result = __assign(__assign({}, result), { luvioSelections: selections_1 });
-                            sameObjectFields2_1.push.apply(sameObjectFields2_1, sames);
-                            return true;
-                        }
-                    }
-                    return false;
-                });
-                sameScalarFields1_1 = node1.luvioSelections
-                    .filter(isScalarFieldNode)
-                    .filter(function (childNode1) {
-                    if (node2.luvioSelections) {
-                        var sames = node2.luvioSelections
-                            .filter(isScalarFieldNode)
-                            .filter(function (childNode2) { return childNode2.name === childNode1.name; });
-                        if (sames.length > 0) {
-                            var mergedNode = sames.reduce(function (accu, cur) { return mergeScalarFieldNode(accu, cur); }, childNode1);
-                            selections_1.push(mergedNode);
-                            result = __assign(__assign({}, result), { luvioSelections: selections_1 });
-                            sameScalarFields2_1.push.apply(sameScalarFields2_1, sames);
-                            return true;
-                        }
-                    }
-                    return false;
-                });
-                if (sameCustomFields1_1.length > 0 ||
-                    sameObjectFields1_1.length > 0 ||
-                    sameScalarFields1_1.length > 0) {
-                    var diffNodes1 = node1.luvioSelections.filter(function (node) {
-                        return !sameCustomFields1_1.includes(node) &&
-                            !sameObjectFields1_1.includes(node) &&
-                            !sameScalarFields1_1.includes(node);
-                    });
-                    selections_1.push.apply(selections_1, diffNodes1);
-                    var diffNodes2 = node2.luvioSelections.filter(function (node) {
-                        return !sameCustomFields2_1.includes(node) &&
-                            !sameObjectFields2_1.includes(node) &&
-                            !sameScalarFields2_1.includes(node);
-                    });
-                    selections_1.push.apply(selections_1, diffNodes2);
-                    result = __assign(__assign({}, result), { luvioSelections: selections_1 });
-                }
-                else {
-                    selections_1.push.apply(selections_1, node1.luvioSelections);
-                    selections_1.push.apply(selections_1, node2.luvioSelections);
-                    result = __assign(__assign({}, result), { luvioSelections: selections_1 });
-                }
-            }
-            else {
-                if (node1.luvioSelections) {
-                    return node1;
-                }
-                if (node2.luvioSelections) {
-                    return node2;
-                }
-            }
-            return result;
-        }
-        else {
-            // eslint-disable-next-line
-            throw new Error('The fields name needs to be same to be merged');
-        }
-    }
-    function mergeObjectFieldNodes(node1, node2) {
-        var result = node1;
-        if (node1.name === node2.name && node1.kind === node2.kind) {
-            result = {
-                kind: node1.kind,
-                name: node1.name,
-                directives: node1.directives,
-                luvioSelections: [],
-            };
-            var selections_2 = [];
-            var sameCustomFields1_2 = [];
-            var sameCustomFields2_2 = [];
-            var sameObjectFields1_2 = [];
-            var sameObjectFields2_2 = [];
-            var sameScalarFields1_2 = [];
-            var sameScalarFields2_2 = [];
-            if (node1.luvioSelections && node2.luvioSelections) {
-                sameCustomFields1_2 = node1.luvioSelections
-                    .filter(isCustomFieldNode)
-                    .filter(function (childNode1) {
-                    if (node2.luvioSelections) {
-                        var sames = node2.luvioSelections
-                            .filter(isCustomFieldNode)
-                            .filter(function (childNode2) { return childNode2.name === childNode1.name; });
-                        if (sames.length > 0) {
-                            var mergedNode = sames.reduce(function (accu, cur) { return mergeCustomFieldNodes(accu, cur); }, childNode1);
-                            selections_2.push(mergedNode);
-                            result = __assign(__assign({}, result), { luvioSelections: selections_2 });
-                            sameCustomFields2_2.push.apply(sameCustomFields2_2, sames);
-                            return true;
-                        }
-                    }
-                    return false;
-                });
-                sameObjectFields1_2 = node1.luvioSelections
-                    .filter(isObjectFieldSelection)
-                    .filter(function (childNode1) {
-                    if (node2.luvioSelections) {
-                        var sames = node2.luvioSelections
-                            .filter(isObjectFieldSelection)
-                            .filter(function (childNode2) { return childNode2.name === childNode1.name; });
-                        if (sames.length > 0) {
-                            var mergedNode = sames.reduce(function (accu, cur) { return mergeObjectFieldNodes(accu, cur); }, childNode1);
-                            selections_2.push(mergedNode);
-                            result = __assign(__assign({}, result), { luvioSelections: selections_2 });
-                            sameObjectFields2_2.push.apply(sameObjectFields2_2, sames);
-                            return true;
-                        }
-                    }
-                    return false;
-                });
-                sameScalarFields1_2 = node1.luvioSelections
-                    .filter(isScalarFieldNode)
-                    .filter(function (childNode1) {
-                    if (node2.luvioSelections) {
-                        var sames = node2.luvioSelections
-                            .filter(isScalarFieldNode)
-                            .filter(function (childNode2) { return childNode2.name === childNode1.name; });
-                        if (sames.length > 0) {
-                            var mergedNode = sames.reduce(function (accu, cur) { return mergeScalarFieldNode(accu, cur); }, childNode1);
-                            selections_2.push(mergedNode);
-                            result = __assign(__assign({}, result), { luvioSelections: selections_2 });
-                            sameScalarFields2_2.push.apply(sameScalarFields2_2, sames);
-                            return true;
-                        }
-                    }
-                    return false;
-                });
-                if (sameCustomFields1_2.length > 0 ||
-                    sameObjectFields1_2.length > 0 ||
-                    sameScalarFields1_2.length > 0) {
-                    var diffNodes1 = node1.luvioSelections.filter(function (node) {
-                        return !sameCustomFields1_2.includes(node) &&
-                            !sameObjectFields1_2.includes(node) &&
-                            !sameScalarFields1_2.includes(node);
-                    });
-                    selections_2.push.apply(selections_2, diffNodes1);
-                    var diffNodes2 = node2.luvioSelections.filter(function (node) {
-                        return !sameCustomFields2_2.includes(node) &&
-                            !sameObjectFields2_2.includes(node) &&
-                            !sameScalarFields2_2.includes(node);
-                    });
-                    selections_2.push.apply(selections_2, diffNodes2);
-                    result = __assign(__assign({}, result), { luvioSelections: selections_2 });
-                }
-                else {
-                    selections_2.push.apply(selections_2, node1.luvioSelections);
-                    selections_2.push.apply(selections_2, node2.luvioSelections);
-                    result = __assign(__assign({}, result), { luvioSelections: selections_2 });
-                }
-            }
-            else {
-                if (node1.luvioSelections) {
-                    return node1;
-                }
-                if (node2.luvioSelections) {
-                    return node2;
-                }
-            }
-            return result;
-        }
-        else {
-            // eslint-disable-next-line
-            throw new Error('The fields name needs to be same to be merged');
-        }
-    }
-    function mergeScalarFieldNode(node1, node2) {
-        if (node1.kind === node1.kind && node1.name === node2.name) {
-            return __assign({}, node1);
-        }
-        // eslint-disable-next-line
-        throw new Error('The fields name needs to be same to be merged');
-    }
-    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 isOperationDefinition(node) {
-        return node.kind === 'OperationDefinition';
-    }
-    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 flatMap(transform) {
-        return function (acc, current) {
-            var mapped = transform(current);
-            return acc.concat(mapped);
-        };
-    }
-    function luvioSelections(node) {
-        return node.luvioSelections === undefined ? [] : node.luvioSelections;
-    }
-    function named(name) {
-        return function (node) { return node.name === name; };
-    }
-
-    var adapterName = 'graphQL';
-    var RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
-    var GRAPHQL_ROOT_KEY = "".concat(namespace, "::").concat(representationName);
-    function buildSnapshotRefresh(luvio, config, fragment) {
-        return {
-            config: config,
-            resolve: function () { return buildNetworkSnapshot(luvio, config, fragment); },
-        };
-    }
-    function createFragment(luvio, query, variables) {
-        return {
-            kind: 'Fragment',
-            synthetic: false,
-            reader: true,
-            version: GRAPHQL_INGEST_VERSION,
-            read: createRead(luvio, query, variables),
-        };
-    }
-    function onFetchResponseSuccess(luvio, config, response, fragment) {
-        var query = config.query, variables = config.variables;
-        var body = response.body;
-        if (body.errors && body.errors.length > 0) {
-            return Promise.resolve(luvio.storeLookup({
-                recordId: representationName,
-                node: {
-                    kind: 'Fragment',
-                    synthetic: true,
-                    reader: true,
-                    read: function (reader) {
-                        var sink = {};
-                        reader.enterPath('data');
-                        reader.assignNonScalar(sink, 'data', body.data);
-                        reader.exitPath();
-                        reader.enterPath('errors');
-                        reader.assignNonScalar(sink, 'errors', deepFreeze(body.errors));
-                        reader.exitPath();
-                        return sink;
-                    },
-                },
-                variables: {},
-            }));
-        }
-        var ingest = createIngest(query, variables);
-        luvio.storeIngest(GRAPHQL_ROOT_KEY, ingest, body.data);
-        var snapshot = luvio.storeLookup({
-            recordId: GRAPHQL_ROOT_KEY,
-            node: fragment,
-            variables: {},
-        }, buildSnapshotRefresh(luvio, config, fragment));
-        return luvio.storeBroadcast().then(function () { return snapshot; });
-    }
-    function getResponseCacheKeys(luvio, config, response, fragment) {
-        // TODO [W-10147827]: make this more efficient
-        // for now we will get the cache keys by actually ingesting then looking at
-        // the seenRecords + recordId
-        var query = config.query, variables = config.variables;
-        var body = response.body;
-        if (body.errors && body.errors.length > 0) {
-            return new engine.StoreKeyMap();
-        }
-        var ingest = createIngest(query, variables);
-        // ingest mutates the response so we have to make a copy
-        var dataCopy = parse(stringify(body.data));
-        luvio.storeIngest(GRAPHQL_ROOT_KEY, ingest, dataCopy);
-        var snapshot = luvio.storeLookup({
-            recordId: GRAPHQL_ROOT_KEY,
-            node: fragment,
-            variables: {},
-        }, buildSnapshotRefresh(luvio, config, fragment));
-        if (snapshot.state === 'Error') {
-            return new engine.StoreKeyMap();
-        }
-        var keys = __spreadArray(__spreadArray([], snapshot.seenRecords.keysAsArray(), true), [snapshot.recordId], false);
-        var keySet = new engine.StoreKeyMap();
-        for (var i = 0, len = keys.length; i < len; i++) {
-            var key = keys[i];
-            var keyNamespace = key.split('::')[0];
-            var representationName_1 = key.split('::')[1].split(':')[0];
-            keySet.set(key, {
-                namespace: keyNamespace,
-                representationName: representationName_1,
-                mergeable: keyNamespace === namespace || representationName_1 === RECORD_REPRESENTATION_NAME,
-            });
-        }
-        return keySet;
-    }
-    function onFetchResponseError(luvio, config, response) {
-        var errorSnapshot = luvio.errorSnapshot(response);
-        luvio.storeIngestError(GRAPHQL_ROOT_KEY, errorSnapshot);
-        return luvio.storeBroadcast().then(function () { return errorSnapshot; });
-    }
-    function buildNetworkSnapshot(luvio, config, fragment, options) {
-        var queryVariables = config.variables, query = config.query;
-        var request = {
-            baseUri: '/services/data/v58.0',
-            basePath: '/graphql',
-            method: 'post',
-            priority: 'normal',
-            body: {
-                query: astToString(query),
-                variables: queryVariables,
-            },
-            queryParams: {},
-            urlParams: {},
-            headers: {},
-        };
-        return luvio.dispatchResourceRequest(request, options).then(function (resp) {
-            return luvio.handleSuccessResponse(function () { return onFetchResponseSuccess(luvio, config, resp, fragment); }, function () { return getResponseCacheKeys(luvio, config, resp, fragment); });
-        }, function (errorResponse) {
-            return luvio.handleErrorResponse(function () {
-                return onFetchResponseError(luvio, config, errorResponse);
-            });
-        });
-    }
-    function validateGraphQlConfig(untrustedConfig) {
-        if (!untrustedIsObject(untrustedConfig)) {
-            return {
-                validatedConfig: null,
-                errors: ["Invalid Config provided isn't an object"],
-            };
-        }
-        if (!('variables' in untrustedConfig && 'query' in untrustedConfig)) {
-            return {
-                validatedConfig: null,
-                errors: [
-                    'Missing one or both of the required config parameters "query" and "variables"',
-                ],
-            };
-        }
-        var _a = untrustedConfig, variables = _a.variables, query = _a.query;
-        var validationErrors = [];
-        if (isLuvioDocumentNode(query) === false) {
-            validationErrors.push('The config parameter "query" isn\'t a valid LuvioDocumentNode');
-        }
-        var ast = query;
-        if (isGraphQLVariables(variables) === false) {
-            validationErrors.push('The config parameter "variables" isn\'t an object');
-        }
-        if (validationErrors.length > 0) {
-            return {
-                validatedConfig: null,
-                errors: validationErrors,
-            };
-        }
-        validationErrors.push.apply(validationErrors, validate(ast, variables));
-        var useUiApiAdapter = untrustedConfig.useUiApiAdapter;
-        if (useUiApiAdapter !== undefined && typeof useUiApiAdapter !== 'boolean') {
-            validationErrors.push('The config parameter "useUiApiAdapter" isn\'t a boolean');
-        }
-        if (validationErrors.length > 0) {
-            return {
-                validatedConfig: null,
-                errors: validationErrors,
-            };
-        }
-        return {
-            validatedConfig: {
-                variables: variables,
-                query: query,
-                useUiApiAdapter: useUiApiAdapter,
-            },
-            errors: [],
-        };
-    }
-    function buildCachedSnapshot(context, storeLookup) {
-        return buildInMemorySnapshot(context, storeLookup);
-    }
-    function buildInMemorySnapshot(context, storeLookup) {
-        var config = context.config, fragment = context.fragment, luvio = context.luvio;
-        var selector = {
-            recordId: GRAPHQL_ROOT_KEY,
-            node: fragment,
-            variables: {},
-        };
-        return storeLookup(selector, buildSnapshotRefresh(luvio, config, fragment));
-    }
-    function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-        var config = context.config, fragment = context.fragment, luvio = context.luvio;
-        var networkPriority = coercedAdapterRequestContext.networkPriority, requestCorrelator = coercedAdapterRequestContext.requestCorrelator, eventObservers = coercedAdapterRequestContext.eventObservers;
-        var dispatchOptions = {
-            resourceRequestContext: {
-                requestCorrelator: requestCorrelator,
-            },
-            eventObservers: eventObservers,
-        };
-        if (networkPriority !== 'normal') {
-            dispatchOptions.overrides = {
-                priority: networkPriority,
-            };
-        }
-        return buildNetworkSnapshot(luvio, config, fragment, dispatchOptions);
-    }
-    var graphQLAdapterFactory = function (luvio) {
-        var uiApiGraphQLAdapter = graphql.graphqlAdapterFactory(luvio);
-        function graphql$1(untrustedConfig, requestContext) {
-            var _a = validateGraphQlConfig(untrustedConfig), validatedConfig = _a.validatedConfig, errors = _a.errors;
-            if (errors.length > 0 || validatedConfig === null) {
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error(errors.join(', '));
-                }
-                return null;
-            }
-            var query = validatedConfig.query, variables = validatedConfig.variables, useUiApiAdapter = validatedConfig.useUiApiAdapter;
-            if (useUiApiAdapter === undefined || useUiApiAdapter === true) {
-                // Forward to new adapters
-                var resolvedQuery = graphqlParser.astResolver(query);
-                if (resolvedQuery === undefined) {
-                    if (process.env.NODE_ENV !== 'production') {
-                        throw new Error('Could not resolve standard AST');
-                    }
-                    return null;
-                }
-                return uiApiGraphQLAdapter({
-                    query: resolvedQuery,
-                    variables: variables,
-                }, requestContext);
-            }
-            else {
-                var fieldInjectionRequired = shouldInjectFields(query);
-                var validatedConfigWithInjection = fieldInjectionRequired
-                    ? graphqlConfigWithInjectedAST(validatedConfig)
-                    : validatedConfig;
-                var fragment = createFragment(luvio, validatedConfigWithInjection.query, variables);
-                var context = {
-                    config: validatedConfigWithInjection,
-                    fragment: fragment,
-                    luvio: luvio,
-                };
-                var snapshotOrPromiseFromCachePolicy = luvio.applyCachePolicy(requestContext || {}, context, buildCachedSnapshot, buildNetworkSnapshotCachePolicy);
-                if (storeEval !== undefined) {
-                    var observers = requestContext && requestContext.eventObservers
-                        ? requestContext.eventObservers
-                        : [];
-                    // uses the original ast to do the eval to avoid fields not needed by users
-                    return storeEval(validatedConfig, snapshotOrPromiseFromCachePolicy, observers);
-                }
-                return snapshotOrPromiseFromCachePolicy;
-            }
-        }
-        return graphql$1;
-    };
-    function graphqlConfigWithInjectedAST(graphqlConfig) {
-        var query = graphqlConfig.query;
-        var astCopy = parse(stringify(query));
-        var modifiedAST = injectFieldsGQL(astCopy);
-        return __assign(__assign({}, graphqlConfig), { query: modifiedAST });
-    }
-    // make sure to register the configuration whenever this module loads
-    ldsDefaultLuvio.register({ id: '@salesforce/lds-adapters-graphql', configuration: configuration });
-
-    exports.adapterName = adapterName;
-    exports.buildCachedSnapshot = buildCachedSnapshot;
-    exports.connectionKeyBuilder = keyBuilder;
-    exports.graphQLAdapterFactory = graphQLAdapterFactory;
-    exports.namespace = namespace;
-    exports.representationName = representationName;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));