@sachitv/avro-typescript 0.4.1 → 0.5.0

package/esm/schemas/primitive/int_type.d.ts

@@ -1,21 +1,24 @@
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { PrimitiveType } from "./primitive_type.js";
 import type { JSONType } from "../type.js";
-import { type ErrorHook } from "../error.js";
+import type { ErrorHook } from "../error.js";
 /**
  * Int type (32-bit).
  */
 export declare class IntType extends PrimitiveType<number> {
+    /** Creates a new int type. */
+    constructor(validate?: boolean);
     /** Checks if the value is a valid 32-bit integer. */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /** Reads a 32-bit integer from the tap. */
     read(tap: ReadableTapLike): Promise<number>;
-    /** Writes a 32-bit integer to the tap. */
-    write(tap: WritableTapLike, value: number): Promise<void>;
+    /** Writes a 32-bit integer to the tap without validation. */
+    writeUnchecked(tap: WritableTapLike, value: number): Promise<void>;
+    /** Returns the encoded byte length of the given value. */
+    protected byteLength(value: number): number;
     /** Skips a 32-bit integer in the tap. */
     skip(tap: ReadableTapLike): Promise<void>;
-    /** Converts a 32-bit integer to its buffer representation. */
-    toBuffer(value: number): Promise<ArrayBuffer>;
     /**
      * Compares two int values.
      */
@@ -28,4 +31,12 @@ export declare class IntType extends PrimitiveType<number> {
     toJSON(): JSONType;
     /** Matches two 32-bit integers in the taps. */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /** Reads a 32-bit integer synchronously from the tap. */
+    readSync(tap: SyncReadableTapLike): number;
+    /** Writes a 32-bit integer synchronously to the tap without validation. */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: number): void;
+    /** Skips a 32-bit integer synchronously in the tap. */
+    skipSync(tap: SyncReadableTapLike): void;
+    /** Matches two 32-bit integers synchronously in the taps. */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
 }

package/esm/schemas/primitive/int_type.js

@@ -1,11 +1,13 @@
-import { WritableTap, } from "../../serialization/tap.js";
 import { PrimitiveType } from "./primitive_type.js";
 import { calculateVarintSize } from "../../internal/varint.js";
-import { throwInvalidError } from "../error.js";
 /**
  * Int type (32-bit).
  */
 export class IntType extends PrimitiveType {
+    /** Creates a new int type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /** Checks if the value is a valid 32-bit integer. */
     check(value, errorHook, path = []) {
         const isValid = typeof value === "number" && Number.isInteger(value) &&
@@ -19,27 +21,18 @@ export class IntType extends PrimitiveType {
     async read(tap) {
         return await tap.readInt();
     }
-    /** Writes a 32-bit integer to the tap. */
-    async write(tap, value) {
-        if (!this.check(value)) {
-            throwInvalidError([], value, this);
-        }
+    /** Writes a 32-bit integer to the tap without validation. */
+    async writeUnchecked(tap, value) {
         await tap.writeInt(value);
     }
+    /** Returns the encoded byte length of the given value. */
+    byteLength(value) {
+        return calculateVarintSize(value);
+    }
     /** Skips a 32-bit integer in the tap. */
     async skip(tap) {
         await tap.skipInt();
     }
-    /** Converts a 32-bit integer to its buffer representation. */
-    async toBuffer(value) {
-        this.check(value, throwInvalidError, []);
-        // For int, allocate exact size based on value
-        const size = calculateVarintSize(value);
-        const buf = new ArrayBuffer(size);
-        const tap = new WritableTap(buf);
-        await this.write(tap, value);
-        return buf;
-    }
     /**
      * Compares two int values.
      */
@@ -60,4 +53,20 @@ export class IntType extends PrimitiveType {
     async match(tap1, tap2) {
         return await tap1.matchInt(tap2);
     }
+    /** Reads a 32-bit integer synchronously from the tap. */
+    readSync(tap) {
+        return tap.readInt();
+    }
+    /** Writes a 32-bit integer synchronously to the tap without validation. */
+    writeSyncUnchecked(tap, value) {
+        tap.writeInt(value);
+    }
+    /** Skips a 32-bit integer synchronously in the tap. */
+    skipSync(tap) {
+        tap.skipInt();
+    }
+    /** Matches two 32-bit integers synchronously in the taps. */
+    matchSync(tap1, tap2) {
+        return tap1.matchInt(tap2);
+    }
 }

package/esm/schemas/primitive/long_type.d.ts

@@ -1,4 +1,5 @@
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { PrimitiveType } from "./primitive_type.js";
 import type { JSONType, Type } from "../type.js";
 import { Resolver } from "../resolver.js";
@@ -7,16 +8,18 @@ import { type ErrorHook } from "../error.js";
  * Long type (64-bit).
  */
 export declare class LongType extends PrimitiveType<bigint> {
+    /** Creates a new long type. */
+    constructor(validate?: boolean);
     /** Checks if the value is a valid long. */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /** Reads a long value from the tap. */
     read(tap: ReadableTapLike): Promise<bigint>;
-    /** Writes a long value to the tap. */
-    write(tap: WritableTapLike, value: bigint): Promise<void>;
+    /** Writes a long value to the tap without validation. */
+    writeUnchecked(tap: WritableTapLike, value: bigint): Promise<void>;
+    /** Returns the encoded byte length of the given value. */
+    protected byteLength(value: bigint): number;
     /** Skips a long value in the tap. */
     skip(tap: ReadableTapLike): Promise<void>;
-    /** Converts a bigint value to its buffer representation. */
-    toBuffer(value: bigint): Promise<ArrayBuffer>;
     /**
      * Compares two long values.
      */
@@ -33,4 +36,12 @@ export declare class LongType extends PrimitiveType<bigint> {
     toJSON(): JSONType;
     /** Compares two taps for long equality. */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /** Reads a long value synchronously from the tap. */
+    readSync(tap: SyncReadableTapLike): bigint;
+    /** Writes a long value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: bigint): void;
+    /** Skips a long value synchronously in the tap. */
+    skipSync(tap: SyncReadableTapLike): void;
+    /** Compares two taps synchronously for long equality. */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
 }

package/esm/schemas/primitive/long_type.js

@@ -1,4 +1,3 @@
-import { WritableTap, } from "../../serialization/tap.js";
 import { PrimitiveType } from "./primitive_type.js";
 import { Resolver } from "../resolver.js";
 import { IntType } from "./int_type.js";
@@ -10,6 +9,10 @@ const MAX_LONG = (1n << 63n) - 1n;
  * Long type (64-bit).
  */
 export class LongType extends PrimitiveType {
+    /** Creates a new long type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /** Checks if the value is a valid long. */
     check(value, errorHook, path = []) {
         const isValid = typeof value === "bigint" && value >= MIN_LONG &&
@@ -23,27 +26,18 @@ export class LongType extends PrimitiveType {
     async read(tap) {
         return await tap.readLong();
     }
-    /** Writes a long value to the tap. */
-    async write(tap, value) {
-        if (!this.check(value)) {
-            throwInvalidError([], value, this);
-        }
+    /** Writes a long value to the tap without validation. */
+    async writeUnchecked(tap, value) {
         await tap.writeLong(value);
     }
+    /** Returns the encoded byte length of the given value. */
+    byteLength(value) {
+        return calculateVarintSize(value);
+    }
     /** Skips a long value in the tap. */
     async skip(tap) {
         await tap.skipLong();
     }
-    /** Converts a bigint value to its buffer representation. */
-    async toBuffer(value) {
-        this.check(value, throwInvalidError, []);
-        // For long, allocate exact size based on value
-        const size = calculateVarintSize(value);
-        const buf = new ArrayBuffer(size);
-        const tap = new WritableTap(buf);
-        await this.write(tap, value);
-        return buf;
-    }
     /**
      * Compares two long values.
      */
@@ -78,6 +72,10 @@ export class LongType extends PrimitiveType {
                     const intValue = await tap.readInt();
                     return BigInt(intValue);
                 }
+                readSync(tap) {
+                    const intValue = tap.readInt();
+                    return BigInt(intValue);
+                }
             }(this);
         }
         else {
@@ -92,4 +90,20 @@ export class LongType extends PrimitiveType {
     async match(tap1, tap2) {
         return await tap1.matchLong(tap2);
     }
+    /** Reads a long value synchronously from the tap. */
+    readSync(tap) {
+        return tap.readLong();
+    }
+    /** Writes a long value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap, value) {
+        tap.writeLong(value);
+    }
+    /** Skips a long value synchronously in the tap. */
+    skipSync(tap) {
+        tap.skipLong();
+    }
+    /** Compares two taps synchronously for long equality. */
+    matchSync(tap1, tap2) {
+        return tap1.matchLong(tap2);
+    }
 }

package/esm/schemas/primitive/null_type.d.ts

@@ -1,4 +1,5 @@
 import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { FixedSizeBaseType } from "./fixed_size_base_type.js";
 import type { JSONType } from "../type.js";
 import { type ErrorHook } from "../error.js";
@@ -6,6 +7,8 @@ import { type ErrorHook } from "../error.js";
  * Null type.
  */
 export declare class NullType extends FixedSizeBaseType<null> {
+    /** Creates a new null type. */
+    constructor(validate?: boolean);
     /**
      * Checks if the value is null.
      */
@@ -14,10 +17,8 @@ export declare class NullType extends FixedSizeBaseType<null> {
      * Reads a null value from the tap.
      */
     read(_tap: ReadableTapLike): Promise<null>;
-    /**
-     * Writes a null value to the tap.
-     */
-    write(_tap: WritableTapLike, value: null): Promise<void>;
+    /** Writes a null value to the tap without validation. */
+    writeUnchecked(_tap: WritableTapLike, _value: null): Promise<void>;
     /**
      * Skips a null value in the tap.
      */
@@ -42,4 +43,14 @@ export declare class NullType extends FixedSizeBaseType<null> {
     toJSON(): JSONType;
     /** Compares two null values in the taps. */
     match(_tap1: ReadableTapLike, _tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Reads a null value synchronously from the tap.
+     */
+    readSync(_tap: SyncReadableTapLike): null;
+    /** Writes a null value synchronously to the tap without validation. */
+    writeSyncUnchecked(_tap: SyncWritableTapLike, _value: null): void;
+    /**
+     * Compares two null values synchronously in the taps.
+     */
+    matchSync(_tap1: SyncReadableTapLike, _tap2: SyncReadableTapLike): number;
 }

package/esm/schemas/primitive/null_type.js

@@ -4,6 +4,10 @@ import { throwInvalidError } from "../error.js";
  * Null type.
  */
 export class NullType extends FixedSizeBaseType {
+    /** Creates a new null type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /**
      * Checks if the value is null.
      */
@@ -20,13 +24,8 @@ export class NullType extends FixedSizeBaseType {
     async read(_tap) {
         return await Promise.resolve(null);
     }
-    /**
-     * Writes a null value to the tap.
-     */
-    async write(_tap, value) {
-        if (value !== null) {
-            throwInvalidError([], value, this);
-        }
+    /** Writes a null value to the tap without validation. */
+    async writeUnchecked(_tap, _value) {
         await Promise.resolve();
     }
     /**
@@ -68,4 +67,18 @@ export class NullType extends FixedSizeBaseType {
     async match(_tap1, _tap2) {
         return await Promise.resolve(0);
     }
+    /**
+     * Reads a null value synchronously from the tap.
+     */
+    readSync(_tap) {
+        return null;
+    }
+    /** Writes a null value synchronously to the tap without validation. */
+    writeSyncUnchecked(_tap, _value) { }
+    /**
+     * Compares two null values synchronously in the taps.
+     */
+    matchSync(_tap1, _tap2) {
+        return 0;
+    }
 }

package/esm/schemas/primitive/primitive_type.d.ts

@@ -3,6 +3,8 @@ import { BaseType } from "../base_type.js";
  * Abstract base class for primitive Avro types.
  */
 export declare abstract class PrimitiveType<T = unknown> extends BaseType<T> {
+    /** Creates a new primitive type. */
+    constructor(validate?: boolean);
     /**
      * Clones a primitive value (primitives are immutable).
      */

package/esm/schemas/primitive/primitive_type.js

@@ -4,6 +4,10 @@ import { throwInvalidError } from "../error.js";
  * Abstract base class for primitive Avro types.
  */
 export class PrimitiveType extends BaseType {
+    /** Creates a new primitive type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /**
      * Clones a primitive value (primitives are immutable).
      */

package/esm/schemas/primitive/string_type.d.ts

@@ -1,20 +1,23 @@
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { PrimitiveType } from "./primitive_type.js";
 import type { JSONType, Type } from "../type.js";
 import { Resolver } from "../resolver.js";
-import { type ErrorHook } from "../error.js";
+import type { ErrorHook } from "../error.js";
 /**
  * String type.
  */
 export declare class StringType extends PrimitiveType<string> {
+    /** Creates a new string type. */
+    constructor(validate?: boolean);
     /** Checks if the value is a valid string. */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
-    /** Converts a string value to its Avro-encoded buffer representation. */
-    toBuffer(value: string): Promise<ArrayBuffer>;
     /** Reads a string value from the tap. */
     read(tap: ReadableTapLike): Promise<string>;
-    /** Writes a string value to the tap. */
-    write(tap: WritableTapLike, value: string): Promise<void>;
+    /** Writes a string value to the tap without validation. */
+    writeUnchecked(tap: WritableTapLike, value: string): Promise<void>;
+    /** Returns the encoded byte length of the given value. */
+    protected byteLength(value: string): number;
     /** Skips a string value in the tap. */
     skip(tap: ReadableTapLike): Promise<void>;
     /**
@@ -31,4 +34,12 @@ export declare class StringType extends PrimitiveType<string> {
     toJSON(): JSONType;
     /** Matches two readable taps for string equality. */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /** Reads a string value synchronously from the tap. */
+    readSync(tap: SyncReadableTapLike): string;
+    /** Writes a string value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: string): void;
+    /** Skips a string value synchronously in the tap. */
+    skipSync(tap: SyncReadableTapLike): void;
+    /** Matches two readable taps synchronously for string equality. */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
 }

package/esm/schemas/primitive/string_type.js

@@ -1,13 +1,15 @@
-import { WritableTap, } from "../../serialization/tap.js";
 import { PrimitiveType } from "./primitive_type.js";
 import { Resolver } from "../resolver.js";
-import { throwInvalidError } from "../error.js";
+import { decode, utf8ByteLength } from "../../serialization/text_encoding.js";
 import { calculateVarintSize } from "../../internal/varint.js";
-import { decode, encode } from "../../serialization/text_encoding.js";
 /**
  * String type.
  */
 export class StringType extends PrimitiveType {
+    /** Creates a new string type. */
+    constructor(validate = true) {
+        super(validate);
+    }
     /** Checks if the value is a valid string. */
     check(value, errorHook, path = []) {
         const isValid = typeof value === "string";
@@ -16,27 +18,19 @@ export class StringType extends PrimitiveType {
         }
         return isValid;
     }
-    /** Converts a string value to its Avro-encoded buffer representation. */
-    async toBuffer(value) {
-        this.check(value, throwInvalidError, []);
-        const strBytes = encode(value);
-        const lengthSize = calculateVarintSize(strBytes.length);
-        const buf = new ArrayBuffer(lengthSize + strBytes.length);
-        const tap = new WritableTap(buf);
-        await this.write(tap, value);
-        return buf;
-    }
     /** Reads a string value from the tap. */
     async read(tap) {
         return await tap.readString();
     }
-    /** Writes a string value to the tap. */
-    async write(tap, value) {
-        if (typeof value !== "string") {
-            throwInvalidError([], value, this);
-        }
+    /** Writes a string value to the tap without validation. */
+    async writeUnchecked(tap, value) {
         await tap.writeString(value);
     }
+    /** Returns the encoded byte length of the given value. */
+    byteLength(value) {
+        const length = utf8ByteLength(value);
+        return calculateVarintSize(length) + length;
+    }
     /** Skips a string value in the tap. */
     async skip(tap) {
         await tap.skipString();
@@ -64,6 +58,11 @@ export class StringType extends PrimitiveType {
                     // Convert bytes to string (assuming UTF-8)
                     return decode(bytes);
                 }
+                readSync(tap) {
+                    const bytes = tap.readBytes();
+                    // Convert bytes to string (assuming UTF-8)
+                    return decode(bytes);
+                }
             }(this);
         }
         else {
@@ -78,4 +77,20 @@ export class StringType extends PrimitiveType {
     async match(tap1, tap2) {
         return await tap1.matchString(tap2);
     }
+    /** Reads a string value synchronously from the tap. */
+    readSync(tap) {
+        return tap.readString();
+    }
+    /** Writes a string value synchronously to the tap without validation. */
+    writeSyncUnchecked(tap, value) {
+        tap.writeString(value);
+    }
+    /** Skips a string value synchronously in the tap. */
+    skipSync(tap) {
+        tap.skipString();
+    }
+    /** Matches two readable taps synchronously for string equality. */
+    matchSync(tap1, tap2) {
+        return tap1.matchString(tap2);
+    }
 }

package/esm/schemas/resolver.d.ts

@@ -1,4 +1,5 @@
 import type { ReadableTapLike } from "../serialization/tap.js";
+import type { SyncReadableTapLike } from "../serialization/tap_sync.js";
 import type { Type } from "./type.js";
 /**
  * Base resolver for schema evolution, allowing reading data written with one schema
@@ -22,4 +23,9 @@ export declare abstract class Resolver<T = unknown> {
      * @param tap The tap to read from.
      */
     abstract read(tap: ReadableTapLike): Promise<T>;
+    /**
+     * Reads a value from the sync tap using the resolution logic.
+     * @param tap The sync tap to read from.
+     */
+    abstract readSync(tap: SyncReadableTapLike): T;
 }

package/esm/schemas/type.d.ts

@@ -1,6 +1,7 @@
-import type { ReadableTapLike, WritableTapLike } from "../serialization/tap.js";
+import { type ReadableTapLike, type WritableTapLike } from "../serialization/tap.js";
+import { type SyncReadableTapLike, type SyncWritableTapLike } from "../serialization/tap_sync.js";
 import type { Resolver } from "./resolver.js";
-import type { ErrorHook } from "./error.js";
+import { type ErrorHook } from "./error.js";
 /**
  * Options for validation, including an optional error hook.
  */
@@ -18,12 +19,16 @@ export type JSONType = string | number | boolean | null | {
  * Provides the common interface for serialization, deserialization, validation, and cloning.
  */
 export declare abstract class Type<T = unknown> {
+    /** Controls whether write operations validate values before serialization. */
+    protected readonly validateWrites: boolean;
+    /** Creates a new Type instance. */
+    protected constructor(validate?: boolean);
     /**
      * Serializes a value into an ArrayBuffer using the schema.
      * @param value The value to serialize.
      * @returns The serialized ArrayBuffer.
      */
-    abstract toBuffer(value: T): Promise<ArrayBuffer>;
+    toBuffer(value: T): Promise<ArrayBuffer>;
     /**
      * Deserializes an ArrayBuffer into a value using the schema.
      * @param buffer The ArrayBuffer to deserialize.
@@ -54,7 +59,15 @@ export declare abstract class Type<T = unknown> {
      * @param tap The tap to write to.
      * @param value The value to write.
      */
-    abstract write(tap: WritableTapLike, value: T): Promise<void>;
+    write(tap: WritableTapLike, value: T): Promise<void>;
+    /**
+     * Writes a value to the tap without performing runtime validation.
+     *
+     * This is used to implement `createType(schema, { validate: false })`
+     * efficiently and recursively. The default implementation delegates to
+     * {@link write}.
+     */
+    abstract writeUnchecked(tap: WritableTapLike, value: T): Promise<void>;
     /**
      * Reads a value from the tap. Must be implemented by subclasses.
      * @param tap The tap to read from.
@@ -98,4 +111,51 @@ export declare abstract class Type<T = unknown> {
      * @returns -1 if tap1 < tap2, 0 if equal, 1 if tap1 > tap2.
      */
     abstract match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Serializes a value into an ArrayBuffer synchronously using the schema.
+     * @param value The value to serialize.
+     * @returns The serialized ArrayBuffer.
+     */
+    toSyncBuffer(value: T): ArrayBuffer;
+    /**
+     * Deserializes an ArrayBuffer into a value synchronously using the schema.
+     * @param buffer The ArrayBuffer to deserialize.
+     * @returns The deserialized value.
+     */
+    abstract fromSyncBuffer(buffer: ArrayBuffer): T;
+    /**
+     * Writes a value to the sync tap. Must be implemented by subclasses.
+     * @param tap The sync tap to write to.
+     * @param value The value to write.
+     */
+    writeSync(tap: SyncWritableTapLike, value: T): void;
+    /**
+     * Writes a value to the sync tap without performing runtime validation.
+     *
+     * The default implementation delegates to {@link writeSync}.
+     */
+    abstract writeSyncUnchecked(tap: SyncWritableTapLike, value: T): void;
+    /**
+     * Reads a value from the sync tap. Must be implemented by subclasses.
+     * @param tap The sync tap to read from.
+     * @returns The read value.
+     */
+    abstract readSync(tap: SyncReadableTapLike): T;
+    /**
+     * Skips a value in the sync tap. Must be implemented by subclasses.
+     * @param tap The sync tap to skip from.
+     */
+    abstract skipSync(tap: SyncReadableTapLike): void;
+    /**
+     * Compares two encoded buffers synchronously. Must be implemented by subclasses.
+     * @param tap1 The first sync tap.
+     * @param tap2 The second sync tap.
+     * @returns -1 if tap1 < tap2, 0 if equal, 1 if tap1 > tap2.
+     */
+    abstract matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
+    /**
+     * Returns the encoded byte length for the value when it is cheap to compute.
+     * Override in types with fixed or easily derived sizes to skip counting taps.
+     */
+    protected byteLength(_value: T): number | undefined;
 }