@luvio/graphql 0.142.2 → 0.142.4

package/dist/luvioGraphql.js

@@ -1,5 +1,3 @@
-'use strict';
-
 function createFragmentMap(documentNode) {
     const fragments = {};
     documentNode.definitions.forEach((node) => {
@@ -130,9 +128,4 @@ function getOperationFromDocument(document, operationName) {
     return operations[0]; // If a named operation is not provided, we return the first one
 }
 
-exports.buildQueryTypeStringKey = buildQueryTypeStringKey;
-exports.buildQueryTypeStructuredKey = buildQueryTypeStructuredKey;
-exports.createFragmentMap = createFragmentMap;
-exports.getOperationFromDocument = getOperationFromDocument;
-exports.serializeFieldArguments = serializeFieldArguments;
-exports.serializeOperationNode = serializeOperationNode;
+export { buildQueryTypeStringKey, buildQueryTypeStructuredKey, createFragmentMap, getOperationFromDocument, serializeFieldArguments, serializeOperationNode };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/graphql",
-    "version": "0.142.2",
+    "version": "0.142.4",
     "description": "GraphQL utilities for Luvio GraphQL adapter support",
     "repository": {
         "type": "git",
@@ -9,11 +9,11 @@
     },
     "license": "MIT",
     "exports": {
-        "require": "./dist/luvioGraphql.js",
-        "import": "./dist/luvioGraphql.mjs"
+        "types": "./dist/types/main.d.ts",
+        "import": "./dist/luvioGraphql.js",
+        "default": "./dist/luvioGraphql.js"
     },
-    "main": "./dist/luvioGraphql.js",
-    "module": "./dist/luvioGraphql.mjs",
+    "module": "./dist/luvioGraphql.js",
     "types": "dist/types/main.d.ts",
     "files": [
         "dist/"
@@ -27,8 +27,8 @@
         "test:size": "luvioBundlesize"
     },
     "dependencies": {
-        "@luvio/engine": "^0.142.2",
-        "@luvio/graphql-parser": "^0.142.2"
+        "@luvio/engine": "^0.142.4",
+        "@luvio/graphql-parser": "^0.142.4"
     },
     "volta": {
         "extends": "../../../package.json"

package/dist/luvioGraphql.mjs

@@ -1,131 +0,0 @@
-function createFragmentMap(documentNode) {
-    const fragments = {};
-    documentNode.definitions.forEach((node) => {
-        if (node.kind === 'FragmentDefinition') {
-            fragments[node.name.value] = node;
-        }
-    });
-    return fragments;
-}
-
-function serializeFieldArguments(argumentNodes, variables) {
-    const mutableArgumentNodes = Object.assign([], argumentNodes);
-    return `args__(${mutableArgumentNodes
-        .sort((a, b) => {
-        const aName = a.name.value.toUpperCase();
-        const bName = b.name.value.toUpperCase();
-        return aName < bName ? -1 : aName > bName ? 1 : 0;
-    })
-        .map((node) => serializeArgNode(node, variables))
-        .join('::')})`;
-}
-function serializeArgNode(argumentNode, variables) {
-    const argName = argumentNode.name.value;
-    return `${argName}:${serializeValueNode(argumentNode.value, variables)}`;
-}
-function serializeValueNode(valueNode, variables) {
-    switch (valueNode.kind) {
-        case 'BooleanValue':
-            return valueNode.value + '';
-        case 'IntValue':
-        case 'FloatValue':
-        case 'EnumValue':
-        case 'StringValue':
-            return valueNode.value;
-        case 'ListValue': {
-            const mutableValueNodeList = Object.assign([], valueNode.values);
-            return mutableValueNodeList
-                .sort((a, b) => {
-                const aVal = serializeValueNode(a, variables).toUpperCase();
-                const bVal = serializeValueNode(b, variables).toUpperCase();
-                return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-            })
-                .map((val, i) => `${serializeValueNode(val, variables)}[${i}]`)
-                .join(',');
-        }
-        case 'Variable': {
-            const variableValue = variables[valueNode.name.value];
-            return typeof variableValue === 'string'
-                ? variableValue
-                : JSON.stringify(variableValue);
-        }
-        case 'NullValue':
-            return 'null';
-        case 'ObjectValue': {
-            const mutableFieldNodeList = Object.assign([], valueNode.fields);
-            return mutableFieldNodeList
-                .sort((a, b) => {
-                const aName = a.name.value.toUpperCase();
-                const bName = b.name.value.toUpperCase();
-                return aName < bName ? -1 : aName > bName ? 1 : 0;
-            })
-                .map((field) => field.name.value + ':' + serializeValueNode(field.value, variables))
-                .join(',');
-        }
-    }
-}
-
-function serializeOperationNode(operationNode, variables, fragmentMap) {
-    return `${serializeSelectionSet(operationNode.selectionSet, variables, fragmentMap)}`;
-}
-function serializeSelectionSet(selectionSetNode, variables, fragmentMap) {
-    return `${selectionSetNode.selections
-        .map((selection) => serializeSelectionNode(selection, variables, fragmentMap))
-        .join()}`;
-}
-/**
- *
- * @description This function takes a GraphQL SelectionNode from an AST and serializes it in a stable way, so we can
- * use it for property names and Store keys.
- * @param selectionNode
- * @param variables
- * @param fragmentMap
- * @returns string
- */
-function serializeSelectionNode(selectionNode, variables, fragmentMap) {
-    switch (selectionNode.kind) {
-        case 'Field': {
-            const hasArguments = selectionNode.arguments !== undefined && selectionNode.arguments.length > 0;
-            const argumentSuffix = hasArguments
-                ? `__${serializeFieldArguments(selectionNode.arguments, variables)}`
-                : '';
-            return `${selectionNode.name.value}${argumentSuffix}`;
-        }
-        case 'FragmentSpread': {
-            const fragment = fragmentMap[selectionNode.name.value];
-            return fragment === undefined
-                ? selectionNode.name.value
-                : serializeSelectionSet(fragment.selectionSet, variables, fragmentMap);
-        }
-        case 'InlineFragment':
-            return serializeSelectionSet(selectionNode.selectionSet, variables, fragmentMap);
-    }
-}
-function buildQueryTypeStringKey(args) {
-    const { keyPrefix, schemaName, queryTypeName, operationNode, variables, fragmentMap } = args;
-    return `${keyPrefix}::${schemaName}::${queryTypeName}[${serializeOperationNode(operationNode, variables, fragmentMap)}]`;
-}
-// TODO: W-13079691 - Need to take another pass at what we want to do for structured keys
-function buildQueryTypeStructuredKey(args) {
-    const { luvio, keyPrefix, schemaName, queryTypeName, operationNode, variables, fragmentMap } = args;
-    return luvio.buildStructuredKey(keyPrefix, queryTypeName, {
-        schemaName,
-        operation: 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
-}
-
-export { buildQueryTypeStringKey, buildQueryTypeStructuredKey, createFragmentMap, getOperationFromDocument, serializeFieldArguments, serializeOperationNode };