@salesforce/lds-adapters-graphql 1.311.1 → 1.312.0

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

@@ -4,1337 +4,18 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { deepFreeze, StoreKeyMap } from '@luvio/engine';
-import { register } from '@salesforce/lds-default-luvio';
-import { Kind, astResolver } from '@luvio/graphql-parser';
+import { astResolver } from '@luvio/graphql-parser';
 import { graphqlAdapterFactory } from '@salesforce/lds-adapters-uiapi';
-import { createIngestRecordWithFields, keyBuilderRecord } from '@salesforce/lds-adapters-uiapi';
-import ldsAdapterForwardingGate from '@salesforce/gate/lds.graphqlAdapterForwarding';
 
 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 untrustedIsObject(untrusted) {
-    return typeof untrusted === 'object' && untrusted !== null && isArray(untrusted) === false;
-}
-/**
- * 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 adapterName = 'graphQL';
 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 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);
-}
-
-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}"`);
-};
-
-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;
-}
-
-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,
-                ingestionTimestamp: timestamp,
-            });
-        }
-        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,
-        ingestionTimestamp: timestamp,
-    });
-    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,
-            ingestionTimestamp: timestamp,
-        });
-        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;
-    };
-};
-
-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)}`;
-}
-
-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 validate$1(ast, variables) {
-    const { variableDefinitions } = ast;
-    const errors = [];
-    if (variableDefinitions !== undefined) {
-        errors.push(...validateVariableDefinitions(variableDefinitions, variables));
-    }
-    return errors;
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && isArray(untrusted) === false;
 }
-
 function isLuvioDocumentNode(unknown) {
     if (untrustedIsObject(unknown) === true &&
         hasOwnProperty.call(unknown, 'kind') === true &&
@@ -1344,737 +25,6 @@ function isLuvioDocumentNode(unknown) {
     }
     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;
-let draftFunctions = undefined;
-const configuration = {
-    setStoreEval: function (storeEvalArg) {
-        storeEval = storeEvalArg;
-    },
-    setDraftFunctions: function (draftFuncs) {
-        draftFunctions = draftFuncs;
-    },
-};
-
-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 swapIdsOfDocumentNode(documentnode, draftFunctions) {
-    const recordNodes = findRecordSelections(documentnode);
-    recordNodes.forEach((recordConnection) => {
-        swapIdsOfFieldNode(recordConnection, draftFunctions);
-    });
-    return documentnode;
-}
-function swapIdsOfFieldNode(selectionNode, draftFunctions) {
-    if (isCustomFieldNode(selectionNode) &&
-        selectionNode.type === 'Connection' &&
-        selectionNode.arguments !== undefined &&
-        selectionNode.arguments.some((argment) => argment.name === 'where')) {
-        const swappedArguments = selectionNode.arguments.map((argument) => {
-            if (argument.name === 'where') {
-                return {
-                    ...argument,
-                    value: swapIdsOfValueNode(argument.value, draftFunctions.isDraftId, draftFunctions.getCanonicalId),
-                };
-            }
-            else {
-                return argument;
-            }
-        });
-        selectionNode.arguments = swappedArguments;
-    }
-    if (selectionNode.luvioSelections !== undefined) {
-        for (const childSelectionNode of selectionNode.luvioSelections) {
-            if (isCustomFieldNode(childSelectionNode) ||
-                isObjectFieldSelection(childSelectionNode)) {
-                swapIdsOfFieldNode(childSelectionNode, draftFunctions);
-            }
-        }
-    }
-}
-function swapIdsOfValueNode(valueNode, isDraftId, idMapper) {
-    switch (valueNode.kind) {
-        case Kind.OBJECT: {
-            const swappedObjectValueNode = {};
-            for (const key of keys(valueNode.fields)) {
-                swappedObjectValueNode[key] = swapIdsOfValueNode(valueNode.fields[key], isDraftId, idMapper);
-            }
-            return {
-                kind: 'ObjectValue',
-                fields: swappedObjectValueNode,
-            };
-        }
-        case Kind.LIST: {
-            const listValueNodes = [];
-            for (const child of valueNode.values) {
-                listValueNodes.push(swapIdsOfValueNode(child, isDraftId, idMapper));
-            }
-            return {
-                kind: 'ListValue',
-                values: listValueNodes,
-            };
-        }
-        case Kind.STRING: {
-            if (!isDraftId(valueNode.value)) {
-                return valueNode;
-            }
-            return {
-                kind: 'StringValue',
-                value: idMapper(valueNode.value),
-                block: false,
-            };
-        }
-        default:
-            return {
-                ...valueNode,
-            };
-    }
-}
-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');
-                    deepFreeze(body.errors);
-                    reader.assignNonScalar(sink, 'errors', 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/v63.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 {
@@ -2095,8 +45,7 @@ function validateGraphQlConfig(untrustedConfig) {
     if (isLuvioDocumentNode(query) === false) {
         validationErrors.push('The config parameter "query" isn\'t a valid LuvioDocumentNode');
     }
-    const ast = query;
-    if (isGraphQLVariables(variables) === false) {
+    if (untrustedIsObject(variables) === false) {
         validationErrors.push('The config parameter "variables" isn\'t an object');
     }
     if (validationErrors.length > 0) {
@@ -2105,83 +54,14 @@ function validateGraphQlConfig(untrustedConfig) {
             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, sourceContext } = coercedAdapterRequestContext;
-    const dispatchOptions = {
-        resourceRequestContext: {
-            requestCorrelator,
-            sourceContext,
-        },
-        eventObservers,
-    };
-    if (networkPriority !== 'normal') {
-        dispatchOptions.overrides = {
-            priority: networkPriority,
-        };
-    }
-    return buildNetworkSnapshot(luvio, config, fragment, dispatchOptions);
-}
-const replaceDraftIdsInVariables = (variables, draftFunctions) => {
-    const replace = (object) => {
-        if (typeof object === 'string') {
-            if (!draftFunctions.isDraftId(object)) {
-                return object;
-            }
-            return draftFunctions.getCanonicalId(object);
-        }
-        else if (isArray(object)) {
-            return object.map(replace);
-        }
-        else if (typeof object === 'object' && object !== null) {
-            let source = object;
-            return keys(source).reduce((acc, key) => {
-                acc[key] = replace(source[key]);
-                return acc;
-            }, {});
-        }
-        else {
-            return object;
-        }
-    };
-    let newVariables = keys(variables).reduce((acc, key) => {
-        acc[key] = replace(variables[key]);
-        return acc;
-    }, {});
-    return newVariables;
-};
 const graphQLAdapterFactory = (luvio) => {
     const uiApiGraphQLAdapter = graphqlAdapterFactory(luvio);
     function graphql(untrustedConfig, requestContext) {
@@ -2192,78 +72,21 @@ const graphQLAdapterFactory = (luvio) => {
             }
             return null;
         }
-        const { query, variables, useUiApiAdapter } = validatedConfig;
-        if (useUiApiAdapter === true || ldsAdapterForwardingGate.isOpen({ fallback: false })) {
-            // 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 sanitizedConfig = draftFunctions !== undefined
-                ? sanitizeConfig(validatedConfigWithInjection, draftFunctions)
-                : validatedConfigWithInjection;
-            if (sanitizedConfig.variables && draftFunctions !== undefined) {
-                const variablesWithSwappedDraftIds = replaceDraftIdsInVariables(sanitizedConfig.variables, draftFunctions);
-                sanitizedConfig.variables = variablesWithSwappedDraftIds;
-                validatedConfig.variables = variablesWithSwappedDraftIds;
-            }
-            const fragment = createFragment(luvio, sanitizedConfig.query, sanitizedConfig.variables);
-            const context = {
-                config: sanitizedConfig,
-                fragment,
-                luvio,
-            };
-            // NOTE: For evaluating environments, set a context property to let the
-            // environment detect that eval will happen and to check varous gates
-            // for eval behavior customizations.
-            if (storeEval !== undefined) {
-                context.gqlEval = true;
-            }
-            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. The draftID swapping happens when filters transform to predicates.
-                return storeEval(validatedConfig, snapshotOrPromiseFromCachePolicy, observers, keyBuilder);
+        const { query, variables } = validatedConfig;
+        // Forward to new adapter
+        const resolvedQuery = astResolver(query);
+        if (resolvedQuery === undefined) {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error('Could not resolve standard AST');
             }
-            return snapshotOrPromiseFromCachePolicy;
+            return null;
         }
+        return uiApiGraphQLAdapter({
+            query: resolvedQuery,
+            variables,
+        }, requestContext);
     }
     return graphql;
 };
-function graphqlConfigWithInjectedAST(graphqlConfig) {
-    const { query } = graphqlConfig;
-    const astCopy = parse(stringify(query));
-    const modifiedAST = injectFieldsGQL(astCopy);
-    return {
-        ...graphqlConfig,
-        query: modifiedAST,
-    };
-}
-function sanitizeConfig(graphqlConfig, draftFunctions) {
-    const { query } = graphqlConfig;
-    const astCopy = parse(stringify(query));
-    const modifiedAST = swapIdsOfDocumentNode(astCopy, draftFunctions);
-    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, graphqlConfigWithInjectedAST, namespace, replaceDraftIdsInVariables, representationName, sanitizeConfig };
+export { adapterName, graphQLAdapterFactory, namespace, representationName };