@salesforce/lwc-adapters-uiapi 1.142.0 → 1.143.0

package/dist/main.js

@@ -364,7 +364,7 @@ var FragmentReadResultState;
 ({
     state: FragmentReadResultState.Missing,
 });
-// engine version: 0.140.3-86f83ec8
+// engine version: 0.142.4-be29f4f3
 
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -7576,6 +7576,20 @@ function buildQueryTypeStringKey(args) {
     return `${keyPrefix}::${schemaName}::${queryTypeName}[${serializeOperationNode(operationNode, variables, fragmentMap)}]`;
 }
 
+/**
+ * @description Spec compliant way to retrieve the correct Operation from the Document that Luvio should operate on. https://spec.graphql.org/June2018/#sec-Named-Operation-Definitions
+ * @param document
+ * @param operationName
+ * @returns The Operation in the GraphQL document we should use for the current call.
+ */
+function getOperationFromDocument(document, operationName) {
+    const operations = document.definitions.filter((def) => def.kind === 'OperationDefinition');
+    if (operationName) {
+        return operations.find((def) => def.name !== undefined && def.name.value === operationName);
+    }
+    return operations[0]; // If a named operation is not provided, we return the first one
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -57314,43 +57328,38 @@ function getInContextFragmentType(fragment, fragmentMap) {
 const TTL$5 = 900000;
 const VERSION$b = "b440235e7e724631f92002fe50e3e096";
 const RepresentationType$c = 'GraphQLRepresentation';
-function select$8(luvio, query, variables) {
-    const definitions = query.definitions === undefined ? [] : query.definitions;
+function select$8(luvio, document, variables, operationName) {
+    const operationToExecute = getOperationFromDocument(document, operationName);
     return {
         kind: 'Fragment',
         synthetic: true,
         reader: true,
         read: (builder) => {
             builder.enterPath('data');
-            let sink = {};
-            const fragments = createFragmentMap(query);
-            for (let i = 0, len = definitions.length; i < len; i += 1) {
-                const def = definitions[i];
-                if (def.kind === 'OperationDefinition') {
-                    const queryTypeRecordId = keyBuilder$e(luvio, def, variables, fragments);
-                    const snapshot = builder.read({
-                        recordId: queryTypeRecordId,
-                        node: {
-                            kind: 'Fragment',
-                            private: [],
-                            opaque: true,
-                            version: VERSION$c
-                        },
-                        variables: {}
-                    });
-                    if (snapshot.data === undefined) {
-                        builder.markMissingLink(queryTypeRecordId);
-                        break;
-                    }
-                    const data = select$9(def, variables, fragments)(snapshot.data, builder, queryTypeRecordId);
-                    sink = {
-                        ...sink,
-                        ...data,
-                    };
-                }
-            }
             const gqlData = {};
-            builder.assignNonScalar(gqlData, 'data', sink);
+            if (operationToExecute === undefined) {
+                builder.markMissing(); // Never give a cache hit for an undefined operation
+                return gqlData;
+            }
+            const fragments = createFragmentMap(document);
+            const queryTypeRecordId = keyBuilder$e(luvio, operationToExecute, variables, fragments);
+            const snapshot = builder.read({
+                recordId: queryTypeRecordId,
+                node: {
+                    kind: 'Fragment',
+                    private: [],
+                    opaque: true,
+                    version: VERSION$c
+                },
+                variables: {}
+            });
+            if (snapshot.data === undefined) {
+                builder.markMissingLink(queryTypeRecordId);
+            }
+            else {
+                const data = select$9(operationToExecute, variables, fragments)(snapshot.data, builder, queryTypeRecordId);
+                builder.assignNonScalar(gqlData, 'data', data);
+            }
             builder.exitPath();
             return gqlData;
         }
@@ -57370,10 +57379,10 @@ function ingestOperationNode(luvio, input, node, state) {
         });
     }
 }
-const ingest$7 = function GraphQLRepresentationIngest(query, variables) {
+const ingest$7 = function GraphQLRepresentationIngest(document, variables, operationName) {
     return (input, path, luvio, store, timestamp) => {
         if (input.data) {
-            const fragments = createFragmentMap(query);
+            const fragments = createFragmentMap(document);
             const state = {
                 data: input.data,
                 luvio,
@@ -57383,58 +57392,63 @@ const ingest$7 = function GraphQLRepresentationIngest(query, variables) {
                 variables,
                 fragments,
             };
-            query.definitions.forEach((node) => {
-                if (node.kind === 'OperationDefinition') {
-                    ingestOperationNode(luvio, input, node, state);
-                }
-            });
+            const operationToExecute = getOperationFromDocument(document, operationName);
+            if (operationToExecute !== undefined) {
+                ingestOperationNode(luvio, input, operationToExecute, state);
+            }
         }
         return {
             __ref: undefined
         };
     };
 };
-function getTypeCacheKeys$8(luvio, query, variables, data) {
+function getTypeCacheKeys$8(luvio, document, variables, data, operationName) {
     const sink = new StoreKeyMap();
     if (data.data) {
-        const fragments = createFragmentMap(query);
-        query.definitions.forEach((node) => {
-            if (node.kind === 'OperationDefinition') {
-                const state = {
-                    luvio,
-                    variables,
-                    fragments,
-                    data: data.data,
-                    path: {
-                        parent: null,
-                        propertyName: null,
-                        fullPath: '' // TODO: W-13079691 - Need to take another pass at what we want to do for structured keys
-                    }
-                };
-                sink.merge(getTypeCacheKeys$9(node, state));
-            }
-        });
+        const fragments = createFragmentMap(document);
+        const operationToExecute = getOperationFromDocument(document, operationName);
+        if (operationToExecute !== undefined) {
+            const state = {
+                luvio,
+                variables,
+                fragments,
+                data: data.data,
+                path: {
+                    parent: null,
+                    propertyName: null,
+                    fullPath: '' // TODO: W-13079691 - Need to take another pass at what we want to do for structured keys
+                }
+            };
+            sink.merge(getTypeCacheKeys$9(operationToExecute, state));
+        }
     }
     return sink;
 }
 
 function select$7(luvio, config) {
-    const { query, variables } = config;
-    return select$8(luvio, query, variables);
+    const { query, variables, operationName } = config;
+    return select$8(luvio, query, variables, operationName);
 }
 function keyBuilder$d(luvio, params) {
-    return keyPrefix + '::' + 'GraphQLRepresentation';
+    const { query, operationName, variables } = params.body;
+    const operationToExecute = getOperationFromDocument(query, operationName);
+    if (operationToExecute !== undefined) {
+        const fragments = createFragmentMap(query);
+        return keyBuilder$e(luvio, operationToExecute, variables || {}, fragments);
+    }
+    return `adapters_adapter$45$utils_keyPrefix::GraphQLRepresentation::InvalidOperation`;
 }
 function getResponseCacheKeys$b(luvio, resourceParams, response) {
     const query = resourceParams.body.query;
     const variables = resourceParams.body.variables || {};
-    return getTypeCacheKeys$8(luvio, query, variables, response);
+    const operationName = resourceParams.body.operationName;
+    return getTypeCacheKeys$8(luvio, query, variables, response, operationName);
 }
 function ingestSuccess$5(luvio, config, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$d();
-    const { query, variables } = resourceParams.body;
-    luvio.storeIngest(key, ingest$7(query, variables), body);
+    const key = keyBuilder$d(luvio, resourceParams);
+    const { query, variables, operationName } = resourceParams.body;
+    luvio.storeIngest(key, ingest$7(query, variables, operationName), body);
     // revert the optimized pagination variables back to its original so that subsequent store lookup will include all records, not just the ones loaded by an optimized query
     // see optimizePagination for initial update to optimize the query
     revertPaginationOptimization(variables);
@@ -57451,7 +57465,7 @@ function ingestSuccess$5(luvio, config, resourceParams, response, snapshotRefres
     return snapshot;
 }
 function ingestError$2(luvio, config, params, error, snapshotRefresh) {
-    const key = keyBuilder$d();
+    const key = keyBuilder$d(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$5,
@@ -57580,7 +57594,7 @@ function selectChildResourceParams(luvio, childResources, resourceParams) {
                 reader.enterPath(i);
                 reader.enterPath(envelopeBodyPath);
                 const childResource = childResources[i];
-                const childKey = keyBuilder$d();
+                const childKey = keyBuilder$d(luvio, childResource);
                 const childFragment = select$7(luvio, childResource.body); // MUST read from the ORIGINAL config not injected
                 const isMissingDataBeforeChildRead = reader.getIsDataMissing();
                 const childSnapshot = reader.read({
@@ -57699,7 +57713,7 @@ function getResponseCacheKeys$a(luvio, resourceParams, response) {
             ObjectAssign(keys, childKeys);
         }
         else if (childStatusCode === 404) {
-            const childKey = keyBuilder$d();
+            const childKey = keyBuilder$d(luvio, childResourceParams);
             keys.set(childKey, {
                 namespace: keyPrefix,
                 representationName: RepresentationType$c,
@@ -57717,7 +57731,7 @@ function ingestSuccessChildResourceParams(luvio, childConfigs, childResourcePara
         // There's an assumption here that the config and resource params aren't reordered.
         const childConfig = childConfigs[index];
         const childResourceParams = childResourceParamsArray[index];
-        const childKey = keyBuilder$d();
+        const childKey = keyBuilder$d(luvio, childResourceParams);
         const result = childEnvelopes[index];
         const { statusCode: childStatusCode, result: childBody } = result;
         if (childStatusCode === 200 &&
@@ -57976,8 +57990,8 @@ function createResourceParams$b(config) {
     return resourceParams;
 }
 function keyBuilder$a(luvio, config) {
-    createResourceParams$b(config);
-    return keyBuilder$d();
+    const resourceParams = createResourceParams$b(config);
+    return keyBuilder$d(luvio, resourceParams);
 }
 function typeCheckConfig$e(untrustedConfig) {
     const config = {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lwc-adapters-uiapi",
-    "version": "1.142.0",
+    "version": "1.143.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "UIAPI adapters with LWC bindings",
     "module": "dist/main.js",
@@ -34,7 +34,7 @@
         "@salesforce/lds-adapters-uiapi": "*"
     },
     "dependencies": {
-        "@luvio/lwc-luvio": "0.140.3",
+        "@luvio/lwc-luvio": "0.142.4",
         "@salesforce/lds-default-luvio": "*"
     }
 }