@sachitv/avro-typescript 0.4.0

package/esm/schemas/logical/logical_type.js

@@ -0,0 +1,240 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _LogicalResolver_logicalType, _LogicalResolver_resolver;
+import { Resolver } from "../resolver.js";
+import { Type } from "../type.js";
+import { throwInvalidError } from "../error.js";
+/**
+ * Base class for Avro logical types that wrap an underlying physical type
+ * while exposing a richer TypeScript representation.
+ */
+export class LogicalType extends Type {
+    /**
+     * Constructs a new LogicalType.
+     * @param underlyingType - The underlying type to wrap.
+     */
+    constructor(underlyingType) {
+        super();
+        /** The underlying type that this logical type wraps. */
+        Object.defineProperty(this, "underlyingType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.underlyingType = underlyingType;
+    }
+    /**
+     * Gets the underlying type that this logical type wraps.
+     */
+    getUnderlyingType() {
+        return this.underlyingType;
+    }
+    /**
+     * Converts a value from the underlying type to the logical type value.
+     * @param value The underlying value.
+     */
+    convertFromUnderlying(value) {
+        return this.fromUnderlying(value);
+    }
+    /**
+     * Determines if this logical type is compatible with the writer logical type for reading.
+     */
+    canReadFromLogical(_writer) {
+        return _writer.constructor === this.constructor;
+    }
+    /**
+     * Serializes the logical value to an ArrayBuffer.
+     * @param value The logical value to serialize.
+     */
+    async toBuffer(value) {
+        this.ensureValid(value, []);
+        const underlying = this.toUnderlying(value);
+        return await this.underlyingType.toBuffer(underlying);
+    }
+    /**
+     * Deserializes a logical value from an ArrayBuffer.
+     * @param buffer The buffer to deserialize from.
+     */
+    async fromBuffer(buffer) {
+        const underlying = await this.underlyingType.fromBuffer(buffer);
+        return this.fromUnderlying(underlying);
+    }
+    /**
+     * Checks if the given value is valid for this type.
+     * @param value The value to validate.
+     * @param opts Optional validation options.
+     */
+    isValid(value, opts) {
+        return this.check(value, opts?.errorHook, []);
+    }
+    /**
+     * Validates the value against this type, reporting errors via the hook if provided.
+     * @param value The value to check.
+     * @param errorHook Optional hook for reporting validation errors.
+     * @param path The path to the value in the schema.
+     */
+    check(value, errorHook, path = []) {
+        if (!this.isInstance(value)) {
+            if (errorHook) {
+                errorHook(path.slice(), value, this);
+            }
+            return false;
+        }
+        let underlying;
+        try {
+            underlying = this.toUnderlying(value);
+        }
+        catch {
+            if (errorHook) {
+                errorHook(path.slice(), value, this);
+            }
+            return false;
+        }
+        return this.underlyingType.check(underlying, errorHook, path);
+    }
+    /**
+     * Clones a value, ensuring it is valid for this type.
+     */
+    cloneFromValue(value) {
+        this.check(value, throwInvalidError, []);
+        const typedValue = value;
+        const cloned = this.underlyingType.cloneFromValue(this.toUnderlying(typedValue));
+        return this.fromUnderlying(cloned);
+    }
+    /**
+     * Compares two values by comparing their underlying representations.
+     */
+    compare(val1, val2) {
+        const u1 = this.toUnderlying(val1);
+        const u2 = this.toUnderlying(val2);
+        return this.underlyingType.compare(u1, u2);
+    }
+    /**
+     * Generates a random value by generating a random underlying value and converting it.
+     */
+    random() {
+        const underlying = this.underlyingType.random();
+        return this.fromUnderlying(underlying);
+    }
+    /**
+     * Writes the value to the tap by writing the underlying value.
+     */
+    async write(tap, value) {
+        this.ensureValid(value, []);
+        await this.underlyingType.write(tap, this.toUnderlying(value));
+    }
+    /** Reads the value from the tap. */
+    async read(tap) {
+        const underlying = await this.underlyingType.read(tap);
+        return this.fromUnderlying(underlying);
+    }
+    /** Skips the value in the tap. */
+    async skip(tap) {
+        await this.underlyingType.skip(tap);
+    }
+    /** Matches the value in the taps. */
+    async match(tap1, tap2) {
+        return await this.underlyingType.match(tap1, tap2);
+    }
+    /**
+     * Creates a resolver for reading from the writer type, handling logical types specially.
+     */
+    createResolver(writerType) {
+        if (writerType instanceof LogicalType) {
+            if (!this.canReadFromLogical(writerType)) {
+                throw new Error("Schema evolution not supported between incompatible logical types.");
+            }
+            const resolver = this.underlyingType.createResolver(writerType.getUnderlyingType());
+            return new LogicalResolver(this, resolver);
+        }
+        const resolver = this.underlyingType.createResolver(writerType);
+        return new LogicalResolver(this, resolver);
+    }
+    /**
+     * Ensures the value is valid for this logical type.
+     * @param value The value to validate.
+     * @param path The path for error reporting.
+     */
+    ensureValid(value, path) {
+        this.check(value, throwInvalidError, path);
+    }
+}
+class LogicalResolver extends Resolver {
+    constructor(logicalType, resolver) {
+        super(logicalType);
+        _LogicalResolver_logicalType.set(this, void 0);
+        _LogicalResolver_resolver.set(this, void 0);
+        __classPrivateFieldSet(this, _LogicalResolver_logicalType, logicalType, "f");
+        __classPrivateFieldSet(this, _LogicalResolver_resolver, resolver, "f");
+    }
+    async read(tap) {
+        const underlying = await __classPrivateFieldGet(this, _LogicalResolver_resolver, "f").read(tap);
+        return __classPrivateFieldGet(this, _LogicalResolver_logicalType, "f").convertFromUnderlying(underlying);
+    }
+}
+_LogicalResolver_logicalType = new WeakMap(), _LogicalResolver_resolver = new WeakMap();
+/**
+ * Logical type variant for named Avro schemas (record, enum, fixed) that keeps
+ * track of the fully qualified name and aliases of the underlying type.
+ */
+/**
+ * Logical type variant for named Avro schemas (record, enum, fixed) that keeps
+ * track of the fully qualified name and aliases of the underlying type.
+ */
+export class NamedLogicalType extends LogicalType {
+    /**
+     * Creates a new NamedLogicalType.
+     * @param namedType The underlying named type.
+     */
+    constructor(namedType) {
+        super(namedType);
+        /** The underlying named type. */
+        Object.defineProperty(this, "namedType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.namedType = namedType;
+    }
+    /**
+     * Gets the full name of the underlying type.
+     */
+    getFullName() {
+        return this.namedType.getFullName();
+    }
+    /**
+     * Gets the namespace of the underlying type.
+     */
+    getNamespace() {
+        return this.namedType.getNamespace();
+    }
+    /**
+     * Gets the aliases of the underlying type.
+     */
+    getAliases() {
+        return this.namedType.getAliases();
+    }
+}
+/**
+ * Helper to attach a logicalType annotation to an underlying Avro schema JSON.
+ */
+export function withLogicalTypeJSON(underlying, logicalType, extras = {}) {
+    if (typeof underlying === "string") {
+        return { type: underlying, logicalType, ...extras };
+    }
+    if (underlying && typeof underlying === "object" && !Array.isArray(underlying)) {
+        return { ...underlying, logicalType, ...extras };
+    }
+    throw new Error("Unsupported underlying schema for logical type serialization.");
+}

package/esm/schemas/logical/temporal_logical_types.d.ts

@@ -0,0 +1,215 @@
+import type { IntType } from "../primitive/int_type.js";
+import type { LongType } from "../primitive/long_type.js";
+import { LogicalType } from "./logical_type.js";
+import type { JSONType } from "../type.js";
+/**
+ * Logical type for `date`.
+ * Represents the number of days since the epoch.
+ */
+export declare class DateLogicalType extends LogicalType<number, number> {
+    /**
+     * Creates a new DateLogicalType.
+     * @param underlying The underlying int type.
+     */
+    constructor(underlying: IntType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is number;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: number): number;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: number): number;
+    /** Generates a random value for testing. */
+    random(): number;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `time-millis`.
+ * Represents the time of day in milliseconds since midnight.
+ */
+export declare class TimeMillisLogicalType extends LogicalType<number, number> {
+    /**
+     * Creates a new TimeMillisLogicalType.
+     * @param underlying The underlying int type.
+     */
+    constructor(underlying: IntType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is number;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: number): number;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: number): number;
+    /** Generates a random value for testing. */
+    random(): number;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `time-micros`.
+ * Represents the time of day in microseconds since midnight.
+ */
+export declare class TimeMicrosLogicalType extends LogicalType<bigint, bigint> {
+    /**
+     * Creates a new TimeMicrosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying: LongType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is bigint;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: bigint): bigint;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: bigint): bigint;
+    /** Generates a random value for testing. */
+    random(): bigint;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `timestamp-millis`.
+ * Represents an instant in time as the number of milliseconds since the epoch.
+ */
+export declare class TimestampMillisLogicalType extends LogicalType<Date, bigint> {
+    /**
+     * Creates a new TimestampMillisLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying: LongType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is Date;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: Date): bigint;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: bigint): Date;
+    /** Generates a random value for testing. */
+    random(): Date;
+    /** Compares two Date values. */
+    compare(val1: Date, val2: Date): number;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `timestamp-micros`.
+ * Represents an instant in time as the number of microseconds since the epoch.
+ */
+export declare class TimestampMicrosLogicalType extends LogicalType<bigint, bigint> {
+    /**
+     * Creates a new TimestampMicrosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying: LongType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is bigint;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: bigint): bigint;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: bigint): bigint;
+    /** Generates a random value for testing. */
+    random(): bigint;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `timestamp-nanos`.
+ * Represents an instant in time as the number of nanoseconds since the epoch.
+ */
+export declare class TimestampNanosLogicalType extends LogicalType<bigint, bigint> {
+    /**
+     * Creates a new TimestampNanosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying: LongType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is bigint;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: bigint): bigint;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: bigint): bigint;
+    /** Generates a random value for testing. */
+    random(): bigint;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `local-timestamp-millis`.
+ * Represents a timestamp in a local time zone, in milliseconds.
+ */
+export declare class LocalTimestampMillisLogicalType extends LogicalType<number, bigint> {
+    /**
+     * Creates a new LocalTimestampMillisLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying: LongType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is number;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: number): bigint;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: bigint): number;
+    /** Generates a random value for testing. */
+    random(): number;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `local-timestamp-micros`.
+ * Represents a timestamp in a local time zone, in microseconds.
+ */
+export declare class LocalTimestampMicrosLogicalType extends LogicalType<bigint, bigint> {
+    /**
+     * Creates a new LocalTimestampMicrosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying: LongType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is bigint;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: bigint): bigint;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: bigint): bigint;
+    /** Generates a random value for testing. */
+    random(): bigint;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}
+/**
+ * Logical type for `local-timestamp-nanos`.
+ * Represents a timestamp in a local time zone, in nanoseconds.
+ */
+export declare class LocalTimestampNanosLogicalType extends LogicalType<bigint, bigint> {
+    /**
+     * Creates a new LocalTimestampNanosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying: LongType);
+    /** Checks if the logical type can read from the underlying type. */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /** Checks if the value is a valid instance of this logical type. */
+    protected isInstance(value: unknown): value is bigint;
+    /** Converts the logical value to the underlying representation. */
+    protected toUnderlying(value: bigint): bigint;
+    /** Converts the underlying value to the logical representation. */
+    protected fromUnderlying(value: bigint): bigint;
+    /** Generates a random value for testing. */
+    random(): bigint;
+    /** Returns the JSON representation of this type. */
+    toJSON(): JSONType;
+}