@wundergraph/protographic 0.11.0 → 0.12.0

package/dist/src/operations/field-numbering.js

@@ -0,0 +1,134 @@
+/**
+ * Creates a new field number manager instance
+ *
+ * @param lockManager - Optional ProtoLockManager for field number stability
+ * @returns A new field number manager
+ */
+export function createFieldNumberManager(lockManager) {
+    // Map of message name to field name to field number
+    const fieldNumbers = new Map();
+    // Map of message name to the next available field number
+    const nextFieldNumbers = new Map();
+    return {
+        getNextFieldNumber(messageName) {
+            // If we have a lock manager and this message has been reconciled,
+            // check if we already have a field number assigned
+            if (lockManager) {
+                const lockData = lockManager.getLockData();
+                const messageData = lockData.messages[messageName];
+                if (messageData) {
+                    // Find the highest assigned number
+                    const assignedNumbers = Object.values(messageData.fields);
+                    const reservedNumbers = messageData.reservedNumbers || [];
+                    const allNumbers = [...assignedNumbers, ...reservedNumbers];
+                    if (allNumbers.length > 0) {
+                        const maxNumber = Math.max(...allNumbers);
+                        // Initialize next field number to be after the max
+                        if (!nextFieldNumbers.has(messageName)) {
+                            nextFieldNumbers.set(messageName, maxNumber + 1);
+                        }
+                    }
+                }
+            }
+            // Initialize if needed
+            if (!nextFieldNumbers.has(messageName)) {
+                nextFieldNumbers.set(messageName, 1);
+            }
+            const current = nextFieldNumbers.get(messageName);
+            nextFieldNumbers.set(messageName, current + 1);
+            return current;
+        },
+        assignFieldNumber(messageName, fieldName, fieldNumber) {
+            // Initialize message map if needed
+            if (!fieldNumbers.has(messageName)) {
+                fieldNumbers.set(messageName, new Map());
+            }
+            const messageFields = fieldNumbers.get(messageName);
+            messageFields.set(fieldName, fieldNumber);
+            // Update next field number if this assignment affects it
+            const currentNext = nextFieldNumbers.get(messageName) || 1;
+            if (fieldNumber >= currentNext) {
+                nextFieldNumbers.set(messageName, fieldNumber + 1);
+            }
+        },
+        getFieldNumber(messageName, fieldName) {
+            var _a;
+            return (_a = fieldNumbers.get(messageName)) === null || _a === void 0 ? void 0 : _a.get(fieldName);
+        },
+        resetMessage(messageName) {
+            fieldNumbers.delete(messageName);
+            nextFieldNumbers.set(messageName, 1);
+        },
+        resetAll() {
+            fieldNumbers.clear();
+            nextFieldNumbers.clear();
+        },
+        getMessageFields(messageName) {
+            const messageFields = fieldNumbers.get(messageName);
+            if (!messageFields) {
+                return {};
+            }
+            const result = {};
+            for (const [fieldName, fieldNumber] of messageFields.entries()) {
+                result[fieldName] = fieldNumber;
+            }
+            return result;
+        },
+        reconcileFieldOrder(messageName, fieldNames) {
+            if (!lockManager) {
+                // No lock manager, return fields in original order
+                return fieldNames;
+            }
+            // Use lock manager to reconcile field order
+            const orderedFields = lockManager.reconcileMessageFieldOrder(messageName, fieldNames);
+            // Update our internal tracking with the reconciled numbers
+            const lockData = lockManager.getLockData();
+            const messageData = lockData.messages[messageName];
+            if (messageData) {
+                // Initialize message map if needed
+                if (!fieldNumbers.has(messageName)) {
+                    fieldNumbers.set(messageName, new Map());
+                }
+                const messageFields = fieldNumbers.get(messageName);
+                // Update field numbers from lock data
+                for (const fieldName of orderedFields) {
+                    const fieldNumber = messageData.fields[fieldName];
+                    if (fieldNumber !== undefined) {
+                        messageFields.set(fieldName, fieldNumber);
+                        // Update next field number
+                        const currentNext = nextFieldNumbers.get(messageName) || 1;
+                        if (fieldNumber >= currentNext) {
+                            nextFieldNumbers.set(messageName, fieldNumber + 1);
+                        }
+                    }
+                }
+            }
+            return orderedFields;
+        },
+        getLockManager() {
+            return lockManager;
+        },
+    };
+}
+/**
+ * Assigns field numbers to a message from lock data
+ * @param messageName - The name of the message
+ * @param fieldNames - The field names to assign numbers to
+ * @param fieldNumberManager - The field number manager to use
+ */
+export function assignFieldNumbersFromLockData(messageName, fieldNames, fieldNumberManager) {
+    var _a;
+    const lockData = (_a = fieldNumberManager === null || fieldNumberManager === void 0 ? void 0 : fieldNumberManager.getLockManager()) === null || _a === void 0 ? void 0 : _a.getLockData();
+    if (!lockData || !fieldNumberManager)
+        return;
+    const messageData = lockData.messages[messageName];
+    if (!messageData)
+        return;
+    for (const protoFieldName of fieldNames) {
+        const fieldNumber = messageData.fields[protoFieldName];
+        if (!fieldNumber)
+            continue;
+        fieldNumberManager.assignFieldNumber(messageName, protoFieldName, fieldNumber);
+    }
+}
+//# sourceMappingURL=field-numbering.js.map

package/dist/src/operations/field-numbering.js.map

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

package/dist/src/operations/list-type-utils.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLType, GraphQLList, GraphQLNonNull } from 'graphql';
+/**
+ * Unwraps a GraphQL type from a GraphQLNonNull wrapper
+ *
+ * @param graphqlType - The GraphQL type to unwrap
+ * @returns The unwrapped type
+ */
+export declare function unwrapNonNullType<T extends GraphQLType>(graphqlType: T | GraphQLNonNull<T>): T;
+/**
+ * Checks if a GraphQL list type contains nested lists
+ * Type guard that narrows the input type when nested lists are detected
+ *
+ * @param listType - The GraphQL list type to check
+ * @returns True if the list contains nested lists
+ */
+export declare function isNestedListType(listType: GraphQLList<GraphQLType>): listType is GraphQLList<GraphQLList<GraphQLType> | GraphQLNonNull<GraphQLList<GraphQLType>>>;
+/**
+ * Calculates the nesting level of a GraphQL list type
+ *
+ * Examples:
+ * - [String] → 1
+ * - [[String]] → 2
+ * - [[[String]]] → 3
+ *
+ * @param listType - The GraphQL list type to analyze
+ * @returns The nesting level (1 for simple list, 2+ for nested lists)
+ */
+export declare function calculateNestingLevel(listType: GraphQLList<GraphQLType>): number;

package/dist/src/operations/list-type-utils.js

@@ -0,0 +1,49 @@
+import { isListType, isNonNullType } from 'graphql';
+/**
+ * Unwraps a GraphQL type from a GraphQLNonNull wrapper
+ *
+ * @param graphqlType - The GraphQL type to unwrap
+ * @returns The unwrapped type
+ */
+export function unwrapNonNullType(graphqlType) {
+    return isNonNullType(graphqlType) ? graphqlType.ofType : graphqlType;
+}
+/**
+ * Checks if a GraphQL list type contains nested lists
+ * Type guard that narrows the input type when nested lists are detected
+ *
+ * @param listType - The GraphQL list type to check
+ * @returns True if the list contains nested lists
+ */
+export function isNestedListType(listType) {
+    return isListType(listType.ofType) || (isNonNullType(listType.ofType) && isListType(listType.ofType.ofType));
+}
+/**
+ * Calculates the nesting level of a GraphQL list type
+ *
+ * Examples:
+ * - [String] → 1
+ * - [[String]] → 2
+ * - [[[String]]] → 3
+ *
+ * @param listType - The GraphQL list type to analyze
+ * @returns The nesting level (1 for simple list, 2+ for nested lists)
+ */
+export function calculateNestingLevel(listType) {
+    let level = 1;
+    let currentType = listType.ofType;
+    while (true) {
+        if (isNonNullType(currentType)) {
+            currentType = currentType.ofType;
+        }
+        else if (isListType(currentType)) {
+            currentType = currentType.ofType;
+            level++;
+        }
+        else {
+            break;
+        }
+    }
+    return level;
+}
+//# sourceMappingURL=list-type-utils.js.map

package/dist/src/operations/list-type-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-type-utils.js","sourceRoot":"","sources":["../../../src/operations/list-type-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE9F;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAwB,WAAkC;IACzF,OAAO,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAAE,WAAW,CAAC,MAAY,CAAC,CAAC,CAAC,WAAW,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,QAAkC;IAElC,OAAO,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AAC/G,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAkC;IACtE,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,WAAW,GAAgB,QAAQ,CAAC,MAAM,CAAC;IAE/C,OAAO,IAAI,EAAE,CAAC;QACZ,IAAI,aAAa,CAAC,WAAW,CAAC,EAAE,CAAC;YAC/B,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;QACnC,CAAC;aAAM,IAAI,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YACnC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC;YACjC,KAAK,EAAE,CAAC;QACV,CAAC;aAAM,CAAC;YACN,MAAM;QACR,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/operations/message-builder.d.ts

@@ -0,0 +1,58 @@
+import protobuf from 'protobufjs';
+import { SelectionSetNode, GraphQLObjectType, GraphQLType, GraphQLSchema, TypeInfo, FragmentDefinitionNode, GraphQLOutputType, GraphQLInterfaceType, GraphQLUnionType } from 'graphql';
+import { FieldNumberManager } from './field-numbering.js';
+/**
+ * Options for building proto messages
+ */
+export interface MessageBuilderOptions {
+    /** Whether to include comments/descriptions */
+    includeComments?: boolean;
+    /** Root object for adding nested types */
+    root?: protobuf.Root;
+    /** Field number manager for consistent numbering */
+    fieldNumberManager?: FieldNumberManager;
+    /** Map of fragment definitions for resolving fragment spreads */
+    fragments?: Map<string, FragmentDefinitionNode>;
+    /** Schema for type lookups */
+    schema?: GraphQLSchema;
+    /** Set to track created enums (to avoid duplicates) */
+    createdEnums?: Set<string>;
+    /** Custom scalar type mappings (scalar name -> proto type) */
+    customScalarMappings?: Record<string, string>;
+    /** Maximum recursion depth to prevent stack overflow (default: 50) */
+    maxDepth?: number;
+    /** Internal: Current recursion depth */
+    _depth?: number;
+    /** Callback to ensure nested list wrapper messages are created */
+    ensureNestedListWrapper?: (graphqlType: GraphQLOutputType) => string;
+}
+/**
+ * Builds a Protocol Buffer message type from a GraphQL selection set
+ *
+ * @param messageName - The name for the proto message
+ * @param selectionSet - The GraphQL selection set to convert
+ * @param parentType - The GraphQL type that contains these selections
+ * @param typeInfo - TypeInfo for resolving field types
+ * @param options - Optional configuration
+ * @returns A protobuf Type object
+ */
+export declare function buildMessageFromSelectionSet(messageName: string, selectionSet: SelectionSetNode, parentType: GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType, typeInfo: TypeInfo, options?: MessageBuilderOptions): protobuf.Type;
+/**
+ * Builds a field definition for a proto message
+ *
+ * @param fieldName - The name of the field
+ * @param fieldType - The GraphQL type of the field
+ * @param fieldNumber - The proto field number
+ * @param options - Optional configuration
+ * @returns A protobuf Field object
+ */
+export declare function buildFieldDefinition(fieldName: string, fieldType: GraphQLType, fieldNumber: number, options?: MessageBuilderOptions): protobuf.Field;
+/**
+ * Builds a nested message type
+ *
+ * @param messageName - The name for the nested message
+ * @param fields - Map of field names to their GraphQL types
+ * @param options - Optional configuration
+ * @returns A protobuf Type object
+ */
+export declare function buildNestedMessage(messageName: string, fields: Map<string, GraphQLType>, options?: MessageBuilderOptions): protobuf.Type;

package/dist/src/operations/message-builder.js

@@ -0,0 +1,377 @@
+import protobuf from 'protobufjs';
+import { isObjectType, isEnumType, getNamedType, isInterfaceType, isUnionType, } from 'graphql';
+import { mapGraphQLTypeToProto } from './type-mapper.js';
+import { assignFieldNumbersFromLockData } from './field-numbering.js';
+import { graphqlFieldToProtoField } from '../naming-conventions.js';
+import { buildEnumType } from './request-builder.js';
+import { upperFirst, camelCase } from 'lodash-es';
+/**
+ * Default maximum recursion depth to prevent stack overflow
+ */
+const DEFAULT_MAX_DEPTH = 50;
+/**
+ * Default starting depth for recursion tracking
+ */
+const DEFAULT_STARTING_DEPTH = 0;
+/**
+ * Builds a Protocol Buffer message type from a GraphQL selection set
+ *
+ * @param messageName - The name for the proto message
+ * @param selectionSet - The GraphQL selection set to convert
+ * @param parentType - The GraphQL type that contains these selections
+ * @param typeInfo - TypeInfo for resolving field types
+ * @param options - Optional configuration
+ * @returns A protobuf Type object
+ */
+export function buildMessageFromSelectionSet(messageName, selectionSet, parentType, typeInfo, options) {
+    var _a, _b;
+    const message = new protobuf.Type(messageName);
+    const fieldNumberManager = options === null || options === void 0 ? void 0 : options.fieldNumberManager;
+    // First pass: collect all field names that will be in this message
+    const fieldNames = [];
+    const fieldSelections = new Map();
+    // Maximum recursion depth to prevent stack overflow
+    const maxDepth = (_a = options === null || options === void 0 ? void 0 : options.maxDepth) !== null && _a !== void 0 ? _a : DEFAULT_MAX_DEPTH;
+    const currentDepth = (_b = options === null || options === void 0 ? void 0 : options._depth) !== null && _b !== void 0 ? _b : DEFAULT_STARTING_DEPTH;
+    // Check depth limit at the start of building each message
+    if (currentDepth > maxDepth) {
+        throw new Error(`Maximum recursion depth (${maxDepth}) exceeded while processing selection set. ` +
+            `This may indicate deeply nested selections or circular fragment references. ` +
+            `You can increase the limit using the maxDepth option.`);
+    }
+    /**
+     * Recursively collects fields from selections with protection against excessive recursion depth.
+     *
+     * Note: Circular fragment references are invalid GraphQL per the spec's NoFragmentCyclesRule.
+     * GraphQL validation should catch these before reaching proto compilation.
+     */
+    const collectFields = (selections, currentType, depth) => {
+        // Stop condition: Check depth limit
+        if (depth > maxDepth) {
+            throw new Error(`Maximum recursion depth (${maxDepth}) exceeded while processing selection set. ` +
+                `This may indicate deeply nested selections or circular fragment references. ` +
+                `You can increase the limit using the maxDepth option.`);
+        }
+        for (const selection of selections) {
+            switch (selection.kind) {
+                case 'Field':
+                    // Only object and interface types have fields that can be selected
+                    // Union types require inline fragments to access their constituent types
+                    if (isObjectType(currentType) || isInterfaceType(currentType)) {
+                        const fieldName = selection.name.value;
+                        const protoFieldName = graphqlFieldToProtoField(fieldName);
+                        if (!fieldNames.includes(protoFieldName)) {
+                            fieldNames.push(protoFieldName);
+                            fieldSelections.set(protoFieldName, { selection, type: currentType });
+                        }
+                    }
+                    break;
+                case 'InlineFragment':
+                    if (selection.typeCondition && (options === null || options === void 0 ? void 0 : options.schema)) {
+                        const typeName = selection.typeCondition.name.value;
+                        const type = options.schema.getType(typeName);
+                        if (type && (isObjectType(type) || isInterfaceType(type))) {
+                            collectFields(selection.selectionSet.selections, type, depth + 1);
+                        }
+                    }
+                    else if (isObjectType(currentType) || isInterfaceType(currentType)) {
+                        // No type condition, but parent type supports fields
+                        collectFields(selection.selectionSet.selections, currentType, depth + 1);
+                    }
+                    break;
+                case 'FragmentSpread':
+                    if (options === null || options === void 0 ? void 0 : options.fragments) {
+                        const fragmentDef = options.fragments.get(selection.name.value);
+                        if (fragmentDef && (options === null || options === void 0 ? void 0 : options.schema)) {
+                            const typeName = fragmentDef.typeCondition.name.value;
+                            const type = options.schema.getType(typeName);
+                            if (type && (isObjectType(type) || isInterfaceType(type) || isUnionType(type))) {
+                                collectFields(fragmentDef.selectionSet.selections, type, depth + 1);
+                            }
+                        }
+                    }
+                    break;
+            }
+        }
+    };
+    // Collect fields from the selection set
+    // For union types, only inline fragments will contribute fields (handled in collectFields)
+    collectFields(selectionSet.selections, parentType, currentDepth);
+    // Reconcile field order using lock manager if available
+    let orderedFieldNames = fieldNames;
+    if (fieldNumberManager && 'reconcileFieldOrder' in fieldNumberManager) {
+        orderedFieldNames = fieldNumberManager.reconcileFieldOrder(messageName, fieldNames);
+    }
+    // Second pass: process fields in reconciled order
+    // Pre-assign field numbers from lock data if available
+    assignFieldNumbersFromLockData(messageName, orderedFieldNames, fieldNumberManager);
+    for (const protoFieldName of orderedFieldNames) {
+        const fieldData = fieldSelections.get(protoFieldName);
+        if (fieldData) {
+            const fieldOptions = {
+                ...options,
+                _depth: currentDepth,
+            };
+            processFieldSelection(fieldData.selection, message, fieldData.type, typeInfo, fieldOptions, fieldNumberManager);
+        }
+    }
+    return message;
+}
+/**
+ * Gets or assigns a field number for a proto field
+ */
+function getOrAssignFieldNumber(message, protoFieldName, fieldNumberManager) {
+    const existingFieldNumber = fieldNumberManager === null || fieldNumberManager === void 0 ? void 0 : fieldNumberManager.getFieldNumber(message.name, protoFieldName);
+    if (existingFieldNumber !== undefined) {
+        return existingFieldNumber;
+    }
+    if (fieldNumberManager) {
+        const fieldNumber = fieldNumberManager.getNextFieldNumber(message.name);
+        fieldNumberManager.assignFieldNumber(message.name, protoFieldName, fieldNumber);
+        return fieldNumber;
+    }
+    return message.fieldsArray.length + 1;
+}
+/**
+ * Resolves the final type name and repetition flag, handling nested list wrappers
+ */
+function resolveTypeNameAndRepetition(baseTypeName, protoTypeInfo, fieldType, options) {
+    let typeName = baseTypeName;
+    let isRepeated = protoTypeInfo.isRepeated;
+    if (protoTypeInfo.requiresNestedWrapper && (options === null || options === void 0 ? void 0 : options.ensureNestedListWrapper)) {
+        typeName = options.ensureNestedListWrapper(fieldType);
+        isRepeated = false; // Wrapper handles the repetition
+    }
+    return { typeName, isRepeated };
+}
+/**
+ * Creates and configures a proto field with comments
+ */
+function createProtoField(protoFieldName, fieldNumber, typeName, isRepeated, fieldDef, options) {
+    const protoField = new protobuf.Field(protoFieldName, fieldNumber, typeName);
+    if (isRepeated) {
+        protoField.repeated = true;
+    }
+    if ((options === null || options === void 0 ? void 0 : options.includeComments) && fieldDef.description) {
+        protoField.comment = fieldDef.description;
+    }
+    return protoField;
+}
+/**
+ * Ensures an enum type is created and added to the root
+ */
+function ensureEnumCreated(namedType, options) {
+    if (!options.root) {
+        return;
+    }
+    const enumTypeName = namedType.name;
+    // Initialize createdEnums in options if missing to ensure persistence across calls
+    if (!options.createdEnums) {
+        options.createdEnums = new Set();
+    }
+    if (!options.createdEnums.has(enumTypeName)) {
+        const protoEnum = buildEnumType(namedType, {
+            includeComments: options.includeComments,
+        });
+        options.root.add(protoEnum);
+        options.createdEnums.add(enumTypeName);
+    }
+}
+/**
+ * Processes a field selection and adds it to the message
+ */
+function processFieldSelection(field, message, parentType, typeInfo, options, fieldNumberManager) {
+    var _a;
+    const fieldName = field.name.value;
+    // Skip __typename - it's a GraphQL introspection field that doesn't need to be in proto
+    if (fieldName === '__typename') {
+        return;
+    }
+    const protoFieldName = graphqlFieldToProtoField(fieldName);
+    // Check if field already exists in the message (avoid duplicates)
+    if (message.fields[protoFieldName]) {
+        return; // Field already added, skip
+    }
+    // Get the field definition from the parent type
+    // Union types don't have fields directly, so skip field validation for them
+    if (isUnionType(parentType)) {
+        // Union types should only be processed through inline fragments
+        // This shouldn't happen in normal GraphQL, but we'll handle it gracefully
+        return;
+    }
+    const fieldDef = parentType.getFields()[fieldName];
+    if (!fieldDef) {
+        throw new Error(`Field "${fieldName}" does not exist on type "${parentType.name}". ` +
+            `GraphQL validation should be performed before proto compilation.`);
+    }
+    const fieldType = fieldDef.type;
+    // Determine the base type name based on whether we have a selection set
+    let baseTypeName;
+    if (field.selectionSet) {
+        // Build nested message for object types
+        const namedType = getNamedType(fieldType);
+        if (isObjectType(namedType) || isInterfaceType(namedType) || isUnionType(namedType)) {
+            const nestedMessageName = upperFirst(camelCase(fieldName));
+            const nestedOptions = {
+                ...options,
+                _depth: ((_a = options === null || options === void 0 ? void 0 : options._depth) !== null && _a !== void 0 ? _a : 0) + 1,
+            };
+            const nestedMessage = buildMessageFromSelectionSet(nestedMessageName, field.selectionSet, namedType, typeInfo, nestedOptions);
+            message.add(nestedMessage);
+            baseTypeName = nestedMessageName;
+        }
+        else {
+            return; // Shouldn't happen with valid GraphQL
+        }
+    }
+    else {
+        // Handle scalar/enum fields
+        const namedType = getNamedType(fieldType);
+        if (isEnumType(namedType) && (options === null || options === void 0 ? void 0 : options.root)) {
+            ensureEnumCreated(namedType, options);
+        }
+        const protoTypeInfo = mapGraphQLTypeToProto(fieldType, {
+            customScalarMappings: options === null || options === void 0 ? void 0 : options.customScalarMappings,
+        });
+        baseTypeName = protoTypeInfo.typeName;
+    }
+    // Common logic for both branches
+    const protoTypeInfo = mapGraphQLTypeToProto(fieldType, {
+        customScalarMappings: options === null || options === void 0 ? void 0 : options.customScalarMappings,
+    });
+    const { typeName, isRepeated } = resolveTypeNameAndRepetition(baseTypeName, protoTypeInfo, fieldType, options);
+    const fieldNumber = getOrAssignFieldNumber(message, protoFieldName, fieldNumberManager);
+    const protoField = createProtoField(protoFieldName, fieldNumber, typeName, isRepeated, fieldDef, options);
+    message.add(protoField);
+}
+/**
+ * Processes an inline fragment and adds its selections to the message
+ * Inline fragments allow type-specific field selections on interfaces/unions
+ */
+function processInlineFragment(fragment, message, parentType, typeInfo, options, fieldNumberManager) {
+    // Determine the type for this inline fragment
+    let fragmentType;
+    if (fragment.typeCondition) {
+        // Type condition specified: ... on User
+        const typeName = fragment.typeCondition.name.value;
+        const schema = options === null || options === void 0 ? void 0 : options.schema;
+        if (!schema) {
+            // Without schema, we can't resolve the type - skip
+            return;
+        }
+        const type = schema.getType(typeName);
+        if (!type || !(isObjectType(type) || isInterfaceType(type) || isUnionType(type))) {
+            // Type not found or not a supported type - skip
+            return;
+        }
+        fragmentType = type;
+    }
+    else {
+        // No type condition: just process with parent type
+        fragmentType = parentType;
+    }
+    // Process all selections in the inline fragment with the resolved type
+    if (fragment.selectionSet) {
+        for (const selection of fragment.selectionSet.selections) {
+            if (selection.kind === 'Field') {
+                processFieldSelection(selection, message, fragmentType, typeInfo, options, fieldNumberManager);
+            }
+            else if (selection.kind === 'InlineFragment') {
+                // Nested inline fragment
+                processInlineFragment(selection, message, fragmentType, typeInfo, options, fieldNumberManager);
+            }
+            else if (selection.kind === 'FragmentSpread') {
+                processFragmentSpread(selection, message, fragmentType, typeInfo, options, fieldNumberManager);
+            }
+        }
+    }
+}
+/**
+ * Processes a fragment spread and adds its selections to the message
+ * Fragment spreads reference named fragment definitions
+ */
+function processFragmentSpread(spread, message, parentType, typeInfo, options, fieldNumberManager) {
+    const fragmentName = spread.name.value;
+    const fragments = options === null || options === void 0 ? void 0 : options.fragments;
+    if (!fragments) {
+        // No fragments provided - skip
+        return;
+    }
+    const fragmentDef = fragments.get(fragmentName);
+    if (!fragmentDef) {
+        // Fragment definition not found - skip
+        return;
+    }
+    // Resolve the fragment's type condition
+    const typeName = fragmentDef.typeCondition.name.value;
+    const schema = options === null || options === void 0 ? void 0 : options.schema;
+    if (!schema) {
+        // Without schema, we can't resolve the type - skip
+        return;
+    }
+    const type = schema.getType(typeName);
+    if (!type || !(isObjectType(type) || isInterfaceType(type) || isUnionType(type))) {
+        // Type not found or not a supported type - skip
+        return;
+    }
+    // Process the fragment's selection set with the resolved type
+    for (const selection of fragmentDef.selectionSet.selections) {
+        if (selection.kind === 'Field') {
+            processFieldSelection(selection, message, type, typeInfo, options, fieldNumberManager);
+        }
+        else if (selection.kind === 'InlineFragment') {
+            processInlineFragment(selection, message, type, typeInfo, options, fieldNumberManager);
+        }
+        else if (selection.kind === 'FragmentSpread') {
+            // Nested fragment spread (fragment inside fragment)
+            processFragmentSpread(selection, message, type, typeInfo, options, fieldNumberManager);
+        }
+    }
+}
+/**
+ * Builds a field definition for a proto message
+ *
+ * @param fieldName - The name of the field
+ * @param fieldType - The GraphQL type of the field
+ * @param fieldNumber - The proto field number
+ * @param options - Optional configuration
+ * @returns A protobuf Field object
+ */
+export function buildFieldDefinition(fieldName, fieldType, fieldNumber, options) {
+    const protoFieldName = graphqlFieldToProtoField(fieldName);
+    const typeInfo = mapGraphQLTypeToProto(fieldType, {
+        customScalarMappings: options === null || options === void 0 ? void 0 : options.customScalarMappings,
+    });
+    const field = new protobuf.Field(protoFieldName, fieldNumber, typeInfo.typeName);
+    if (typeInfo.isRepeated) {
+        field.repeated = true;
+    }
+    return field;
+}
+/**
+ * Builds a nested message type
+ *
+ * @param messageName - The name for the nested message
+ * @param fields - Map of field names to their GraphQL types
+ * @param options - Optional configuration
+ * @returns A protobuf Type object
+ */
+export function buildNestedMessage(messageName, fields, options) {
+    const message = new protobuf.Type(messageName);
+    const fieldNumberManager = options === null || options === void 0 ? void 0 : options.fieldNumberManager;
+    let fieldNumber = 1;
+    for (const [fieldName, fieldType] of fields.entries()) {
+        const protoFieldName = graphqlFieldToProtoField(fieldName);
+        if (fieldNumberManager) {
+            fieldNumber = fieldNumberManager.getNextFieldNumber(messageName);
+            fieldNumberManager.assignFieldNumber(messageName, protoFieldName, fieldNumber);
+        }
+        const field = buildFieldDefinition(fieldName, fieldType, fieldNumber, options);
+        message.add(field);
+        if (!fieldNumberManager) {
+            fieldNumber++;
+        }
+    }
+    return message;
+}
+//# sourceMappingURL=message-builder.js.map