prettier

Author: asoorm

protographic/src/index.ts

@@ -100,19 +100,35 @@ export { compileOperationsToProto } from './operation-to-proto.js';
 export type { OperationsToProtoOptions, CompileOperationsToProtoResult } from './operation-to-proto.js';
 
 // Export operation modules
-export { mapGraphQLTypeToProto, getProtoTypeName, isGraphQLScalarType, requiresWrapperType, getRequiredImports } from './operations/type-mapper.js';
+export {
+  mapGraphQLTypeToProto,
+  getProtoTypeName,
+  isGraphQLScalarType,
+  requiresWrapperType,
+  getRequiredImports,
+} from './operations/type-mapper.js';
 export type { ProtoTypeInfo, TypeMapperOptions } from './operations/type-mapper.js';
 
 export { createFieldNumberManager } from './operations/field-numbering.js';
 export type { FieldNumberManager } from './operations/field-numbering.js';
 
-export { buildMessageFromSelectionSet, buildFieldDefinition, buildNestedMessage } from './operations/message-builder.js';
+export {
+  buildMessageFromSelectionSet,
+  buildFieldDefinition,
+  buildNestedMessage,
+} from './operations/message-builder.js';
 export type { MessageBuilderOptions } from './operations/message-builder.js';
 
 export { buildRequestMessage, buildInputObjectMessage, buildEnumType } from './operations/request-builder.js';
 export type { RequestBuilderOptions } from './operations/request-builder.js';
 
-export { rootToProtoText, serviceToProtoText, messageToProtoText, enumToProtoText, formatField } from './operations/proto-text-generator.js';
+export {
+  rootToProtoText,
+  serviceToProtoText,
+  messageToProtoText,
+  enumToProtoText,
+  formatField,
+} from './operations/proto-text-generator.js';
 export type { ProtoTextOptions } from './operations/proto-text-generator.js';
 
 export type { GraphQLToProtoTextVisitorOptions } from './sdl-to-proto-visitor.js';

protographic/src/operation-to-proto.ts

@@ -79,7 +79,7 @@ export function compileOperationsToProto(
   const root = visitor.visit();
 
   const proto = visitor.toProtoText(root);
-  
+
   // Get the updated lock data for field number stability
   const lockData = visitor.getLockData();
 
@@ -107,7 +107,7 @@ class OperationsToProtoVisitor {
 
   // Lock manager for field number stability
   private readonly lockManager: ProtoLockManager;
-  
+
   // Field number manager
   private readonly fieldNumberManager;
 
@@ -125,12 +125,12 @@ class OperationsToProtoVisitor {
 
     // Initialize lock manager with previous lock data if provided
     this.lockManager = new ProtoLockManager(options?.lockData);
-    
+
     // Create field number manager with lock manager integration
     this.fieldNumberManager = createFieldNumberManager(this.lockManager);
 
     this.root = new protobuf.Root();
-    
+
     // Collect all fragment definitions from the document
     this.collectFragments();
   }
@@ -203,20 +203,14 @@ class OperationsToProtoVisitor {
     const responseMessageName = createResponseMessageName(methodName);
     if (node.selectionSet) {
       const rootType = this.getRootType(node.operation);
-      const responseMessage = buildMessageFromSelectionSet(
-        responseMessageName,
-        node.selectionSet,
-        rootType,
-        typeInfo,
-        {
-          includeComments: this.includeComments,
-          root: this.root,
-          fieldNumberManager: this.fieldNumberManager,
-          fragments: this.fragments,
-          schema: this.schema,
-          createdEnums: this.createdEnums,
-        },
-      );
+      const responseMessage = buildMessageFromSelectionSet(responseMessageName, node.selectionSet, rootType, typeInfo, {
+        includeComments: this.includeComments,
+        root: this.root,
+        fieldNumberManager: this.fieldNumberManager,
+        fragments: this.fragments,
+        schema: this.schema,
+        createdEnums: this.createdEnums,
+      });
 
       // Add response message to root
       if (!this.createdMessages.has(responseMessageName)) {
@@ -300,7 +294,7 @@ class OperationsToProtoVisitor {
    */
   private processEnumType(enumType: GraphQLEnumType): void {
     const typeName = enumType.name;
-    
+
     if (!this.createdEnums.has(typeName)) {
       const protoEnum = buildEnumType(enumType, {
         includeComments: this.includeComments,
@@ -323,7 +317,7 @@ class OperationsToProtoVisitor {
         return this.schema.getSubscriptionType()!;
     }
   }
-  
+
   /**
    * Get the current lock data for field number stability
    */

protographic/src/operations/field-numbering.ts

@@ -18,49 +18,49 @@ export interface FieldNumberManager {
    * @returns The next available field number
    */
   getNextFieldNumber(messageName: string): number;
-  
+
   /**
    * Assigns a specific field number to a field in a message
    * @param messageName - The name of the message
    * @param fieldName - The name of the field
    * @param fieldNumber - The field number to assign
    */
   assignFieldNumber(messageName: string, fieldName: string, fieldNumber: number): void;
-  
+
   /**
    * Gets the field number for a specific field if it exists
    * @param messageName - The name of the message
    * @param fieldName - The name of the field
    * @returns The field number or undefined if not assigned
    */
   getFieldNumber(messageName: string, fieldName: string): number | undefined;
-  
+
   /**
    * Resets field numbering for a specific message
    * @param messageName - The name of the message to reset
    */
   resetMessage(messageName: string): void;
-  
+
   /**
    * Resets all field numbering
    */
   resetAll(): void;
-  
+
   /**
    * Gets all field mappings for a message
    * @param messageName - The name of the message
    * @returns Record of field names to field numbers
    */
   getMessageFields(messageName: string): Record<string, number>;
-  
+
   /**
    * Reconciles field order for a message using lock data
    * @param messageName - The name of the message
    * @param fieldNames - The field names to reconcile
    * @returns Ordered array of field names
    */
   reconcileFieldOrder(messageName: string, fieldNames: string[]): string[];
-  
+
   /**
    * Gets the lock manager if available
    */
@@ -76,115 +76,115 @@ export interface FieldNumberManager {
 export function createFieldNumberManager(lockManager?: ProtoLockManager): FieldNumberManager {
   // Map of message name to field name to field number
   const fieldNumbers = new Map<string, Map<string, number>>();
-  
+
   // Map of message name to the next available field number
   const nextFieldNumbers = new Map<string, number>();
-  
+
   return {
     getNextFieldNumber(messageName: string): number {
       // 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: string, fieldName: string, fieldNumber: number): void {
       // 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: string, fieldName: string): number | undefined {
       return fieldNumbers.get(messageName)?.get(fieldName);
     },
-    
+
     resetMessage(messageName: string): void {
       fieldNumbers.delete(messageName);
       nextFieldNumbers.set(messageName, 1);
     },
-    
+
     resetAll(): void {
       fieldNumbers.clear();
       nextFieldNumbers.clear();
     },
-    
+
     getMessageFields(messageName: string): Record<string, number> {
       const messageFields = fieldNumbers.get(messageName);
       if (!messageFields) {
         return {};
       }
-      
+
       const result: Record<string, number> = {};
       for (const [fieldName, fieldNumber] of messageFields.entries()) {
         result[fieldName] = fieldNumber;
       }
       return result;
     },
-    
+
     reconcileFieldOrder(messageName: string, fieldNames: string[]): string[] {
       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) {
@@ -193,13 +193,12 @@ export function createFieldNumberManager(lockManager?: ProtoLockManager): FieldN
           }
         }
       }
-      
+
       return orderedFields;
     },
-    
+
     getLockManager(): ProtoLockManager | undefined {
       return lockManager;
     },
   };
 }
-