@luvio/graphql 0.145.0 → 0.145.2

package/dist/luvioGraphql.js

@@ -7,6 +7,21 @@ function createFragmentMap(documentNode) {
     });
     return fragments;
 }
+function mergeFragmentWithExistingSelections(fragmentFieldSelection, existingSelections) {
+    // Check if there is an existing selection for this field we can merge with
+    const existingField = getRequestedField(fragmentFieldSelection.name.value, existingSelections);
+    if (existingField === undefined) {
+        existingSelections.push(fragmentFieldSelection);
+    }
+    else {
+        if (existingField.selectionSet) {
+            const mergedSelections = mergeSelectionSets(existingField.selectionSet, fragmentFieldSelection.selectionSet);
+            existingField.selectionSet.selections = mergedSelections
+                ? mergedSelections.selections
+                : [];
+        }
+    }
+}
 
 function buildFieldState(state, fullPath, data) {
     return {
@@ -75,6 +90,220 @@ function serializeValueNode(valueNode, variables) {
         }
     }
 }
+let selectionSetRequestedFieldsWeakMap = new WeakMap();
+function getRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
+    let cachedRequestedFieldsConfigurations = selectionSetRequestedFieldsWeakMap.get(selectionSet);
+    if (cachedRequestedFieldsConfigurations === undefined) {
+        cachedRequestedFieldsConfigurations = new Map();
+        selectionSetRequestedFieldsWeakMap.set(selectionSet, cachedRequestedFieldsConfigurations);
+    }
+    const cachedRequestedFieldsForType = cachedRequestedFieldsConfigurations.get(typename);
+    if (cachedRequestedFieldsForType !== undefined) {
+        return cachedRequestedFieldsForType;
+    }
+    const selections = calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable);
+    cachedRequestedFieldsConfigurations.set(typename, selections);
+    return selections;
+}
+function getRequestedField(responseDataFieldName, requestedFields) {
+    return requestedFields.find((fieldNode) => (fieldNode.alias && fieldNode.alias.value === responseDataFieldName) ||
+        (!fieldNode.alias && fieldNode.name.value === responseDataFieldName));
+}
+function calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsMap, isFragmentApplicable) {
+    const selections = [];
+    selectionSet.selections.forEach((selection) => {
+        if (selection.kind === 'Field') {
+            selections.push(selection);
+        }
+        if (selection.kind === 'InlineFragment' && isFragmentApplicable(selection, typename)) {
+            // loops over the map to get the values.
+            getRequestedFieldsForType(typename, selection.selectionSet, namedFragmentsMap, isFragmentApplicable).forEach((fragmentFieldSelection) => {
+                mergeFragmentWithExistingSelections(fragmentFieldSelection, selections);
+            });
+        }
+        if (selection.kind === 'FragmentSpread') {
+            const namedFragment = namedFragmentsMap[selection.name.value];
+            if (namedFragment && isFragmentApplicable(namedFragment, typename)) {
+                // loops over the map to get the values.
+                getRequestedFieldsForType(typename, namedFragment.selectionSet, namedFragmentsMap, isFragmentApplicable).forEach((fragmentFieldSelection) => {
+                    mergeFragmentWithExistingSelections(fragmentFieldSelection, selections);
+                });
+            }
+        }
+    });
+    // Needs to happen after the selections are merged.
+    return selections.reduce((acc, fieldNode) => {
+        const fieldName = fieldNode.alias ? fieldNode.alias.value : fieldNode.name.value;
+        // TODO: W-13485835. Some fields are not being merged, and this logic reproduces the current behavior in which the first field with name is being used.
+        if (!acc.has(fieldName)) {
+            acc.set(fieldName, fieldNode);
+        }
+        else {
+            const existingFieldNode = acc.get(fieldName);
+            acc.set(fieldName, {
+                ...existingFieldNode,
+                selectionSet: mergeSelectionSets(existingFieldNode === null || existingFieldNode === void 0 ? void 0 : existingFieldNode.selectionSet, fieldNode.selectionSet),
+            });
+        }
+        return acc;
+    }, new Map());
+}
+function mergeSelectionSets(set1, set2) {
+    if (!set2) {
+        return set1;
+    }
+    const set1Selections = !set1 ? [] : set1.selections;
+    const mergedSelections = [...set1Selections];
+    for (const selection of set2.selections) {
+        if (selection.kind === 'Field') {
+            const existingFieldIndex = mergedSelections.findIndex((sel) => {
+                return sel.kind === 'Field' && isExactSameField(sel, selection);
+            });
+            if (existingFieldIndex > -1) {
+                const existingField = mergedSelections[existingFieldIndex];
+                const mergedSelectionSet = mergeSelectionSets(existingField.selectionSet, selection.selectionSet);
+                if (mergedSelectionSet) {
+                    mergedSelections[existingFieldIndex] = {
+                        ...existingField,
+                        selectionSet: mergedSelectionSet,
+                    };
+                }
+            }
+            else {
+                mergedSelections.push(selection);
+            }
+        }
+        else if (selection.kind === 'FragmentSpread') {
+            if (!mergedSelections.some((sel) => sel.kind === 'FragmentSpread' &&
+                sel.name.value === selection.name.value &&
+                areDirectivesEqual(sel.directives, selection.directives))) {
+                mergedSelections.push(selection);
+            }
+        }
+        else if (selection.kind === 'InlineFragment') {
+            const existingFragmentIndex = mergedSelections.findIndex((sel) => {
+                return (sel.kind === 'InlineFragment' &&
+                    areTypeConditionsEqual(sel.typeCondition, selection.typeCondition) &&
+                    areDirectivesEqual(sel.directives, selection.directives));
+            });
+            if (existingFragmentIndex > -1) {
+                const existingFragment = mergedSelections[existingFragmentIndex];
+                const mergedSelectionSet = mergeSelectionSets(existingFragment.selectionSet, selection.selectionSet);
+                if (mergedSelectionSet) {
+                    mergedSelections[existingFragmentIndex] = {
+                        ...existingFragment,
+                        selectionSet: mergedSelectionSet,
+                    };
+                }
+            }
+            else {
+                mergedSelections.push(selection);
+            }
+        }
+    }
+    return { kind: 'SelectionSet', selections: mergedSelections };
+}
+function areArgumentsEqual(args1, args2) {
+    if (!args1 && !args2) {
+        return true;
+    }
+    // length 0 arguments is semantically equivalent to falsy arguments.
+    if ((!args1 || args1.length === 0) && (!args2 || args2.length === 0)) {
+        return true;
+    }
+    if ((!args1 && args2) || (args1 && !args2)) {
+        return false;
+    }
+    if (args1.length !== args2.length) {
+        return false;
+    }
+    for (const arg of args1) {
+        const matchingArg = args2.find((a) => a.name.value === arg.name.value && areValuesEqual(a.value, arg.value));
+        if (!matchingArg) {
+            return false;
+        }
+    }
+    return true;
+}
+function areDirectivesEqual(dirs1, dirs2) {
+    if (!dirs1 && !dirs2) {
+        return true;
+    }
+    if ((!dirs1 || dirs1.length === 0) && (!dirs2 || dirs2.length === 0)) {
+        return true;
+    }
+    if ((!dirs1 && dirs2) || (dirs1 && !dirs2)) {
+        return false;
+    }
+    if (dirs1.length !== dirs2.length) {
+        return false;
+    }
+    for (const dir of dirs1) {
+        const matchingDir = dirs2.find((d) => d.name.value === dir.name.value && areArgumentsEqual(d.arguments, dir.arguments));
+        if (!matchingDir) {
+            return false;
+        }
+    }
+    return true;
+}
+function areValuesEqual(valueNode1, valueNode2) {
+    if (valueNode1.kind !== valueNode2.kind) {
+        return false;
+    }
+    // Typescript doesn't understand that the above check means that the switch applies to both values. So there will be casts here.
+    switch (valueNode1.kind) {
+        case 'StringValue':
+        case 'IntValue':
+        case 'FloatValue':
+        case 'BooleanValue':
+        case 'EnumValue':
+            return valueNode1.value === valueNode2.value;
+        case 'NullValue':
+            return true; // Both Null value nodes? Always true.
+        case 'ListValue':
+            if (valueNode1.values.length !== valueNode2.values.length) {
+                return false;
+            }
+            for (let i = 0; i < valueNode1.values.length; i++) {
+                if (!areValuesEqual(valueNode1.values[i], valueNode2.values[i])) {
+                    return false;
+                }
+            }
+            return true;
+        case 'ObjectValue':
+            if (valueNode1.fields.length !== valueNode2.fields.length) {
+                return false;
+            }
+            for (let i = 0; i < valueNode1.fields.length; i++) {
+                const field1 = valueNode1.fields[i];
+                const field2 = valueNode2.fields.find((f) => f.name.value === field1.name.value);
+                if (!field2 || !areValuesEqual(field1.value, field2.value)) {
+                    return false;
+                }
+            }
+            return true;
+        case 'Variable':
+            return valueNode1.name.value === valueNode2.name.value;
+        default:
+            return false;
+    }
+}
+function areTypeConditionsEqual(typeCondition1, typeCondition2) {
+    if (typeCondition1 === undefined && typeCondition2 === undefined) {
+        return true;
+    }
+    if ((!typeCondition1 && typeCondition2) || (typeCondition1 && !typeCondition2)) {
+        return false;
+    }
+    return typeCondition1.name.value === typeCondition2.name.value;
+}
+function isExactSameField(field1, field2) {
+    var _a, _b;
+    return (field1.name.value === field2.name.value &&
+        ((_a = field1.alias) === null || _a === void 0 ? void 0 : _a.value) === ((_b = field2.alias) === null || _b === void 0 ? void 0 : _b.value) &&
+        areArgumentsEqual(field1.arguments, field2.arguments) &&
+        areDirectivesEqual(field1.directives, field2.directives));
+}
 
 function serializeOperationNode(operationNode, variables, fragmentMap) {
     return `${serializeSelectionSet(operationNode.selectionSet, variables, fragmentMap)}`;
@@ -139,4 +368,51 @@ function getOperationFromDocument(document, operationName) {
     return operations[0]; // If a named operation is not provided, we return the first one
 }
 
-export { buildFieldState, buildQueryTypeStringKey, buildQueryTypeStructuredKey, createFragmentMap, getOperationFromDocument, serializeFieldArguments, serializeOperationNode };
+const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
+// Deep merge that works on GraphQL data. It:
+// - recursively merges any Object properties that are present in both
+// - recursively merges arrays by deepMerging each Object item in the array (by index).
+function deepMerge(target, ...sources) {
+    for (const source of sources) {
+        for (const key in source) {
+            if (ObjectPrototypeHasOwnProperty.call(source, key)) {
+                const targetValue = target[key];
+                const sourceValue = source[key];
+                if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+                    const maxLength = Math.max(targetValue.length, sourceValue.length);
+                    target[key] = Array.from({ length: maxLength }, (_, index) => {
+                        const targetItem = targetValue[index];
+                        const sourceItem = sourceValue[index];
+                        if (targetItem === undefined) {
+                            return sourceItem;
+                        }
+                        else if (sourceItem === undefined) {
+                            return targetItem;
+                        }
+                        else if (targetItem instanceof Object &&
+                            !Array.isArray(targetItem) &&
+                            sourceItem instanceof Object &&
+                            !Array.isArray(sourceItem)) {
+                            return deepMerge({}, targetItem, sourceItem);
+                        }
+                        else {
+                            return sourceItem;
+                        }
+                    });
+                }
+                else if (targetValue instanceof Object &&
+                    !Array.isArray(targetValue) &&
+                    sourceValue instanceof Object &&
+                    !Array.isArray(sourceValue)) {
+                    deepMerge(targetValue, sourceValue);
+                }
+                else {
+                    target[key] = sourceValue;
+                }
+            }
+        }
+    }
+    return target;
+}
+
+export { areArgumentsEqual, areDirectivesEqual, areTypeConditionsEqual, areValuesEqual, buildFieldState, buildQueryTypeStringKey, buildQueryTypeStructuredKey, createFragmentMap, deepMerge, getOperationFromDocument, getRequestedField, getRequestedFieldsForType, isExactSameField, mergeFragmentWithExistingSelections, mergeSelectionSets, serializeFieldArguments, serializeOperationNode };

package/dist/types/fields.d.ts

@@ -1,6 +1,6 @@
 import type { NormalizedKeyMetadata } from '@luvio/engine';
-import type { ArgumentNode } from '@luvio/graphql-parser';
-import type { GraphQLVariables } from './main';
+import type { ArgumentNode, DirectiveNode, FieldNode, SelectionSetNode, ValueNode, NamedTypeNode } from '@luvio/graphql-parser';
+import type { GraphQLFragmentMap, GraphQLVariables, IsFragmentApplicableType } from './main';
 export declare function buildFieldState<T = Record<string, any>>(state: T, fullPath: string | NormalizedKeyMetadata, data: any): T & {
     data: any;
     path: {
@@ -10,3 +10,11 @@ export declare function buildFieldState<T = Record<string, any>>(state: T, fullP
     };
 };
 export declare function serializeFieldArguments(argumentNodes: Readonly<ArgumentNode[]>, variables: GraphQLVariables): string;
+export declare function getRequestedFieldsForType(typename: string, selectionSet: SelectionSetNode, namedFragmentsMap: GraphQLFragmentMap, isFragmentApplicable: IsFragmentApplicableType): Map<string, FieldNode>;
+export declare function getRequestedField(responseDataFieldName: string, requestedFields: FieldNode[]): FieldNode | undefined;
+export declare function mergeSelectionSets(set1: SelectionSetNode | undefined, set2: SelectionSetNode | undefined): SelectionSetNode | undefined;
+export declare function areArgumentsEqual(args1?: ReadonlyArray<ArgumentNode>, args2?: ReadonlyArray<ArgumentNode>): boolean;
+export declare function areDirectivesEqual(dirs1: readonly DirectiveNode[] | undefined, dirs2: readonly DirectiveNode[] | undefined): boolean;
+export declare function areValuesEqual(valueNode1: ValueNode, valueNode2: ValueNode): boolean;
+export declare function areTypeConditionsEqual(typeCondition1?: NamedTypeNode, typeCondition2?: NamedTypeNode): boolean;
+export declare function isExactSameField(field1: FieldNode, field2: FieldNode): boolean;

package/dist/types/fragments.d.ts

@@ -1,3 +1,5 @@
-import type { DocumentNode } from '@luvio/graphql-parser';
+import type { FieldNode, DocumentNode, FragmentDefinitionNode, InlineFragmentNode } from '@luvio/graphql-parser';
 import type { GraphQLFragmentMap } from './types';
+export type IsFragmentApplicableType = (fragment: FragmentDefinitionNode | InlineFragmentNode, typename: string) => boolean;
 export declare function createFragmentMap(documentNode: DocumentNode): GraphQLFragmentMap;
+export declare function mergeFragmentWithExistingSelections(fragmentFieldSelection: FieldNode, existingSelections: FieldNode[]): void;

package/dist/types/main.d.ts

@@ -3,3 +3,4 @@ export * from './fragments';
 export * from './fields';
 export * from './keys';
 export * from './document';
+export * from './utils';

package/dist/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge(target: any, ...sources: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/graphql",
-    "version": "0.145.0",
+    "version": "0.145.2",
     "description": "GraphQL utilities for Luvio GraphQL adapter support",
     "repository": {
         "type": "git",
@@ -27,8 +27,8 @@
         "test:size": "luvioBundlesize"
     },
     "dependencies": {
-        "@luvio/engine": "^0.145.0",
-        "@luvio/graphql-parser": "^0.145.0"
+        "@luvio/engine": "^0.145.2",
+        "@luvio/graphql-parser": "^0.145.2"
     },
     "volta": {
         "extends": "../../../package.json"
@@ -40,7 +40,7 @@
         {
             "path": "./dist/luvioGraphql.js",
             "maxSize": {
-                "none": "10 kB",
+                "none": "18 kB",
                 "min": "10 kB",
                 "compressed": "5 kB"
             }