@salesforce/lds-adapters-graphql 0.131.0

package/sfdc/index.js

@@ -0,0 +1,2307 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*  *******************************************************************************************
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { createLDSAdapter, createWireAdapterConstructor, createInstrumentedAdapter, createImperativeAdapter } from 'force/ldsBindings';
+import { register, withDefaultLuvio } from 'force/ldsEngine';
+import { StoreKeyMap } from 'force/luvioEngine';
+import { Kind, astResolver } from 'force/ldsGraphqlParser';
+import { graphqlAdapterFactory } from 'force/ldsAdaptersUiapiGraphql';
+import { createIngestRecordWithFields, keyBuilderRecord } from 'force/ldsAdaptersUiapi';
+
+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;
+}
+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 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,
+            });
+        }
+        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);
+    }
+}
+
+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 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;
+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');
+                    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 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) {
+        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 === 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 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);
+            }
+            return snapshotOrPromiseFromCachePolicy;
+        }
+    }
+    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 });
+
+let graphQL;
+let unstable_graphQL_imperative;
+// TODO [W-9992865]: remove this export when lds-worker-api usage has been updated
+let graphQLImperative;
+const adapterMetadata = {
+    apiFamily: namespace,
+    name: adapterName,
+};
+withDefaultLuvio((luvio) => {
+    const ldsAdapter = createLDSAdapter(luvio, namespace, graphQLAdapterFactory);
+    graphQL = createWireAdapterConstructor(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
+    unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
+    graphQLImperative = ldsAdapter;
+});
+
+export { graphQL, graphQLImperative, unstable_graphQL_imperative };
+// version: 0.131.0-c1ec5b7de