style: fix code formatting with prettier

Co-authored-by: streamich <[email protected]>

Author: Copilot

src/avro/AvroEncoder.ts

@@ -121,20 +121,20 @@ export class AvroEncoder implements BinaryJsonEncoder {
     const writer = this.writer;
     const maxSize = str.length * 4; // Max UTF-8 bytes for string
     writer.ensureCapacity(5 + maxSize); // 5 bytes max for varint length
-    
+
     // Reserve space for length (we'll come back to fill this)
     const lengthOffset = writer.x;
     writer.x += 5; // Max varint size
-    
+
     // Write the string and get actual byte count
     const bytesWritten = writer.utf8(str);
     const endPos = writer.x;
-    
+
     // Go back to encode the actual length
     writer.x = lengthOffset;
     this.writeVarIntUnsigned(bytesWritten);
     const actualLengthSize = writer.x - lengthOffset;
-    
+
     // If we reserved more space than needed, shift the string data
     if (actualLengthSize < 5) {
       const stringStart = lengthOffset + 5;
@@ -266,7 +266,7 @@ export class AvroEncoder implements BinaryJsonEncoder {
     let n = value;
     const mask = BigInt(0x7f);
     const shift = BigInt(7);
-    
+
     while (n >= BigInt(0x80)) {
       writer.u8(Number((n & mask) | BigInt(0x80)));
       n >>= shift;
@@ -287,4 +287,4 @@ export class AvroEncoder implements BinaryJsonEncoder {
   private encodeZigZag64(value: bigint): bigint {
     return (value << BigInt(1)) ^ (value >> BigInt(63));
   }
-}
+}

src/avro/AvroSchemaEncoder.ts

@@ -34,25 +34,25 @@ export class AvroSchemaEncoder {
   public encode(value: unknown, schema: AvroSchema, selectedIndex?: number): Uint8Array {
     this.writer.reset();
     this.namedSchemas.clear();
-    
+
     // Validate schema first
     if (!this.validator.validateSchema(schema)) {
       throw new Error('Invalid Avro schema');
     }
-    
+
     // Validate value against schema
     if (!this.validator.validateValue(value, schema)) {
       throw new Error('Value does not conform to schema');
     }
-    
+
     this.collectNamedSchemas(schema);
-    
+
     if (Array.isArray(schema) && selectedIndex !== undefined) {
       this.writeUnion(value, schema, selectedIndex);
     } else {
       this.writeValue(value, schema);
     }
-    
+
     return this.writer.flush();
   }
 
@@ -130,7 +130,7 @@ export class AvroSchemaEncoder {
     if (typeof schema === 'object' && schema.type !== 'record') {
       throw new Error('Schema is not a record schema');
     }
-    
+
     const recordSchema = this.resolveSchema(schema) as AvroRecordSchema;
     if (recordSchema.type !== 'record') {
       throw new Error('Schema is not a record schema');
@@ -156,7 +156,7 @@ export class AvroSchemaEncoder {
     if (typeof schema === 'object' && schema.type !== 'enum') {
       throw new Error('Schema is not an enum schema');
     }
-    
+
     const enumSchema = this.resolveSchema(schema) as AvroEnumSchema;
     if (enumSchema.type !== 'enum') {
       throw new Error('Schema is not an enum schema');
@@ -166,7 +166,7 @@ export class AvroSchemaEncoder {
     if (index === -1) {
       throw new Error(`Invalid enum value: ${value}`);
     }
-    
+
     this.writeVarIntSigned(this.encodeZigZag32(index));
   }
 
@@ -177,21 +177,21 @@ export class AvroSchemaEncoder {
     if (typeof schema === 'object' && schema.type !== 'array') {
       throw new Error('Schema is not an array schema');
     }
-    
+
     const arraySchema = this.resolveSchema(schema) as AvroArraySchema;
     if (arraySchema.type !== 'array') {
       throw new Error('Schema is not an array schema');
     }
 
     // Write array length
     this.writeVarIntUnsigned(value.length);
-    
+
     // Write array items
     const length = value.length;
     for (let i = 0; i < length; i++) {
       this.writeValue(value[i], arraySchema.items);
     }
-    
+
     // Write end-of-array marker
     this.writeVarIntUnsigned(0);
   }
@@ -203,25 +203,25 @@ export class AvroSchemaEncoder {
     if (typeof schema === 'object' && schema.type !== 'map') {
       throw new Error('Schema is not a map schema');
     }
-    
+
     const mapSchema = this.resolveSchema(schema) as AvroMapSchema;
     if (mapSchema.type !== 'map') {
       throw new Error('Schema is not a map schema');
     }
 
     const entries = Object.entries(value);
-    
+
     // Write map length
     this.writeVarIntUnsigned(entries.length);
-    
+
     // Write map entries
     const length = entries.length;
     for (let i = 0; i < length; i++) {
       const entry = entries[i];
       this.encoder.writeStr(entry[0]);
       this.writeValue(entry[1], mapSchema.values);
     }
-    
+
     // Write end-of-map marker
     this.writeVarIntUnsigned(0);
   }
@@ -237,7 +237,7 @@ export class AvroSchemaEncoder {
     let index = selectedIndex;
     if (index === undefined) {
       // Find the first matching schema in the union
-      index = schema.findIndex(subSchema => this.validator.validateValue(value, subSchema));
+      index = schema.findIndex((subSchema) => this.validator.validateValue(value, subSchema));
       if (index === -1) {
         throw new Error('Value does not match any schema in the union');
       }
@@ -249,7 +249,7 @@ export class AvroSchemaEncoder {
 
     // Write union index
     this.writeVarIntSigned(this.encodeZigZag32(index));
-    
+
     // Write the value according to the selected schema
     this.writeValue(value, schema[index]);
   }
@@ -261,7 +261,7 @@ export class AvroSchemaEncoder {
     if (typeof schema === 'object' && schema.type !== 'fixed') {
       throw new Error('Schema is not a fixed schema');
     }
-    
+
     const fixedSchema = this.resolveSchema(schema) as AvroFixedSchema;
     if (fixedSchema.type !== 'fixed') {
       throw new Error('Schema is not a fixed schema');
@@ -270,7 +270,7 @@ export class AvroSchemaEncoder {
     if (value.length !== fixedSchema.size) {
       throw new Error(`Fixed value length ${value.length} does not match schema size ${fixedSchema.size}`);
     }
-    
+
     this.writer.buf(value, value.length);
   }
 
@@ -279,12 +279,13 @@ export class AvroSchemaEncoder {
    */
   public writeNumber(value: number, schema: AvroSchema): void {
     const resolvedSchema = this.resolveSchema(schema);
-    const schemaType = typeof resolvedSchema === 'string' 
-      ? resolvedSchema 
-      : Array.isArray(resolvedSchema) 
-        ? 'union' 
-        : resolvedSchema.type;
-    
+    const schemaType =
+      typeof resolvedSchema === 'string'
+        ? resolvedSchema
+        : Array.isArray(resolvedSchema)
+          ? 'union'
+          : resolvedSchema.type;
+
     switch (schemaType) {
       case 'int':
         this.writeInt(value, schema);
@@ -369,12 +370,13 @@ export class AvroSchemaEncoder {
 
   private validateSchemaType(schema: AvroSchema, expectedType: string): void {
     const resolvedSchema = this.resolveSchema(schema);
-    const actualType = typeof resolvedSchema === 'string' 
-      ? resolvedSchema 
-      : Array.isArray(resolvedSchema) 
-        ? 'union' 
-        : resolvedSchema.type;
-    
+    const actualType =
+      typeof resolvedSchema === 'string'
+        ? resolvedSchema
+        : Array.isArray(resolvedSchema)
+          ? 'union'
+          : resolvedSchema.type;
+
     if (actualType !== expectedType) {
       throw new Error(`Expected schema type ${expectedType}, got ${actualType}`);
     }
@@ -399,7 +401,7 @@ export class AvroSchemaEncoder {
           const recordSchema = schema as AvroRecordSchema;
           const recordFullName = this.getFullName(recordSchema.name, recordSchema.namespace);
           this.namedSchemas.set(recordFullName, recordSchema);
-          recordSchema.fields.forEach(field => this.collectNamedSchemas(field.type));
+          recordSchema.fields.forEach((field) => this.collectNamedSchemas(field.type));
           break;
         case 'enum':
           const enumSchema = schema as AvroEnumSchema;
@@ -457,4 +459,4 @@ export class AvroSchemaEncoder {
   private encodeZigZag32(value: number): number {
     return (value << 1) ^ (value >> 31);
   }
-}
+}

src/avro/AvroSchemaValidator.ts

@@ -97,16 +97,16 @@ export class AvroSchemaValidator {
   private validateUnionSchema(schema: AvroUnionSchema): boolean {
     if (schema.length === 0) return false;
     const typeSet = new Set<string>();
-    
+
     for (const subSchema of schema) {
       if (!this.validateSchemaInternal(subSchema)) return false;
-      
+
       // Union types must be unique
       const typeName = this.getSchemaTypeName(subSchema);
       if (typeSet.has(typeName)) return false;
       typeSet.add(typeName);
     }
-    
+
     return true;
   }
 
@@ -144,7 +144,7 @@ export class AvroSchemaValidator {
 
   private validateRecordSchema(schema: AvroRecordSchema): boolean {
     if (schema.type !== 'record' || !schema.name || !Array.isArray(schema.fields)) return false;
-    
+
     const fullName = this.getFullName(schema.name, schema.namespace);
     if (this.namedSchemas.has(fullName)) return false;
     this.namedSchemas.set(fullName, schema);
@@ -160,16 +160,12 @@ export class AvroSchemaValidator {
   }
 
   private validateRecordField(field: AvroRecordField): boolean {
-    return (
-      typeof field.name === 'string' &&
-      field.name.length > 0 &&
-      this.validateSchemaInternal(field.type)
-    );
+    return typeof field.name === 'string' && field.name.length > 0 && this.validateSchemaInternal(field.type);
   }
 
   private validateEnumSchema(schema: AvroEnumSchema): boolean {
     if (schema.type !== 'enum' || !schema.name || !Array.isArray(schema.symbols)) return false;
-    
+
     const fullName = this.getFullName(schema.name, schema.namespace);
     if (this.namedSchemas.has(fullName)) return false;
     this.namedSchemas.set(fullName, schema);
@@ -198,7 +194,7 @@ export class AvroSchemaValidator {
   private validateFixedSchema(schema: AvroFixedSchema): boolean {
     if (schema.type !== 'fixed' || !schema.name || typeof schema.size !== 'number') return false;
     if (schema.size < 0) return false;
-    
+
     const fullName = this.getFullName(schema.name, schema.namespace);
     if (this.namedSchemas.has(fullName)) return false;
     this.namedSchemas.set(fullName, schema);
@@ -213,7 +209,7 @@ export class AvroSchemaValidator {
 
     if (Array.isArray(schema)) {
       // Union - value must match one of the schemas
-      return schema.some(subSchema => this.validateValueAgainstSchema(value, subSchema));
+      return schema.some((subSchema) => this.validateValueAgainstSchema(value, subSchema));
     }
 
     if (typeof schema === 'object' && schema !== null) {
@@ -294,13 +290,13 @@ export class AvroSchemaValidator {
 
   private validateValueAgainstArray(value: unknown, schema: AvroArraySchema): boolean {
     if (!Array.isArray(value)) return false;
-    return value.every(item => this.validateValueAgainstSchema(item, schema.items));
+    return value.every((item) => this.validateValueAgainstSchema(item, schema.items));
   }
 
   private validateValueAgainstMap(value: unknown, schema: AvroMapSchema): boolean {
     if (typeof value !== 'object' || value === null) return false;
     const obj = value as Record<string, unknown>;
-    return Object.values(obj).every(val => this.validateValueAgainstSchema(val, schema.values));
+    return Object.values(obj).every((val) => this.validateValueAgainstSchema(val, schema.values));
   }
 
   private validateValueAgainstFixed(value: unknown, schema: AvroFixedSchema): boolean {
@@ -316,4 +312,4 @@ export class AvroSchemaValidator {
   private getFullName(name: string, namespace?: string): string {
     return namespace ? `${namespace}.${name}` : name;
   }
-}
+}

src/avro/__tests__/AvroEncoder.spec.ts

@@ -196,14 +196,14 @@ describe('AvroEncoder', () => {
       expect(result).toEqual(new Uint8Array([84])); // 42 zigzag encoded
 
       writer.reset();
-      
+
       // Integer outside int range
       encoder.writeNumber(3000000000);
       result = writer.flush();
       expect(result.length).toBeGreaterThan(1);
 
       writer.reset();
-      
+
       // Float
       encoder.writeNumber(3.14);
       result = writer.flush();
@@ -284,4 +284,4 @@ describe('AvroEncoder', () => {
       expect(result.length).toBe(8);
     });
   });
-});
+});

src/avro/__tests__/AvroSchemaEncoder.spec.ts

@@ -249,7 +249,7 @@ describe('AvroSchemaEncoder', () => {
 
     test('encodes union value with explicit index', () => {
       const schema: AvroUnionSchema = ['null', 'string'];
-      
+
       const result = encoder.encode('hello', schema, 1);
       expect(result[0]).toBe(2); // index 1 zigzag encoded is 2
     });
@@ -403,4 +403,4 @@ describe('AvroSchemaEncoder', () => {
       expect(result.length).toBeGreaterThan(0);
     });
   });
-});
+});

src/avro/__tests__/AvroSchemaValidator.spec.ts

@@ -357,4 +357,4 @@ describe('AvroSchemaValidator', () => {
       expect(validator.validateValue(new Uint8Array([1, 2, 3, 4, 5]), schema)).toBe(false);
     });
   });
-});
+});

src/avro/index.ts

@@ -1,4 +1,4 @@
 export * from './types';
 export * from './AvroSchemaValidator';
 export * from './AvroEncoder';
-export * from './AvroSchemaEncoder';
+export * from './AvroSchemaEncoder';