@sachitv/avro-typescript 0.4.0

package/esm/schemas/complex/record_type.js

@@ -0,0 +1,547 @@
+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 __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 _a, _RecordField_name, _RecordField_type, _RecordField_aliases, _RecordField_order, _RecordField_hasDefault, _RecordField_defaultValue, _RecordField_isValidOrder, _RecordType_instances, _RecordType_fields, _RecordType_fieldNameToIndex, _RecordType_fieldsThunk, _RecordType_ensureFields, _RecordType_setFields, _RecordType_getOrderValue, _RecordType_isRecord, _RecordType_extractFieldValue, _RecordType_checkField, _RecordType_writeField, _RecordType_getFieldBuffer, _RecordType_cloneField, _RecordType_getComparableValue, _RecordResolver_mappings, _RecordResolver_readerFields;
+import { NamedType } from "./named_type.js";
+import { Resolver } from "../resolver.js";
+import { Type } from "../type.js";
+import { throwInvalidError } from "../error.js";
+import { isValidName } from "./resolve_names.js";
+/**
+ * Represents a field in an Avro record type.
+ */
+export class RecordField {
+    /**
+     * Constructs a new RecordField instance.
+     */
+    constructor(params) {
+        _RecordField_name.set(this, void 0);
+        _RecordField_type.set(this, void 0);
+        _RecordField_aliases.set(this, void 0);
+        _RecordField_order.set(this, void 0);
+        _RecordField_hasDefault.set(this, void 0);
+        _RecordField_defaultValue.set(this, void 0);
+        const { name, type, aliases = [], order = "ascending" } = params;
+        if (typeof name !== "string" || !isValidName(name)) {
+            throw new Error(`Invalid record field name: ${name}`);
+        }
+        if (!(type instanceof Type)) {
+            throw new Error(`Invalid field type for ${name}`);
+        }
+        if (!__classPrivateFieldGet(_a, _a, "m", _RecordField_isValidOrder).call(_a, order)) {
+            throw new Error(`Invalid record field order: ${order}`);
+        }
+        __classPrivateFieldSet(this, _RecordField_name, name, "f");
+        __classPrivateFieldSet(this, _RecordField_type, type, "f");
+        __classPrivateFieldSet(this, _RecordField_order, order, "f");
+        const aliasSet = new Set();
+        const resolvedAliases = [];
+        for (const alias of aliases) {
+            if (typeof alias !== "string" || !isValidName(alias)) {
+                throw new Error(`Invalid record field alias: ${alias}`);
+            }
+            if (!aliasSet.has(alias)) {
+                aliasSet.add(alias);
+                resolvedAliases.push(alias);
+            }
+        }
+        __classPrivateFieldSet(this, _RecordField_aliases, resolvedAliases, "f");
+        __classPrivateFieldSet(this, _RecordField_hasDefault, Object.prototype.hasOwnProperty.call(params, "default"), "f");
+        if (__classPrivateFieldGet(this, _RecordField_hasDefault, "f")) {
+            __classPrivateFieldSet(this, _RecordField_defaultValue, __classPrivateFieldGet(this, _RecordField_type, "f").cloneFromValue(params.default), "f");
+        }
+    }
+    /**
+     * Gets the name of the field.
+     */
+    getName() {
+        return __classPrivateFieldGet(this, _RecordField_name, "f");
+    }
+    /**
+     * Gets the type of the field.
+     */
+    getType() {
+        return __classPrivateFieldGet(this, _RecordField_type, "f");
+    }
+    /**
+     * Gets the aliases of the field.
+     */
+    getAliases() {
+        return __classPrivateFieldGet(this, _RecordField_aliases, "f").slice();
+    }
+    /**
+     * Gets the order of the field.
+     */
+    getOrder() {
+        return __classPrivateFieldGet(this, _RecordField_order, "f");
+    }
+    /**
+     * Returns true if the field has a default value.
+     */
+    hasDefault() {
+        return __classPrivateFieldGet(this, _RecordField_hasDefault, "f");
+    }
+    /**
+     * Gets the default value for the field.
+     * @returns The default value.
+     * @throws Error if the field has no default.
+     */
+    getDefault() {
+        if (!__classPrivateFieldGet(this, _RecordField_hasDefault, "f")) {
+            throw new Error(`Field '${__classPrivateFieldGet(this, _RecordField_name, "f")}' has no default.`);
+        }
+        return __classPrivateFieldGet(this, _RecordField_type, "f").cloneFromValue(__classPrivateFieldGet(this, _RecordField_defaultValue, "f"));
+    }
+    /**
+     * Checks if the given name matches the field name or any of its aliases.
+     * @param name The name to check.
+     * @returns True if the name matches, false otherwise.
+     */
+    nameMatches(name) {
+        return name === __classPrivateFieldGet(this, _RecordField_name, "f") || __classPrivateFieldGet(this, _RecordField_aliases, "f").includes(name);
+    }
+}
+_a = RecordField, _RecordField_name = new WeakMap(), _RecordField_type = new WeakMap(), _RecordField_aliases = new WeakMap(), _RecordField_order = new WeakMap(), _RecordField_hasDefault = new WeakMap(), _RecordField_defaultValue = new WeakMap(), _RecordField_isValidOrder = function _RecordField_isValidOrder(order) {
+    return order === "ascending" || order === "descending" ||
+        order === "ignore";
+};
+/**
+ * Avro `record` type supporting ordered fields, aliases, and schema evolution.
+ */
+export class RecordType extends NamedType {
+    /**
+     * Creates a new RecordType.
+     * @param params The record type parameters.
+     */
+    constructor(params) {
+        const { fields, ...names } = params;
+        super(names);
+        _RecordType_instances.add(this);
+        _RecordType_fields.set(this, void 0);
+        _RecordType_fieldNameToIndex.set(this, void 0);
+        _RecordType_fieldsThunk.set(this, void 0);
+        __classPrivateFieldSet(this, _RecordType_fields, [], "f");
+        __classPrivateFieldSet(this, _RecordType_fieldNameToIndex, new Map(), "f");
+        if (typeof fields === "function") {
+            // Defer field materialization until the first time the record is used.
+            // This mirrors the classic Avro parsing strategy where named types are
+            // registered before their fields are resolved, allowing recursive schemas.
+            __classPrivateFieldSet(this, _RecordType_fieldsThunk, fields, "f");
+        }
+        else {
+            __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_setFields).call(this, fields);
+        }
+    }
+    /**
+     * Gets the fields of the record.
+     */
+    getFields() {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        return __classPrivateFieldGet(this, _RecordType_fields, "f").slice();
+    }
+    /**
+     * Gets a specific field by name.
+     */
+    getField(name) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        const index = __classPrivateFieldGet(this, _RecordType_fieldNameToIndex, "f").get(name);
+        if (index === undefined) {
+            return undefined;
+        }
+        return __classPrivateFieldGet(this, _RecordType_fields, "f")[index];
+    }
+    /**
+     * Checks if the given value conforms to this record type.
+     * @param value The value to check.
+     * @param errorHook Optional error hook for validation errors.
+     * @param path The current path in the schema for error reporting.
+     * @returns True if the value is valid, false otherwise.
+     */
+    check(value, errorHook, path = []) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        if (!__classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_isRecord).call(this, value)) {
+            if (errorHook) {
+                errorHook(path.slice(), value, this);
+            }
+            return false;
+        }
+        const record = value;
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            if (!__classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_checkField).call(this, field, record, errorHook, path)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Writes the given record value to the tap.
+     * @param tap The writable tap to write to.
+     * @param value The record value to write.
+     */
+    async write(tap, value) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        if (!__classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_isRecord).call(this, value)) {
+            throwInvalidError([], value, this);
+        }
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            await __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_writeField).call(this, field, value, tap);
+        }
+    }
+    /**
+     * Reads a record value from the tap.
+     * @param tap The readable tap to read from.
+     * @returns The read record value.
+     */
+    async read(tap) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        const result = {};
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            result[field.getName()] = await field.getType().read(tap);
+        }
+        return result;
+    }
+    /**
+     * Skips a record value in the tap.
+     * @param tap The readable tap to skip in.
+     */
+    async skip(tap) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            await field.getType().skip(tap);
+        }
+    }
+    /**
+     * Converts the given record value to a buffer.
+     * @param value The record value to convert.
+     * @returns The buffer representation of the value.
+     */
+    async toBuffer(value) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        if (!__classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_isRecord).call(this, value)) {
+            throwInvalidError([], value, this);
+        }
+        const buffers = [];
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            buffers.push(await __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_getFieldBuffer).call(this, field, value));
+        }
+        const totalSize = buffers.reduce((sum, buf) => sum + buf.byteLength, 0);
+        const combined = new Uint8Array(totalSize);
+        let offset = 0;
+        for (const buf of buffers) {
+            combined.set(buf, offset);
+            offset += buf.byteLength;
+        }
+        return combined.buffer;
+    }
+    /**
+     * Clones a record value, ensuring it conforms to the schema.
+     * @param value The value to clone.
+     * @returns The cloned record value.
+     */
+    cloneFromValue(value) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        if (!__classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_isRecord).call(this, value)) {
+            throw new Error("Cannot clone non-record value.");
+        }
+        const recordValue = value;
+        const result = {};
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_cloneField).call(this, field, recordValue, result);
+        }
+        return result;
+    }
+    /**
+     * Compares two record values for ordering.
+     * @param val1 The first record value.
+     * @param val2 The second record value.
+     * @returns A negative number if val1 < val2, zero if equal, positive if val1 > val2.
+     */
+    compare(val1, val2) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        if (!__classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_isRecord).call(this, val1) || !__classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_isRecord).call(this, val2)) {
+            throw new Error("Record comparison requires object values.");
+        }
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            const order = field.getOrder();
+            if (order === "ignore") {
+                continue;
+            }
+            const v1 = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_getComparableValue).call(this, val1, field);
+            const v2 = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_getComparableValue).call(this, val2, field);
+            let comparison = field.getType().compare(v1, v2);
+            if (comparison !== 0) {
+                if (order === "descending") {
+                    comparison = -comparison;
+                }
+                return comparison;
+            }
+        }
+        return 0;
+    }
+    /**
+     * Generates a random record value conforming to this schema.
+     * @returns A random record value.
+     */
+    random() {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        const result = {};
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            result[field.getName()] = field.getType().random();
+        }
+        return result;
+    }
+    /**
+     * Converts this record type to its JSON schema representation.
+     * @returns The JSON representation of the record type.
+     */
+    toJSON() {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        const fieldsJson = __classPrivateFieldGet(this, _RecordType_fields, "f").map((field) => {
+            const fieldJson = {
+                name: field.getName(),
+                type: field.getType().toJSON(),
+            };
+            if (field.hasDefault()) {
+                fieldJson.default = field.getDefault();
+            }
+            const aliases = field.getAliases();
+            if (aliases.length > 0) {
+                fieldJson.aliases = aliases;
+            }
+            if (field.getOrder() !== "ascending") {
+                fieldJson.order = field.getOrder();
+            }
+            return fieldJson;
+        });
+        return {
+            name: this.getFullName(),
+            type: "record",
+            fields: fieldsJson,
+        };
+    }
+    /**
+     * Matches two record values from the taps for comparison.
+     * @param tap1 The first readable tap.
+     * @param tap2 The second readable tap.
+     * @returns A comparison result.
+     */
+    async match(tap1, tap2) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        for (const field of __classPrivateFieldGet(this, _RecordType_fields, "f")) {
+            const order = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_getOrderValue).call(this, field.getOrder());
+            const type = field.getType();
+            if (order !== 0) {
+                const result = (await type.match(tap1, tap2)) * order;
+                if (result !== 0) {
+                    return result;
+                }
+            }
+            else {
+                await type.skip(tap1);
+                await type.skip(tap2);
+            }
+        }
+        return 0;
+    }
+    /**
+     * Creates a resolver for schema evolution from the writer type to this reader type.
+     * @param writerType The writer type to resolve from.
+     * @returns A resolver for reading writer data with this schema.
+     */
+    createResolver(writerType) {
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_ensureFields).call(this);
+        if (!(writerType instanceof RecordType)) {
+            return super.createResolver(writerType);
+        }
+        const acceptableNames = new Set([
+            this.getFullName(),
+            ...this.getAliases(),
+        ]);
+        if (!acceptableNames.has(writerType.getFullName())) {
+            throw new Error(`Schema evolution not supported from writer type: ${writerType.getFullName()} to reader type: ${this.getFullName()}`);
+        }
+        const readerFields = __classPrivateFieldGet(this, _RecordType_fields, "f");
+        const writerFields = writerType.getFields();
+        const readerNameToIndex = new Map();
+        readerFields.forEach((field, index) => {
+            readerNameToIndex.set(field.getName(), index);
+            field.getAliases().forEach((alias) => {
+                readerNameToIndex.set(alias, index);
+            });
+        });
+        const assignedReaderIndexes = new Set();
+        const mappings = [];
+        writerFields.forEach((writerField) => {
+            let readerIndex = readerNameToIndex.get(writerField.getName());
+            if (readerIndex === undefined) {
+                for (const alias of writerField.getAliases()) {
+                    const idx = readerNameToIndex.get(alias);
+                    if (idx !== undefined) {
+                        readerIndex = idx;
+                        break;
+                    }
+                }
+            }
+            if (readerIndex === undefined) {
+                mappings.push({
+                    readerIndex: -1,
+                    writerField,
+                });
+                return;
+            }
+            if (assignedReaderIndexes.has(readerIndex)) {
+                throw new Error(`Multiple writer fields map to reader field: ${readerFields[readerIndex].getName()}`);
+            }
+            const readerField = readerFields[readerIndex];
+            const readerType = readerField.getType();
+            const writerType = writerField.getType();
+            const resolver = readerType === writerType
+                ? undefined
+                : readerType.createResolver(writerType);
+            mappings.push({
+                readerIndex,
+                writerField,
+                resolver,
+            });
+            assignedReaderIndexes.add(readerIndex);
+        });
+        readerFields.forEach((field, index) => {
+            if (!assignedReaderIndexes.has(index) && !field.hasDefault()) {
+                throw new Error(`Field '${field.getName()}' missing from writer schema and has no default.`);
+            }
+        });
+        return new RecordResolver(this, mappings, readerFields);
+    }
+}
+_RecordType_fields = new WeakMap(), _RecordType_fieldNameToIndex = new WeakMap(), _RecordType_fieldsThunk = new WeakMap(), _RecordType_instances = new WeakSet(), _RecordType_ensureFields = function _RecordType_ensureFields() {
+    if (__classPrivateFieldGet(this, _RecordType_fieldsThunk, "f")) {
+        const builder = __classPrivateFieldGet(this, _RecordType_fieldsThunk, "f");
+        __classPrivateFieldSet(this, _RecordType_fieldsThunk, undefined, "f");
+        const resolved = builder();
+        __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_setFields).call(this, resolved);
+    }
+}, _RecordType_setFields = function _RecordType_setFields(candidate) {
+    if (!Array.isArray(candidate)) {
+        throw new Error("RecordType requires a fields array.");
+    }
+    __classPrivateFieldSet(this, _RecordType_fields, [], "f");
+    __classPrivateFieldGet(this, _RecordType_fieldNameToIndex, "f").clear();
+    candidate.forEach((fieldParams) => {
+        const field = new RecordField(fieldParams);
+        if (__classPrivateFieldGet(this, _RecordType_fieldNameToIndex, "f").has(field.getName())) {
+            throw new Error(`Duplicate record field name: ${field.getName()}`);
+        }
+        __classPrivateFieldGet(this, _RecordType_fieldNameToIndex, "f").set(field.getName(), __classPrivateFieldGet(this, _RecordType_fields, "f").length);
+        __classPrivateFieldGet(this, _RecordType_fields, "f").push(field);
+    });
+}, _RecordType_getOrderValue = function _RecordType_getOrderValue(order) {
+    switch (order) {
+        case "ascending":
+            return 1;
+        case "descending":
+            return -1;
+        case "ignore":
+            return 0;
+    }
+}, _RecordType_isRecord = function _RecordType_isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}, _RecordType_extractFieldValue = function _RecordType_extractFieldValue(record, field) {
+    const name = field.getName();
+    const hasValue = Object.hasOwn(record, name);
+    const fieldValue = hasValue ? record[name] : undefined;
+    return { hasValue, fieldValue };
+}, _RecordType_checkField = function _RecordType_checkField(field, record, errorHook, path) {
+    const { hasValue, fieldValue } = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_extractFieldValue).call(this, record, field);
+    if (!hasValue) {
+        if (!field.hasDefault()) {
+            if (errorHook) {
+                errorHook([...path, field.getName()], undefined, this);
+            }
+            return false;
+        }
+        return true;
+    }
+    const nextPath = errorHook ? [...path, field.getName()] : undefined;
+    const valid = field.getType().check(fieldValue, errorHook, nextPath);
+    return valid || (errorHook !== undefined);
+}, _RecordType_writeField = async function _RecordType_writeField(field, record, tap) {
+    const { hasValue, fieldValue } = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_extractFieldValue).call(this, record, field);
+    let toWrite = fieldValue;
+    if (!hasValue) {
+        if (!field.hasDefault()) {
+            throwInvalidError([field.getName()], undefined, this);
+        }
+        toWrite = field.getDefault();
+    }
+    await field.getType().write(tap, toWrite);
+}, _RecordType_getFieldBuffer = async function _RecordType_getFieldBuffer(field, record) {
+    const { hasValue, fieldValue } = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_extractFieldValue).call(this, record, field);
+    let toEncode = fieldValue;
+    if (!hasValue) {
+        if (!field.hasDefault()) {
+            throwInvalidError([field.getName()], undefined, this);
+        }
+        toEncode = field.getDefault();
+    }
+    return new Uint8Array(await field.getType().toBuffer(toEncode));
+}, _RecordType_cloneField = function _RecordType_cloneField(field, record, result) {
+    const { hasValue, fieldValue } = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_extractFieldValue).call(this, record, field);
+    if (!hasValue) {
+        if (!field.hasDefault()) {
+            throw new Error(`Missing value for record field ${field.getName()} with no default.`);
+        }
+        result[field.getName()] = field.getDefault();
+        return;
+    }
+    result[field.getName()] = field.getType().cloneFromValue(fieldValue);
+}, _RecordType_getComparableValue = function _RecordType_getComparableValue(record, field) {
+    const { hasValue, fieldValue } = __classPrivateFieldGet(this, _RecordType_instances, "m", _RecordType_extractFieldValue).call(this, record, field);
+    if (hasValue) {
+        return fieldValue;
+    }
+    if (field.hasDefault()) {
+        return field.getDefault();
+    }
+    throw new Error(`Missing comparable value for field '${field.getName()}' with no default.`);
+};
+class RecordResolver extends Resolver {
+    constructor(reader, mappings, readerFields) {
+        super(reader);
+        _RecordResolver_mappings.set(this, void 0);
+        _RecordResolver_readerFields.set(this, void 0);
+        __classPrivateFieldSet(this, _RecordResolver_mappings, mappings, "f");
+        __classPrivateFieldSet(this, _RecordResolver_readerFields, readerFields, "f");
+    }
+    async read(tap) {
+        const result = {};
+        const seen = new Array(__classPrivateFieldGet(this, _RecordResolver_readerFields, "f").length).fill(false);
+        for (const mapping of __classPrivateFieldGet(this, _RecordResolver_mappings, "f")) {
+            if (mapping.readerIndex === -1) {
+                await mapping.writerField.getType().skip(tap);
+                continue;
+            }
+            const value = mapping.resolver
+                ? await mapping.resolver.read(tap)
+                : await mapping.writerField.getType().read(tap);
+            const readerField = __classPrivateFieldGet(this, _RecordResolver_readerFields, "f")[mapping.readerIndex];
+            result[readerField.getName()] = value;
+            seen[mapping.readerIndex] = true;
+        }
+        for (let i = 0; i < __classPrivateFieldGet(this, _RecordResolver_readerFields, "f").length; i++) {
+            if (!seen[i]) {
+                const field = __classPrivateFieldGet(this, _RecordResolver_readerFields, "f")[i];
+                result[field.getName()] = field.getDefault();
+            }
+        }
+        return result;
+    }
+}
+_RecordResolver_mappings = new WeakMap(), _RecordResolver_readerFields = new WeakMap();

package/esm/schemas/complex/resolve_names.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Checks if the given name is a valid Avro identifier.
+ * @param name - The name to validate.
+ * @returns True if the name is valid, false otherwise.
+ */
+export declare function isValidName(name: string): boolean;
+/**
+ * Parameters for resolving Avro names, including namespace qualification and aliases.
+ */
+export interface ResolveNamesParams {
+    /** The base name of the type. */
+    name: string;
+    /** Optional namespace to qualify the name. */
+    namespace?: string;
+    /** Optional list of aliases for the type. */
+    aliases?: string[];
+}
+/**
+ * Represents the resolved names for an Avro type, including its full name, aliases, and namespace.
+ */
+export interface ResolvedNames {
+    /** The fully qualified name of the type. */
+    fullName: string;
+    /** The resolved aliases for the type. */
+    aliases: string[];
+    /** The namespace of the type. */
+    namespace: string;
+}
+/**
+ * Resolves the full name, aliases, and namespace for an Avro type based on the provided parameters.
+ */
+export declare function resolveNames({ name, namespace, aliases }: ResolveNamesParams): ResolvedNames;

package/esm/schemas/complex/resolve_names.js

@@ -0,0 +1,85 @@
+const NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+ * Checks if the given name is a valid Avro identifier.
+ * @param name - The name to validate.
+ * @returns True if the name is valid, false otherwise.
+ */
+export function isValidName(name) {
+    return NAME_PATTERN.test(name);
+}
+const PRIMITIVE_TYPE_NAMES = new Set([
+    "null",
+    "boolean",
+    "int",
+    "long",
+    "float",
+    "double",
+    "bytes",
+    "string",
+]);
+/**
+ * Resolves the full name, aliases, and namespace for an Avro type based on the provided parameters.
+ */
+export function resolveNames({ name, namespace, aliases = [] }) {
+    const fullName = qualifyName(name, namespace);
+    const typeNamespace = getNamespaceFromName(fullName);
+    const resolvedAliases = [];
+    const seen = new Set();
+    seen.add(fullName);
+    for (const alias of aliases) {
+        const qualified = qualifyAlias(alias, typeNamespace);
+        if (!seen.has(qualified)) {
+            seen.add(qualified);
+            resolvedAliases.push(qualified);
+        }
+    }
+    return {
+        fullName,
+        aliases: resolvedAliases,
+        namespace: typeNamespace ?? "",
+    };
+}
+function qualifyName(name, namespace) {
+    if (!name) {
+        throw new Error("Avro name is required.");
+    }
+    let qualified = name;
+    if (namespace && !name.includes(".")) {
+        qualified = `${namespace}.${name}`;
+    }
+    validateFullName(qualified, false);
+    return qualified;
+}
+function qualifyAlias(alias, namespace) {
+    if (!alias) {
+        throw new Error("Avro alias is required.");
+    }
+    let qualified = alias;
+    if (namespace && !alias.includes(".")) {
+        qualified = `${namespace}.${alias}`;
+    }
+    validateFullName(qualified, true);
+    return qualified;
+}
+function validateFullName(name, isAlias) {
+    const parts = name.split(".");
+    parts.forEach((part) => {
+        if (!isValidName(part)) {
+            throw new Error(`${isAlias ? "Invalid Avro alias: " : "Invalid Avro name: "}${name}`);
+        }
+    });
+    const tail = parts[parts.length - 1];
+    if (PRIMITIVE_TYPE_NAMES.has(tail)) {
+        throw new Error(`${isAlias
+            ? "Cannot rename primitive Avro alias: "
+            : "Cannot rename primitive Avro type: "}${tail}`);
+    }
+}
+function getNamespaceFromName(name) {
+    const parts = name.split(".");
+    if (parts.length <= 1) {
+        return undefined;
+    }
+    parts.pop();
+    return parts.join(".");
+}