@sachitv/avro-typescript 0.4.0

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

@@ -0,0 +1,49 @@
+import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.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";
+/**
+ * Bytes type.
+ */
+export declare class BytesType extends PrimitiveType<Uint8Array> {
+    #private;
+    /** Checks if the value is a valid bytes array. */
+    check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
+    /**
+     * Reads a byte array from the tap.
+     */
+    read(tap: ReadableTapLike): Promise<Uint8Array>;
+    /**
+     * Writes a byte array to the tap.
+     */
+    write(tap: WritableTapLike, value: Uint8Array): Promise<void>;
+    /**
+     * Skips a byte array in the tap.
+     */
+    skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Converts a byte array to an ArrayBuffer.
+     */
+    toBuffer(value: Uint8Array): Promise<ArrayBuffer>;
+    /**
+     * Creates a resolver for the writer type.
+     */
+    createResolver(writerType: Type): Resolver;
+    /**
+     * Compares two byte arrays.
+     */
+    compare(val1: Uint8Array, val2: Uint8Array): number;
+    /**
+     * Clones a byte array value.
+     */
+    cloneFromValue(value: unknown): Uint8Array;
+    /**
+     * Generates a random byte array.
+     */
+    random(): Uint8Array;
+    /** Returns the JSON representation of the type. */
+    toJSON(): JSONType;
+    /** Matches bytes between two taps. */
+    match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+}

package/esm/schemas/primitive/bytes_type.js

@@ -0,0 +1,136 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _BytesType_fromJsonString;
+import { WritableTap, } from "../../serialization/tap.js";
+import { PrimitiveType } from "./primitive_type.js";
+import { Resolver } from "../resolver.js";
+import { throwInvalidError } from "../error.js";
+import { calculateVarintSize } from "../../internal/varint.js";
+/**
+ * Bytes type.
+ */
+export class BytesType extends PrimitiveType {
+    /** Checks if the value is a valid bytes array. */
+    check(value, errorHook, path = []) {
+        const isValid = value instanceof Uint8Array;
+        if (!isValid && errorHook) {
+            errorHook(path, value, this);
+        }
+        return isValid;
+    }
+    /**
+     * Reads a byte array from the tap.
+     */
+    async read(tap) {
+        return await tap.readBytes();
+    }
+    /**
+     * Writes a byte array to the tap.
+     */
+    async write(tap, value) {
+        if (!(value instanceof Uint8Array)) {
+            throwInvalidError([], value, this);
+        }
+        await tap.writeBytes(value);
+    }
+    /**
+     * Skips a byte array in the tap.
+     */
+    async skip(tap) {
+        await tap.skipBytes();
+    }
+    /**
+     * Converts a byte array to an ArrayBuffer.
+     */
+    async toBuffer(value) {
+        this.check(value, throwInvalidError, []);
+        // Pre-allocate buffer based on value length for efficiency
+        const lengthSize = calculateVarintSize(value.length);
+        const totalSize = lengthSize + value.length;
+        const buf = new ArrayBuffer(totalSize);
+        const tap = new WritableTap(buf);
+        await this.write(tap, value);
+        return buf;
+    }
+    /**
+     * Creates a resolver for the writer type.
+     */
+    createResolver(writerType) {
+        if (writerType.toJSON() === "string") {
+            // Bytes can promote from string. We use an anonymous class here to avoid a
+            // cyclic dependency between this file and the string type file.
+            return new class extends Resolver {
+                async read(tap) {
+                    const str = await tap.readString();
+                    // Convert string to bytes (assuming UTF-8)
+                    const encoder = new TextEncoder();
+                    return encoder.encode(str);
+                }
+            }(this);
+        }
+        else {
+            return super.createResolver(writerType);
+        }
+    }
+    /**
+     * Compares two byte arrays.
+     */
+    compare(val1, val2) {
+        const len1 = val1.length;
+        const len2 = val2.length;
+        const len = Math.min(len1, len2);
+        for (let i = 0; i < len; i++) {
+            if (val1[i] !== val2[i]) {
+                return val1[i] < val2[i] ? -1 : 1;
+            }
+        }
+        return len1 < len2 ? -1 : len1 > len2 ? 1 : 0;
+    }
+    /**
+     * Clones a byte array value.
+     */
+    cloneFromValue(value) {
+        let bytes;
+        if (value instanceof Uint8Array) {
+            bytes = value;
+        }
+        else if (typeof value === "string") {
+            bytes = __classPrivateFieldGet(_a, _a, "m", _BytesType_fromJsonString).call(_a, value);
+        }
+        else {
+            throwInvalidError([], value, this);
+        }
+        this.check(bytes, throwInvalidError, []);
+        return new Uint8Array(bytes);
+    }
+    /**
+     * Generates a random byte array.
+     */
+    random() {
+        // Generate at least one byte.
+        const len = Math.ceil(Math.random() * 31) + 1;
+        const buf = new Uint8Array(len);
+        for (let i = 0; i < len; i++) {
+            buf[i] = Math.floor(Math.random() * 256);
+        }
+        return buf;
+    }
+    /** Returns the JSON representation of the type. */
+    toJSON() {
+        return "bytes";
+    }
+    /** Matches bytes between two taps. */
+    async match(tap1, tap2) {
+        return await tap1.matchBytes(tap2);
+    }
+}
+_a = BytesType, _BytesType_fromJsonString = function _BytesType_fromJsonString(value) {
+    const bytes = new Uint8Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+        bytes[i] = value.charCodeAt(i) & 0xff;
+    }
+    return bytes;
+};

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

@@ -0,0 +1,38 @@
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import { FixedSizeBaseType } from "./fixed_size_base_type.js";
+import type { JSONType, Type } from "../type.js";
+import { Resolver } from "../resolver.js";
+import { type ErrorHook } from "../error.js";
+/**
+ * Double type (64-bit).
+ */
+export declare class DoubleType extends FixedSizeBaseType<number> {
+    /** Checks if the value is a valid double. */
+    check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
+    /** Reads a double value from the tap. */
+    read(tap: ReadableTapLike): Promise<number>;
+    /** Writes a double value to the tap. */
+    write(tap: WritableTapLike, value: number): Promise<void>;
+    /** Skips a double value in the tap. */
+    skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Gets the size in bytes.
+     */
+    sizeBytes(): number;
+    /** Clones the value to a number. */
+    cloneFromValue(value: unknown): number;
+    /**
+     * Compares two double values.
+     */
+    compare(val1: number, val2: number): number;
+    /**
+     * Generates a random double value.
+     */
+    random(): number;
+    /** Creates a resolver for the given writer type. */
+    createResolver(writerType: Type): Resolver;
+    /** Returns the JSON representation of the type. */
+    toJSON(): JSONType;
+    /** Matches two taps for equality. */
+    match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+}

package/esm/schemas/primitive/double_type.js

@@ -0,0 +1,98 @@
+import { FixedSizeBaseType } from "./fixed_size_base_type.js";
+import { Resolver } from "../resolver.js";
+import { IntType } from "./int_type.js";
+import { LongType } from "./long_type.js";
+import { FloatType } from "./float_type.js";
+import { throwInvalidError } from "../error.js";
+/**
+ * Double type (64-bit).
+ */
+export class DoubleType extends FixedSizeBaseType {
+    /** Checks if the value is a valid double. */
+    check(value, errorHook, path = []) {
+        const isValid = typeof value === "number";
+        if (!isValid && errorHook) {
+            errorHook(path, value, this);
+        }
+        return isValid;
+    }
+    /** Reads a double value from the tap. */
+    async read(tap) {
+        return await tap.readDouble();
+    }
+    /** Writes a double value to the tap. */
+    async write(tap, value) {
+        if (!this.check(value)) {
+            throwInvalidError([], value, this);
+        }
+        await tap.writeDouble(value);
+    }
+    /** Skips a double value in the tap. */
+    async skip(tap) {
+        await tap.skipDouble();
+    }
+    /**
+     * Gets the size in bytes.
+     */
+    sizeBytes() {
+        return 8; // 8 bytes
+    }
+    /** Clones the value to a number. */
+    cloneFromValue(value) {
+        this.check(value, throwInvalidError, []);
+        return value;
+    }
+    /**
+     * Compares two double values.
+     */
+    compare(val1, val2) {
+        return val1 < val2 ? -1 : val1 > val2 ? 1 : 0;
+    }
+    /**
+     * Generates a random double value.
+     */
+    random() {
+        return Math.random();
+    }
+    /** Creates a resolver for the given writer type. */
+    createResolver(writerType) {
+        if (writerType instanceof IntType) {
+            // Double can promote from int (32-bit to 64-bit double)
+            return new class extends Resolver {
+                async read(tap) {
+                    const intValue = await tap.readInt();
+                    return intValue;
+                }
+            }(this);
+        }
+        else if (writerType instanceof LongType) {
+            // Double can promote from long (64-bit to 64-bit double, lossy for large values)
+            return new class extends Resolver {
+                async read(tap) {
+                    const longValue = await tap.readLong();
+                    return Number(longValue);
+                }
+            }(this);
+        }
+        else if (writerType instanceof FloatType) {
+            // Double can promote from float (32-bit to 64-bit double)
+            return new class extends Resolver {
+                async read(tap) {
+                    const floatValue = await tap.readFloat();
+                    return floatValue;
+                }
+            }(this);
+        }
+        else {
+            return super.createResolver(writerType);
+        }
+    }
+    /** Returns the JSON representation of the type. */
+    toJSON() {
+        return "double";
+    }
+    /** Matches two taps for equality. */
+    async match(tap1, tap2) {
+        return await tap1.matchDouble(tap2);
+    }
+}

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

@@ -0,0 +1,28 @@
+import { type ReadableTapLike } from "../../serialization/tap.js";
+import { BaseType } from "../base_type.js";
+/**
+ * Base class for fixed-size Avro types.
+ * Provides optimized serialization for types with known fixed byte sizes.
+ */
+/**
+ * Base class for fixed-size Avro types.
+ * Provides optimized serialization for types with known fixed byte sizes.
+ */
+export declare abstract class FixedSizeBaseType<T = unknown> extends BaseType<T> {
+    /**
+     * Returns the fixed size in bytes for this type.
+     * @returns The exact size in bytes.
+     */
+    abstract sizeBytes(): number;
+    /**
+     * Serializes a value into an ArrayBuffer using the exact fixed size.
+     * @param value The value to serialize.
+     * @returns The serialized ArrayBuffer.
+     */
+    toBuffer(value: T): Promise<ArrayBuffer>;
+    /**
+     * Skips a fixed-size value by advancing the tap by the fixed size.
+     * @param tap The tap to skip from.
+     */
+    skip(tap: ReadableTapLike): Promise<void>;
+}

package/esm/schemas/primitive/fixed_size_base_type.js

@@ -0,0 +1,33 @@
+import { WritableTap } from "../../serialization/tap.js";
+import { BaseType } from "../base_type.js";
+import { throwInvalidError } from "../error.js";
+/**
+ * Base class for fixed-size Avro types.
+ * Provides optimized serialization for types with known fixed byte sizes.
+ */
+/**
+ * Base class for fixed-size Avro types.
+ * Provides optimized serialization for types with known fixed byte sizes.
+ */
+export class FixedSizeBaseType extends BaseType {
+    /**
+     * Serializes a value into an ArrayBuffer using the exact fixed size.
+     * @param value The value to serialize.
+     * @returns The serialized ArrayBuffer.
+     */
+    async toBuffer(value) {
+        this.check(value, throwInvalidError, []);
+        const size = this.sizeBytes();
+        const buf = new ArrayBuffer(size);
+        const tap = new WritableTap(buf);
+        await this.write(tap, value);
+        return buf;
+    }
+    /**
+     * Skips a fixed-size value by advancing the tap by the fixed size.
+     * @param tap The tap to skip from.
+     */
+    async skip(tap) {
+        await tap.skipFixed(this.sizeBytes());
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import { FixedSizeBaseType } from "./fixed_size_base_type.js";
+import type { JSONType, Type } from "../type.js";
+import { Resolver } from "../resolver.js";
+import { type ErrorHook } from "../error.js";
+/**
+ * Float type (32-bit).
+ */
+export declare class FloatType extends FixedSizeBaseType<number> {
+    /** Checks if the value is a valid float. */
+    check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
+    /** Reads a float value from the tap. */
+    read(tap: ReadableTapLike): Promise<number>;
+    /** Writes a float value to the tap. */
+    write(tap: WritableTapLike, value: number): Promise<void>;
+    /** Skips a float value in the tap. */
+    skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Gets the size in bytes.
+     */
+    sizeBytes(): number;
+    /** Clones a value to a float. */
+    cloneFromValue(value: unknown): number;
+    /**
+     * Compares two float values.
+     */
+    compare(val1: number, val2: number): number;
+    /**
+     * Generates a random float value.
+     */
+    random(): number;
+    /** Creates a resolver for schema evolution. */
+    createResolver(writerType: Type): Resolver;
+    /** Returns the JSON representation. */
+    toJSON(): JSONType;
+    /** Matches float values between taps. */
+    match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+}

package/esm/schemas/primitive/float_type.js

@@ -0,0 +1,88 @@
+import { FixedSizeBaseType } from "./fixed_size_base_type.js";
+import { Resolver } from "../resolver.js";
+import { IntType } from "./int_type.js";
+import { LongType } from "./long_type.js";
+import { throwInvalidError } from "../error.js";
+/**
+ * Float type (32-bit).
+ */
+export class FloatType extends FixedSizeBaseType {
+    /** Checks if the value is a valid float. */
+    check(value, errorHook, path = []) {
+        const isValid = typeof value === "number";
+        if (!isValid && errorHook) {
+            errorHook(path, value, this);
+        }
+        return isValid;
+    }
+    /** Reads a float value from the tap. */
+    async read(tap) {
+        return await tap.readFloat();
+    }
+    /** Writes a float value to the tap. */
+    async write(tap, value) {
+        if (!this.check(value)) {
+            throwInvalidError([], value, this);
+        }
+        await tap.writeFloat(value);
+    }
+    /** Skips a float value in the tap. */
+    async skip(tap) {
+        await tap.skipFloat();
+    }
+    /**
+     * Gets the size in bytes.
+     */
+    sizeBytes() {
+        return 4; // 4 bytes
+    }
+    /** Clones a value to a float. */
+    cloneFromValue(value) {
+        this.check(value, throwInvalidError, []);
+        return value;
+    }
+    /**
+     * Compares two float values.
+     */
+    compare(val1, val2) {
+        return val1 < val2 ? -1 : val1 > val2 ? 1 : 0;
+    }
+    /**
+     * Generates a random float value.
+     */
+    random() {
+        return Math.random() * 1000;
+    }
+    /** Creates a resolver for schema evolution. */
+    createResolver(writerType) {
+        if (writerType instanceof IntType) {
+            // Float can promote from int (32-bit to 32-bit float)
+            return new class extends Resolver {
+                async read(tap) {
+                    const intValue = await tap.readInt();
+                    return intValue;
+                }
+            }(this);
+        }
+        else if (writerType instanceof LongType) {
+            // Float can promote from long (64-bit to 32-bit float, lossy)
+            return new class extends Resolver {
+                async read(tap) {
+                    const longValue = await tap.readLong();
+                    return Number(longValue);
+                }
+            }(this);
+        }
+        else {
+            return super.createResolver(writerType);
+        }
+    }
+    /** Returns the JSON representation. */
+    toJSON() {
+        return "float";
+    }
+    /** Matches float values between taps. */
+    async match(tap1, tap2) {
+        return await tap1.matchFloat(tap2);
+    }
+}

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

@@ -0,0 +1,31 @@
+import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import { PrimitiveType } from "./primitive_type.js";
+import type { JSONType } from "../type.js";
+import { type ErrorHook } from "../error.js";
+/**
+ * Int type (32-bit).
+ */
+export declare class IntType extends PrimitiveType<number> {
+    /** 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>;
+    /** 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.
+     */
+    compare(val1: number, val2: number): number;
+    /**
+     * Generates a random int value.
+     */
+    random(): number;
+    /** Returns the JSON schema representation for int type. */
+    toJSON(): JSONType;
+    /** Matches two 32-bit integers in the taps. */
+    match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+}

package/esm/schemas/primitive/int_type.js

@@ -0,0 +1,63 @@
+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 {
+    /** Checks if the value is a valid 32-bit integer. */
+    check(value, errorHook, path = []) {
+        const isValid = typeof value === "number" && Number.isInteger(value) &&
+            value >= -2147483648 && value <= 2147483647;
+        if (!isValid && errorHook) {
+            errorHook(path, value, this);
+        }
+        return isValid;
+    }
+    /** Reads a 32-bit integer from the tap. */
+    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);
+        }
+        await tap.writeInt(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.
+     */
+    compare(val1, val2) {
+        return val1 < val2 ? -1 : val1 > val2 ? 1 : 0;
+    }
+    /**
+     * Generates a random int value.
+     */
+    random() {
+        return Math.floor(Math.random() * 1000);
+    }
+    /** Returns the JSON schema representation for int type. */
+    toJSON() {
+        return "int";
+    }
+    /** Matches two 32-bit integers in the taps. */
+    async match(tap1, tap2) {
+        return await tap1.matchInt(tap2);
+    }
+}

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

@@ -0,0 +1,36 @@
+import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.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";
+/**
+ * Long type (64-bit).
+ */
+export declare class LongType extends PrimitiveType<bigint> {
+    /** 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>;
+    /** 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.
+     */
+    compare(val1: bigint, val2: bigint): number;
+    /**
+     * Generates a random long value.
+     */
+    random(): bigint;
+    /** Clones and validates a value as a bigint. */
+    cloneFromValue(value: unknown): bigint;
+    /** Creates a resolver for reading from the writer type. */
+    createResolver(writerType: Type): Resolver;
+    /** Returns the JSON representation of the type. */
+    toJSON(): JSONType;
+    /** Compares two taps for long equality. */
+    match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+}