@wundergraph/protographic 0.1.0

package/dist/src/proto-lock.js

@@ -0,0 +1,150 @@
+/**
+ * Class to manage proto lock data for deterministic field ordering
+ */
+export class ProtoLockManager {
+    /**
+     * Create a new ProtoLockManager
+     *
+     * @param initialLockData - Initial lock data to use, if any
+     */
+    constructor(initialLockData) {
+        this.lockData = initialLockData || {
+            version: '1.0.0',
+            messages: {},
+            enums: {},
+        };
+    }
+    /**
+     * Generic method to reconcile items and their numbers
+     *
+     * @param container - The container object (messages or enums)
+     * @param itemName - Name of the item (message or enum)
+     * @param availableItems - Available item names (fields or enum values)
+     * @returns Ordered array of item names
+     */
+    reconcileItems(container, itemName, availableItems) {
+        // Ensure container item exists
+        if (!container[itemName]) {
+            container[itemName] = { fields: {} };
+        }
+        // Get existing fields map
+        const fieldsMap = container[itemName].fields;
+        // Get existing reserved numbers
+        let reservedNumbers = container[itemName].reservedNumbers || [];
+        // Track removed items and their numbers
+        const removedItems = {};
+        // Identify removed items
+        Object.entries(fieldsMap).forEach(([item, number]) => {
+            if (!availableItems.includes(item)) {
+                reservedNumbers.push(number);
+                removedItems[item] = number;
+            }
+        });
+        // Deduplicate reserved numbers
+        reservedNumbers = [...new Set(reservedNumbers)];
+        // Create new fields map
+        const newFieldsMap = {};
+        // Preserve existing numbers for items that are still available
+        availableItems.forEach((item) => {
+            const existingNumber = fieldsMap[item];
+            if (existingNumber !== undefined) {
+                newFieldsMap[item] = existingNumber;
+                // Remove from reserved if it's reused
+                const index = reservedNumbers.indexOf(existingNumber);
+                if (index !== -1) {
+                    reservedNumbers.splice(index, 1);
+                }
+            }
+        });
+        // Get highest assigned number
+        let maxNumber = 0;
+        Object.values(newFieldsMap).forEach((num) => {
+            maxNumber = Math.max(maxNumber, num);
+        });
+        // Also consider reserved numbers for max
+        if (reservedNumbers.length > 0) {
+            maxNumber = Math.max(maxNumber, ...reservedNumbers);
+        }
+        // Assign numbers to items that don't have one
+        availableItems.forEach((item) => {
+            if (newFieldsMap[item] === undefined) {
+                // Check if the item was previously removed (exists in our reservedNumbers)
+                let reservedNumber;
+                Object.entries(removedItems).forEach(([removedItem, number]) => {
+                    if (removedItem === item && reservedNumbers.includes(number)) {
+                        reservedNumber = number;
+                    }
+                });
+                if (reservedNumber !== undefined) {
+                    // Reuse the reserved number for this item
+                    newFieldsMap[item] = reservedNumber;
+                    // Remove from reserved list
+                    const index = reservedNumbers.indexOf(reservedNumber);
+                    if (index !== -1) {
+                        reservedNumbers.splice(index, 1);
+                    }
+                }
+                else {
+                    // Find next available number
+                    let nextNumber = maxNumber + 1;
+                    while (reservedNumbers.includes(nextNumber)) {
+                        nextNumber++;
+                    }
+                    newFieldsMap[item] = nextNumber;
+                    maxNumber = nextNumber;
+                }
+            }
+        });
+        // Update the fields map and reserved numbers
+        container[itemName].fields = newFieldsMap;
+        if (reservedNumbers.length > 0) {
+            container[itemName].reservedNumbers = reservedNumbers;
+        }
+        else {
+            // If no reserved numbers, make sure the property doesn't exist
+            delete container[itemName].reservedNumbers;
+        }
+        // Sort available items by their assigned numbers
+        return [...availableItems].sort((a, b) => {
+            return newFieldsMap[a] - newFieldsMap[b];
+        });
+    }
+    /**
+     * Reconcile and get the ordered field names for a message
+     *
+     * @param messageName - Name of the message
+     * @param availableFields - Available field names (used when no lock exists)
+     * @returns Ordered array of field names
+     */
+    reconcileMessageFieldOrder(messageName, availableFields) {
+        return this.reconcileItems(this.lockData.messages, messageName, availableFields);
+    }
+    /**
+     * Reconcile and get the ordered enum values
+     *
+     * @param enumName - Name of the enum
+     * @param availableValues - Available enum values (used when no lock exists)
+     * @returns Ordered array of enum values
+     */
+    reconcileEnumValueOrder(enumName, availableValues) {
+        return this.reconcileItems(this.lockData.enums, enumName, availableValues);
+    }
+    /**
+     * Reconcile and get the ordered argument names for a field
+     *
+     * @param fieldPath - Path to the field in the format "TypeName.fieldName"
+     * @param availableArgs - Available argument names (used when no lock exists)
+     * @returns Ordered array of argument names
+     */
+    reconcileArgumentOrder(fieldPath, availableArgs) {
+        // Use the regular message field ordering for arguments
+        return this.reconcileMessageFieldOrder(fieldPath, availableArgs);
+    }
+    /**
+     * Get the current lock data
+     */
+    getLockData() {
+        return this.lockData;
+    }
+}
+//# sourceMappingURL=proto-lock.js.map

package/dist/src/proto-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proto-lock.js","sourceRoot":"","sources":["../../src/proto-lock.ts"],"names":[],"mappings":"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"}

package/dist/src/sdl-to-mapping-visitor.d.ts

@@ -0,0 +1,172 @@
+import { GraphQLSchema } from 'graphql';
+import { GRPCMapping } from '@wundergraph/cosmo-connect/dist/node/v1/node_pb';
+/**
+ * Visitor that converts a GraphQL schema to gRPC mapping definitions
+ *
+ * This visitor traverses a GraphQL schema and generates mappings between:
+ * - GraphQL operations and gRPC RPC methods
+ * - GraphQL entity types (with @key directive) and corresponding lookup methods
+ * - GraphQL types/fields and Protocol Buffer message types/fields
+ * - GraphQL enums and Protocol Buffer enums
+ *
+ * The generated mappings are used to translate between GraphQL and Protocol Buffer
+ * representations in a consistent manner.
+ */
+export declare class GraphQLToProtoVisitor {
+    private readonly mapping;
+    private readonly schema;
+    /**
+     * Creates a new visitor for generating gRPC mappings from a GraphQL schema
+     *
+     * @param schema - The GraphQL schema to process
+     * @param serviceName - Name for the generated service (defaults to "DefaultService")
+     */
+    constructor(schema: GraphQLSchema, serviceName?: string);
+    /**
+     * Process the GraphQL schema and generate all necessary mappings
+     *
+     * The processing order is important:
+     * 1. First entity types (with @key directives) are processed to identify federated entities
+     * 2. Then Query operations are processed to map GraphQL queries to RPC methods
+     * 3. Finally all remaining types are processed to ensure complete mapping coverage
+     *
+     * @returns The completed gRPC mapping definitions
+     */
+    visit(): GRPCMapping;
+    /**
+     * Processes entity types (GraphQL types with @key directive)
+     *
+     * Federation entities require special handling to generate appropriate
+     * lookup RPC methods and entity mappings.
+     */
+    private processEntityTypes;
+    /**
+     * Extract the key directive from a GraphQL object type
+     *
+     * @param type - The GraphQL object type to check for key directive
+     * @returns The key directive if found, undefined otherwise
+     */
+    private getKeyDirective;
+    /**
+     * Creates an entity mapping for a federated entity type
+     *
+     * This defines how a GraphQL federated entity maps to a gRPC lookup method
+     * and its corresponding request/response messages.
+     *
+     * @param typeName - The name of the GraphQL entity type
+     * @param keyField - The field that serves as the entity's key
+     */
+    private createEntityMapping;
+    /**
+     * Extract key fields from a @key directive
+     *
+     * The @key directive specifies which fields form the entity's primary key
+     * in Federation. This method extracts those field names.
+     *
+     * @param directive - The @key directive from the GraphQL AST
+     * @returns Array of field names that form the key
+     */
+    private getKeyFieldsFromDirective;
+    /**
+     * Process the GraphQL Query type to generate query operation mappings
+     *
+     * Each field on the Query type represents a GraphQL query operation that
+     * needs to be mapped to a corresponding gRPC RPC method.
+     */
+    private processQueryType;
+    /**
+     * Process the GraphQL Mutation type to generate mutation operation mappings
+     *
+     * Each field on the Mutation type represents a GraphQL mutation operation that
+     * needs to be mapped to a corresponding gRPC RPC method.
+     */
+    private processMutationType;
+    /**
+     * Process the GraphQL Subscription type to generate subscription operation mappings
+     *
+     * Each field on the Subscription type represents a GraphQL subscription operation that
+     * needs to be mapped to a corresponding gRPC RPC method.
+     */
+    private processSubscriptionType;
+    /**
+     * Process a GraphQL type to generate operation mappings
+     *
+     * This method processes a specific GraphQL type (e.g., Query, Mutation, Subscription)
+     * and generates mappings for its fields to corresponding gRPC RPC methods.
+     *
+     * @param operationTypeName - The name of the GraphQL type (Query, Mutation, Subscription)
+     * @param operationType - The type of operation (Query, Mutation, Subscription)
+     * @param graphqlType - The GraphQL type to process
+     */
+    private processType;
+    /**
+     * Create an operation mapping between a GraphQL query and gRPC method
+     *
+     * @param operationType - The type of operation (Query, Mutation, Subscription)
+     * @param fieldName - Original GraphQL field name
+     * @param mappedName - Transformed name for use in gRPC context
+     */
+    private createOperationMapping;
+    /**
+     * Process all remaining GraphQL types to generate complete mappings
+     *
+     * This ensures that all object types, input types, and enums in the schema
+     * have appropriate mappings for their fields and values.
+     */
+    private processAllTypes;
+    /**
+     * Determines if a type should be skipped during processing
+     *
+     * We skip:
+     * - Built-in GraphQL types (prefixed with __)
+     * - Root operation types (Query, Mutation, Subscription)
+     *
+     * @param type - The GraphQL type to check
+     * @returns True if the type should be skipped, false otherwise
+     */
+    private shouldSkipRootType;
+    /**
+     * Process a GraphQL object type to generate field mappings
+     *
+     * @param type - The GraphQL object type to process
+     */
+    private processObjectType;
+    /**
+     * Process a GraphQL input object type to generate field mappings
+     *
+     * Input objects are handled separately because they have different
+     * field structures than regular object types.
+     *
+     * @param type - The GraphQL input object type to process
+     */
+    private processInputObjectType;
+    /**
+     * Process a GraphQL enum type to generate value mappings
+     *
+     * GraphQL enums are mapped to Protocol Buffer enums with appropriate
+     * naming conventions for the enum values.
+     *
+     * @param type - The GraphQL enum type to process
+     */
+    private processEnumType;
+    /**
+     * Create a field mapping between a GraphQL field and Protocol Buffer field
+     *
+     * This includes mapping the field name and any arguments the field may have.
+     *
+     * @param type - The name of the containing GraphQL type
+     * @param field - The GraphQL field to create a mapping for
+     * @returns The created field mapping
+     */
+    private createFieldMapping;
+    /**
+     * Create argument mappings for a GraphQL field
+     *
+     * Maps each argument to its Protocol Buffer representation with
+     * appropriate naming conventions.
+     *
+     * @param field - The GraphQL field containing arguments
+     * @returns Array of argument mappings
+     */
+    private createArgumentMappings;
+}

package/dist/src/sdl-to-mapping-visitor.js

@@ -0,0 +1,365 @@
+import { isEnumType, isInputObjectType, isObjectType, Kind, } from 'graphql';
+import { createEntityLookupMethodName, createEntityLookupRequestName, createEntityLookupResponseName, createOperationMethodName, createRequestMessageName, createResponseMessageName, graphqlArgumentToProtoField, graphqlEnumValueToProtoEnumValue, graphqlFieldToProtoField, } from './naming-conventions.js';
+import { ArgumentMapping, EntityMapping, EnumMapping, EnumValueMapping, FieldMapping, GRPCMapping, OperationMapping, OperationType, TypeFieldMapping, } from '@wundergraph/cosmo-connect/dist/node/v1/node_pb';
+/**
+ * Visitor that converts a GraphQL schema to gRPC mapping definitions
+ *
+ * This visitor traverses a GraphQL schema and generates mappings between:
+ * - GraphQL operations and gRPC RPC methods
+ * - GraphQL entity types (with @key directive) and corresponding lookup methods
+ * - GraphQL types/fields and Protocol Buffer message types/fields
+ * - GraphQL enums and Protocol Buffer enums
+ *
+ * The generated mappings are used to translate between GraphQL and Protocol Buffer
+ * representations in a consistent manner.
+ */
+export class GraphQLToProtoVisitor {
+    /**
+     * Creates a new visitor for generating gRPC mappings from a GraphQL schema
+     *
+     * @param schema - The GraphQL schema to process
+     * @param serviceName - Name for the generated service (defaults to "DefaultService")
+     */
+    constructor(schema, serviceName = 'DefaultService') {
+        this.schema = schema;
+        this.mapping = new GRPCMapping({
+            version: 1,
+            service: serviceName,
+            operationMappings: [],
+            entityMappings: [],
+            typeFieldMappings: [],
+            enumMappings: [],
+        });
+    }
+    /**
+     * Process the GraphQL schema and generate all necessary mappings
+     *
+     * The processing order is important:
+     * 1. First entity types (with @key directives) are processed to identify federated entities
+     * 2. Then Query operations are processed to map GraphQL queries to RPC methods
+     * 3. Finally all remaining types are processed to ensure complete mapping coverage
+     *
+     * @returns The completed gRPC mapping definitions
+     */
+    visit() {
+        // Process entity types first (types with @key directive)
+        this.processEntityTypes();
+        // Process query type
+        this.processQueryType();
+        // Process mutation type
+        this.processMutationType();
+        // Process subscription type
+        this.processSubscriptionType();
+        // Process all other types for field mappings
+        this.processAllTypes();
+        return this.mapping;
+    }
+    /**
+     * Processes entity types (GraphQL types with @key directive)
+     *
+     * Federation entities require special handling to generate appropriate
+     * lookup RPC methods and entity mappings.
+     */
+    processEntityTypes() {
+        const typeMap = this.schema.getTypeMap();
+        for (const typeName in typeMap) {
+            const type = typeMap[typeName];
+            // Skip built-in types and query/mutation/subscription types
+            if (this.shouldSkipRootType(type))
+                continue;
+            // Check if this is an entity type (has @key directive)
+            if (isObjectType(type)) {
+                const keyDirective = this.getKeyDirective(type);
+                if (!keyDirective)
+                    continue;
+                const keyFields = this.getKeyFieldsFromDirective(keyDirective);
+                if (keyFields.length > 0) {
+                    // Create entity mapping using the first key field
+                    this.createEntityMapping(typeName, keyFields[0]);
+                }
+            }
+        }
+    }
+    /**
+     * Extract the key directive from a GraphQL object type
+     *
+     * @param type - The GraphQL object type to check for key directive
+     * @returns The key directive if found, undefined otherwise
+     */
+    getKeyDirective(type) {
+        var _a, _b;
+        return (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.find((d) => d.name.value === 'key');
+    }
+    /**
+     * Creates an entity mapping for a federated entity type
+     *
+     * This defines how a GraphQL federated entity maps to a gRPC lookup method
+     * and its corresponding request/response messages.
+     *
+     * @param typeName - The name of the GraphQL entity type
+     * @param keyField - The field that serves as the entity's key
+     */
+    createEntityMapping(typeName, keyField) {
+        const entityMapping = new EntityMapping({
+            typeName,
+            kind: 'entity',
+            key: keyField,
+            rpc: createEntityLookupMethodName(typeName, keyField),
+            request: createEntityLookupRequestName(typeName, keyField),
+            response: createEntityLookupResponseName(typeName, keyField),
+        });
+        this.mapping.entityMappings.push(entityMapping);
+    }
+    /**
+     * Extract key fields from a @key directive
+     *
+     * The @key directive specifies which fields form the entity's primary key
+     * in Federation. This method extracts those field names.
+     *
+     * @param directive - The @key directive from the GraphQL AST
+     * @returns Array of field names that form the key
+     */
+    getKeyFieldsFromDirective(directive) {
+        var _a;
+        // Extract fields argument from the key directive
+        const fieldsArg = (_a = directive.arguments) === null || _a === void 0 ? void 0 : _a.find((arg) => arg.name.value === 'fields');
+        if (fieldsArg && fieldsArg.value.kind === Kind.STRING) {
+            return fieldsArg.value.value.split(' ');
+        }
+        return [];
+    }
+    /**
+     * Process the GraphQL Query type to generate query operation mappings
+     *
+     * Each field on the Query type represents a GraphQL query operation that
+     * needs to be mapped to a corresponding gRPC RPC method.
+     */
+    processQueryType() {
+        this.processType('Query', OperationType.QUERY, this.schema.getQueryType());
+    }
+    /**
+     * Process the GraphQL Mutation type to generate mutation operation mappings
+     *
+     * Each field on the Mutation type represents a GraphQL mutation operation that
+     * needs to be mapped to a corresponding gRPC RPC method.
+     */
+    processMutationType() {
+        this.processType('Mutation', OperationType.MUTATION, this.schema.getMutationType());
+    }
+    /**
+     * Process the GraphQL Subscription type to generate subscription operation mappings
+     *
+     * Each field on the Subscription type represents a GraphQL subscription operation that
+     * needs to be mapped to a corresponding gRPC RPC method.
+     */
+    processSubscriptionType() {
+        this.processType('Subscription', OperationType.SUBSCRIPTION, this.schema.getSubscriptionType());
+    }
+    /**
+     * Process a GraphQL type to generate operation mappings
+     *
+     * This method processes a specific GraphQL type (e.g., Query, Mutation, Subscription)
+     * and generates mappings for its fields to corresponding gRPC RPC methods.
+     *
+     * @param operationTypeName - The name of the GraphQL type (Query, Mutation, Subscription)
+     * @param operationType - The type of operation (Query, Mutation, Subscription)
+     * @param graphqlType - The GraphQL type to process
+     */
+    processType(operationTypeName, operationType, graphqlType) {
+        if (!graphqlType)
+            return;
+        const typeFieldMapping = new TypeFieldMapping({
+            type: operationTypeName,
+            fieldMappings: [],
+        });
+        const fields = graphqlType.getFields();
+        for (const fieldName in fields) {
+            // Skip special federation fields
+            if (fieldName === '_entities')
+                continue;
+            const field = fields[fieldName];
+            const mappedName = createOperationMethodName(operationTypeName, fieldName);
+            this.createOperationMapping(operationType, fieldName, mappedName);
+            const fieldMapping = this.createFieldMapping(operationTypeName, field);
+            typeFieldMapping.fieldMappings.push(fieldMapping);
+        }
+        this.mapping.typeFieldMappings.push(typeFieldMapping);
+    }
+    /**
+     * Create an operation mapping between a GraphQL query and gRPC method
+     *
+     * @param operationType - The type of operation (Query, Mutation, Subscription)
+     * @param fieldName - Original GraphQL field name
+     * @param mappedName - Transformed name for use in gRPC context
+     */
+    createOperationMapping(operationType, fieldName, mappedName) {
+        const operationMapping = new OperationMapping({
+            type: operationType,
+            original: fieldName,
+            mapped: mappedName,
+            request: createRequestMessageName(mappedName),
+            response: createResponseMessageName(mappedName),
+        });
+        this.mapping.operationMappings.push(operationMapping);
+    }
+    /**
+     * Process all remaining GraphQL types to generate complete mappings
+     *
+     * This ensures that all object types, input types, and enums in the schema
+     * have appropriate mappings for their fields and values.
+     */
+    processAllTypes() {
+        const typeMap = this.schema.getTypeMap();
+        for (const typeName in typeMap) {
+            const type = typeMap[typeName];
+            if (this.shouldSkipRootType(type))
+                continue;
+            // Process each type according to its kind
+            if (isObjectType(type)) {
+                this.processObjectType(type);
+            }
+            else if (isInputObjectType(type)) {
+                this.processInputObjectType(type);
+            }
+            else if (isEnumType(type)) {
+                this.processEnumType(type);
+            }
+            // Note: Union types don't need field mappings in our implementation
+        }
+    }
+    /**
+     * Determines if a type should be skipped during processing
+     *
+     * We skip:
+     * - Built-in GraphQL types (prefixed with __)
+     * - Root operation types (Query, Mutation, Subscription)
+     *
+     * @param type - The GraphQL type to check
+     * @returns True if the type should be skipped, false otherwise
+     */
+    shouldSkipRootType(type) {
+        var _a, _b, _c;
+        const typeName = type.name;
+        return (typeName.startsWith('__') ||
+            typeName === ((_a = this.schema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name) ||
+            typeName === ((_b = this.schema.getMutationType()) === null || _b === void 0 ? void 0 : _b.name) ||
+            typeName === ((_c = this.schema.getSubscriptionType()) === null || _c === void 0 ? void 0 : _c.name));
+    }
+    /**
+     * Process a GraphQL object type to generate field mappings
+     *
+     * @param type - The GraphQL object type to process
+     */
+    processObjectType(type) {
+        const typeFieldMapping = new TypeFieldMapping({
+            type: type.name,
+            fieldMappings: [],
+        });
+        const fields = type.getFields();
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            const fieldMapping = this.createFieldMapping(type.name, field);
+            typeFieldMapping.fieldMappings.push(fieldMapping);
+        }
+        // Only add to mappings if there are fields to map
+        if (typeFieldMapping.fieldMappings.length > 0) {
+            this.mapping.typeFieldMappings.push(typeFieldMapping);
+        }
+    }
+    /**
+     * Process a GraphQL input object type to generate field mappings
+     *
+     * Input objects are handled separately because they have different
+     * field structures than regular object types.
+     *
+     * @param type - The GraphQL input object type to process
+     */
+    processInputObjectType(type) {
+        const typeFieldMapping = new TypeFieldMapping({
+            type: type.name,
+            fieldMappings: [],
+        });
+        const fields = type.getFields();
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            // Input fields don't have args, so we create a simpler field mapping
+            const fieldMapping = new FieldMapping({
+                original: field.name,
+                mapped: graphqlFieldToProtoField(field.name),
+                argumentMappings: [],
+            });
+            typeFieldMapping.fieldMappings.push(fieldMapping);
+        }
+        // Only add to mappings if there are fields to map
+        if (typeFieldMapping.fieldMappings.length > 0) {
+            this.mapping.typeFieldMappings.push(typeFieldMapping);
+        }
+    }
+    /**
+     * Process a GraphQL enum type to generate value mappings
+     *
+     * GraphQL enums are mapped to Protocol Buffer enums with appropriate
+     * naming conventions for the enum values.
+     *
+     * @param type - The GraphQL enum type to process
+     */
+    processEnumType(type) {
+        const enumMapping = new EnumMapping({
+            type: type.name,
+            values: [],
+        });
+        const enumValues = type.getValues();
+        // Map each enum value to its Protocol Buffer representation
+        for (const enumValue of enumValues) {
+            enumMapping.values.push(new EnumValueMapping({
+                original: enumValue.name,
+                // Convert to UPPER_SNAKE_CASE with type name prefix for Proto enums
+                mapped: graphqlEnumValueToProtoEnumValue(type.name, enumValue.name),
+            }));
+        }
+        this.mapping.enumMappings.push(enumMapping);
+    }
+    /**
+     * Create a field mapping between a GraphQL field and Protocol Buffer field
+     *
+     * This includes mapping the field name and any arguments the field may have.
+     *
+     * @param type - The name of the containing GraphQL type
+     * @param field - The GraphQL field to create a mapping for
+     * @returns The created field mapping
+     */
+    createFieldMapping(type, field) {
+        const fieldName = field.name;
+        // Convert field names to snake_case for Protocol Buffers
+        const mappedFieldName = graphqlFieldToProtoField(fieldName);
+        const argumentMappings = this.createArgumentMappings(field);
+        return new FieldMapping({
+            original: fieldName,
+            mapped: mappedFieldName,
+            argumentMappings,
+        });
+    }
+    /**
+     * Create argument mappings for a GraphQL field
+     *
+     * Maps each argument to its Protocol Buffer representation with
+     * appropriate naming conventions.
+     *
+     * @param field - The GraphQL field containing arguments
+     * @returns Array of argument mappings
+     */
+    createArgumentMappings(field) {
+        const argumentMappings = [];
+        if (field.args && field.args.length > 0) {
+            for (const arg of field.args) {
+                argumentMappings.push(new ArgumentMapping({
+                    original: arg.name,
+                    // Convert argument names to snake_case for Protocol Buffers
+                    mapped: graphqlArgumentToProtoField(arg.name),
+                }));
+            }
+        }
+        return argumentMappings;
+    }
+}
+//# sourceMappingURL=sdl-to-mapping-visitor.js.map