@vendure/dashboard 3.4.0-minor-202506250934 → 3.4.0

package/src/lib/framework/document-extension/extend-document.ts

@@ -0,0 +1,159 @@
+import { Variables } from '@/vdb/graphql/api.js';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import {
+    DefinitionNode,
+    DocumentNode,
+    FieldNode,
+    FragmentDefinitionNode,
+    Kind,
+    OperationDefinitionNode,
+    parse,
+    SelectionNode,
+    SelectionSetNode,
+} from 'graphql';
+
+/**
+ * Type-safe template string function for extending GraphQL documents
+ */
+export function extendDocument<T extends TypedDocumentNode, V extends Variables = Variables>(
+    defaultDocument: T,
+    template: TemplateStringsArray,
+    ...values: any[]
+): T;
+export function extendDocument<T extends TypedDocumentNode, V extends Variables = Variables>(
+    defaultDocument: T,
+    sdl: string | DocumentNode,
+): T;
+export function extendDocument<T extends TypedDocumentNode, V extends Variables = Variables>(
+    defaultDocument: T,
+    template: TemplateStringsArray | string | DocumentNode,
+    ...values: any[]
+): T {
+    // Handle template strings, regular strings, and DocumentNode
+    let extensionDocument: DocumentNode;
+    if (Array.isArray(template)) {
+        // Template string array
+        const sdl = (template as TemplateStringsArray).reduce((result, str, i) => {
+            return result + str + String(values[i] ?? '');
+        }, '');
+        extensionDocument = parse(sdl);
+    } else if (typeof template === 'string') {
+        // Regular string
+        extensionDocument = parse(template);
+    } else {
+        // DocumentNode
+        extensionDocument = template as DocumentNode;
+    }
+
+    // Merge the documents
+    const mergedDocument = mergeDocuments(defaultDocument, extensionDocument);
+
+    return mergedDocument as T;
+}
+
+/**
+ * Merges two GraphQL documents, adding fields from the extension to the base document
+ */
+function mergeDocuments(baseDocument: DocumentNode, extensionDocument: DocumentNode): DocumentNode {
+    const baseClone = JSON.parse(JSON.stringify(baseDocument)) as DocumentNode;
+
+    // Get all operation definitions from both documents
+    const baseOperations = baseClone.definitions.filter(isOperationDefinition);
+    const extensionOperations = extensionDocument.definitions.filter(isOperationDefinition);
+
+    // Get all fragment definitions from both documents
+    const baseFragments = baseClone.definitions.filter(isFragmentDefinition);
+    const extensionFragments = extensionDocument.definitions.filter(isFragmentDefinition);
+
+    // Merge fragments first (extensions can reference them)
+    const mergedFragments = [...baseFragments, ...extensionFragments];
+
+    // For each operation in the extension, find the corresponding base operation and merge
+    for (const extensionOp of extensionOperations) {
+        // Get the top-level field name from the extension operation
+        const extensionField = extensionOp.selectionSet.selections[0] as FieldNode;
+        if (!extensionField) {
+            throw new Error('Extension query must have at least one top-level field');
+        }
+
+        // Find a base operation that has the same top-level field
+        const baseOp = baseOperations.find(op => {
+            const baseField = op.selectionSet.selections[0] as FieldNode;
+            return baseField && baseField.name.value === extensionField.name.value;
+        });
+
+        if (!baseOp) {
+            const validQueryFields = baseOperations
+                .map(op => {
+                    const field = op.selectionSet.selections[0] as FieldNode;
+                    return field ? field.name.value : 'unknown';
+                })
+                .join(', ');
+            throw new Error(
+                `The query extension must extend the '${validQueryFields}' query. ` +
+                    `Got '${extensionField.name.value}' instead.`,
+            );
+        }
+
+        // Merge the selection sets of the matching top-level fields
+        const baseFieldNode = baseOp.selectionSet.selections[0] as FieldNode;
+        if (baseFieldNode.selectionSet && extensionField.selectionSet) {
+            mergeSelectionSets(baseFieldNode.selectionSet, extensionField.selectionSet);
+        }
+    }
+
+    // Update the document with merged definitions
+    (baseClone as any).definitions = [...baseOperations, ...mergedFragments];
+
+    return baseClone;
+}
+
+/**
+ * Merges two selection sets, adding fields from the extension to the base
+ */
+function mergeSelectionSets(
+    baseSelectionSet: SelectionSetNode,
+    extensionSelectionSet: SelectionSetNode,
+): void {
+    const baseFields = baseSelectionSet.selections.filter(isFieldNode);
+    const extensionFields = extensionSelectionSet.selections.filter(isFieldNode);
+
+    for (const extensionField of extensionFields) {
+        const existingField = baseFields.find(field => field.name.value === extensionField.name.value);
+
+        if (existingField) {
+            // Field already exists, merge their selection sets if both have them
+            if (existingField.selectionSet && extensionField.selectionSet) {
+                mergeSelectionSets(existingField.selectionSet, extensionField.selectionSet);
+            } else if (extensionField.selectionSet && !existingField.selectionSet) {
+                // Extension has a selection set but base doesn't, add it
+                (existingField as any).selectionSet = extensionField.selectionSet;
+            }
+        } else {
+            // Field doesn't exist, add it
+            (baseSelectionSet as any).selections.push(extensionField);
+        }
+    }
+}
+
+/**
+ * Type guards
+ */
+function isOperationDefinition(value: DefinitionNode): value is OperationDefinitionNode {
+    return value.kind === Kind.OPERATION_DEFINITION;
+}
+
+function isFragmentDefinition(value: DefinitionNode): value is FragmentDefinitionNode {
+    return value.kind === Kind.FRAGMENT_DEFINITION;
+}
+
+function isFieldNode(value: SelectionNode): value is FieldNode {
+    return value.kind === Kind.FIELD;
+}
+
+/**
+ * Utility function to create a template string tag for better DX
+ */
+export function gqlExtend(strings: TemplateStringsArray, ...values: any[]) {
+    return (defaultDocument: DocumentNode) => extendDocument(defaultDocument, strings, ...values);
+}

package/src/lib/framework/document-introspection/add-custom-fields.ts

@@ -1,9 +1,9 @@
-import { Variables } from '@/graphql/api.js';
+import { Variables } from '@/vdb/graphql/api.js';
 import {
     getServerConfigDocument,
     relationCustomFieldFragment,
     structCustomFieldFragment,
-} from '@/providers/server-config.js';
+} from '@/vdb/providers/server-config.js';
 import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
 import { CustomFieldConfig } from '@vendure/common/lib/generated-types';
 import { ResultOf } from 'gql.tada';
@@ -25,6 +25,35 @@ type RelationCustomFieldFragment = ResultOf<typeof relationCustomFieldFragment>;
 
 let globalCustomFieldsMap: Map<string, CustomFieldConfig[]> = new Map();
 
+// Memoization cache using WeakMap to avoid memory leaks
+const memoizationCache = new WeakMap<DocumentNode, Map<string, TypedDocumentNode<any, any>>>();
+
+/**
+ * Creates a cache key for the options object
+ */
+function createOptionsKey(options?: {
+    customFieldsMap?: Map<string, CustomFieldConfig[]>;
+    includeCustomFields?: string[];
+}): string {
+    if (!options) return 'default';
+
+    const parts: string[] = [];
+
+    if (options.customFieldsMap) {
+        // Create a deterministic key for the customFieldsMap
+        const mapEntries = Array.from(options.customFieldsMap.entries())
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, value]) => `${key}:${value.length}`);
+        parts.push(`map:${mapEntries.join(',')}`);
+    }
+
+    if (options.includeCustomFields) {
+        parts.push(`include:${options.includeCustomFields.sort().join(',')}`);
+    }
+
+    return parts.join('|') || 'default';
+}
+
 /**
  * @description
  * This function is used to set the global custom fields map.
@@ -56,6 +85,8 @@ export function getCustomFieldsMap() {
 /**
  * Given a GraphQL AST (DocumentNode), this function looks for fragment definitions and adds and configured
  * custom fields to those fragments.
+ *
+ * This function is memoized to return a stable identity for given inputs.
  */
 export function addCustomFields<T, V extends Variables = Variables>(
     documentNode: DocumentNode | TypedDocumentNode<T, V>,
@@ -64,6 +95,21 @@ export function addCustomFields<T, V extends Variables = Variables>(
         includeCustomFields?: string[];
     },
 ): TypedDocumentNode<T, V> {
+    const optionsKey = createOptionsKey(options);
+
+    // Check if we have a cached result for this document and options
+    let documentCache = memoizationCache.get(documentNode);
+    if (!documentCache) {
+        documentCache = new Map();
+        memoizationCache.set(documentNode, documentCache);
+    }
+
+    const cachedResult = documentCache.get(optionsKey);
+    if (cachedResult) {
+        return cachedResult as TypedDocumentNode<T, V>;
+    }
+
+    // If not cached, compute the result
     const clone = JSON.parse(JSON.stringify(documentNode)) as DocumentNode;
     const customFields = options?.customFieldsMap || globalCustomFieldsMap;
 
@@ -209,6 +255,8 @@ export function addCustomFields<T, V extends Variables = Variables>(
         }
     }
 
+    // Cache the result before returning
+    documentCache.set(optionsKey, clone);
     return clone;
 }
 

package/src/lib/framework/document-introspection/get-document-structure.spec.ts

@@ -1,7 +1,11 @@
 import { graphql } from 'gql.tada';
 import { describe, expect, it, vi } from 'vitest';
 
-import { getListQueryFields, getOperationVariablesFields } from './get-document-structure.js';
+import {
+    getFieldsFromDocumentNode,
+    getListQueryFields,
+    getOperationVariablesFields,
+} from './get-document-structure.js';
 
 vi.mock('virtual:admin-api-schema', () => {
     return {
@@ -11,6 +15,7 @@ vi.mock('virtual:admin-api-schema', () => {
                     products: ['ProductList', false, false, true],
                     product: ['Product', false, false, false],
                     collection: ['Collection', false, false, false],
+                    order: ['Order', false, false, false],
                 },
                 Mutation: {
                     updateProduct: ['Product', false, false, false],
@@ -148,7 +153,17 @@ vi.mock('virtual:admin-api-schema', () => {
                     quantity: ['Int', false, false, false],
                 },
             },
-            scalars: ['ID', 'String', 'Int', 'Boolean', 'Float', 'JSON', 'DateTime', 'Upload', 'Money'],
+            scalars: [
+                'ID',
+                'String',
+                'Int',
+                'Boolean',
+                'Float',
+                'JSON',
+                'DateTime',
+                'Upload',
+                'CurrencyCode',
+            ],
             enums: {},
         },
     };
@@ -372,6 +387,9 @@ describe('getOperationVariablesFields', () => {
             mutation AdjustDraftOrderLine($orderId: ID!, $input: AdjustDraftOrderLineInput!) {
                 adjustDraftOrderLine(orderId: $orderId, input: $input) {
                     id
+                    lines {
+                        id
+                    }
                 }
             }
         `);
@@ -418,3 +436,304 @@ describe('getOperationVariablesFields', () => {
         ]);
     });
 });
+
+describe('getFieldsFromDocumentNode', () => {
+    it('should extract fields from a simple path', () => {
+        const doc = graphql(`
+            query {
+                order(id: "1") {
+                    id
+                    lines {
+                        id
+                        quantity
+                    }
+                }
+            }
+        `);
+
+        const fields = getFieldsFromDocumentNode(doc, ['order', 'lines']);
+        expect(fields).toEqual([
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'id',
+                nullable: false,
+                type: 'ID',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'quantity',
+                nullable: false,
+                type: 'Int',
+            },
+        ]);
+    });
+
+    it('should extract fields from root level', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    id
+                    name
+                    description
+                }
+            }
+        `);
+
+        const fields = getFieldsFromDocumentNode(doc, ['product']);
+        expect(fields).toEqual([
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'id',
+                nullable: false,
+                type: 'ID',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'name',
+                nullable: false,
+                type: 'String',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'description',
+                nullable: false,
+                type: 'String',
+            },
+        ]);
+    });
+
+    it('should handle fragments in the target selection', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    id
+                    featuredAsset {
+                        ...AssetFields
+                    }
+                }
+            }
+
+            fragment AssetFields on Asset {
+                id
+                name
+                preview
+            }
+        `);
+
+        const fields = getFieldsFromDocumentNode(doc, ['product', 'featuredAsset']);
+        expect(fields).toEqual([
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'id',
+                nullable: false,
+                type: 'ID',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'name',
+                nullable: false,
+                type: 'String',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'preview',
+                nullable: false,
+                type: 'String',
+            },
+        ]);
+    });
+
+    it('should handle deep nested paths', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    variants {
+                        prices {
+                            currencyCode
+                            price
+                        }
+                    }
+                }
+            }
+        `);
+
+        const fields = getFieldsFromDocumentNode(doc, ['product', 'variants', 'prices']);
+        expect(fields).toEqual([
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'currencyCode',
+                nullable: false,
+                type: 'CurrencyCode',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: false,
+                list: false,
+                name: 'price',
+                nullable: false,
+                type: 'Money',
+            },
+        ]);
+    });
+
+    it('should throw error for non-existent field', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    id
+                }
+            }
+        `);
+
+        expect(() => getFieldsFromDocumentNode(doc, ['product', 'nonExistentField'])).toThrow(
+            'Field "nonExistentField" not found at path product.nonExistentField',
+        );
+    });
+
+    it('should throw error for non-existent path', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    id
+                }
+            }
+        `);
+
+        expect(() => getFieldsFromDocumentNode(doc, ['nonExistentProduct'])).toThrow(
+            'Field "nonExistentProduct" not found at path nonExistentProduct',
+        );
+    });
+
+    it('should throw error when field has no selection set but path continues', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    id
+                }
+            }
+        `);
+
+        expect(() => getFieldsFromDocumentNode(doc, ['product', 'id', 'something'])).toThrow(
+            'Field "id" has no selection set but path continues',
+        );
+    });
+
+    it('should handle empty selection set', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    id
+                    name
+                }
+            }
+        `);
+
+        // Test with a path that leads to a field with no selection set
+        expect(() => getFieldsFromDocumentNode(doc, ['product', 'id', 'something'])).toThrow(
+            'Field "id" has no selection set but path continues',
+        );
+    });
+
+    it('should handle mixed field types and fragments', () => {
+        const doc = graphql(`
+            query {
+                product {
+                    id
+                    featuredAsset {
+                        ...AssetFields
+                        fileSize
+                    }
+                }
+            }
+
+            fragment AssetFields on Asset {
+                id
+                name
+            }
+        `);
+
+        const fields = getFieldsFromDocumentNode(doc, ['product', 'featuredAsset']);
+        expect(fields).toEqual([
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'id',
+                nullable: false,
+                type: 'ID',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'name',
+                nullable: false,
+                type: 'String',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'fileSize',
+                nullable: false,
+                type: 'Int',
+            },
+        ]);
+    });
+
+    it('should handle fields within fragment spreads', () => {
+        const doc = graphql(`
+            query {
+                order {
+                    ...OrderFields
+                }
+            }
+
+            fragment OrderFields on Order {
+                id
+                lines {
+                    id
+                    quantity
+                }
+            }
+        `);
+
+        const fields = getFieldsFromDocumentNode(doc, ['order', 'lines']);
+        expect(fields).toEqual([
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'id',
+                nullable: false,
+                type: 'ID',
+            },
+            {
+                isPaginatedList: false,
+                isScalar: true,
+                list: false,
+                name: 'quantity',
+                nullable: false,
+                type: 'Int',
+            },
+        ]);
+    });
+});