@salesforce/lds-adapters-graphql 1.124.2 → 1.124.3

package/dist/es/es2018/graphql-service.js

@@ -10,2146 +10,2146 @@ import { astResolver } from '@luvio/graphql-parser';
 import { graphqlAdapterFactory } from '@salesforce/lds-adapters-uiapi';
 import { createIngestRecordWithFields, keyBuilderRecord } from '@salesforce/lds-adapters-uiapi';
 
-const { isArray } = Array;
-const { keys, freeze, create } = Object;
-const { hasOwnProperty } = Object.prototype;
+const { isArray } = Array;
+const { keys, freeze, create } = Object;
+const { hasOwnProperty } = Object.prototype;
 const { parse, stringify } = JSON;
 
-function sortAndCopyUsingObjectKey(arr, key) {
-    return [...arr].sort((a, b) => {
-        const aKey = a[key];
-        const bKey = b[key];
-        if (aKey < bKey) {
-            return -1;
-        }
-        if (aKey > bKey) {
-            return 1;
-        }
-        return 0;
-    });
+function sortAndCopyUsingObjectKey(arr, key) {
+    return [...arr].sort((a, b) => {
+        const aKey = a[key];
+        const 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 (let i = 0, len = value.length; i < len; i += 1) {
-            deepFreeze(value[i]);
-        }
-    }
-    else {
-        const keys$1 = keys(value);
-        for (let i = 0, len = keys$1.length; i < len; i += 1) {
-            const 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);
-    }
-    let i;
-    let 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';
-    }
-    const keys$1 = keys(node).sort();
-    out = '';
-    for (i = 0; i < keys$1.length; i++) {
-        const key = keys$1[i];
-        const value = stableJSONStringify(node[key]);
-        if (!value) {
-            continue;
-        }
-        if (out) {
-            out += ',';
-        }
-        out += key + ':' + value;
-    }
-    return '{' + out + '}';
-}
-const namespace = 'GraphQL';
+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 (let i = 0, len = value.length; i < len; i += 1) {
+            deepFreeze(value[i]);
+        }
+    }
+    else {
+        const keys$1 = keys(value);
+        for (let i = 0, len = keys$1.length; i < len; i += 1) {
+            const 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);
+    }
+    let i;
+    let 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';
+    }
+    const keys$1 = keys(node).sort();
+    out = '';
+    for (i = 0; i < keys$1.length; i++) {
+        const key = keys$1[i];
+        const value = stableJSONStringify(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += key + ':' + value;
+    }
+    return '{' + out + '}';
+}
+const namespace = 'GraphQL';
 const representationName = 'graphql';
 
-function serialize$1(args) {
-    return serializeArgs(args, { render: false });
-}
-function render$1(args, variables) {
-    return serializeArgs(args, { render: true, variables });
-}
-function serializeArgs(args, option) {
-    const sortedArgs = option.render === true ? sortAndCopyUsingObjectKey(args, 'name') : args;
-    let str = '';
-    for (let i = 0, len = sortedArgs.length; i < len; i += 1) {
-        str = `${str}${serializeArgumentNode(sortedArgs[i], option)}`;
-        if (len > 1 && i < len - 1) {
-            str = `${str},`;
-        }
-    }
-    return str;
-}
-function serializeArgumentValueNode(valueDefinition, option) {
-    const { kind } = valueDefinition;
-    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 `$${literalValueNode.name}`;
-    }
-    return `${serializeVariableValue(option.variables[literalValueNode.name])}`;
-}
-function serializeVariableValue(value) {
-    return stableJSONStringify(value);
-}
-function serializeAndSortListValueNode(objectValueDefinition, option) {
-    const { values } = objectValueDefinition;
-    const str = [];
-    const sorted = option.render === true ? sortAndCopyUsingObjectKey(values, 'value') : values;
-    for (let i = 0, len = sorted.length; i < len; i += 1) {
-        str.push(serializeArgumentValueNode(sorted[i], option));
-    }
-    return `[${str.join(',')}]`;
-}
-function serializeAndSortObjectValueNode(objectValueDefinition, option) {
-    const { fields } = objectValueDefinition;
-    let str = '';
-    const fieldKeys = keys(fields).sort();
-    for (let i = 0, len = fieldKeys.length; i < len; i += 1) {
-        const fieldKey = fieldKeys[i];
-        str = `${str}${fieldKey}:${serializeArgumentValueNode(fields[fieldKey], option)}`;
-        if (len > 1 && i < len - 1) {
-            str = `${str},`;
-        }
-    }
-    return `{${str}}`;
-}
-function serializeArgumentNode(arg, option) {
-    const { name, value } = arg;
-    return `${name}:${serializeArgumentValueNode(value, option)}`;
+function serialize$1(args) {
+    return serializeArgs(args, { render: false });
+}
+function render$1(args, variables) {
+    return serializeArgs(args, { render: true, variables });
+}
+function serializeArgs(args, option) {
+    const sortedArgs = option.render === true ? sortAndCopyUsingObjectKey(args, 'name') : args;
+    let str = '';
+    for (let i = 0, len = sortedArgs.length; i < len; i += 1) {
+        str = `${str}${serializeArgumentNode(sortedArgs[i], option)}`;
+        if (len > 1 && i < len - 1) {
+            str = `${str},`;
+        }
+    }
+    return str;
+}
+function serializeArgumentValueNode(valueDefinition, option) {
+    const { kind } = valueDefinition;
+    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 `$${literalValueNode.name}`;
+    }
+    return `${serializeVariableValue(option.variables[literalValueNode.name])}`;
+}
+function serializeVariableValue(value) {
+    return stableJSONStringify(value);
+}
+function serializeAndSortListValueNode(objectValueDefinition, option) {
+    const { values } = objectValueDefinition;
+    const str = [];
+    const sorted = option.render === true ? sortAndCopyUsingObjectKey(values, 'value') : values;
+    for (let i = 0, len = sorted.length; i < len; i += 1) {
+        str.push(serializeArgumentValueNode(sorted[i], option));
+    }
+    return `[${str.join(',')}]`;
+}
+function serializeAndSortObjectValueNode(objectValueDefinition, option) {
+    const { fields } = objectValueDefinition;
+    let str = '';
+    const fieldKeys = keys(fields).sort();
+    for (let i = 0, len = fieldKeys.length; i < len; i += 1) {
+        const fieldKey = fieldKeys[i];
+        str = `${str}${fieldKey}:${serializeArgumentValueNode(fields[fieldKey], option)}`;
+        if (len > 1 && i < len - 1) {
+            str = `${str},`;
+        }
+    }
+    return `{${str}}`;
+}
+function serializeArgumentNode(arg, option) {
+    const { name, value } = arg;
+    return `${name}:${serializeArgumentValueNode(value, option)}`;
 }
 
-function render(sel, variables) {
-    return serializeField(sel, { render: true, variables });
-}
-function serializeField(sel, option) {
-    const { name: fieldName } = sel;
-    if (sel.kind === 'ScalarFieldSelection') {
-        return fieldName;
-    }
-    const { arguments: selectionArguments } = sel;
-    if (selectionArguments === undefined || selectionArguments.length === 0) {
-        return fieldName;
-    }
-    return `${fieldName}(${option.render === true
-        ? render$1(selectionArguments, option.variables)
-        : serialize$1(selectionArguments)})`;
+function render(sel, variables) {
+    return serializeField(sel, { render: true, variables });
+}
+function serializeField(sel, option) {
+    const { name: fieldName } = sel;
+    if (sel.kind === 'ScalarFieldSelection') {
+        return fieldName;
+    }
+    const { arguments: selectionArguments } = sel;
+    if (selectionArguments === undefined || selectionArguments.length === 0) {
+        return fieldName;
+    }
+    return `${fieldName}(${option.render === true
+        ? render$1(selectionArguments, option.variables)
+        : serialize$1(selectionArguments)})`;
 }
 
-function readScalarFieldSelection(builder, source, fieldName, sink) {
-    const gqlData = source[fieldName];
-    if (gqlData !== undefined && gqlData !== null && gqlData.__ref !== undefined) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`Scalar requested at "${fieldName}" but is instead an object at "${gqlData.__ref}"`);
-        }
-    }
-    builder.readScalar(fieldName, source, sink);
+function readScalarFieldSelection(builder, source, fieldName, sink) {
+    const gqlData = source[fieldName];
+    if (gqlData !== undefined && gqlData !== null && gqlData.__ref !== undefined) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error(`Scalar requested at "${fieldName}" but is instead an object at "${gqlData.__ref}"`);
+        }
+    }
+    builder.readScalar(fieldName, source, sink);
 }
 
-const CUSTOM_FIELD_NODE_TYPE = 'Record';
-const 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) {
-    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-    const children = {};
-    const trie = {
-        name: ast.name,
-        children,
-    };
-    for (let i = 0, len = selections.length; i < len; i += 1) {
-        const sel = getLuvioFieldNodeSelection(selections[i]);
-        const { name: selName, kind } = sel;
-        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),
-        };
-    }
-    const { recordRepresentation, fieldsTrie } = convertToRecordRepresentation(sel, data);
-    return {
-        trie: fieldsTrie,
-        value: {
-            displayValue: data.DisplayValue,
-            value: recordRepresentation,
-        },
-    };
-}
-function convertToRecordRepresentation(ast, record) {
-    const { Id, WeakEtag, ApiName, LastModifiedById, LastModifiedDate, SystemModstamp, ldsRecordTypeId, } = record;
-    const { luvioSelections } = ast;
-    if (luvioSelections === undefined) {
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Undefined selections');
-    }
-    const trieChildren = {};
-    const trie = {
-        name: ApiName,
-        children: trieChildren,
-    };
-    const childRelationships = {};
-    const fieldsBag = {};
-    for (let i = 0, len = luvioSelections.length; i < len; i += 1) {
-        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-        const { name: fieldName, alias } = sel;
-        const propertyName = alias === undefined ? fieldName : alias;
-        const data = record[propertyName];
-        switch (sel.kind) {
-            case 'ObjectFieldSelection': {
-                trieChildren[fieldName] = {
-                    name: fieldName,
-                    children: {},
-                };
-                fieldsBag[fieldName] = collectObjectFieldSelection(data);
-                break;
-            }
-            case 'CustomFieldSelection': {
-                if (childTypeIsSpanningGqlRecord(sel)) {
-                    const { value, trie } = formatSpanningCustomFieldSelection(sel, data);
-                    trieChildren[fieldName] = trie;
-                    fieldsBag[fieldName] = value;
-                }
-                else if (childTypeIsChildRelationships(sel)) {
-                    childRelationships[fieldName] = {
-                        ast: sel,
-                        data: data,
-                    };
-                }
-                break;
-            }
-        }
-    }
-    const 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,
-    };
-}
-const defaultRecordFieldsFragmentName = 'defaultRecordFields';
-const defaultRecordFieldsFragment = `fragment ${defaultRecordFieldsFragmentName} on Record { __typename, ApiName, WeakEtag, Id, DisplayValue, SystemModstamp { value } LastModifiedById { value } LastModifiedDate { value } ldsRecordTypeId: RecordTypeId(fallback: true) { value } }`;
-function getChildRelationshipsKey(recordKey, propertyName) {
-    return `${recordKey}__childRelationships__${propertyName}`;
-}
-const createIngest$4 = (ast, variables) => {
-    return (data, path, luvio, store, timestamp) => {
-        const { recordRepresentation, fieldsTrie, childRelationships } = convertToRecordRepresentation(ast, data);
-        const ingestRecord = createIngestRecordWithFields(fieldsTrie, {
-            name: recordRepresentation.apiName,
-            children: {},
-        });
-        const recordIngest = ingestRecord(recordRepresentation, path, luvio, store, timestamp);
-        const recordKey = recordIngest.__ref;
-        const childRelationshipKeys = Object.keys(childRelationships);
-        for (let i = 0, len = childRelationshipKeys.length; i < len; i += 1) {
-            const propertyName = childRelationshipKeys[i];
-            const childRelationship = childRelationships[propertyName];
-            const { ast: childRelationshipAst, data: childRelationshipData } = childRelationship;
-            const fullPath = getChildRelationshipsKey(recordKey, propertyName);
-            createIngest$1(childRelationshipAst, fullPath, variables)(childRelationshipData, {
-                parent: {
-                    data,
-                    key: recordKey,
-                    existing: undefined,
-                },
-                fullPath: fullPath,
-                propertyName: propertyName,
-            }, luvio, store, timestamp);
-        }
-        return recordIngest;
-    };
-};
-const recordProperties = {
-    Id: {
-        propertyName: 'id',
-    },
-    ApiName: {
-        propertyName: 'apiName',
-    },
-};
-function getNonSpanningField(sel, builder, source) {
-    const sink = {};
-    const { luvioSelections } = sel;
-    if (luvioSelections === undefined) {
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Empty selections not supported');
-    }
-    for (let i = 0, len = luvioSelections.length; i < len; i += 1) {
-        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-        const { kind } = sel;
-        const name = sel.name;
-        builder.enterPath(name);
-        if (kind !== 'ScalarFieldSelection') {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error(`Unexpected kind "${kind}"`);
-            }
-        }
-        builder.assignScalar(name, sink, source[name]);
-        builder.exitPath();
-    }
-    return sink;
-}
-function getCustomSelection(luvio, selection, builder, options, variables) {
-    const { type } = selection;
-    switch (type) {
-        case 'Record':
-            return readRecordRepresentation(luvio, selection, builder, options, variables);
-    }
-}
-function getScalarValue(selectionName, state) {
-    if (selectionName === 'DisplayValue') {
-        const { parentFieldValue } = state;
-        if (parentFieldValue === undefined) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('Unable to calculate DisplayValue');
-            }
-            else {
-                return undefined;
-            }
-        }
-        return parentFieldValue.displayValue;
-    }
-    const assignment = recordProperties[selectionName];
-    if (assignment === undefined) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`Unknown assignment for ScalarFieldSelection at property "${selectionName}"`);
-        }
-    }
-    return state.source[assignment.propertyName];
-}
-function assignConnectionSelection(luvio, builder, sink, sel, recordKey, propertyName, variables) {
-    const key = getChildRelationshipsKey(recordKey, propertyName);
-    const resolved = resolveKey(builder, key);
-    if (resolved === undefined) {
-        return;
-    }
-    const data = createRead$2(luvio, sel, variables)(resolved.value, builder);
-    builder.assignNonScalar(sink, propertyName, data);
-}
-function assignSelection(luvio, selection, builder, state, variables) {
-    const sel = getLuvioFieldNodeSelection(selection);
-    const { name: selectionName, kind, alias } = sel;
-    const propertyName = alias === undefined ? selectionName : alias;
-    const { source, sink } = state;
-    const { fields } = source;
-    builder.enterPath(selectionName);
-    switch (kind) {
-        case 'ScalarFieldSelection': {
-            builder.assignScalar(propertyName, sink, getScalarValue(selectionName, state));
-            break;
-        }
-        case 'ObjectFieldSelection': {
-            // regular field, not spanning
-            const field = propertyLookup(builder, selectionName, fields);
-            if (field.state === PropertyLookupResultState.Missing) {
-                break;
-            }
-            const resolved = resolveLink(builder, field.value);
-            if (resolved === undefined) {
-                break;
-            }
-            const data = getNonSpanningField(sel, builder, resolved.value);
-            builder.assignNonScalar(sink, propertyName, data);
-            break;
-        }
-        case 'CustomFieldSelection': {
-            if (sel.type === 'Connection') {
-                const recordKey = keyBuilderRecord(luvio, {
-                    recordId: state.source.id,
-                });
-                assignConnectionSelection(luvio, builder, sink, sel, recordKey, propertyName, variables);
-            }
-            else {
-                const field = fields[selectionName];
-                const resolvedParentFieldValue = resolveLink(builder, field);
-                if (resolvedParentFieldValue === undefined) {
-                    break;
-                }
-                const { value: spanningFieldResult } = resolvedParentFieldValue;
-                const { value: spanningFieldValue } = spanningFieldResult;
-                if (spanningFieldValue === null || typeof spanningFieldValue !== 'object') {
-                    sink[propertyName] = null;
-                    break;
-                }
-                const resolvedSpanningRecordValue = resolveLink(builder, spanningFieldValue);
-                if (resolvedSpanningRecordValue === undefined) {
-                    break;
-                }
-                const 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) {
-    const { luvioSelections } = ast;
-    if (luvioSelections === undefined) {
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Empty selections not supported');
-    }
-    const sink = {};
-    const state = {
-        source: options.source,
-        sink,
-        parentFieldValue: options.parentFieldValue,
-    };
-    for (let i = 0, len = luvioSelections.length; i < len; i += 1) {
-        assignSelection(luvio, luvioSelections[i], builder, state, variables);
-    }
-    return sink;
-}
-const createRead$3 = (luvio, ast, variables) => {
-    return (data, builder) => {
-        return readRecordRepresentation(luvio, ast, builder, {
-            source: data,
-            parentFieldValue: undefined,
-        }, variables);
-    };
+const CUSTOM_FIELD_NODE_TYPE = 'Record';
+const 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) {
+    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
+    const children = {};
+    const trie = {
+        name: ast.name,
+        children,
+    };
+    for (let i = 0, len = selections.length; i < len; i += 1) {
+        const sel = getLuvioFieldNodeSelection(selections[i]);
+        const { name: selName, kind } = sel;
+        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),
+        };
+    }
+    const { recordRepresentation, fieldsTrie } = convertToRecordRepresentation(sel, data);
+    return {
+        trie: fieldsTrie,
+        value: {
+            displayValue: data.DisplayValue,
+            value: recordRepresentation,
+        },
+    };
+}
+function convertToRecordRepresentation(ast, record) {
+    const { Id, WeakEtag, ApiName, LastModifiedById, LastModifiedDate, SystemModstamp, ldsRecordTypeId, } = record;
+    const { luvioSelections } = ast;
+    if (luvioSelections === undefined) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error('Undefined selections');
+    }
+    const trieChildren = {};
+    const trie = {
+        name: ApiName,
+        children: trieChildren,
+    };
+    const childRelationships = {};
+    const fieldsBag = {};
+    for (let i = 0, len = luvioSelections.length; i < len; i += 1) {
+        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
+        const { name: fieldName, alias } = sel;
+        const propertyName = alias === undefined ? fieldName : alias;
+        const data = record[propertyName];
+        switch (sel.kind) {
+            case 'ObjectFieldSelection': {
+                trieChildren[fieldName] = {
+                    name: fieldName,
+                    children: {},
+                };
+                fieldsBag[fieldName] = collectObjectFieldSelection(data);
+                break;
+            }
+            case 'CustomFieldSelection': {
+                if (childTypeIsSpanningGqlRecord(sel)) {
+                    const { value, trie } = formatSpanningCustomFieldSelection(sel, data);
+                    trieChildren[fieldName] = trie;
+                    fieldsBag[fieldName] = value;
+                }
+                else if (childTypeIsChildRelationships(sel)) {
+                    childRelationships[fieldName] = {
+                        ast: sel,
+                        data: data,
+                    };
+                }
+                break;
+            }
+        }
+    }
+    const 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,
+    };
+}
+const defaultRecordFieldsFragmentName = 'defaultRecordFields';
+const defaultRecordFieldsFragment = `fragment ${defaultRecordFieldsFragmentName} on Record { __typename, ApiName, WeakEtag, Id, DisplayValue, SystemModstamp { value } LastModifiedById { value } LastModifiedDate { value } ldsRecordTypeId: RecordTypeId(fallback: true) { value } }`;
+function getChildRelationshipsKey(recordKey, propertyName) {
+    return `${recordKey}__childRelationships__${propertyName}`;
+}
+const createIngest$4 = (ast, variables) => {
+    return (data, path, luvio, store, timestamp) => {
+        const { recordRepresentation, fieldsTrie, childRelationships } = convertToRecordRepresentation(ast, data);
+        const ingestRecord = createIngestRecordWithFields(fieldsTrie, {
+            name: recordRepresentation.apiName,
+            children: {},
+        });
+        const recordIngest = ingestRecord(recordRepresentation, path, luvio, store, timestamp);
+        const recordKey = recordIngest.__ref;
+        const childRelationshipKeys = Object.keys(childRelationships);
+        for (let i = 0, len = childRelationshipKeys.length; i < len; i += 1) {
+            const propertyName = childRelationshipKeys[i];
+            const childRelationship = childRelationships[propertyName];
+            const { ast: childRelationshipAst, data: childRelationshipData } = childRelationship;
+            const fullPath = getChildRelationshipsKey(recordKey, propertyName);
+            createIngest$1(childRelationshipAst, fullPath, variables)(childRelationshipData, {
+                parent: {
+                    data,
+                    key: recordKey,
+                    existing: undefined,
+                },
+                fullPath: fullPath,
+                propertyName: propertyName,
+            }, luvio, store, timestamp);
+        }
+        return recordIngest;
+    };
+};
+const recordProperties = {
+    Id: {
+        propertyName: 'id',
+    },
+    ApiName: {
+        propertyName: 'apiName',
+    },
+};
+function getNonSpanningField(sel, builder, source) {
+    const sink = {};
+    const { luvioSelections } = sel;
+    if (luvioSelections === undefined) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error('Empty selections not supported');
+    }
+    for (let i = 0, len = luvioSelections.length; i < len; i += 1) {
+        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
+        const { kind } = sel;
+        const name = sel.name;
+        builder.enterPath(name);
+        if (kind !== 'ScalarFieldSelection') {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error(`Unexpected kind "${kind}"`);
+            }
+        }
+        builder.assignScalar(name, sink, source[name]);
+        builder.exitPath();
+    }
+    return sink;
+}
+function getCustomSelection(luvio, selection, builder, options, variables) {
+    const { type } = selection;
+    switch (type) {
+        case 'Record':
+            return readRecordRepresentation(luvio, selection, builder, options, variables);
+    }
+}
+function getScalarValue(selectionName, state) {
+    if (selectionName === 'DisplayValue') {
+        const { parentFieldValue } = state;
+        if (parentFieldValue === undefined) {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error('Unable to calculate DisplayValue');
+            }
+            else {
+                return undefined;
+            }
+        }
+        return parentFieldValue.displayValue;
+    }
+    const assignment = recordProperties[selectionName];
+    if (assignment === undefined) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error(`Unknown assignment for ScalarFieldSelection at property "${selectionName}"`);
+        }
+    }
+    return state.source[assignment.propertyName];
+}
+function assignConnectionSelection(luvio, builder, sink, sel, recordKey, propertyName, variables) {
+    const key = getChildRelationshipsKey(recordKey, propertyName);
+    const resolved = resolveKey(builder, key);
+    if (resolved === undefined) {
+        return;
+    }
+    const data = createRead$2(luvio, sel, variables)(resolved.value, builder);
+    builder.assignNonScalar(sink, propertyName, data);
+}
+function assignSelection(luvio, selection, builder, state, variables) {
+    const sel = getLuvioFieldNodeSelection(selection);
+    const { name: selectionName, kind, alias } = sel;
+    const propertyName = alias === undefined ? selectionName : alias;
+    const { source, sink } = state;
+    const { fields } = source;
+    builder.enterPath(selectionName);
+    switch (kind) {
+        case 'ScalarFieldSelection': {
+            builder.assignScalar(propertyName, sink, getScalarValue(selectionName, state));
+            break;
+        }
+        case 'ObjectFieldSelection': {
+            // regular field, not spanning
+            const field = propertyLookup(builder, selectionName, fields);
+            if (field.state === PropertyLookupResultState.Missing) {
+                break;
+            }
+            const resolved = resolveLink(builder, field.value);
+            if (resolved === undefined) {
+                break;
+            }
+            const data = getNonSpanningField(sel, builder, resolved.value);
+            builder.assignNonScalar(sink, propertyName, data);
+            break;
+        }
+        case 'CustomFieldSelection': {
+            if (sel.type === 'Connection') {
+                const recordKey = keyBuilderRecord(luvio, {
+                    recordId: state.source.id,
+                });
+                assignConnectionSelection(luvio, builder, sink, sel, recordKey, propertyName, variables);
+            }
+            else {
+                const field = fields[selectionName];
+                const resolvedParentFieldValue = resolveLink(builder, field);
+                if (resolvedParentFieldValue === undefined) {
+                    break;
+                }
+                const { value: spanningFieldResult } = resolvedParentFieldValue;
+                const { value: spanningFieldValue } = spanningFieldResult;
+                if (spanningFieldValue === null || typeof spanningFieldValue !== 'object') {
+                    sink[propertyName] = null;
+                    break;
+                }
+                const resolvedSpanningRecordValue = resolveLink(builder, spanningFieldValue);
+                if (resolvedSpanningRecordValue === undefined) {
+                    break;
+                }
+                const 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) {
+    const { luvioSelections } = ast;
+    if (luvioSelections === undefined) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error('Empty selections not supported');
+    }
+    const sink = {};
+    const state = {
+        source: options.source,
+        sink,
+        parentFieldValue: options.parentFieldValue,
+    };
+    for (let i = 0, len = luvioSelections.length; i < len; i += 1) {
+        assignSelection(luvio, luvioSelections[i], builder, state, variables);
+    }
+    return sink;
+}
+const createRead$3 = (luvio, ast, variables) => {
+    return (data, builder) => {
+        return readRecordRepresentation(luvio, ast, builder, {
+            source: data,
+            parentFieldValue: undefined,
+        }, variables);
+    };
 };
 
-const createIngest$3 = (ast, variables) => {
-    const { type } = ast;
-    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: "${type}"`);
+const createIngest$3 = (ast, variables) => {
+    const { type } = ast;
+    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: "${type}"`);
 };
 
-function merge(existing, incoming) {
-    if (existing === undefined) {
-        return incoming;
-    }
-    // Merge existing and incoming values together
-    return {
-        ...existing,
-        ...incoming,
-    };
+function merge(existing, incoming) {
+    if (existing === undefined) {
+        return incoming;
+    }
+    // Merge existing and incoming values together
+    return {
+        ...existing,
+        ...incoming,
+    };
 }
 
-function resolveValue(ast, variables, source) {
-    const { alias } = ast;
-    const propertyName = render(ast, variables);
-    if (process.env.NODE_ENV !== 'production') {
-        if (alias !== undefined && alias in source) {
-            throw new Error(`Invalid alias "${alias}" passed to "equal" function. All aliases need to be normalized before calling equal`);
-        }
-    }
-    return source[propertyName];
-}
-function linkEquals(ast, variables, existing, incoming) {
-    const value = resolveValue(ast, variables, existing);
-    if (value === undefined) {
-        return false;
-    }
-    const 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) {
-    const { name } = ast;
-    const value = existing[name];
-    if (value === undefined) {
-        return false;
-    }
-    return value === resolveValue(ast, variables, incoming);
-}
-function equals(ast, variables, existing, incoming) {
-    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-    for (let i = 0, len = selections.length; i < len; i += 1) {
-        const 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;
+function resolveValue(ast, variables, source) {
+    const { alias } = ast;
+    const propertyName = render(ast, variables);
+    if (process.env.NODE_ENV !== 'production') {
+        if (alias !== undefined && alias in source) {
+            throw new Error(`Invalid alias "${alias}" passed to "equal" function. All aliases need to be normalized before calling equal`);
+        }
+    }
+    return source[propertyName];
+}
+function linkEquals(ast, variables, existing, incoming) {
+    const value = resolveValue(ast, variables, existing);
+    if (value === undefined) {
+        return false;
+    }
+    const 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) {
+    const { name } = ast;
+    const value = existing[name];
+    if (value === undefined) {
+        return false;
+    }
+    return value === resolveValue(ast, variables, incoming);
+}
+function equals(ast, variables, existing, incoming) {
+    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
+    for (let i = 0, len = selections.length; i < len; i += 1) {
+        const 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;
 }
 
-const DEFAULT_GRAPHQL_TTL = 30000;
-const 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) {
-    const { store, key, ast, incoming, luvio, variables } = params;
-    const existing = store.readEntry(key);
-    if (existing === undefined || equals(ast, variables, existing, incoming) === false) {
-        const newData = merge(existing, incoming);
-        luvio.storePublish(key, newData);
-    }
-}
-function genericCreateIngest(ast, variables) {
-    let selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-    return (data, path, luvio, store, timestamp) => {
-        const { fullPath } = path;
-        for (let i = 0, len = selections.length; i < len; i += 1) {
-            const sel = getLuvioFieldNodeSelection(selections[i]);
-            if (sel.kind === 'ScalarFieldSelection') {
-                continue;
-            }
-            const { name: fieldName, alias } = sel;
-            const readPropertyName = alias === undefined ? fieldName : alias;
-            const propertyFullPath = `${fullPath}__${fieldName}`;
-            const writePropertyName = render(sel, variables);
-            const childPath = {
-                parent: {
-                    existing: null,
-                    key: fullPath,
-                    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,
-            luvio,
-            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,
-        };
-    };
+const DEFAULT_GRAPHQL_TTL = 30000;
+const 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) {
+    const { store, key, ast, incoming, luvio, variables } = params;
+    const existing = store.readEntry(key);
+    if (existing === undefined || equals(ast, variables, existing, incoming) === false) {
+        const newData = merge(existing, incoming);
+        luvio.storePublish(key, newData);
+    }
+}
+function genericCreateIngest(ast, variables) {
+    let selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
+    return (data, path, luvio, store, timestamp) => {
+        const { fullPath } = path;
+        for (let i = 0, len = selections.length; i < len; i += 1) {
+            const sel = getLuvioFieldNodeSelection(selections[i]);
+            if (sel.kind === 'ScalarFieldSelection') {
+                continue;
+            }
+            const { name: fieldName, alias } = sel;
+            const readPropertyName = alias === undefined ? fieldName : alias;
+            const propertyFullPath = `${fullPath}__${fieldName}`;
+            const writePropertyName = render(sel, variables);
+            const childPath = {
+                parent: {
+                    existing: null,
+                    key: fullPath,
+                    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,
+            luvio,
+            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,
+        };
+    };
 }
 
-const CONNECTION_NODE_TYPE = 'Connection';
-const TYPENAME_FIELD$1 = '__typename';
-const PAGE_INFO_REQUIRED_FIELDS = ['hasNextPage', 'hasPreviousPage'];
-const EDGE_REQUIRED_FIELDS = ['cursor'];
-const PROPERTY_NAME_EDGES = 'edges';
-const PROPERTY_NAME_PAGE_INFO = 'pageInfo';
-const PROPERTY_NAME_TOTAL_COUNT = 'totalCount';
-function keyBuilder(ast, variables) {
-    const { arguments: args, name } = ast;
-    if (args === undefined) {
-        return `${namespace}::${CONNECTION_NODE_TYPE}:${name}()`;
-    }
-    const serialized = render$1(args, variables);
-    return `${namespace}::${CONNECTION_NODE_TYPE}:${name}(${serialized})`;
-}
-function selectEdges(luvio, builder, ast, links, variables) {
-    const sink = [];
-    for (let i = 0, len = links.length; i < len; i += 1) {
-        builder.enterPath(i);
-        const link = links[i];
-        const resolved = followLink(luvio, ast, builder, link, variables);
-        builder.assignNonScalar(sink, i, resolved);
-        builder.exitPath();
-    }
-    return sink;
-}
-const createRead$2 = (luvio, ast, variables) => {
-    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-    return (source, builder) => {
-        const sink = {};
-        for (let i = 0, len = selections.length; i < len; i += 1) {
-            const sel = getLuvioFieldNodeSelection(selections[i]);
-            const { name, kind } = sel;
-            if (kind === 'ScalarFieldSelection') {
-                readScalarFieldSelection(builder, source, name, sink);
-                continue;
-            }
-            const readPropertyName = render(sel, variables);
-            builder.enterPath(readPropertyName);
-            const edges = resolveLink(builder, source[readPropertyName]);
-            if (edges === undefined) {
-                builder.exitPath();
-                break;
-            }
-            if (readPropertyName === PROPERTY_NAME_EDGES) {
-                const 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) {
-    const 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) {
-    const key = path.fullPath;
-    const existing = store.readEntry(key);
-    let hasChanges = existing === undefined || data.length !== existing.length;
-    for (let i = 0, len = data.length; i < len; i += 1) {
-        const incomingItem = (data[i] = createIngest$2(sel, variables)(data[i], {
-            parent: {
-                data,
-                existing: null,
-                key,
-            },
-            propertyName: i,
-            fullPath: `${key}__${i}`,
-        }, luvio, store, timestamp));
-        const 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,
-    };
-}
-const createIngest$1 = (ast, key, variables) => {
-    const { luvioSelections } = ast;
-    const selections = luvioSelections === undefined ? [] : luvioSelections;
-    return (data, path, luvio, store, timestamp) => {
-        for (let i = 0, len = selections.length; i < len; i += 1) {
-            const sel = getLuvioFieldNodeSelection(selections[i]);
-            const { kind } = sel;
-            const propertyName = sel.name;
-            if (kind !== 'ObjectFieldSelection') {
-                continue;
-            }
-            data[propertyName] = ingestConnectionProperty(sel, data[propertyName], {
-                parent: {
-                    existing: null,
-                    key,
-                    data,
-                },
-                fullPath: `${key}__${propertyName}`,
-                propertyName,
-            }, luvio, store, timestamp, variables);
-        }
-        publishDataIfChanged({
-            key,
-            luvio,
-            store,
-            incoming: data,
-            variables: {},
-            ast,
-        });
-        const 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) {
-    const { luvioSelections, arguments: args } = def;
-    if (luvioSelections === undefined) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('Connection field node must have selections');
-        }
-        return '';
-    }
-    const argsString = args === undefined || args.length === 0 ? '' : `(${serializeArguments(args)})`;
-    const seenFields = {};
-    const serializedFields = [];
-    for (let i = 0; i < luvioSelections.length; i++) {
-        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-        const { name: fieldName } = sel;
-        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 `${serializeFieldNodeName(def)}${argsString} { ${serializedFields.join(' ')} }`;
-}
-function serializeEdges(node, state) {
-    if (!isLuvioFieldNodeObjectFieldNode(node)) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('PageInfo must be an ObjectFieldNode');
-        }
-        return '';
-    }
-    const { luvioSelections } = node;
-    if (luvioSelections === undefined)
-        return '';
-    const seenFields = {};
-    const serializedFields = [];
-    for (let i = 0; i < luvioSelections.length; i++) {
-        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-        seenFields[sel.name] = true;
-        serializedFields.push(serializeFieldNode(sel, state));
-    }
-    appendRequiredFields(EDGE_REQUIRED_FIELDS, seenFields, serializedFields);
-    insertTypeName(seenFields, serializedFields);
-    return `${serializeFieldNodeName(node)} { ${serializedFields.join(' ')} }`;
-}
-function serializePageInfo(node, state) {
-    if (!isLuvioFieldNodeObjectFieldNode(node)) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('PageInfo must be an ObjectFieldNode');
-        }
-        return '';
-    }
-    const { luvioSelections } = node;
-    if (luvioSelections === undefined)
-        return '';
-    const seenFields = {};
-    const serializedFields = [];
-    for (let i = 0; i < luvioSelections.length; i++) {
-        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-        seenFields[sel.name] = true;
-        serializedFields.push(serializeFieldNode(sel, state));
-    }
-    appendRequiredFields(PAGE_INFO_REQUIRED_FIELDS, seenFields, serializedFields);
-    return `${serializeFieldNodeName(node)} { ${serializedFields.join(' ')} }`;
-}
-function appendRequiredFields(requiredFields, seenFields, result) {
-    for (let i = 0; i < requiredFields.length; i++) {
-        const 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);
-    }
+const CONNECTION_NODE_TYPE = 'Connection';
+const TYPENAME_FIELD$1 = '__typename';
+const PAGE_INFO_REQUIRED_FIELDS = ['hasNextPage', 'hasPreviousPage'];
+const EDGE_REQUIRED_FIELDS = ['cursor'];
+const PROPERTY_NAME_EDGES = 'edges';
+const PROPERTY_NAME_PAGE_INFO = 'pageInfo';
+const PROPERTY_NAME_TOTAL_COUNT = 'totalCount';
+function keyBuilder(ast, variables) {
+    const { arguments: args, name } = ast;
+    if (args === undefined) {
+        return `${namespace}::${CONNECTION_NODE_TYPE}:${name}()`;
+    }
+    const serialized = render$1(args, variables);
+    return `${namespace}::${CONNECTION_NODE_TYPE}:${name}(${serialized})`;
+}
+function selectEdges(luvio, builder, ast, links, variables) {
+    const sink = [];
+    for (let i = 0, len = links.length; i < len; i += 1) {
+        builder.enterPath(i);
+        const link = links[i];
+        const resolved = followLink(luvio, ast, builder, link, variables);
+        builder.assignNonScalar(sink, i, resolved);
+        builder.exitPath();
+    }
+    return sink;
+}
+const createRead$2 = (luvio, ast, variables) => {
+    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
+    return (source, builder) => {
+        const sink = {};
+        for (let i = 0, len = selections.length; i < len; i += 1) {
+            const sel = getLuvioFieldNodeSelection(selections[i]);
+            const { name, kind } = sel;
+            if (kind === 'ScalarFieldSelection') {
+                readScalarFieldSelection(builder, source, name, sink);
+                continue;
+            }
+            const readPropertyName = render(sel, variables);
+            builder.enterPath(readPropertyName);
+            const edges = resolveLink(builder, source[readPropertyName]);
+            if (edges === undefined) {
+                builder.exitPath();
+                break;
+            }
+            if (readPropertyName === PROPERTY_NAME_EDGES) {
+                const 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) {
+    const 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) {
+    const key = path.fullPath;
+    const existing = store.readEntry(key);
+    let hasChanges = existing === undefined || data.length !== existing.length;
+    for (let i = 0, len = data.length; i < len; i += 1) {
+        const incomingItem = (data[i] = createIngest$2(sel, variables)(data[i], {
+            parent: {
+                data,
+                existing: null,
+                key,
+            },
+            propertyName: i,
+            fullPath: `${key}__${i}`,
+        }, luvio, store, timestamp));
+        const 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,
+    };
+}
+const createIngest$1 = (ast, key, variables) => {
+    const { luvioSelections } = ast;
+    const selections = luvioSelections === undefined ? [] : luvioSelections;
+    return (data, path, luvio, store, timestamp) => {
+        for (let i = 0, len = selections.length; i < len; i += 1) {
+            const sel = getLuvioFieldNodeSelection(selections[i]);
+            const { kind } = sel;
+            const propertyName = sel.name;
+            if (kind !== 'ObjectFieldSelection') {
+                continue;
+            }
+            data[propertyName] = ingestConnectionProperty(sel, data[propertyName], {
+                parent: {
+                    existing: null,
+                    key,
+                    data,
+                },
+                fullPath: `${key}__${propertyName}`,
+                propertyName,
+            }, luvio, store, timestamp, variables);
+        }
+        publishDataIfChanged({
+            key,
+            luvio,
+            store,
+            incoming: data,
+            variables: {},
+            ast,
+        });
+        const 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) {
+    const { luvioSelections, arguments: args } = def;
+    if (luvioSelections === undefined) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('Connection field node must have selections');
+        }
+        return '';
+    }
+    const argsString = args === undefined || args.length === 0 ? '' : `(${serializeArguments(args)})`;
+    const seenFields = {};
+    const serializedFields = [];
+    for (let i = 0; i < luvioSelections.length; i++) {
+        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
+        const { name: fieldName } = sel;
+        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 `${serializeFieldNodeName(def)}${argsString} { ${serializedFields.join(' ')} }`;
+}
+function serializeEdges(node, state) {
+    if (!isLuvioFieldNodeObjectFieldNode(node)) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('PageInfo must be an ObjectFieldNode');
+        }
+        return '';
+    }
+    const { luvioSelections } = node;
+    if (luvioSelections === undefined)
+        return '';
+    const seenFields = {};
+    const serializedFields = [];
+    for (let i = 0; i < luvioSelections.length; i++) {
+        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
+        seenFields[sel.name] = true;
+        serializedFields.push(serializeFieldNode(sel, state));
+    }
+    appendRequiredFields(EDGE_REQUIRED_FIELDS, seenFields, serializedFields);
+    insertTypeName(seenFields, serializedFields);
+    return `${serializeFieldNodeName(node)} { ${serializedFields.join(' ')} }`;
+}
+function serializePageInfo(node, state) {
+    if (!isLuvioFieldNodeObjectFieldNode(node)) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('PageInfo must be an ObjectFieldNode');
+        }
+        return '';
+    }
+    const { luvioSelections } = node;
+    if (luvioSelections === undefined)
+        return '';
+    const seenFields = {};
+    const serializedFields = [];
+    for (let i = 0; i < luvioSelections.length; i++) {
+        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
+        seenFields[sel.name] = true;
+        serializedFields.push(serializeFieldNode(sel, state));
+    }
+    appendRequiredFields(PAGE_INFO_REQUIRED_FIELDS, seenFields, serializedFields);
+    return `${serializeFieldNodeName(node)} { ${serializedFields.join(' ')} }`;
+}
+function appendRequiredFields(requiredFields, seenFields, result) {
+    for (let i = 0; i < requiredFields.length; i++) {
+        const 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);
-}
-const genericCreateRead = (luvio, ast, variables) => {
-    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
-    return (source, builder) => {
-        const sink = {};
-        for (let i = 0, len = selections.length; i < len; i += 1) {
-            const sel = getLuvioFieldNodeSelection(selections[i]);
-            const { name: fieldName, alias } = sel;
-            const propertyName = alias === undefined ? fieldName : alias;
-            builder.enterPath(fieldName);
-            switch (sel.kind) {
-                case 'ScalarFieldSelection':
-                    readScalarFieldSelection(builder, source, fieldName, sink);
-                    break;
-                default: {
-                    const data = followLink(luvio, sel, builder, source[render(sel, variables)], variables);
-                    builder.assignNonScalar(sink, propertyName, data);
-                }
-            }
-            builder.exitPath();
-        }
-        return sink;
-    };
+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);
+}
+const genericCreateRead = (luvio, ast, variables) => {
+    const selections = ast.luvioSelections === undefined ? [] : ast.luvioSelections;
+    return (source, builder) => {
+        const sink = {};
+        for (let i = 0, len = selections.length; i < len; i += 1) {
+            const sel = getLuvioFieldNodeSelection(selections[i]);
+            const { name: fieldName, alias } = sel;
+            const propertyName = alias === undefined ? fieldName : alias;
+            builder.enterPath(fieldName);
+            switch (sel.kind) {
+                case 'ScalarFieldSelection':
+                    readScalarFieldSelection(builder, source, fieldName, sink);
+                    break;
+                default: {
+                    const 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 = {}));
-const 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) {
-    const { redirects, resolvedKey } = state;
-    builder.markSeenId(resolvedKey);
-    const { length: len } = redirects;
-    if (len === 0) {
-        return;
-    }
-    for (let i = 0; i < len; i += 1) {
-        builder.markSeenId(redirects[i]);
-    }
-}
-function resolveKey(builder, key) {
-    const { StoreResolveResultState } = builder;
-    const 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) {
-    const { StoreLinkStateValues } = builder;
-    const 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 "${builder.currentPath.fullPath}"`);
-            }
-            else {
-                return;
-            }
-    }
-    const { key: __ref } = linkState;
-    return resolveKey(builder, __ref);
-}
-function followLink(luvio, sel, builder, storeLink, variables) {
-    const linkState = resolveLink(builder, storeLink);
-    if (linkState === undefined) {
-        return;
-    }
-    const { value } = linkState;
-    return createRead$1(luvio, sel, variables)(value, builder);
-}
-function getLuvioFieldNodeSelection(ast) {
-    const { kind } = ast;
-    if (kind === 'FragmentSpread' || kind === 'InlineFragment') {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('"FragmentSpread" and "InlineFragment" currently not supported');
-        }
-    }
-    return ast;
+var PropertyLookupResultState;
+(function (PropertyLookupResultState) {
+    PropertyLookupResultState[PropertyLookupResultState["Missing"] = 0] = "Missing";
+    PropertyLookupResultState[PropertyLookupResultState["Present"] = 1] = "Present";
+})(PropertyLookupResultState || (PropertyLookupResultState = {}));
+const 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) {
+    const { redirects, resolvedKey } = state;
+    builder.markSeenId(resolvedKey);
+    const { length: len } = redirects;
+    if (len === 0) {
+        return;
+    }
+    for (let i = 0; i < len; i += 1) {
+        builder.markSeenId(redirects[i]);
+    }
+}
+function resolveKey(builder, key) {
+    const { StoreResolveResultState } = builder;
+    const 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) {
+    const { StoreLinkStateValues } = builder;
+    const 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 "${builder.currentPath.fullPath}"`);
+            }
+            else {
+                return;
+            }
+    }
+    const { key: __ref } = linkState;
+    return resolveKey(builder, __ref);
+}
+function followLink(luvio, sel, builder, storeLink, variables) {
+    const linkState = resolveLink(builder, storeLink);
+    if (linkState === undefined) {
+        return;
+    }
+    const { value } = linkState;
+    return createRead$1(luvio, sel, variables)(value, builder);
+}
+function getLuvioFieldNodeSelection(ast) {
+    const { kind } = ast;
+    if (kind === 'FragmentSpread' || kind === 'InlineFragment') {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('"FragmentSpread" and "InlineFragment" currently not supported');
+        }
+    }
+    return ast;
 }
 
-const TYPENAME_FIELD = '__typename';
-const KIND_OBJECT_FIELD_SELECTION = 'ObjectFieldSelection';
-function serializeFieldNodeName(node) {
-    const { name, alias } = node;
-    return alias === undefined ? `${name}` : `${alias}: ${name}`;
-}
-function serializeSelections(selections, state) {
-    if (selections === undefined) {
-        return '';
-    }
-    let str = '';
-    for (let i = 0, len = selections.length; i < len; i += 1) {
-        const def = serializeFieldNode(selections[i], state);
-        str = `${str}${def}`;
-    }
-    return str;
-}
-function serializeFieldNode(def, state) {
-    const { kind } = def;
-    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 "${kind}"`);
-    }
-    return '';
-}
-function serializeObjectFieldNode(def, state) {
-    const { luvioSelections, arguments: defArgs } = def;
-    const args = defArgs === undefined ? '' : `(${serializeArguments(defArgs)})`;
-    return `${serializeFieldNodeName(def)}${args} { ${TYPENAME_FIELD} ${serializeSelections(luvioSelections, state)} }`;
-}
-function serializeCustomFieldNode(def, state) {
-    const { type } = def;
-    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 "${type}"`);
-    }
-    return '';
-}
-function serializeScalarFieldNode(def) {
-    return `${serializeFieldNodeName(def)}, `;
-}
-function serializeRecordSelections(selections, state) {
-    if (selections === undefined) {
-        return '';
-    }
-    let str = '';
-    for (let i = 0, len = selections.length; i < len; i += 1) {
-        const sel = getLuvioFieldNodeSelection(selections[i]);
-        const def = isLuvioFieldNodeObjectFieldNode(sel)
-            ? serializeObjectFieldNodeUnderRecord(sel)
-            : serializeFieldNode(sel, state);
-        str = `${str}${def}`;
-    }
-    return str;
-}
-function isLuvioFieldNodeObjectFieldNode(node) {
-    return node.kind === KIND_OBJECT_FIELD_SELECTION;
-}
-function serializeObjectFieldNodeUnderRecord(node) {
-    const { luvioSelections, arguments: nodeArgs, name: nodeName } = node;
-    const fields = {};
-    let result = ``;
-    if (luvioSelections === undefined) {
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('selection should not be empty for ObjectFieldNodeUnderRecord');
-    }
-    const luvioSelectionsLength = luvioSelections.length;
-    for (let i = 0; i < luvioSelectionsLength; i++) {
-        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
-        const { name } = sel;
-        if (sel.kind !== 'ScalarFieldSelection') {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error(`Invalid selection for ${nodeName}. ${nodeName} appears to be a Record, but is missing @resource(type: "Record")`);
-            }
-        }
-        if (RECORD_DEFAULT_FIELD_VALUES.indexOf(name) === -1) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error(`Invalid selection for "${nodeName}.${name}". Only ${RECORD_DEFAULT_FIELD_VALUES.join(', ')} are supported. If "${nodeName}" is a spanning Record, please include @resource(type: "Record") directive.`);
-            }
-        }
-        fields[name] = true;
-        result = `${result}${serializeScalarFieldNode(sel)}`;
-    }
-    result = appendRecordDefaultFieldValues(result, fields);
-    const args = nodeArgs === undefined ? '' : `(${serializeArguments(nodeArgs)})`;
-    return `${serializeFieldNodeName(node)}${args} { ${TYPENAME_FIELD} ${result} }`;
-}
-function appendRecordDefaultFieldValues(fieldValues, fieldValuesMap) {
-    let str = fieldValues;
-    for (let i = 0, len = RECORD_DEFAULT_FIELD_VALUES.length; i < len; i++) {
-        const defaultField = RECORD_DEFAULT_FIELD_VALUES[i];
-        if (fieldValuesMap[defaultField] !== true) {
-            str = `${str}${defaultField}, `;
-        }
-    }
-    return str;
-}
-function appendSpanningRecordIds(luvioSelections) {
-    if (luvioSelections === undefined) {
-        return undefined;
-    }
-    //add record ref ids
-    let spanningRecordIdFields = [];
-    let 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 (let i = 0; i < selections.length; i++) {
-        const selection = selections[i];
-        if (selection.kind === 'CustomFieldSelection' && selection.type === 'Record') {
-            const customFieldMatches = selection.name.match(/(.*__)r$/);
-            if (customFieldMatches) {
-                // For `FSL__Related_Service__r {...}`, inject `FSL__Related_Service__c { value } as a peer field`
-                const [, captureGroup] = customFieldMatches;
-                spanningRecordIdFields.push(`${captureGroup}c`);
-            }
-            else {
-                // For `Owner {...}`, inject `OwnerId { value } as a peer field`
-                spanningRecordIdFields.push(`${selection.name}Id`);
-            }
-        }
-    }
-    //Add all missing reference IDs to the set of selections
-    for (let i = 0; i < spanningRecordIdFields.length; i++) {
-        const idField = spanningRecordIdFields[i];
-        if (selections.findIndex((e) => e.kind === 'ObjectFieldSelection' && e.name === idField) >
-            -1) {
-            continue;
-        }
-        selections.push({
-            kind: 'ObjectFieldSelection',
-            name: idField,
-            luvioSelections: [{ kind: 'ScalarFieldSelection', name: 'value' }],
-        });
-    }
-    return selections;
-}
-function serializeCustomFieldRecord(def, state) {
-    const { luvioSelections } = def;
-    if (state.fragments[defaultRecordFieldsFragmentName] === undefined) {
-        state.fragments[defaultRecordFieldsFragmentName] = defaultRecordFieldsFragment;
-    }
-    const selections = appendSpanningRecordIds(luvioSelections);
-    return `${serializeFieldNodeName(def)} { ${serializeRecordSelections(selections, state)} ...${defaultRecordFieldsFragmentName} }`;
-}
-function serializeArguments(argDefinitions) {
-    if (argDefinitions === undefined) {
-        return '';
-    }
-    let str = '';
-    for (let i = 0, len = argDefinitions.length; i < len; i += 1) {
-        let def = serializeArgument(argDefinitions[i]);
-        if (i !== 0) {
-            def = ` ${def}`;
-        }
-        str = `${str}${def}`;
-    }
-    return str;
-}
-function serializeArgument(argDefinition) {
-    const { name, value } = argDefinition;
-    return `${name}: ${serializeValueNode(value)}`;
+const TYPENAME_FIELD = '__typename';
+const KIND_OBJECT_FIELD_SELECTION = 'ObjectFieldSelection';
+function serializeFieldNodeName(node) {
+    const { name, alias } = node;
+    return alias === undefined ? `${name}` : `${alias}: ${name}`;
+}
+function serializeSelections(selections, state) {
+    if (selections === undefined) {
+        return '';
+    }
+    let str = '';
+    for (let i = 0, len = selections.length; i < len; i += 1) {
+        const def = serializeFieldNode(selections[i], state);
+        str = `${str}${def}`;
+    }
+    return str;
+}
+function serializeFieldNode(def, state) {
+    const { kind } = def;
+    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 "${kind}"`);
+    }
+    return '';
+}
+function serializeObjectFieldNode(def, state) {
+    const { luvioSelections, arguments: defArgs } = def;
+    const args = defArgs === undefined ? '' : `(${serializeArguments(defArgs)})`;
+    return `${serializeFieldNodeName(def)}${args} { ${TYPENAME_FIELD} ${serializeSelections(luvioSelections, state)} }`;
+}
+function serializeCustomFieldNode(def, state) {
+    const { type } = def;
+    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 "${type}"`);
+    }
+    return '';
+}
+function serializeScalarFieldNode(def) {
+    return `${serializeFieldNodeName(def)}, `;
+}
+function serializeRecordSelections(selections, state) {
+    if (selections === undefined) {
+        return '';
+    }
+    let str = '';
+    for (let i = 0, len = selections.length; i < len; i += 1) {
+        const sel = getLuvioFieldNodeSelection(selections[i]);
+        const def = isLuvioFieldNodeObjectFieldNode(sel)
+            ? serializeObjectFieldNodeUnderRecord(sel)
+            : serializeFieldNode(sel, state);
+        str = `${str}${def}`;
+    }
+    return str;
+}
+function isLuvioFieldNodeObjectFieldNode(node) {
+    return node.kind === KIND_OBJECT_FIELD_SELECTION;
+}
+function serializeObjectFieldNodeUnderRecord(node) {
+    const { luvioSelections, arguments: nodeArgs, name: nodeName } = node;
+    const fields = {};
+    let result = ``;
+    if (luvioSelections === undefined) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error('selection should not be empty for ObjectFieldNodeUnderRecord');
+    }
+    const luvioSelectionsLength = luvioSelections.length;
+    for (let i = 0; i < luvioSelectionsLength; i++) {
+        const sel = getLuvioFieldNodeSelection(luvioSelections[i]);
+        const { name } = sel;
+        if (sel.kind !== 'ScalarFieldSelection') {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error(`Invalid selection for ${nodeName}. ${nodeName} appears to be a Record, but is missing @resource(type: "Record")`);
+            }
+        }
+        if (RECORD_DEFAULT_FIELD_VALUES.indexOf(name) === -1) {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error(`Invalid selection for "${nodeName}.${name}". Only ${RECORD_DEFAULT_FIELD_VALUES.join(', ')} are supported. If "${nodeName}" is a spanning Record, please include @resource(type: "Record") directive.`);
+            }
+        }
+        fields[name] = true;
+        result = `${result}${serializeScalarFieldNode(sel)}`;
+    }
+    result = appendRecordDefaultFieldValues(result, fields);
+    const args = nodeArgs === undefined ? '' : `(${serializeArguments(nodeArgs)})`;
+    return `${serializeFieldNodeName(node)}${args} { ${TYPENAME_FIELD} ${result} }`;
+}
+function appendRecordDefaultFieldValues(fieldValues, fieldValuesMap) {
+    let str = fieldValues;
+    for (let i = 0, len = RECORD_DEFAULT_FIELD_VALUES.length; i < len; i++) {
+        const defaultField = RECORD_DEFAULT_FIELD_VALUES[i];
+        if (fieldValuesMap[defaultField] !== true) {
+            str = `${str}${defaultField}, `;
+        }
+    }
+    return str;
+}
+function appendSpanningRecordIds(luvioSelections) {
+    if (luvioSelections === undefined) {
+        return undefined;
+    }
+    //add record ref ids
+    let spanningRecordIdFields = [];
+    let 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 (let i = 0; i < selections.length; i++) {
+        const selection = selections[i];
+        if (selection.kind === 'CustomFieldSelection' && selection.type === 'Record') {
+            const customFieldMatches = selection.name.match(/(.*__)r$/);
+            if (customFieldMatches) {
+                // For `FSL__Related_Service__r {...}`, inject `FSL__Related_Service__c { value } as a peer field`
+                const [, captureGroup] = customFieldMatches;
+                spanningRecordIdFields.push(`${captureGroup}c`);
+            }
+            else {
+                // For `Owner {...}`, inject `OwnerId { value } as a peer field`
+                spanningRecordIdFields.push(`${selection.name}Id`);
+            }
+        }
+    }
+    //Add all missing reference IDs to the set of selections
+    for (let i = 0; i < spanningRecordIdFields.length; i++) {
+        const idField = spanningRecordIdFields[i];
+        if (selections.findIndex((e) => e.kind === 'ObjectFieldSelection' && e.name === idField) >
+            -1) {
+            continue;
+        }
+        selections.push({
+            kind: 'ObjectFieldSelection',
+            name: idField,
+            luvioSelections: [{ kind: 'ScalarFieldSelection', name: 'value' }],
+        });
+    }
+    return selections;
+}
+function serializeCustomFieldRecord(def, state) {
+    const { luvioSelections } = def;
+    if (state.fragments[defaultRecordFieldsFragmentName] === undefined) {
+        state.fragments[defaultRecordFieldsFragmentName] = defaultRecordFieldsFragment;
+    }
+    const selections = appendSpanningRecordIds(luvioSelections);
+    return `${serializeFieldNodeName(def)} { ${serializeRecordSelections(selections, state)} ...${defaultRecordFieldsFragmentName} }`;
+}
+function serializeArguments(argDefinitions) {
+    if (argDefinitions === undefined) {
+        return '';
+    }
+    let str = '';
+    for (let i = 0, len = argDefinitions.length; i < len; i += 1) {
+        let def = serializeArgument(argDefinitions[i]);
+        if (i !== 0) {
+            def = ` ${def}`;
+        }
+        str = `${str}${def}`;
+    }
+    return str;
+}
+function serializeArgument(argDefinition) {
+    const { name, value } = argDefinition;
+    return `${name}: ${serializeValueNode(value)}`;
 }
 
-function serializeValueNode(valueDefinition) {
-    const { kind } = valueDefinition;
-    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 "${kind}"`);
-    }
-}
-function serializeVariableNode(variableNode) {
-    return `$${variableNode.name}`;
-}
-function serializeListValueNode(listNode) {
-    const { values } = listNode;
-    if (values.length === 0) {
-        return '';
-    }
-    let str = '';
-    for (let i = 0, len = values.length; i < len; i += 1) {
-        str = `${str}${serializeValueNode(values[i])}, `;
-    }
-    return `[${str.substring(0, str.length - 2)}]`;
-}
-function serializeStringValueNode(literalValueNode) {
-    return `"${literalValueNode.value}"`;
-}
-function serializeObjectValueNode(objectValueDefinition) {
-    const { fields } = objectValueDefinition;
-    let str = [];
-    const fieldKeys = keys(fields);
-    for (let i = 0, len = fieldKeys.length; i < len; i += 1) {
-        const fieldKey = fieldKeys[i];
-        str.push(`${fieldKey}: ${serializeValueNode(fields[fieldKey])}`);
-    }
-    return `{ ${str.join(', ')} }`;
-}
-function serializeVariableDefinitions(definitons) {
-    if (definitons === undefined || definitons.length === 0) {
-        return '';
-    }
-    let str = '';
-    for (let i = 0, len = definitons.length; i < len; i += 1) {
-        const def = serializeVariableDefinitionNode(definitons[i]);
-        str = `${str}${def}, `;
-    }
-    return ` (${str.substring(0, str.length - 2)})`;
-}
-function serializeVariableDefinitionNode(def) {
-    const { variable, type, defaultValue } = def;
-    return defaultValue === undefined
-        ? `$${variable.name}: ${serializeTypeNode(type)}`
-        : `$${variable.name}: ${serializeTypeNode(type)} = ${serializeValueNode(defaultValue)}`;
-}
-function serializeTypeNode(type) {
-    const { kind } = type;
-    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 "${type.kind}"`);
-    }
-    return '';
-}
-function serializeNamedTypeNode(type) {
-    return type.name;
-}
-function serializeListTypeNode(type) {
-    return `[${serializeTypeNode(type.type)}]`;
-}
-function serializeOperationNode(def, state) {
-    const { kind } = def;
-    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 "${kind}"`);
-    }
-}
-function serializeOperationDefinition(def, state) {
-    const { operation, luvioSelections, name, variableDefinitions } = def;
-    const nameStr = name === undefined ? ' ' : ` ${name} `;
-    return `${operation}${nameStr}${serializeVariableDefinitions(variableDefinitions)}{ ${TYPENAME_FIELD} ${serializeSelections(luvioSelections, state)} }`;
-}
-function applyFragments(str, fragments) {
-    let appliedString = str;
-    const fragmentNames = Object.keys(fragments);
-    for (let i = 0, len = fragmentNames.length; i < len; i += 1) {
-        const name = fragmentNames[i];
-        appliedString = `${appliedString} ${fragments[name]}`;
-    }
-    return appliedString;
-}
-function astToString(ast) {
-    const { definitions } = ast;
-    const state = {
-        fragments: {},
-    };
-    let str = '';
-    for (let i = 0, len = definitions.length; i < len; i += 1) {
-        const def = serializeOperationNode(definitions[i], state);
-        str = `${str}${def}`;
-    }
-    return applyFragments(str, state.fragments);
+function serializeValueNode(valueDefinition) {
+    const { kind } = valueDefinition;
+    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 "${kind}"`);
+    }
+}
+function serializeVariableNode(variableNode) {
+    return `$${variableNode.name}`;
+}
+function serializeListValueNode(listNode) {
+    const { values } = listNode;
+    if (values.length === 0) {
+        return '';
+    }
+    let str = '';
+    for (let i = 0, len = values.length; i < len; i += 1) {
+        str = `${str}${serializeValueNode(values[i])}, `;
+    }
+    return `[${str.substring(0, str.length - 2)}]`;
+}
+function serializeStringValueNode(literalValueNode) {
+    return `"${literalValueNode.value}"`;
+}
+function serializeObjectValueNode(objectValueDefinition) {
+    const { fields } = objectValueDefinition;
+    let str = [];
+    const fieldKeys = keys(fields);
+    for (let i = 0, len = fieldKeys.length; i < len; i += 1) {
+        const fieldKey = fieldKeys[i];
+        str.push(`${fieldKey}: ${serializeValueNode(fields[fieldKey])}`);
+    }
+    return `{ ${str.join(', ')} }`;
+}
+function serializeVariableDefinitions(definitons) {
+    if (definitons === undefined || definitons.length === 0) {
+        return '';
+    }
+    let str = '';
+    for (let i = 0, len = definitons.length; i < len; i += 1) {
+        const def = serializeVariableDefinitionNode(definitons[i]);
+        str = `${str}${def}, `;
+    }
+    return ` (${str.substring(0, str.length - 2)})`;
+}
+function serializeVariableDefinitionNode(def) {
+    const { variable, type, defaultValue } = def;
+    return defaultValue === undefined
+        ? `$${variable.name}: ${serializeTypeNode(type)}`
+        : `$${variable.name}: ${serializeTypeNode(type)} = ${serializeValueNode(defaultValue)}`;
+}
+function serializeTypeNode(type) {
+    const { kind } = type;
+    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 "${type.kind}"`);
+    }
+    return '';
+}
+function serializeNamedTypeNode(type) {
+    return type.name;
+}
+function serializeListTypeNode(type) {
+    return `[${serializeTypeNode(type.type)}]`;
+}
+function serializeOperationNode(def, state) {
+    const { kind } = def;
+    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 "${kind}"`);
+    }
+}
+function serializeOperationDefinition(def, state) {
+    const { operation, luvioSelections, name, variableDefinitions } = def;
+    const nameStr = name === undefined ? ' ' : ` ${name} `;
+    return `${operation}${nameStr}${serializeVariableDefinitions(variableDefinitions)}{ ${TYPENAME_FIELD} ${serializeSelections(luvioSelections, state)} }`;
+}
+function applyFragments(str, fragments) {
+    let appliedString = str;
+    const fragmentNames = Object.keys(fragments);
+    for (let i = 0, len = fragmentNames.length; i < len; i += 1) {
+        const name = fragmentNames[i];
+        appliedString = `${appliedString} ${fragments[name]}`;
+    }
+    return appliedString;
+}
+function astToString(ast) {
+    const { definitions } = ast;
+    const state = {
+        fragments: {},
+    };
+    let str = '';
+    for (let i = 0, len = definitions.length; i < len; i += 1) {
+        const def = serializeOperationNode(definitions[i], state);
+        str = `${str}${def}`;
+    }
+    return applyFragments(str, state.fragments);
 }
 
-function isGraphQLVariables(unknown) {
-    return untrustedIsObject(unknown);
-}
-function validateVariableDefinitions(definitons, variables) {
-    const errors = [];
-    for (let i = 0, len = definitons.length; i < len; i += 1) {
-        const { variable, type, defaultValue } = definitons[i];
-        const value = getVariableValue(variable.name, variables, defaultValue);
-        if (value === undefined) {
-            errors.push(`Variable $${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 $${variable.name}`);
-        }
-        if (type.kind === 'ListType' && value !== null && !Array.isArray(value)) {
-            errors.push(`Expected a list to be provided as value for $${variable.name}`);
-        }
-    }
-    return errors;
-}
-function getVariableValue(name, variables, defaultValue) {
-    if (name in variables) {
-        return variables[name];
-    }
-    if (defaultValue === undefined) {
-        return null;
-    }
-    return defaultValue;
+function isGraphQLVariables(unknown) {
+    return untrustedIsObject(unknown);
+}
+function validateVariableDefinitions(definitons, variables) {
+    const errors = [];
+    for (let i = 0, len = definitons.length; i < len; i += 1) {
+        const { variable, type, defaultValue } = definitons[i];
+        const value = getVariableValue(variable.name, variables, defaultValue);
+        if (value === undefined) {
+            errors.push(`Variable $${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 $${variable.name}`);
+        }
+        if (type.kind === 'ListType' && value !== null && !Array.isArray(value)) {
+            errors.push(`Expected a list to be provided as value for $${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) {
-    const { variableDefinitions } = ast;
-    const errors = [];
-    if (variableDefinitions !== undefined) {
-        errors.push(...validateVariableDefinitions(variableDefinitions, variables));
-    }
-    return errors;
+function validate$1(ast, variables) {
+    const { variableDefinitions } = ast;
+    const errors = [];
+    if (variableDefinitions !== undefined) {
+        errors.push(...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;
-}
-const createRead = (luvio, ast, variables) => {
-    const definitions = ast.definitions === undefined ? [] : ast.definitions;
-    return (source, builder) => {
-        builder.enterPath('data');
-        let sink = {};
-        for (let i = 0, len = definitions.length; i < len; i += 1) {
-            const def = definitions[i];
-            if (def.kind !== 'OperationDefinition') {
-                // eslint-disable-next-line @salesforce/lds/no-error-in-production
-                throw new Error(`Unsupported document definition "${def.kind}"`);
-            }
-            const data = createRead$1(luvio, def, variables)(source, builder);
-            sink = {
-                ...sink,
-                ...data,
-            };
-        }
-        const gqlData = {};
-        builder.assignNonScalar(gqlData, 'data', sink);
-        builder.exitPath();
-        builder.enterPath('errors');
-        builder.assignNonScalar(gqlData, 'errors', []);
-        builder.exitPath();
-        return gqlData;
-    };
-};
-function createIngest(ast, variables) {
-    const definitions = ast.definitions === undefined ? [] : ast.definitions;
-    return (data, path, luvio, store, timestamp) => {
-        const key = path.fullPath;
-        for (let i = 0, len = definitions.length; i < len; i += 1) {
-            const def = definitions[i];
-            if (def.kind !== 'OperationDefinition') {
-                // eslint-disable-next-line @salesforce/lds/no-error-in-production
-                throw new Error(`Unsupported document definition "${def.kind}"`);
-            }
-            createIngest$2(def, variables)(data, {
-                parent: null,
-                fullPath: key,
-                propertyName: null,
-            }, luvio, store, timestamp);
-        }
-        return {
-            __ref: key,
-        };
-    };
-}
-function validate(ast, variables) {
-    const errors = [];
-    const { definitions } = ast;
-    for (let i = 0, len = definitions.length; i < len; i += 1) {
-        const def = definitions[i];
-        if (def.kind !== 'OperationDefinition') {
-            errors.push(`Unsupported document definition "${def.kind}"`);
-        }
-        else {
-            errors.push(...validate$1(def, 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;
+}
+const createRead = (luvio, ast, variables) => {
+    const definitions = ast.definitions === undefined ? [] : ast.definitions;
+    return (source, builder) => {
+        builder.enterPath('data');
+        let sink = {};
+        for (let i = 0, len = definitions.length; i < len; i += 1) {
+            const def = definitions[i];
+            if (def.kind !== 'OperationDefinition') {
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
+                throw new Error(`Unsupported document definition "${def.kind}"`);
+            }
+            const data = createRead$1(luvio, def, variables)(source, builder);
+            sink = {
+                ...sink,
+                ...data,
+            };
+        }
+        const gqlData = {};
+        builder.assignNonScalar(gqlData, 'data', sink);
+        builder.exitPath();
+        builder.enterPath('errors');
+        builder.assignNonScalar(gqlData, 'errors', []);
+        builder.exitPath();
+        return gqlData;
+    };
+};
+function createIngest(ast, variables) {
+    const definitions = ast.definitions === undefined ? [] : ast.definitions;
+    return (data, path, luvio, store, timestamp) => {
+        const key = path.fullPath;
+        for (let i = 0, len = definitions.length; i < len; i += 1) {
+            const def = definitions[i];
+            if (def.kind !== 'OperationDefinition') {
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
+                throw new Error(`Unsupported document definition "${def.kind}"`);
+            }
+            createIngest$2(def, variables)(data, {
+                parent: null,
+                fullPath: key,
+                propertyName: null,
+            }, luvio, store, timestamp);
+        }
+        return {
+            __ref: key,
+        };
+    };
+}
+function validate(ast, variables) {
+    const errors = [];
+    const { definitions } = ast;
+    for (let i = 0, len = definitions.length; i < len; i += 1) {
+        const def = definitions[i];
+        if (def.kind !== 'OperationDefinition') {
+            errors.push(`Unsupported document definition "${def.kind}"`);
+        }
+        else {
+            errors.push(...validate$1(def, variables));
+        }
+    }
+    return errors;
 }
 
-let storeEval = undefined;
-const configuration = {
-    setStoreEval: function (storeEvalArg) {
-        storeEval = storeEvalArg;
-    },
+let storeEval = undefined;
+const configuration = {
+    setStoreEval: function (storeEvalArg) {
+        storeEval = storeEvalArg;
+    },
 };
 
-const 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) {
-    let injectScope = false;
-    const recordNodes = findRecordSelections(ast);
-    if (recordNodes !== undefined && recordNodes.length > 0) {
-        for (const recordNode of recordNodes) {
-            if (recordNode.arguments !== undefined) {
-                for (const argument of recordNode.arguments) {
-                    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) {
-    const modifiedDocumentNode = {
-        kind: 'Document',
-        definitions: [
-            {
-                kind: 'OperationDefinition',
-                operation: 'query',
-                luvioSelections: [
-                    {
-                        kind: 'ObjectFieldSelection',
-                        name: 'uiapi',
-                        luvioSelections: [
-                            {
-                                kind: 'ObjectFieldSelection',
-                                name: 'query',
-                                luvioSelections: [],
-                            },
-                        ],
-                    },
-                ],
-            },
-        ],
-    };
-    const modifiedSelections = [];
-    const recordNodes = findRecordSelections(ast);
-    if (recordNodes !== undefined && recordNodes.length > 0) {
-        // each record node represent a connection
-        for (const recordNode of recordNodes) {
-            modifiedSelections.push(injectConnectionForScope(recordNode));
-        }
-    }
-    const queryNode = modifiedDocumentNode.definitions
-        .filter(isOperationDefinition)
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isObjectFieldSelection)
-        .filter(named('uiapi'))
-        .reduce(flatMap(luvioSelections), [])
-        .filter(isObjectFieldSelection)
-        .filter(named('query'))[0];
-    queryNode.luvioSelections.push(...modifiedSelections);
-    return ast;
-}
-function injectConnectionForScope(connectionNode) {
-    if (connectionNode.name === 'ServiceAppointment') {
-        if (connectionNode.arguments !== undefined) {
-            for (const argument of connectionNode.arguments) {
-                if (argument.name === 'scope' &&
-                    argument.value.kind === 'EnumValue' &&
-                    argument.value.value === 'ASSIGNEDTOME') {
-                    const injectedConnctionNode = {
-                        ...connectionNode,
-                    };
-                    if (injectedConnctionNode.luvioSelections !== undefined) {
-                        const injectedNodes = injectedConnctionNode.luvioSelections
-                            .filter(isObjectFieldSelection)
-                            .filter(named('edges'))
-                            .reduce(flatMap(luvioSelections), [])
-                            .filter(isCustomFieldNode)
-                            .filter(named('node'));
-                        if (injectedNodes !== undefined && injectedNodes.length > 0) {
-                            const injectedNode = injectedNodes[0];
-                            if (injectedNode.luvioSelections !== undefined) {
-                                injectedNode.luvioSelections = mergeSelectionNodes(injectedNode.luvioSelections, [assignedToMe]);
-                            }
-                        }
-                    }
-                    return injectedConnctionNode;
-                }
-            }
-        }
-    }
-    return { ...connectionNode };
-}
-function mergeSelectionNodes(group1, group2) {
-    let sameFields1 = [];
-    let sameFields2 = [];
-    let results = [];
-    for (const node2 of group2) {
-        if (isCustomFieldNode(node2)) {
-            const nodes1SameLevel = group1
-                .filter(isCustomFieldNode)
-                .filter((node1) => node1.name === node2.name && node1.type === node2.type);
-            if (nodes1SameLevel.length > 0) {
-                sameFields1.push(...nodes1SameLevel);
-                sameFields2.push(node2);
-                const mergedNode = nodes1SameLevel.reduce((accu, cur) => mergeCustomFieldNodes(accu, cur), node2);
-                results.push(mergedNode);
-            }
-        }
-        else if (isObjectFieldSelection(node2)) {
-            const nodes1SameLevel = group1
-                .filter(isObjectFieldSelection)
-                .filter((node1) => node1.name === node2.name);
-            if (nodes1SameLevel.length > 0) {
-                sameFields1.push(...nodes1SameLevel);
-                sameFields2.push(node2);
-                const mergedNode = nodes1SameLevel.reduce((accu, cur) => mergeObjectFieldNodes(accu, cur), node2);
-                results.push(mergedNode);
-            }
-        }
-    }
-    if (sameFields1.length > 0) {
-        const differentNodes1 = group1.filter((node) => !sameFields1.includes(node));
-        results.push(...differentNodes1);
-        const differentNodes2 = group2.filter((node) => !sameFields2.includes(node));
-        results.push(...differentNodes2);
-    }
-    else {
-        return group1.concat(group2);
-    }
-    return results;
-}
-function mergeCustomFieldNodes(node1, node2) {
-    let 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: [],
-        };
-        let selections = [];
-        let sameCustomFields1 = [];
-        let sameCustomFields2 = [];
-        let sameObjectFields1 = [];
-        let sameObjectFields2 = [];
-        let sameScalarFields1 = [];
-        let sameScalarFields2 = [];
-        if (node1.luvioSelections && node2.luvioSelections) {
-            sameCustomFields1 = node1.luvioSelections
-                .filter(isCustomFieldNode)
-                .filter((childNode1) => {
-                if (node2.luvioSelections) {
-                    const sames = node2.luvioSelections
-                        .filter(isCustomFieldNode)
-                        .filter((childNode2) => childNode2.name === childNode1.name);
-                    if (sames.length > 0) {
-                        const mergedNode = sames.reduce((accu, cur) => mergeCustomFieldNodes(accu, cur), childNode1);
-                        selections.push(mergedNode);
-                        result = {
-                            ...result,
-                            luvioSelections: selections,
-                        };
-                        sameCustomFields2.push(...sames);
-                        return true;
-                    }
-                }
-                return false;
-            });
-            sameObjectFields1 = node1.luvioSelections
-                .filter(isObjectFieldSelection)
-                .filter((childNode1) => {
-                if (node2.luvioSelections) {
-                    const sames = node2.luvioSelections
-                        .filter(isObjectFieldSelection)
-                        .filter((childNode2) => childNode2.name === childNode1.name);
-                    if (sames.length > 0) {
-                        const mergedNode = sames.reduce((accu, cur) => mergeObjectFieldNodes(accu, cur), childNode1);
-                        selections.push(mergedNode);
-                        result = {
-                            ...result,
-                            luvioSelections: selections,
-                        };
-                        sameObjectFields2.push(...sames);
-                        return true;
-                    }
-                }
-                return false;
-            });
-            sameScalarFields1 = node1.luvioSelections
-                .filter(isScalarFieldNode)
-                .filter((childNode1) => {
-                if (node2.luvioSelections) {
-                    const sames = node2.luvioSelections
-                        .filter(isScalarFieldNode)
-                        .filter((childNode2) => childNode2.name === childNode1.name);
-                    if (sames.length > 0) {
-                        const mergedNode = sames.reduce((accu, cur) => mergeScalarFieldNode(accu, cur), childNode1);
-                        selections.push(mergedNode);
-                        result = {
-                            ...result,
-                            luvioSelections: selections,
-                        };
-                        sameScalarFields2.push(...sames);
-                        return true;
-                    }
-                }
-                return false;
-            });
-            if (sameCustomFields1.length > 0 ||
-                sameObjectFields1.length > 0 ||
-                sameScalarFields1.length > 0) {
-                const diffNodes1 = node1.luvioSelections.filter((node) => !sameCustomFields1.includes(node) &&
-                    !sameObjectFields1.includes(node) &&
-                    !sameScalarFields1.includes(node));
-                selections.push(...diffNodes1);
-                const diffNodes2 = node2.luvioSelections.filter((node) => !sameCustomFields2.includes(node) &&
-                    !sameObjectFields2.includes(node) &&
-                    !sameScalarFields2.includes(node));
-                selections.push(...diffNodes2);
-                result = {
-                    ...result,
-                    luvioSelections: selections,
-                };
-            }
-            else {
-                selections.push(...node1.luvioSelections);
-                selections.push(...node2.luvioSelections);
-                result = {
-                    ...result,
-                    luvioSelections: selections,
-                };
-            }
-        }
-        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) {
-    let result = node1;
-    if (node1.name === node2.name && node1.kind === node2.kind) {
-        result = {
-            kind: node1.kind,
-            name: node1.name,
-            directives: node1.directives,
-            luvioSelections: [],
-        };
-        let selections = [];
-        let sameCustomFields1 = [];
-        let sameCustomFields2 = [];
-        let sameObjectFields1 = [];
-        let sameObjectFields2 = [];
-        let sameScalarFields1 = [];
-        let sameScalarFields2 = [];
-        if (node1.luvioSelections && node2.luvioSelections) {
-            sameCustomFields1 = node1.luvioSelections
-                .filter(isCustomFieldNode)
-                .filter((childNode1) => {
-                if (node2.luvioSelections) {
-                    const sames = node2.luvioSelections
-                        .filter(isCustomFieldNode)
-                        .filter((childNode2) => childNode2.name === childNode1.name);
-                    if (sames.length > 0) {
-                        const mergedNode = sames.reduce((accu, cur) => mergeCustomFieldNodes(accu, cur), childNode1);
-                        selections.push(mergedNode);
-                        result = {
-                            ...result,
-                            luvioSelections: selections,
-                        };
-                        sameCustomFields2.push(...sames);
-                        return true;
-                    }
-                }
-                return false;
-            });
-            sameObjectFields1 = node1.luvioSelections
-                .filter(isObjectFieldSelection)
-                .filter((childNode1) => {
-                if (node2.luvioSelections) {
-                    const sames = node2.luvioSelections
-                        .filter(isObjectFieldSelection)
-                        .filter((childNode2) => childNode2.name === childNode1.name);
-                    if (sames.length > 0) {
-                        const mergedNode = sames.reduce((accu, cur) => mergeObjectFieldNodes(accu, cur), childNode1);
-                        selections.push(mergedNode);
-                        result = {
-                            ...result,
-                            luvioSelections: selections,
-                        };
-                        sameObjectFields2.push(...sames);
-                        return true;
-                    }
-                }
-                return false;
-            });
-            sameScalarFields1 = node1.luvioSelections
-                .filter(isScalarFieldNode)
-                .filter((childNode1) => {
-                if (node2.luvioSelections) {
-                    const sames = node2.luvioSelections
-                        .filter(isScalarFieldNode)
-                        .filter((childNode2) => childNode2.name === childNode1.name);
-                    if (sames.length > 0) {
-                        const mergedNode = sames.reduce((accu, cur) => mergeScalarFieldNode(accu, cur), childNode1);
-                        selections.push(mergedNode);
-                        result = {
-                            ...result,
-                            luvioSelections: selections,
-                        };
-                        sameScalarFields2.push(...sames);
-                        return true;
-                    }
-                }
-                return false;
-            });
-            if (sameCustomFields1.length > 0 ||
-                sameObjectFields1.length > 0 ||
-                sameScalarFields1.length > 0) {
-                const diffNodes1 = node1.luvioSelections.filter((node) => !sameCustomFields1.includes(node) &&
-                    !sameObjectFields1.includes(node) &&
-                    !sameScalarFields1.includes(node));
-                selections.push(...diffNodes1);
-                const diffNodes2 = node2.luvioSelections.filter((node) => !sameCustomFields2.includes(node) &&
-                    !sameObjectFields2.includes(node) &&
-                    !sameScalarFields2.includes(node));
-                selections.push(...diffNodes2);
-                result = {
-                    ...result,
-                    luvioSelections: selections,
-                };
-            }
-            else {
-                selections.push(...node1.luvioSelections);
-                selections.push(...node2.luvioSelections);
-                result = {
-                    ...result,
-                    luvioSelections: selections,
-                };
-            }
-        }
-        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 { ...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 (acc, current) => {
-        const mapped = transform(current);
-        return acc.concat(mapped);
-    };
-}
-function luvioSelections(node) {
-    return node.luvioSelections === undefined ? [] : node.luvioSelections;
-}
-function named(name) {
-    return (node) => node.name === name;
+const 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) {
+    let injectScope = false;
+    const recordNodes = findRecordSelections(ast);
+    if (recordNodes !== undefined && recordNodes.length > 0) {
+        for (const recordNode of recordNodes) {
+            if (recordNode.arguments !== undefined) {
+                for (const argument of recordNode.arguments) {
+                    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) {
+    const modifiedDocumentNode = {
+        kind: 'Document',
+        definitions: [
+            {
+                kind: 'OperationDefinition',
+                operation: 'query',
+                luvioSelections: [
+                    {
+                        kind: 'ObjectFieldSelection',
+                        name: 'uiapi',
+                        luvioSelections: [
+                            {
+                                kind: 'ObjectFieldSelection',
+                                name: 'query',
+                                luvioSelections: [],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+    const modifiedSelections = [];
+    const recordNodes = findRecordSelections(ast);
+    if (recordNodes !== undefined && recordNodes.length > 0) {
+        // each record node represent a connection
+        for (const recordNode of recordNodes) {
+            modifiedSelections.push(injectConnectionForScope(recordNode));
+        }
+    }
+    const queryNode = modifiedDocumentNode.definitions
+        .filter(isOperationDefinition)
+        .reduce(flatMap(luvioSelections), [])
+        .filter(isObjectFieldSelection)
+        .filter(named('uiapi'))
+        .reduce(flatMap(luvioSelections), [])
+        .filter(isObjectFieldSelection)
+        .filter(named('query'))[0];
+    queryNode.luvioSelections.push(...modifiedSelections);
+    return ast;
+}
+function injectConnectionForScope(connectionNode) {
+    if (connectionNode.name === 'ServiceAppointment') {
+        if (connectionNode.arguments !== undefined) {
+            for (const argument of connectionNode.arguments) {
+                if (argument.name === 'scope' &&
+                    argument.value.kind === 'EnumValue' &&
+                    argument.value.value === 'ASSIGNEDTOME') {
+                    const injectedConnctionNode = {
+                        ...connectionNode,
+                    };
+                    if (injectedConnctionNode.luvioSelections !== undefined) {
+                        const injectedNodes = injectedConnctionNode.luvioSelections
+                            .filter(isObjectFieldSelection)
+                            .filter(named('edges'))
+                            .reduce(flatMap(luvioSelections), [])
+                            .filter(isCustomFieldNode)
+                            .filter(named('node'));
+                        if (injectedNodes !== undefined && injectedNodes.length > 0) {
+                            const injectedNode = injectedNodes[0];
+                            if (injectedNode.luvioSelections !== undefined) {
+                                injectedNode.luvioSelections = mergeSelectionNodes(injectedNode.luvioSelections, [assignedToMe]);
+                            }
+                        }
+                    }
+                    return injectedConnctionNode;
+                }
+            }
+        }
+    }
+    return { ...connectionNode };
+}
+function mergeSelectionNodes(group1, group2) {
+    let sameFields1 = [];
+    let sameFields2 = [];
+    let results = [];
+    for (const node2 of group2) {
+        if (isCustomFieldNode(node2)) {
+            const nodes1SameLevel = group1
+                .filter(isCustomFieldNode)
+                .filter((node1) => node1.name === node2.name && node1.type === node2.type);
+            if (nodes1SameLevel.length > 0) {
+                sameFields1.push(...nodes1SameLevel);
+                sameFields2.push(node2);
+                const mergedNode = nodes1SameLevel.reduce((accu, cur) => mergeCustomFieldNodes(accu, cur), node2);
+                results.push(mergedNode);
+            }
+        }
+        else if (isObjectFieldSelection(node2)) {
+            const nodes1SameLevel = group1
+                .filter(isObjectFieldSelection)
+                .filter((node1) => node1.name === node2.name);
+            if (nodes1SameLevel.length > 0) {
+                sameFields1.push(...nodes1SameLevel);
+                sameFields2.push(node2);
+                const mergedNode = nodes1SameLevel.reduce((accu, cur) => mergeObjectFieldNodes(accu, cur), node2);
+                results.push(mergedNode);
+            }
+        }
+    }
+    if (sameFields1.length > 0) {
+        const differentNodes1 = group1.filter((node) => !sameFields1.includes(node));
+        results.push(...differentNodes1);
+        const differentNodes2 = group2.filter((node) => !sameFields2.includes(node));
+        results.push(...differentNodes2);
+    }
+    else {
+        return group1.concat(group2);
+    }
+    return results;
+}
+function mergeCustomFieldNodes(node1, node2) {
+    let 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: [],
+        };
+        let selections = [];
+        let sameCustomFields1 = [];
+        let sameCustomFields2 = [];
+        let sameObjectFields1 = [];
+        let sameObjectFields2 = [];
+        let sameScalarFields1 = [];
+        let sameScalarFields2 = [];
+        if (node1.luvioSelections && node2.luvioSelections) {
+            sameCustomFields1 = node1.luvioSelections
+                .filter(isCustomFieldNode)
+                .filter((childNode1) => {
+                if (node2.luvioSelections) {
+                    const sames = node2.luvioSelections
+                        .filter(isCustomFieldNode)
+                        .filter((childNode2) => childNode2.name === childNode1.name);
+                    if (sames.length > 0) {
+                        const mergedNode = sames.reduce((accu, cur) => mergeCustomFieldNodes(accu, cur), childNode1);
+                        selections.push(mergedNode);
+                        result = {
+                            ...result,
+                            luvioSelections: selections,
+                        };
+                        sameCustomFields2.push(...sames);
+                        return true;
+                    }
+                }
+                return false;
+            });
+            sameObjectFields1 = node1.luvioSelections
+                .filter(isObjectFieldSelection)
+                .filter((childNode1) => {
+                if (node2.luvioSelections) {
+                    const sames = node2.luvioSelections
+                        .filter(isObjectFieldSelection)
+                        .filter((childNode2) => childNode2.name === childNode1.name);
+                    if (sames.length > 0) {
+                        const mergedNode = sames.reduce((accu, cur) => mergeObjectFieldNodes(accu, cur), childNode1);
+                        selections.push(mergedNode);
+                        result = {
+                            ...result,
+                            luvioSelections: selections,
+                        };
+                        sameObjectFields2.push(...sames);
+                        return true;
+                    }
+                }
+                return false;
+            });
+            sameScalarFields1 = node1.luvioSelections
+                .filter(isScalarFieldNode)
+                .filter((childNode1) => {
+                if (node2.luvioSelections) {
+                    const sames = node2.luvioSelections
+                        .filter(isScalarFieldNode)
+                        .filter((childNode2) => childNode2.name === childNode1.name);
+                    if (sames.length > 0) {
+                        const mergedNode = sames.reduce((accu, cur) => mergeScalarFieldNode(accu, cur), childNode1);
+                        selections.push(mergedNode);
+                        result = {
+                            ...result,
+                            luvioSelections: selections,
+                        };
+                        sameScalarFields2.push(...sames);
+                        return true;
+                    }
+                }
+                return false;
+            });
+            if (sameCustomFields1.length > 0 ||
+                sameObjectFields1.length > 0 ||
+                sameScalarFields1.length > 0) {
+                const diffNodes1 = node1.luvioSelections.filter((node) => !sameCustomFields1.includes(node) &&
+                    !sameObjectFields1.includes(node) &&
+                    !sameScalarFields1.includes(node));
+                selections.push(...diffNodes1);
+                const diffNodes2 = node2.luvioSelections.filter((node) => !sameCustomFields2.includes(node) &&
+                    !sameObjectFields2.includes(node) &&
+                    !sameScalarFields2.includes(node));
+                selections.push(...diffNodes2);
+                result = {
+                    ...result,
+                    luvioSelections: selections,
+                };
+            }
+            else {
+                selections.push(...node1.luvioSelections);
+                selections.push(...node2.luvioSelections);
+                result = {
+                    ...result,
+                    luvioSelections: selections,
+                };
+            }
+        }
+        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) {
+    let result = node1;
+    if (node1.name === node2.name && node1.kind === node2.kind) {
+        result = {
+            kind: node1.kind,
+            name: node1.name,
+            directives: node1.directives,
+            luvioSelections: [],
+        };
+        let selections = [];
+        let sameCustomFields1 = [];
+        let sameCustomFields2 = [];
+        let sameObjectFields1 = [];
+        let sameObjectFields2 = [];
+        let sameScalarFields1 = [];
+        let sameScalarFields2 = [];
+        if (node1.luvioSelections && node2.luvioSelections) {
+            sameCustomFields1 = node1.luvioSelections
+                .filter(isCustomFieldNode)
+                .filter((childNode1) => {
+                if (node2.luvioSelections) {
+                    const sames = node2.luvioSelections
+                        .filter(isCustomFieldNode)
+                        .filter((childNode2) => childNode2.name === childNode1.name);
+                    if (sames.length > 0) {
+                        const mergedNode = sames.reduce((accu, cur) => mergeCustomFieldNodes(accu, cur), childNode1);
+                        selections.push(mergedNode);
+                        result = {
+                            ...result,
+                            luvioSelections: selections,
+                        };
+                        sameCustomFields2.push(...sames);
+                        return true;
+                    }
+                }
+                return false;
+            });
+            sameObjectFields1 = node1.luvioSelections
+                .filter(isObjectFieldSelection)
+                .filter((childNode1) => {
+                if (node2.luvioSelections) {
+                    const sames = node2.luvioSelections
+                        .filter(isObjectFieldSelection)
+                        .filter((childNode2) => childNode2.name === childNode1.name);
+                    if (sames.length > 0) {
+                        const mergedNode = sames.reduce((accu, cur) => mergeObjectFieldNodes(accu, cur), childNode1);
+                        selections.push(mergedNode);
+                        result = {
+                            ...result,
+                            luvioSelections: selections,
+                        };
+                        sameObjectFields2.push(...sames);
+                        return true;
+                    }
+                }
+                return false;
+            });
+            sameScalarFields1 = node1.luvioSelections
+                .filter(isScalarFieldNode)
+                .filter((childNode1) => {
+                if (node2.luvioSelections) {
+                    const sames = node2.luvioSelections
+                        .filter(isScalarFieldNode)
+                        .filter((childNode2) => childNode2.name === childNode1.name);
+                    if (sames.length > 0) {
+                        const mergedNode = sames.reduce((accu, cur) => mergeScalarFieldNode(accu, cur), childNode1);
+                        selections.push(mergedNode);
+                        result = {
+                            ...result,
+                            luvioSelections: selections,
+                        };
+                        sameScalarFields2.push(...sames);
+                        return true;
+                    }
+                }
+                return false;
+            });
+            if (sameCustomFields1.length > 0 ||
+                sameObjectFields1.length > 0 ||
+                sameScalarFields1.length > 0) {
+                const diffNodes1 = node1.luvioSelections.filter((node) => !sameCustomFields1.includes(node) &&
+                    !sameObjectFields1.includes(node) &&
+                    !sameScalarFields1.includes(node));
+                selections.push(...diffNodes1);
+                const diffNodes2 = node2.luvioSelections.filter((node) => !sameCustomFields2.includes(node) &&
+                    !sameObjectFields2.includes(node) &&
+                    !sameScalarFields2.includes(node));
+                selections.push(...diffNodes2);
+                result = {
+                    ...result,
+                    luvioSelections: selections,
+                };
+            }
+            else {
+                selections.push(...node1.luvioSelections);
+                selections.push(...node2.luvioSelections);
+                result = {
+                    ...result,
+                    luvioSelections: selections,
+                };
+            }
+        }
+        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 { ...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 (acc, current) => {
+        const mapped = transform(current);
+        return acc.concat(mapped);
+    };
+}
+function luvioSelections(node) {
+    return node.luvioSelections === undefined ? [] : node.luvioSelections;
+}
+function named(name) {
+    return (node) => node.name === name;
 }
 
-const adapterName = 'graphQL';
-const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
-const GRAPHQL_ROOT_KEY = `${namespace}::${representationName}`;
-function buildSnapshotRefresh(luvio, config, fragment) {
-    return {
-        config,
-        resolve: () => 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) {
-    const { query, variables } = config;
-    const { body } = response;
-    if (body.errors && body.errors.length > 0) {
-        return Promise.resolve(luvio.storeLookup({
-            recordId: representationName,
-            node: {
-                kind: 'Fragment',
-                synthetic: true,
-                reader: true,
-                read: (reader) => {
-                    const 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: {},
-        }));
-    }
-    const ingest = createIngest(query, variables);
-    luvio.storeIngest(GRAPHQL_ROOT_KEY, ingest, body.data);
-    const snapshot = luvio.storeLookup({
-        recordId: GRAPHQL_ROOT_KEY,
-        node: fragment,
-        variables: {},
-    }, buildSnapshotRefresh(luvio, config, fragment));
-    return luvio.storeBroadcast().then(() => 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
-    const { query, variables } = config;
-    const { body } = response;
-    if (body.errors && body.errors.length > 0) {
-        return new StoreKeyMap();
-    }
-    const ingest = createIngest(query, variables);
-    // ingest mutates the response so we have to make a copy
-    const dataCopy = parse(stringify(body.data));
-    luvio.storeIngest(GRAPHQL_ROOT_KEY, ingest, dataCopy);
-    const snapshot = luvio.storeLookup({
-        recordId: GRAPHQL_ROOT_KEY,
-        node: fragment,
-        variables: {},
-    }, buildSnapshotRefresh(luvio, config, fragment));
-    if (snapshot.state === 'Error') {
-        return new StoreKeyMap();
-    }
-    const keys = [...snapshot.seenRecords.keysAsArray(), snapshot.recordId];
-    const keySet = new StoreKeyMap();
-    for (let i = 0, len = keys.length; i < len; i++) {
-        const key = keys[i];
-        const keyNamespace = key.split('::')[0];
-        const representationName = key.split('::')[1].split(':')[0];
-        keySet.set(key, {
-            namespace: keyNamespace,
-            representationName,
-            mergeable: keyNamespace === namespace || representationName === RECORD_REPRESENTATION_NAME,
-        });
-    }
-    return keySet;
-}
-function onFetchResponseError(luvio, config, response) {
-    const errorSnapshot = luvio.errorSnapshot(response);
-    luvio.storeIngestError(GRAPHQL_ROOT_KEY, errorSnapshot);
-    return luvio.storeBroadcast().then(() => errorSnapshot);
-}
-function buildNetworkSnapshot(luvio, config, fragment, options) {
-    const { variables: queryVariables, query } = config;
-    const 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((resp) => {
-        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resp, fragment), () => getResponseCacheKeys(luvio, config, resp, fragment));
-    }, (errorResponse) => {
-        return luvio.handleErrorResponse(() => 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"',
-            ],
-        };
-    }
-    const { variables, query } = untrustedConfig;
-    const validationErrors = [];
-    if (isLuvioDocumentNode(query) === false) {
-        validationErrors.push('The config parameter "query" isn\'t a valid LuvioDocumentNode');
-    }
-    const 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(...validate(ast, variables));
-    const { useUiApiAdapter } = untrustedConfig;
-    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,
-            query,
-            useUiApiAdapter,
-        },
-        errors: [],
-    };
-}
-function buildCachedSnapshot(context, storeLookup) {
-    return buildInMemorySnapshot(context, storeLookup);
-}
-function buildInMemorySnapshot(context, storeLookup) {
-    const { config, fragment, luvio } = context;
-    const selector = {
-        recordId: GRAPHQL_ROOT_KEY,
-        node: fragment,
-        variables: {},
-    };
-    return storeLookup(selector, buildSnapshotRefresh(luvio, config, fragment));
-}
-function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    const { config, fragment, luvio } = context;
-    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-        },
-        eventObservers,
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority,
-        };
-    }
-    return buildNetworkSnapshot(luvio, config, fragment, dispatchOptions);
-}
-const graphQLAdapterFactory = (luvio) => {
-    const uiApiGraphQLAdapter = graphqlAdapterFactory(luvio);
-    function graphql(untrustedConfig, requestContext) {
-        const { validatedConfig, errors } = validateGraphQlConfig(untrustedConfig);
-        if (errors.length > 0 || validatedConfig === null) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error(errors.join(', '));
-            }
-            return null;
-        }
-        const { query, variables, useUiApiAdapter } = validatedConfig;
-        if (useUiApiAdapter === undefined || useUiApiAdapter === true) {
-            // Forward to new adapters
-            const resolvedQuery = 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,
-            }, requestContext);
-        }
-        else {
-            const fieldInjectionRequired = shouldInjectFields(query);
-            const validatedConfigWithInjection = fieldInjectionRequired
-                ? graphqlConfigWithInjectedAST(validatedConfig)
-                : validatedConfig;
-            const fragment = createFragment(luvio, validatedConfigWithInjection.query, variables);
-            const context = {
-                config: validatedConfigWithInjection,
-                fragment,
-                luvio,
-            };
-            const snapshotOrPromiseFromCachePolicy = luvio.applyCachePolicy(requestContext || {}, context, buildCachedSnapshot, buildNetworkSnapshotCachePolicy);
-            if (storeEval !== undefined) {
-                const 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;
-};
-function graphqlConfigWithInjectedAST(graphqlConfig) {
-    const { query } = graphqlConfig;
-    const astCopy = parse(stringify(query));
-    const modifiedAST = injectFieldsGQL(astCopy);
-    return {
-        ...graphqlConfig,
-        query: modifiedAST,
-    };
-}
-// make sure to register the configuration whenever this module loads
+const adapterName = 'graphQL';
+const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
+const GRAPHQL_ROOT_KEY = `${namespace}::${representationName}`;
+function buildSnapshotRefresh(luvio, config, fragment) {
+    return {
+        config,
+        resolve: () => 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) {
+    const { query, variables } = config;
+    const { body } = response;
+    if (body.errors && body.errors.length > 0) {
+        return Promise.resolve(luvio.storeLookup({
+            recordId: representationName,
+            node: {
+                kind: 'Fragment',
+                synthetic: true,
+                reader: true,
+                read: (reader) => {
+                    const 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: {},
+        }));
+    }
+    const ingest = createIngest(query, variables);
+    luvio.storeIngest(GRAPHQL_ROOT_KEY, ingest, body.data);
+    const snapshot = luvio.storeLookup({
+        recordId: GRAPHQL_ROOT_KEY,
+        node: fragment,
+        variables: {},
+    }, buildSnapshotRefresh(luvio, config, fragment));
+    return luvio.storeBroadcast().then(() => 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
+    const { query, variables } = config;
+    const { body } = response;
+    if (body.errors && body.errors.length > 0) {
+        return new StoreKeyMap();
+    }
+    const ingest = createIngest(query, variables);
+    // ingest mutates the response so we have to make a copy
+    const dataCopy = parse(stringify(body.data));
+    luvio.storeIngest(GRAPHQL_ROOT_KEY, ingest, dataCopy);
+    const snapshot = luvio.storeLookup({
+        recordId: GRAPHQL_ROOT_KEY,
+        node: fragment,
+        variables: {},
+    }, buildSnapshotRefresh(luvio, config, fragment));
+    if (snapshot.state === 'Error') {
+        return new StoreKeyMap();
+    }
+    const keys = [...snapshot.seenRecords.keysAsArray(), snapshot.recordId];
+    const keySet = new StoreKeyMap();
+    for (let i = 0, len = keys.length; i < len; i++) {
+        const key = keys[i];
+        const keyNamespace = key.split('::')[0];
+        const representationName = key.split('::')[1].split(':')[0];
+        keySet.set(key, {
+            namespace: keyNamespace,
+            representationName,
+            mergeable: keyNamespace === namespace || representationName === RECORD_REPRESENTATION_NAME,
+        });
+    }
+    return keySet;
+}
+function onFetchResponseError(luvio, config, response) {
+    const errorSnapshot = luvio.errorSnapshot(response);
+    luvio.storeIngestError(GRAPHQL_ROOT_KEY, errorSnapshot);
+    return luvio.storeBroadcast().then(() => errorSnapshot);
+}
+function buildNetworkSnapshot(luvio, config, fragment, options) {
+    const { variables: queryVariables, query } = config;
+    const 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((resp) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resp, fragment), () => getResponseCacheKeys(luvio, config, resp, fragment));
+    }, (errorResponse) => {
+        return luvio.handleErrorResponse(() => 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"',
+            ],
+        };
+    }
+    const { variables, query } = untrustedConfig;
+    const validationErrors = [];
+    if (isLuvioDocumentNode(query) === false) {
+        validationErrors.push('The config parameter "query" isn\'t a valid LuvioDocumentNode');
+    }
+    const 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(...validate(ast, variables));
+    const { useUiApiAdapter } = untrustedConfig;
+    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,
+            query,
+            useUiApiAdapter,
+        },
+        errors: [],
+    };
+}
+function buildCachedSnapshot(context, storeLookup) {
+    return buildInMemorySnapshot(context, storeLookup);
+}
+function buildInMemorySnapshot(context, storeLookup) {
+    const { config, fragment, luvio } = context;
+    const selector = {
+        recordId: GRAPHQL_ROOT_KEY,
+        node: fragment,
+        variables: {},
+    };
+    return storeLookup(selector, buildSnapshotRefresh(luvio, config, fragment));
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    const { config, fragment, luvio } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+        },
+        eventObservers,
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority,
+        };
+    }
+    return buildNetworkSnapshot(luvio, config, fragment, dispatchOptions);
+}
+const graphQLAdapterFactory = (luvio) => {
+    const uiApiGraphQLAdapter = graphqlAdapterFactory(luvio);
+    function graphql(untrustedConfig, requestContext) {
+        const { validatedConfig, errors } = validateGraphQlConfig(untrustedConfig);
+        if (errors.length > 0 || validatedConfig === null) {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error(errors.join(', '));
+            }
+            return null;
+        }
+        const { query, variables, useUiApiAdapter } = validatedConfig;
+        if (useUiApiAdapter === undefined || useUiApiAdapter === true) {
+            // Forward to new adapters
+            const resolvedQuery = 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,
+            }, requestContext);
+        }
+        else {
+            const fieldInjectionRequired = shouldInjectFields(query);
+            const validatedConfigWithInjection = fieldInjectionRequired
+                ? graphqlConfigWithInjectedAST(validatedConfig)
+                : validatedConfig;
+            const fragment = createFragment(luvio, validatedConfigWithInjection.query, variables);
+            const context = {
+                config: validatedConfigWithInjection,
+                fragment,
+                luvio,
+            };
+            const snapshotOrPromiseFromCachePolicy = luvio.applyCachePolicy(requestContext || {}, context, buildCachedSnapshot, buildNetworkSnapshotCachePolicy);
+            if (storeEval !== undefined) {
+                const 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;
+};
+function graphqlConfigWithInjectedAST(graphqlConfig) {
+    const { query } = graphqlConfig;
+    const astCopy = parse(stringify(query));
+    const modifiedAST = injectFieldsGQL(astCopy);
+    return {
+        ...graphqlConfig,
+        query: modifiedAST,
+    };
+}
+// make sure to register the configuration whenever this module loads
 register({ id: '@salesforce/lds-adapters-graphql', configuration });
 
 export { adapterName, buildCachedSnapshot, keyBuilder as connectionKeyBuilder, graphQLAdapterFactory, namespace, representationName };