@luvio/graphql 0.157.3 → 0.157.4

package/dist/luvioGraphql.js

@@ -148,7 +148,7 @@ function calculateRequestedFieldsForType(typename, selectionSet, namedFragmentsM
         return acc;
     }, new Map());
 }
-function mergeSelectionSets(set1, set2) {
+function mergeSelectionSets(set1 = { kind: 'SelectionSet', selections: [] }, set2) {
     if (!set2) {
         return set1;
     }
@@ -304,6 +304,124 @@ function isExactSameField(field1, field2) {
         areArgumentsEqual(field1.arguments, field2.arguments) &&
         areDirectivesEqual(field1.directives, field2.directives));
 }
+function injectSelectionSet(selectionSet, queryTransformHelper, fragmentMap, getQueryTransformerForType, processedNodes = new Set(), currentFragmentName) {
+    if (!queryTransformHelper || !selectionSet) {
+        return;
+    }
+    const { selections, fragmentDefinitions, shortCircuit } = queryTransformHelper.getMinimumSelections();
+    // Add new fragment definitions to the map
+    if (fragmentDefinitions) {
+        Object.entries(fragmentDefinitions).forEach(([name, fragment]) => {
+            if (!fragmentMap[name]) {
+                fragmentMap[name] = fragment;
+            }
+        });
+    }
+    const minimumSelectionSet = {
+        kind: 'SelectionSet',
+        selections: selections.filter((selection) => {
+            // Filter out self-referential fragment spreads
+            if (selection.kind === 'FragmentSpread' && currentFragmentName) {
+                return selection.name.value !== currentFragmentName;
+            }
+            return true;
+        }),
+    };
+    // Process each selection in the selection set
+    const mergedSelections = mergeSelectionSets(selectionSet, minimumSelectionSet);
+    Object.assign(selectionSet, mergedSelections);
+    // Some injected fragments or fields will make the query invalid if we continue processing them recursively, so we need to short circuit.
+    if (shortCircuit) {
+        return;
+    }
+    mergedSelections.selections.forEach((selection) => {
+        if (processedNodes.has(selection)) {
+            return;
+        }
+        if (selection.kind === 'Field') {
+            const fieldType = queryTransformHelper.getFieldType(selection);
+            if (fieldType) {
+                const { typename } = fieldType;
+                const fieldQueryTransformHelper = getQueryTransformerForType(typename, fragmentMap);
+                if (fieldQueryTransformHelper) {
+                    // Process nested selection set if it exists
+                    if (!selection.selectionSet) {
+                        Object.assign(selection, {
+                            selectionSet: {
+                                kind: 'SelectionSet',
+                                selections: [],
+                            },
+                        });
+                    }
+                    if (selection.selectionSet) {
+                        injectSelectionSet(selection.selectionSet, fieldQueryTransformHelper, fragmentMap, getQueryTransformerForType, processedNodes, currentFragmentName);
+                    }
+                }
+            }
+        }
+        else if (selection.kind === 'FragmentSpread') {
+            // Skip processing if it's a self-referential fragment spread
+            if (currentFragmentName && selection.name.value === currentFragmentName) {
+                return;
+            }
+            const fragment = fragmentMap[selection.name.value];
+            if (!fragment)
+                return; // FragmentSpread on an undefined fragment
+            const fragmentType = queryTransformHelper.getInContextFragmentType(selection, fragmentMap);
+            if (!fragmentType)
+                return; // We don't know what type this fragment is, so we can't inject anything.
+            const fragmentTransformHelper = getQueryTransformerForType(fragmentType, fragmentMap);
+            if (!fragmentTransformHelper)
+                return; // The Type doesn't exist from build time
+            injectSelectionSet(fragment.selectionSet, fragmentTransformHelper, fragmentMap, getQueryTransformerForType, processedNodes, selection.name.value // Fragment name to prevent infinite recursion
+            );
+        }
+        else if (selection.kind === 'InlineFragment') {
+            const fragmentType = queryTransformHelper.getInContextFragmentType(selection, fragmentMap);
+            const fragmentSelections = selection.selectionSet;
+            if (fragmentType === undefined) {
+                // Untyped or unknown fragment
+                injectSelectionSet(fragmentSelections, queryTransformHelper, fragmentMap, getQueryTransformerForType, processedNodes, currentFragmentName);
+            }
+            else {
+                const fragmentTransformHelper = getQueryTransformerForType(fragmentType, fragmentMap);
+                if (fragmentTransformHelper === undefined) {
+                    return;
+                }
+                injectSelectionSet(fragmentSelections, fragmentTransformHelper, fragmentMap, getQueryTransformerForType, processedNodes, currentFragmentName);
+            }
+        }
+        processedNodes.add(selection);
+    });
+}
+function applyMinimumFieldsToDocument(document, options, getQueryTransformerForType, operationName) {
+    // Return original document for non-query operations
+    const operation = getOperationFromDocument(document, operationName);
+    if (!operation || operation.kind !== 'OperationDefinition' || operation.operation !== 'query') {
+        return document;
+    }
+    const fragmentMap = createFragmentMap(document);
+    const queryTransformHelper = getQueryTransformerForType(options.queryTypeName, fragmentMap);
+    if (queryTransformHelper) {
+        injectSelectionSet(operation.selectionSet, queryTransformHelper, fragmentMap, getQueryTransformerForType);
+    }
+    // Only add new fragments that weren't in the original document
+    const newFragmentDefinitions = Object.entries(fragmentMap)
+        .filter(([name]) => !document.definitions.some((d) => d.kind === 'FragmentDefinition' && d.name.value === name))
+        .map(([name, fragment]) => ({
+        kind: 'FragmentDefinition',
+        name: { kind: 'Name', value: name },
+        typeCondition: fragment.typeCondition,
+        selectionSet: fragment.selectionSet,
+    }));
+    if (newFragmentDefinitions.length > 0) {
+        return {
+            ...document,
+            definitions: [...document.definitions, ...newFragmentDefinitions],
+        };
+    }
+    return document;
+}
 
 function serializeOperationNode(operationNode, variables, fragmentMap) {
     return `${serializeSelectionSet(operationNode.selectionSet, variables, fragmentMap)}`;
@@ -415,4 +533,4 @@ function deepMerge(target, ...sources) {
     return target;
 }
 
-export { areArgumentsEqual, areDirectivesEqual, areTypeConditionsEqual, areValuesEqual, buildFieldState, buildQueryTypeStringKey, buildQueryTypeStructuredKey, createFragmentMap, deepMerge, getOperationFromDocument, getRequestedField, getRequestedFieldsForType, isExactSameField, mergeFragmentWithExistingSelections, mergeSelectionSets, serializeFieldArguments, serializeOperationNode };
+export { applyMinimumFieldsToDocument, areArgumentsEqual, areDirectivesEqual, areTypeConditionsEqual, areValuesEqual, buildFieldState, buildQueryTypeStringKey, buildQueryTypeStructuredKey, createFragmentMap, deepMerge, getOperationFromDocument, getRequestedField, getRequestedFieldsForType, injectSelectionSet, isExactSameField, mergeFragmentWithExistingSelections, mergeSelectionSets, serializeFieldArguments, serializeOperationNode };

package/dist/types/fields.d.ts

@@ -1,5 +1,5 @@
+import type { DocumentNode, FieldNode, FragmentSpreadNode, InlineFragmentNode, NamedTypeNode, SelectionNode, SelectionSetNode, ValueNode, ArgumentNode, DirectiveNode } from '@luvio/graphql-parser';
 import type { NormalizedKeyMetadata } from '@luvio/engine';
-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;
@@ -12,9 +12,58 @@ 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 mergeSelectionSets(set1: SelectionSetNode | undefined, set2: SelectionSetNode | undefined): SelectionSetNode;
 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;
+export type GraphQLTypeDetails = {
+    isArray: boolean;
+    typename: string;
+};
+export interface GetFieldTypeFunction {
+    (field: FieldNode): GraphQLTypeDetails | undefined;
+}
+export interface GetInContextFragmentTypeFunction {
+    (fragment: FragmentSpreadNode | InlineFragmentNode, fragmentMap: GraphQLFragmentMap): string | undefined;
+}
+/**
+ * Returns the minimum selections (fields/fragments) that must be present for a given type.
+ *
+ * @returns An object containing:
+ *   - selections: The minimum set of SelectionNode objects (fields, fragments, etc.) that must be present for this type.
+ *   - fragmentDefinitions: (Optional) Any named fragment definitions that should be added to the document as a result of this injection.
+ *   - shortCircuit: (Advanced) If true, signals that no further recursive field injection should be performed for this selection set.
+ *     Use with extreme caution! Setting this will prevent all further minimum field injection for this subtree, which may result in missing required fields for nested types.
+ *     Only use this if you are certain that no further injection is needed and you fully understand the implications for query correctness and downstream processing.
+ */
+export interface GetMinimumSelectionsFunction {
+    (): {
+        /**
+         * The minimum set of selections (fields, fragment spreads, etc.) that must be present for this type.
+         * These will be merged into the selection set for the current type.
+         */
+        selections: SelectionNode[];
+        /**
+         * (Optional) Any named fragment definitions that should be added to the document as a result of this injection.
+         * These fragments will be added to the document if not already present, but will only be processed if referenced by a FragmentSpread.
+         */
+        fragmentDefinitions?: GraphQLFragmentMap;
+        /**
+         * (Optional)(Advanced) If true, signals that no further recursive field injection should be performed for this selection set.
+         * Use with extreme caution! Setting this will prevent all further minimum field injection for this subtree, which may result in missing required fields for nested types.
+         * Only use this if you are certain that no further injection is needed and you fully understand the implications for query correctness and downstream processing.
+         */
+        shortCircuit?: boolean;
+    };
+}
+export interface QueryTransformHelper {
+    getInContextFragmentType: GetInContextFragmentTypeFunction;
+    getFieldType: GetFieldTypeFunction;
+    getMinimumSelections: GetMinimumSelectionsFunction;
+}
+export declare function injectSelectionSet(selectionSet: SelectionSetNode | undefined, queryTransformHelper: QueryTransformHelper | undefined, fragmentMap: GraphQLFragmentMap, getQueryTransformerForType: (typename: string, fragmentMap: GraphQLFragmentMap) => QueryTransformHelper | undefined, processedNodes?: Set<SelectionNode>, currentFragmentName?: string): void;
+export declare function applyMinimumFieldsToDocument(document: DocumentNode, options: {
+    queryTypeName: string;
+}, getQueryTransformerForType: (typename: string, fragmentMap: GraphQLFragmentMap) => QueryTransformHelper | undefined, operationName?: string): DocumentNode;

package/package.json

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