@wundergraph/protographic 0.15.5 → 0.16.0

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

@@ -1,36 +1,11 @@
-import { getNamedType, GraphQLID, isEnumType, isInputObjectType, isInterfaceType, isListType, isNamedType, isNonNullType, isObjectType, isScalarType, isUnionType, Kind, } from 'graphql';
-import { createEntityLookupMethodName, createEnumUnspecifiedValue, createOperationMethodName, createRequestMessageName, createResolverMethodName, createResponseMessageName, graphqlEnumValueToProtoEnumValue, graphqlFieldToProtoField, resolverResponseResultName, typeFieldArgsName, typeFieldContextName, } from './naming-conventions.js';
+import { getNamedType, GraphQLID, isEnumType, isInputObjectType, isInterfaceType, isNamedType, isObjectType, isScalarType, isUnionType, Kind, } from 'graphql';
 import { camelCase } from 'lodash-es';
+import { createEntityLookupMethodName, createEnumUnspecifiedValue, createOperationMethodName, createRequestMessageName, createResolverMethodName, createResponseMessageName, graphqlEnumValueToProtoEnumValue, graphqlFieldToProtoField, resolverResponseResultName, typeFieldArgsName, typeFieldContextName, } from './naming-conventions.js';
 import { ProtoLockManager } from './proto-lock.js';
-import { CONNECT_FIELD_RESOLVER, CONTEXT, FIELD_ARGS, RESULT } from './string-constants.js';
-import { unwrapNonNullType, isNestedListType, calculateNestingLevel } from './operations/list-type-utils.js';
+import { CONNECT_FIELD_RESOLVER, CONTEXT, EXTERNAL_DIRECTIVE_NAME, FIELD_ARGS, KEY_DIRECTIVE_NAME, REQUIRES_DIRECTIVE_NAME, RESULT, } from './string-constants.js';
 import { buildProtoOptions } from './proto-options.js';
-/**
- * Maps GraphQL scalar types to Protocol Buffer types
- *
- * GraphQL has a smaller set of primitive types compared to Protocol Buffers.
- * This mapping ensures consistent representation between the two type systems.
- */
-const SCALAR_TYPE_MAP = {
-    ID: 'string', // GraphQL IDs map to Proto strings
-    String: 'string', // Direct mapping
-    Int: 'int32', // GraphQL Int is 32-bit signed
-    Float: 'double', // Using double for GraphQL Float gives better precision
-    Boolean: 'bool', // Direct mapping
-};
-/**
- * Maps GraphQL scalar types to Protocol Buffer wrapper types for nullable fields
- *
- * These wrapper types allow distinguishing between unset fields and zero values
- * in Protocol Buffers, which is important for GraphQL nullable semantics.
- */
-const SCALAR_WRAPPER_TYPE_MAP = {
-    ID: 'google.protobuf.StringValue',
-    String: 'google.protobuf.StringValue',
-    Int: 'google.protobuf.Int32Value',
-    Float: 'google.protobuf.DoubleValue',
-    Boolean: 'google.protobuf.BoolValue',
-};
+import { buildProtoMessage, createNestedListWrapper, formatComment, getProtoTypeFromGraphQL, listNameByNestingLevel, renderRPCMethod, } from './proto-utils.js';
+import { RequiredFieldsVisitor } from './required-fields-visitor.js';
 /**
  * Visitor that converts GraphQL SDL to Protocol Buffer text definition
  *
@@ -77,7 +52,7 @@ export class GraphQLToProtoTextVisitor {
          * This maintains field numbers even when fields are removed from the schema
          */
         this.fieldNumbersMap = {};
-        const { serviceName = 'DefaultService', packageName = 'service.v1', lockData, includeComments = true } = options;
+        const { serviceName = 'DefaultService', packageName = 'service.v1', lockData, includeComments = true, protoOptions, ...languageOptions } = options;
         this.schema = schema;
         this.serviceName = serviceName;
         this.packageName = packageName;
@@ -89,27 +64,117 @@ export class GraphQLToProtoTextVisitor {
         }
         // Process language-specific proto options using buildProtoOptions
         const protoOptionsFromLanguageProps = buildProtoOptions({
-            goPackage: options.goPackage,
-            javaPackage: options.javaPackage,
-            javaOuterClassname: options.javaOuterClassname,
-            javaMultipleFiles: options.javaMultipleFiles,
-            csharpNamespace: options.csharpNamespace,
-            rubyPackage: options.rubyPackage,
-            phpNamespace: options.phpNamespace,
-            phpMetadataNamespace: options.phpMetadataNamespace,
-            objcClassPrefix: options.objcClassPrefix,
-            swiftPrefix: options.swiftPrefix,
+            ...languageOptions,
         }, packageName);
         // Add language-specific options
         if (protoOptionsFromLanguageProps.length > 0) {
             this.options.push(...protoOptionsFromLanguageProps);
         }
         // Process custom protoOptions array (for backward compatibility)
-        if (options.protoOptions && options.protoOptions.length > 0) {
-            const processedOptions = options.protoOptions.map((opt) => `option ${opt.name} = ${opt.constant};`);
+        if (protoOptions && protoOptions.length > 0) {
+            const processedOptions = protoOptions.map((opt) => `option ${opt.name} = ${opt.constant};`);
             this.options.push(...processedOptions);
         }
     }
+    /**
+     * Visit the GraphQL schema to generate Proto buffer definition
+     *
+     * @returns The complete Protocol Buffer definition as a string
+     */
+    visit() {
+        // Collect RPC methods and message definitions from all sources
+        const resolverResult = this.collectResolverRpcMethods();
+        const requiredFieldResult = this.collectRequiredFieldRpcMethods();
+        const entityResult = this.collectEntityRpcMethods();
+        const queryResult = this.collectQueryRpcMethods();
+        const mutationResult = this.collectMutationRpcMethods();
+        // Combine all RPC methods and message definitions
+        const allRpcMethods = [
+            ...entityResult.rpcMethods,
+            ...queryResult.rpcMethods,
+            ...mutationResult.rpcMethods,
+            ...resolverResult.rpcMethods,
+            ...requiredFieldResult.rpcMethods,
+        ];
+        const allMethodNames = [
+            ...entityResult.methodNames,
+            ...queryResult.methodNames,
+            ...mutationResult.methodNames,
+            ...resolverResult.methodNames,
+            ...requiredFieldResult.methodNames,
+        ];
+        const allMessageDefinitions = [
+            ...entityResult.messageDefinitions,
+            ...queryResult.messageDefinitions,
+            ...mutationResult.messageDefinitions,
+            ...resolverResult.messageDefinitions,
+            ...requiredFieldResult.messageDefinitions,
+        ];
+        // Add all types from the schema to the queue that weren't already queued
+        this.queueAllSchemaTypes();
+        // Process all complex types from the message queue to determine if wrapper types are needed
+        this.processMessageQueue();
+        // Add wrapper import if needed
+        if (this.usesWrapperTypes) {
+            this.addImport('google/protobuf/wrappers.proto');
+        }
+        // Build the complete proto file
+        let protoContent = [];
+        // Add the header (syntax, package, imports, options)
+        protoContent.push(...this.buildProtoHeader());
+        // Add a service description comment
+        if (this.includeComments) {
+            const serviceComment = `Service definition for ${this.serviceName}`;
+            protoContent.push(...this.formatComment(serviceComment, 0)); // Top-level comment, no indent
+        }
+        // Add service block containing RPC methods
+        protoContent.push(`service ${this.serviceName} {`);
+        this.indent++;
+        // Sort method names deterministically by alphabetical order
+        const orderedMethodNames = [...allMethodNames].sort();
+        // Add RPC methods in the ordered sequence
+        for (const methodName of orderedMethodNames) {
+            const methodIndex = allMethodNames.indexOf(methodName);
+            if (methodIndex !== -1) {
+                // Handle multi-line RPC definitions that include comments
+                const rpcMethodText = allRpcMethods[methodIndex];
+                if (rpcMethodText.includes('\n')) {
+                    // For multi-line RPC method definitions (with comments), add each line separately
+                    const lines = rpcMethodText.split('\n');
+                    protoContent.push(...lines);
+                }
+                else {
+                    protoContent.push(`${rpcMethodText}`);
+                }
+            }
+        }
+        // Close service definition
+        this.indent--;
+        protoContent.push('}');
+        protoContent.push('');
+        // Add all wrapper messages first since they might be referenced by other messages
+        if (this.nestedListWrappers.size > 0) {
+            // Sort the wrappers by name for deterministic output
+            const sortedWrapperNames = [...this.nestedListWrappers.keys()].sort();
+            for (const wrapperName of sortedWrapperNames) {
+                protoContent.push(this.nestedListWrappers.get(wrapperName));
+            }
+        }
+        // Add all message definitions
+        for (const messageDef of allMessageDefinitions) {
+            protoContent.push(messageDef);
+        }
+        protoContent = this.trimEmptyLines(protoContent);
+        this.protoText = this.trimEmptyLines(this.protoText);
+        if (this.protoText.length > 0) {
+            protoContent.push('');
+        }
+        // Add all processed types from protoText (populated by processMessageQueue)
+        protoContent.push(...this.protoText);
+        // Store the generated lock data for retrieval
+        this.generatedLockData = this.lockManager.getLockData();
+        return protoContent.join('\n');
+    }
     /**
      * Initialize the field numbers map from the lock data to preserve field numbers
      * even when fields are removed and later re-added
@@ -303,102 +368,6 @@ export class GraphQLToProtoTextVisitor {
         }
         return header;
     }
-    /**
-     * Visit the GraphQL schema to generate Proto buffer definition
-     *
-     * @returns The complete Protocol Buffer definition as a string
-     */
-    visit() {
-        // Collect RPC methods and message definitions from all sources
-        const resolverResult = this.collectResolverRpcMethods();
-        const entityResult = this.collectEntityRpcMethods();
-        const queryResult = this.collectQueryRpcMethods();
-        const mutationResult = this.collectMutationRpcMethods();
-        // Combine all RPC methods and message definitions
-        const allRpcMethods = [
-            ...entityResult.rpcMethods,
-            ...queryResult.rpcMethods,
-            ...mutationResult.rpcMethods,
-            ...resolverResult.rpcMethods,
-        ];
-        const allMethodNames = [
-            ...entityResult.methodNames,
-            ...queryResult.methodNames,
-            ...mutationResult.methodNames,
-            ...resolverResult.methodNames,
-        ];
-        const allMessageDefinitions = [
-            ...entityResult.messageDefinitions,
-            ...queryResult.messageDefinitions,
-            ...mutationResult.messageDefinitions,
-            ...resolverResult.messageDefinitions,
-        ];
-        // Add all types from the schema to the queue that weren't already queued
-        this.queueAllSchemaTypes();
-        // Process all complex types from the message queue to determine if wrapper types are needed
-        this.processMessageQueue();
-        // Add wrapper import if needed
-        if (this.usesWrapperTypes) {
-            this.addImport('google/protobuf/wrappers.proto');
-        }
-        // Build the complete proto file
-        let protoContent = [];
-        // Add the header (syntax, package, imports, options)
-        protoContent.push(...this.buildProtoHeader());
-        // Add a service description comment
-        if (this.includeComments) {
-            const serviceComment = `Service definition for ${this.serviceName}`;
-            protoContent.push(...this.formatComment(serviceComment, 0)); // Top-level comment, no indent
-        }
-        // Add service block containing RPC methods
-        protoContent.push(`service ${this.serviceName} {`);
-        this.indent++;
-        // Sort method names deterministically by alphabetical order
-        const orderedMethodNames = [...allMethodNames].sort();
-        // Add RPC methods in the ordered sequence
-        for (const methodName of orderedMethodNames) {
-            const methodIndex = allMethodNames.indexOf(methodName);
-            if (methodIndex !== -1) {
-                // Handle multi-line RPC definitions that include comments
-                const rpcMethodText = allRpcMethods[methodIndex];
-                if (rpcMethodText.includes('\n')) {
-                    // For multi-line RPC method definitions (with comments), add each line separately
-                    const lines = rpcMethodText.split('\n');
-                    protoContent.push(...lines);
-                }
-                else {
-                    // For simple one-line RPC method definitions (ensure 2-space indentation)
-                    protoContent.push(`  ${rpcMethodText}`);
-                }
-            }
-        }
-        // Close service definition
-        this.indent--;
-        protoContent.push('}');
-        protoContent.push('');
-        // Add all wrapper messages first since they might be referenced by other messages
-        if (this.nestedListWrappers.size > 0) {
-            // Sort the wrappers by name for deterministic output
-            const sortedWrapperNames = Array.from(this.nestedListWrappers.keys()).sort();
-            for (const wrapperName of sortedWrapperNames) {
-                protoContent.push(this.nestedListWrappers.get(wrapperName));
-            }
-        }
-        // Add all message definitions
-        for (const messageDef of allMessageDefinitions) {
-            protoContent.push(messageDef);
-        }
-        protoContent = this.trimEmptyLines(protoContent);
-        this.protoText = this.trimEmptyLines(this.protoText);
-        if (this.protoText.length > 0) {
-            protoContent.push('');
-        }
-        // Add all processed types from protoText (populated by processMessageQueue)
-        protoContent.push(...this.protoText);
-        // Store the generated lock data for retrieval
-        this.generatedLockData = this.lockManager.getLockData();
-        return protoContent.join('\n');
-    }
     /**
      * Trim empty lines from the beginning and end of the array
      */
@@ -438,44 +407,49 @@ export class GraphQLToProtoTextVisitor {
                 typeName === ((_c = this.schema.getSubscriptionType()) === null || _c === void 0 ? void 0 : _c.name)) {
                 continue;
             }
-            // Check if this is an entity type (has @key directive)
-            if (isObjectType(type)) {
-                const keyDirectives = this.getKeyDirectives(type);
-                if (keyDirectives.length > 0) {
-                    // Queue this type for message generation (only once)
-                    this.queueTypeForProcessing(type);
-                    // Normalize keys by sorting fields alphabetically and deduplicating
-                    const normalizedKeysSet = new Set();
-                    for (const keyDirective of keyDirectives) {
-                        const keyInfo = this.getKeyInfoFromDirective(keyDirective);
-                        if (!keyInfo)
-                            continue;
-                        const { keyString, resolvable } = keyInfo;
-                        if (!resolvable)
-                            continue;
-                        const normalizedKey = keyString
-                            .split(/[,\s]+/)
-                            .filter((field) => field.length > 0)
-                            .sort()
-                            .join(' ');
-                        normalizedKeysSet.add(normalizedKey);
-                    }
-                    // Process each normalized key
-                    for (const normalizedKeyString of normalizedKeysSet) {
-                        const methodName = createEntityLookupMethodName(typeName, normalizedKeyString);
-                        const requestName = createRequestMessageName(methodName);
-                        const responseName = createResponseMessageName(methodName);
-                        // Add method name and RPC method with description from the entity type
-                        result.methodNames.push(methodName);
-                        const keyFields = normalizedKeyString.split(' ');
-                        const keyDescription = keyFields.length === 1 ? keyFields[0] : keyFields.join(' and ');
-                        const description = `Lookup ${typeName} entity by ${keyDescription}${type.description ? ': ' + type.description : ''}`;
-                        result.rpcMethods.push(this.createRpcMethod(methodName, requestName, responseName, description));
-                        // Create request and response messages for this key combination
-                        result.messageDefinitions.push(...this.createKeyRequestMessage(typeName, requestName, normalizedKeyString, responseName));
-                        result.messageDefinitions.push(...this.createKeyResponseMessage(typeName, responseName, requestName));
-                    }
+            // Skip non-object types
+            if (!isObjectType(type)) {
+                continue;
+            }
+            const keyDirectives = this.getKeyDirectives(type);
+            // Skip types that don't have @key directives
+            if (keyDirectives.length === 0) {
+                continue;
+            }
+            // Queue this type for message generation (only once)
+            this.queueTypeForProcessing(type);
+            // Normalize keys by sorting fields alphabetically and deduplicating
+            const normalizedKeysSet = new Set();
+            for (const keyDirective of keyDirectives) {
+                const keyInfo = this.getKeyInfoFromDirective(keyDirective);
+                if (!keyInfo) {
+                    continue;
+                }
+                const { keyString, resolvable } = keyInfo;
+                if (!resolvable) {
+                    continue;
                 }
+                const normalizedKey = keyString
+                    .split(/[\s,]+/)
+                    .filter((field) => field.length > 0)
+                    .sort()
+                    .join(' ');
+                normalizedKeysSet.add(normalizedKey);
+            }
+            // Process each normalized key
+            for (const normalizedKeyString of normalizedKeysSet) {
+                const methodName = createEntityLookupMethodName(typeName, normalizedKeyString);
+                const requestName = createRequestMessageName(methodName);
+                const responseName = createResponseMessageName(methodName);
+                // Add method name and RPC method with description from the entity type
+                result.methodNames.push(methodName);
+                const keyFields = normalizedKeyString.split(' ');
+                const keyDescription = keyFields.length === 1 ? keyFields[0] : keyFields.join(' and ');
+                const description = `Lookup ${typeName} entity by ${keyDescription}${type.description ? ': ' + type.description : ''}`;
+                result.rpcMethods.push(this.createRpcMethod(methodName, requestName, responseName, description));
+                // Create request and response messages for this key combination
+                result.messageDefinitions.push(...this.createKeyRequestMessage(typeName, requestName, normalizedKeyString, responseName));
+                result.messageDefinitions.push(...this.createKeyResponseMessage(typeName, responseName, requestName));
             }
         }
         return result;
@@ -503,18 +477,21 @@ export class GraphQLToProtoTextVisitor {
         const result = { rpcMethods: [], methodNames: [], messageDefinitions: [] };
         // Get the root operation type (Query or Mutation)
         const rootType = operationType === 'Query' ? this.schema.getQueryType() : this.schema.getMutationType();
-        if (!rootType)
+        if (!rootType) {
             return result;
+        }
         const fields = rootType.getFields();
         // Get field names and order them using the lock manager
         const fieldNames = Object.keys(fields);
         const orderedFieldNames = this.lockManager.reconcileMessageFieldOrder(operationType, fieldNames);
         for (const fieldName of orderedFieldNames) {
             // Skip special fields like _entities
-            if (fieldName === '_entities')
+            if (fieldName === '_entities' || fieldName === '_service') {
                 continue;
-            if (!fields[fieldName])
+            }
+            if (!fields[fieldName]) {
                 continue;
+            }
             const field = fields[fieldName];
             const mappedName = createOperationMethodName(operationType, fieldName);
             const requestName = createRequestMessageName(mappedName);
@@ -557,13 +534,13 @@ export class GraphQLToProtoTextVisitor {
      * @returns The RPC method definition with or without comment
      */
     createRpcMethod(methodName, requestName, responseName, description) {
-        if (!this.includeComments || !description) {
-            return `rpc ${methodName}(${requestName}) returns (${responseName}) {}`;
-        }
-        // RPC method comments should be indented 1 level (2 spaces)
-        const commentLines = this.formatComment(description, 1);
-        const methodLine = `  rpc ${methodName}(${requestName}) returns (${responseName}) {}`;
-        return [...commentLines, methodLine].join('\n');
+        const rpcLines = renderRPCMethod(this.includeComments, {
+            name: methodName,
+            request: requestName,
+            response: responseName,
+            description,
+        });
+        return rpcLines.join('\n');
     }
     /**
      * Creates a request message for entity lookup without adding to protoText
@@ -592,7 +569,7 @@ export class GraphQLToProtoTextVisitor {
         }
         // Add all key fields to the key message
         const protoKeyFields = [];
-        keyFields.forEach((keyField, index) => {
+        for (const [index, keyField] of keyFields.entries()) {
             const protoKeyField = graphqlFieldToProtoField(keyField);
             protoKeyFields.push(protoKeyField);
             // Get the appropriate field number for this key field
@@ -602,7 +579,7 @@ export class GraphQLToProtoTextVisitor {
                 messageLines.push(...this.formatComment(keyFieldComment, 1)); // Field comment, indent 1 level
             }
             messageLines.push(`  string ${protoKeyField} = ${keyFieldNumber};`);
-        });
+        }
         messageLines.push('}');
         messageLines.push('');
         // Ensure the key message is registered in the lock manager data
@@ -717,8 +694,9 @@ Example:
             // Process arguments in the order specified by the lock manager
             for (const argName of orderedArgNames) {
                 const arg = field.args.find((a) => a.name === argName);
-                if (!arg)
+                if (!arg) {
                     continue;
+                }
                 const argType = this.getProtoTypeFromGraphQL(arg.type);
                 const argProtoName = graphqlFieldToProtoField(arg.name);
                 const fieldNumber = this.getFieldNumber(requestName, argProtoName, this.getNextAvailableFieldNumber(requestName));
@@ -801,7 +779,16 @@ Example:
      */
     getKeyDirectives(type) {
         var _a, _b;
-        return ((_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.filter((d) => d.name.value === 'key')) || [];
+        return ((_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.filter((d) => d.name.value === KEY_DIRECTIVE_NAME)) || [];
+    }
+    /**
+     * Checks if a type has a @key directive
+     * @param type - The type to check
+     * @returns True if the type has a @key directive, false otherwise
+     */
+    hasKeyDirective(type) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.some((d) => d.name.value === KEY_DIRECTIVE_NAME)) !== null && _c !== void 0 ? _c : false;
     }
     /**
      * Extract key info from a directive
@@ -835,14 +822,14 @@ Example:
     collectResolverRpcMethods() {
         const typeMap = this.schema.getTypeMap();
         const result = { rpcMethods: [], methodNames: [], messageDefinitions: [] };
-        Object.values(typeMap).forEach((type) => {
+        for (const type of Object.values(typeMap)) {
             if (!isObjectType(type) || this.isOperationType(type)) {
-                return;
+                continue;
             }
             const fields = type.getFields();
-            Object.values(fields).forEach((field) => {
+            for (const field of Object.values(fields)) {
                 if (field.args.length === 0) {
-                    return;
+                    continue;
                 }
                 const methodName = createResolverMethodName(type.name, field.name);
                 const requestName = createRequestMessageName(methodName);
@@ -852,10 +839,38 @@ Example:
                 result.rpcMethods.push(this.createRpcMethod(methodName, requestName, responseName, field.description));
                 result.messageDefinitions.push(...this.createResolverRequestMessage(methodName, requestName, type, field));
                 result.messageDefinitions.push(...this.createResolverResponseMessage(methodName, responseName, field));
-            });
-        });
+            }
+        }
         return result;
     }
+    collectRequiredFieldRpcMethods() {
+        const typeMap = this.schema.getTypeMap();
+        const result = { rpcMethods: [], methodNames: [], messageDefinitions: [] };
+        const entityTypes = Object.values(typeMap).filter((type) => this.isEntityType(type));
+        for (const entity of entityTypes) {
+            const requiredFields = Object.values(entity.getFields()).filter((field) => { var _a, _b; return (_b = (_a = field.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.some((d) => d.name.value === REQUIRES_DIRECTIVE_NAME); });
+            for (const requiredField of requiredFields) {
+                const fieldSet = this.getRequiredFieldSet(requiredField);
+                const visitor = new RequiredFieldsVisitor(this.schema, entity, requiredField, fieldSet);
+                visitor.visit();
+                const rpcMethods = visitor.getRPCMethods();
+                const messageDefinitions = visitor.getMessageDefinitions();
+                result.rpcMethods.push(...rpcMethods.map((m) => renderRPCMethod(this.includeComments, m).join('\n')));
+                result.methodNames.push(...rpcMethods.map((m) => m.name));
+                const messageLines = messageDefinitions.flatMap((m) => buildProtoMessage(this.includeComments, m));
+                result.messageDefinitions.push(...messageLines);
+            }
+        }
+        return result;
+    }
+    getRequiredFieldSet(field) {
+        var _a, _b, _c, _d, _e;
+        const node = (_e = (_d = (_c = (_b = (_a = field.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.find((d) => d.name.value === REQUIRES_DIRECTIVE_NAME)) === null || _c === void 0 ? void 0 : _c.arguments) === null || _d === void 0 ? void 0 : _d.find((arg) => arg.name.value === 'fields')) === null || _e === void 0 ? void 0 : _e.value;
+        if (!node) {
+            throw new Error(`Required field set not found for field ${field.name}`);
+        }
+        return node.value;
+    }
     getFieldContext(parent, field) {
         var _a, _b;
         const resolvedDirective = this.findResolverDirective(field);
@@ -868,15 +883,18 @@ Example:
         }
         const idFields = this.getIDFields(parent, field.name);
         switch (idFields.length) {
-            case 0:
+            case 0: {
                 return { context: '', error: 'No fields with type ID found' };
-            case 1:
+            }
+            case 1: {
                 return { context: idFields[0].name, error: undefined };
-            default:
+            }
+            default: {
                 return {
                     context: '',
                     error: `Multiple fields with type ID found - provide a context with the fields you want to use in the @${CONNECT_FIELD_RESOLVER} directive`,
                 };
+            }
         }
     }
     getIDFields(type, currentFieldName) {
@@ -950,7 +968,7 @@ Example:
             })),
         }));
         // filter the fields in the parent type that are in the context
-        const searchFields = context.split(/[,\s]+/).filter((field) => field.length > 0);
+        const searchFields = context.split(/[\s,]+/).filter((field) => field.length > 0);
         const fieldFilter = Object.values(parent.getFields()).filter((field) => searchFields.includes(field.name));
         if (searchFields.length !== fieldFilter.length) {
             throw new Error(`Invalid field context for resolver. Could not find all fields in the parent type: ${context}`);
@@ -966,7 +984,7 @@ Example:
             })),
         }));
         fieldNumber = 0;
-        let keyMessageFields = [];
+        const keyMessageFields = [];
         // add the context message to the key message
         keyMessageFields.push({
             fieldName: CONTEXT,
@@ -1047,6 +1065,14 @@ Example:
         }
         return type.name === 'Query' || type.name === 'Mutation' || type.name === 'Subscription';
     }
+    /**
+     * Checks if a type is an entity type
+     * @param type - The type to check
+     * @returns True if the type is an entity type, false otherwise
+     */
+    isEntityType(type) {
+        return isObjectType(type) && !this.isOperationType(type) && this.hasKeyDirective(type);
+    }
     /**
      * Queue all types from the schema that need processing
      */
@@ -1125,12 +1151,19 @@ Example:
             this.processedTypes.add(type.name);
             return;
         }
-        const fieldsWithoutArguments = Object.values(type.getFields()).filter((field) => field.args.length === 0);
+        const allFields = Object.values(type.getFields());
+        // Filter out fields that have arguments as those are handled in separate resolver rpcs
+        const validFields = allFields
+            .filter((field) => field.args.length === 0)
+            .filter((field) => {
+            var _a, _b;
+            return !((_b = (_a = field.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.some((directive) => directive.name.value === EXTERNAL_DIRECTIVE_NAME || directive.name.value === REQUIRES_DIRECTIVE_NAME));
+        });
         // Check for field removals if lock data exists for this type
         const lockData = this.lockManager.getLockData();
         if (lockData.messages[type.name]) {
             const originalFieldNames = Object.keys(lockData.messages[type.name].fields);
-            const currentFieldNames = fieldsWithoutArguments.map((field) => field.name);
+            const currentFieldNames = validFields.map((field) => field.name);
             this.trackRemovedFields(type.name, originalFieldNames, currentFieldNames);
         }
         this.protoText.push('');
@@ -1147,11 +1180,12 @@ Example:
         }
         const fields = type.getFields();
         // Get field names and order them using the lock manager
-        const fieldNames = Object.keys(fields);
+        const fieldNames = Object.keys(fields).filter((fieldName) => validFields.some((field) => field.name === fieldName));
         const orderedFieldNames = this.lockManager.reconcileMessageFieldOrder(type.name, fieldNames);
         for (const fieldName of orderedFieldNames) {
-            if (!fields[fieldName])
+            if (!fields[fieldName]) {
                 continue;
+            }
             // ignore fields with arguments as those are handled in separate resolver rpcs
             const field = fields[fieldName];
             if (field.args.length > 0) {
@@ -1268,8 +1302,9 @@ Example:
         const fieldNames = Object.keys(fields);
         const orderedFieldNames = this.lockManager.reconcileMessageFieldOrder(type.name, fieldNames);
         for (const fieldName of orderedFieldNames) {
-            if (!fields[fieldName])
+            if (!fields[fieldName]) {
                 continue;
+            }
             const field = fields[fieldName];
             const fieldType = this.getProtoTypeFromGraphQL(field.type);
             const protoFieldName = graphqlFieldToProtoField(fieldName);
@@ -1315,7 +1350,7 @@ Example:
         // Mark the interface as processed to avoid infinite recursion
         this.processedTypes.add(type.name);
         const implementingTypes = Object.values(this.schema.getTypeMap())
-            .filter(isObjectType)
+            .filter((t) => isObjectType(t))
             .filter((t) => t.getInterfaces().some((i) => i.name === type.name));
         if (implementingTypes.length === 0) {
             // No implementing types, just create a regular message
@@ -1335,11 +1370,11 @@ Example:
         // Use lock manager to order implementing types
         const typeNames = implementingTypes.map((t) => t.name);
         const orderedTypeNames = this.lockManager.reconcileMessageFieldOrder(`${type.name}Implementations`, typeNames);
-        for (let i = 0; i < orderedTypeNames.length; i++) {
-            const typeName = orderedTypeNames[i];
+        for (const [i, typeName] of orderedTypeNames.entries()) {
             const implType = implementingTypes.find((t) => t.name === typeName);
-            if (!implType)
+            if (!implType) {
                 continue;
+            }
             // Add implementing type description as comment if available
             if (implType.description) {
                 this.protoText.push(...this.formatComment(implType.description, 1)); // Field comment, indent 1 level
@@ -1383,11 +1418,11 @@ Example:
         const types = type.getTypes();
         const typeNames = types.map((t) => t.name);
         const orderedTypeNames = this.lockManager.reconcileMessageFieldOrder(`${type.name}Members`, typeNames);
-        for (let i = 0; i < orderedTypeNames.length; i++) {
-            const typeName = orderedTypeNames[i];
+        for (const [i, typeName] of orderedTypeNames.entries()) {
             const memberType = types.find((t) => t.name === typeName);
-            if (!memberType)
+            if (!memberType) {
                 continue;
+            }
             // Add member type description as comment if available
             if (memberType.description) {
                 this.protoText.push(...this.formatComment(memberType.description, 1)); // Field comment, indent 1 level
@@ -1412,7 +1447,6 @@ Example:
      * @param type - The GraphQL enum type
      */
     processEnumType(type) {
-        var _a, _b;
         // Check for enum value removals if lock data exists for this enum
         const lockData = this.lockManager.getLockData();
         if (lockData.enums[type.name]) {
@@ -1435,33 +1469,36 @@ Example:
         // Add unspecified value as first enum value (required in proto3)
         const unspecifiedValue = createEnumUnspecifiedValue(type.name);
         this.protoText.push(`  ${unspecifiedValue} = 0;`);
-        // Use lock manager to order enum values
+        // Use lock manager to order enum values, filtering out any value whose proto name
+        // collides with the auto-generated UNSPECIFIED value (already emitted at position 0)
         const values = type.getValues();
-        const valueNames = values.map((v) => v.name);
+        const valueNames = values
+            .filter((v) => graphqlEnumValueToProtoEnumValue(type.name, v.name) !== unspecifiedValue)
+            .map((v) => v.name);
         const orderedValueNames = this.lockManager.reconcileEnumValueOrder(type.name, valueNames);
         for (const valueName of orderedValueNames) {
             const value = values.find((v) => v.name === valueName);
-            if (!value)
+            if (!value) {
                 continue;
+            }
             const protoEnumValue = graphqlEnumValueToProtoEnumValue(type.name, value.name);
             const deprecationInfo = this.enumValueIsDeprecated(value);
             // Add enum value description as comment
             if (value.description) {
                 this.protoText.push(...this.formatComment(value.description, 1)); // Field comment, indent 1 level
             }
-            if (deprecationInfo.deprecated && ((_b = (_a = deprecationInfo.reason) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
+            if (deprecationInfo.deprecated && deprecationInfo.reason && deprecationInfo.reason.length > 0) {
                 this.protoText.push(...this.formatComment(`Deprecation notice: ${deprecationInfo.reason}`, 1));
             }
             // Get value number from lock data
-            const lockData = this.lockManager.getLockData();
             let valueNumber = 0;
             if (lockData.enums[type.name] && lockData.enums[type.name].fields[value.name]) {
                 valueNumber = lockData.enums[type.name].fields[value.name];
             }
             else {
-                // This should never happen since we just reconciled, but just in case
-                console.warn(`Missing enum value number for ${type.name}.${value.name}`);
-                continue;
+                // Indicates a bug in lock reconciliation; fail fast rather than silently
+                // producing a proto enum value with number 0, which would collide with UNSPECIFIED.
+                throw new Error(`Missing enum value number for ${type.name}.${value.name}`);
             }
             const fieldOptions = [];
             if (deprecationInfo.deprecated) {
@@ -1484,142 +1521,23 @@ Example:
      * @returns The corresponding Protocol Buffer type name
      */
     getProtoTypeFromGraphQL(graphqlType, ignoreWrapperTypes = false) {
-        // Nullable lists need to be handled first, otherwise they will be treated as scalar types
-        if (isListType(graphqlType) || (isNonNullType(graphqlType) && isListType(graphqlType.ofType))) {
-            return this.handleListType(graphqlType);
-        }
-        // For nullable scalar types, use wrapper types
-        if (isScalarType(graphqlType)) {
-            if (ignoreWrapperTypes) {
-                return { typeName: SCALAR_TYPE_MAP[graphqlType.name] || 'string', isRepeated: false };
-            }
-            this.usesWrapperTypes = true; // Track that we're using wrapper types
-            return {
-                typeName: SCALAR_WRAPPER_TYPE_MAP[graphqlType.name] || 'google.protobuf.StringValue',
-                isRepeated: false,
-            };
-        }
-        if (isEnumType(graphqlType)) {
-            return { typeName: graphqlType.name, isRepeated: false };
-        }
-        if (isNonNullType(graphqlType)) {
-            // For non-null scalar types, use the base type
-            if (isScalarType(graphqlType.ofType)) {
-                return { typeName: SCALAR_TYPE_MAP[graphqlType.ofType.name] || 'string', isRepeated: false };
+        const protoFieldType = getProtoTypeFromGraphQL(this.includeComments, graphqlType, ignoreWrapperTypes);
+        if (!ignoreWrapperTypes && protoFieldType.isWrapper) {
+            this.usesWrapperTypes = true;
+        }
+        const listWrapper = protoFieldType.listWrapper;
+        if (listWrapper) {
+            for (let i = 1; i <= listWrapper.nestingLevel; i++) {
+                const wrapperName = listNameByNestingLevel(i, listWrapper.baseType);
+                if (this.processedTypes.has(wrapperName) || this.nestedListWrappers.has(wrapperName)) {
+                    continue;
+                }
+                const wrapperMessage = createNestedListWrapper(this.includeComments, i, listWrapper.baseType);
+                this.nestedListWrappers.set(wrapperName, wrapperMessage);
+                this.processedTypes.add(wrapperName);
             }
-            return this.getProtoTypeFromGraphQL(graphqlType.ofType);
-        }
-        // Named types (object, interface, union, input)
-        const namedType = graphqlType;
-        if (namedType && typeof namedType.name === 'string') {
-            return { typeName: namedType.name, isRepeated: false };
-        }
-        return { typeName: 'string', isRepeated: false }; // Default fallback
-    }
-    /**
-     * Converts GraphQL list types to appropriate Protocol Buffer representations.
-     *
-     * For non-nullable, single-level lists (e.g., [String!]!), generates simple repeated fields.
-     * For nullable lists (e.g., [String]) or nested lists (e.g., [[String]]), creates wrapper
-     * messages to properly handle nullability in proto3.
-     *
-     * Examples:
-     * - [String!]! → repeated string field_name = 1;
-     * - [String] → ListOfString field_name = 1; (with wrapper message)
-     * - [[String!]!]! → ListOfListOfString field_name = 1; (with nested wrapper messages)
-     * - [[String]] → ListOfListOfString field_name = 1; (with nested wrapper messages)
-     *
-     * @param graphqlType - The GraphQL list type to convert
-     * @returns ProtoType object containing the type name and whether it should be repeated
-     */
-    handleListType(graphqlType) {
-        const listType = unwrapNonNullType(graphqlType);
-        const isNullableList = !isNonNullType(graphqlType);
-        const isNested = isNestedListType(listType);
-        // Simple non-nullable lists can use repeated fields directly
-        if (!isNullableList && !isNested) {
-            return { ...this.getProtoTypeFromGraphQL(getNamedType(listType), true), isRepeated: true };
-        }
-        // Nullable or nested lists need wrapper messages
-        const baseType = getNamedType(listType);
-        const nestingLevel = calculateNestingLevel(listType);
-        // For nested lists, always use full nesting level to preserve inner list nullability
-        // For single-level nullable lists, use nesting level 1
-        const wrapperNestingLevel = isNested ? nestingLevel : 1;
-        // Generate all required wrapper messages
-        let wrapperName = '';
-        for (let i = 1; i <= wrapperNestingLevel; i++) {
-            wrapperName = this.createNestedListWrapper(i, baseType);
-        }
-        // For nested lists, never use repeated at field level to preserve nullability
-        return { typeName: wrapperName, isRepeated: false };
-    }
-    /**
-     * Creates wrapper messages for nullable or nested GraphQL lists.
-     *
-     * Generates Protocol Buffer message definitions to handle list nullability and nesting.
-     * The wrapper messages are stored and later included in the final proto output.
-     *
-     * For level 1: Creates simple wrapper like:
-     *   message ListOfString {
-     *     repeated string items = 1;
-     *   }
-     *
-     * For level > 1: Creates nested wrapper structures like:
-     *   message ListOfListOfString {
-     *     message List {
-     *       repeated ListOfString items = 1;
-     *     }
-     *     List list = 1;
-     *   }
-     *
-     * @param level - The nesting level (1 for simple wrapper, >1 for nested structures)
-     * @param baseType - The GraphQL base type being wrapped (e.g., String, User, etc.)
-     * @returns The generated wrapper message name (e.g., "ListOfString", "ListOfListOfUser")
-     */
-    createNestedListWrapper(level, baseType) {
-        const wrapperName = `${'ListOf'.repeat(level)}${baseType.name}`;
-        // Return existing wrapper if already created
-        if (this.processedTypes.has(wrapperName) || this.nestedListWrappers.has(wrapperName)) {
-            return wrapperName;
-        }
-        this.processedTypes.add(wrapperName);
-        const messageLines = this.buildWrapperMessage(wrapperName, level, baseType);
-        this.nestedListWrappers.set(wrapperName, messageLines.join('\n'));
-        return wrapperName;
-    }
-    /**
-     * Builds the message lines for a wrapper message
-     */
-    buildWrapperMessage(wrapperName, level, baseType) {
-        const lines = [];
-        // Add comment if enabled
-        if (this.includeComments) {
-            lines.push(...this.formatComment(`Wrapper message for a list of ${baseType.name}.`, 0));
-        }
-        const formatIndent = (indent, content) => {
-            return '  '.repeat(indent) + content;
-        };
-        lines.push(`message ${wrapperName} {`);
-        let innerWrapperName = '';
-        if (level > 1) {
-            innerWrapperName = `${'ListOf'.repeat(level - 1)}${baseType.name}`;
-        }
-        else {
-            innerWrapperName = this.getProtoTypeFromGraphQL(baseType, true).typeName;
         }
-        lines.push(formatIndent(1, `message List {`), formatIndent(2, `repeated ${innerWrapperName} items = 1;`), formatIndent(1, `}`), formatIndent(1, `List list = 1;`), formatIndent(0, `}`));
-        return lines;
-    }
-    /**
-     * Get indentation based on the current level
-     *
-     * Helper method to maintain consistent indentation in the output.
-     *
-     * @returns String with spaces for the current indentation level
-     */
-    getIndent() {
-        return '  '.repeat(this.indent);
+        return protoFieldType;
     }
     /**
      * Get the generated lock data after visiting
@@ -1639,8 +1557,9 @@ Example:
      * @returns A formatted string for the reserved statement
      */
     formatReservedNumbers(numbers) {
-        if (numbers.length === 0)
+        if (numbers.length === 0) {
             return '';
+        }
         // Sort numbers for better readability
         const sortedNumbers = [...numbers].sort((a, b) => a - b);
         // Simple case: only one number
@@ -1668,12 +1587,7 @@ Example:
         // Format the ranges
         return ranges
             .map(([start, end]) => {
-            if (start === end) {
-                return start.toString();
-            }
-            else {
-                return `${start} to ${end}`;
-            }
+            return start === end ? start.toString() : `${start} to ${end}`;
         })
             .join(', ');
     }
@@ -1684,18 +1598,7 @@ Example:
      * @returns Array of comment lines with proper indentation
      */
     formatComment(description, indentLevel = 0) {
-        if (!this.includeComments || !description) {
-            return [];
-        }
-        // Use 2-space indentation consistently
-        const indent = '  '.repeat(indentLevel);
-        const lines = description.trim().split('\n');
-        if (lines.length === 1) {
-            return [`${indent}// ${lines[0]}`];
-        }
-        else {
-            return [`${indent}/*`, ...lines.map((line) => `${indent} * ${line}`), `${indent} */`];
-        }
+        return formatComment(this.includeComments, description, indentLevel);
     }
     /**
      * Builds a message definition from a ProtoMessage object
@@ -1703,29 +1606,7 @@ Example:
      * @returns The message definition
      */
     buildMessage(message) {
-        const messageLines = this.formatComment(message.description, 0);
-        messageLines.push(`message ${message.messageName} {`);
-        if (message.reservedNumbers && message.reservedNumbers.length > 0) {
-            messageLines.push(this.formatIndent(1, `reserved ${message.reservedNumbers};`));
-        }
-        message.fields.forEach((field) => {
-            if (field.description) {
-                messageLines.push(...this.formatComment(field.description, 1));
-            }
-            let repeated = field.isRepeated ? 'repeated ' : '';
-            messageLines.push(this.formatIndent(1, `${repeated}${field.typeName} ${field.fieldName} = ${field.fieldNumber};`));
-        });
-        messageLines.push('}', '');
-        return messageLines;
-    }
-    /**
-     * Formats the indent for the content
-     * @param indent - The indent level
-     * @param content - The content to format
-     * @returns The formatted content
-     */
-    formatIndent(indent, content) {
-        return '  '.repeat(indent) + content;
+        return buildProtoMessage(this.includeComments, message);
     }
 }
 //# sourceMappingURL=sdl-to-proto-visitor.js.map