@sachitv/avro-typescript 0.4.0

package/esm/type/create_type.js

@@ -0,0 +1,401 @@
+import { ArrayType } from "../schemas/complex/array_type.js";
+import { BooleanType } from "../schemas/primitive/boolean_type.js";
+import { BytesType } from "../schemas/primitive/bytes_type.js";
+import { DoubleType } from "../schemas/primitive/double_type.js";
+import { EnumType } from "../schemas/complex/enum_type.js";
+import { FixedType, } from "../schemas/complex/fixed_type.js";
+import { FloatType } from "../schemas/primitive/float_type.js";
+import { IntType } from "../schemas/primitive/int_type.js";
+import { LongType } from "../schemas/primitive/long_type.js";
+import { MapType } from "../schemas/complex/map_type.js";
+import { RecordType, } from "../schemas/complex/record_type.js";
+import { resolveNames } from "../schemas/complex/resolve_names.js";
+import { StringType } from "../schemas/primitive/string_type.js";
+import { UnionType } from "../schemas/complex/union_type.js";
+import { NullType } from "../schemas/primitive/null_type.js";
+import { Type } from "../schemas/type.js";
+import { safeStringify } from "../schemas/json.js";
+import { DecimalLogicalType } from "../schemas/logical/decimal_logical_type.js";
+import { UuidLogicalType } from "../schemas/logical/uuid_logical_type.js";
+import { DateLogicalType, LocalTimestampMicrosLogicalType, LocalTimestampMillisLogicalType, LocalTimestampNanosLogicalType, TimeMicrosLogicalType, TimeMillisLogicalType, TimestampMicrosLogicalType, TimestampMillisLogicalType, TimestampNanosLogicalType, } from "../schemas/logical/temporal_logical_types.js";
+import { DurationLogicalType } from "../schemas/logical/duration_logical_type.js";
+import { NamedType } from "../schemas/complex/named_type.js";
+const PRIMITIVE_FACTORIES = {
+    "null": () => new NullType(),
+    "boolean": () => new BooleanType(),
+    "int": () => new IntType(),
+    "long": () => new LongType(),
+    "float": () => new FloatType(),
+    "double": () => new DoubleType(),
+    "bytes": () => new BytesType(),
+    "string": () => new StringType(),
+};
+/**
+ * Constructs an Avro {@link Type} from a schema definition.
+ */
+export function createType(schema, options = {}) {
+    const registry = options.registry ?? new Map();
+    const context = {
+        namespace: options.namespace,
+        registry,
+    };
+    return constructType(schema, context);
+}
+function constructType(schema, context) {
+    if (schema instanceof Type) {
+        return schema;
+    }
+    if (typeof schema === "string") {
+        return createFromTypeName(schema, context);
+    }
+    if (Array.isArray(schema)) {
+        return createUnionType(schema, context);
+    }
+    if (schema === null || typeof schema !== "object") {
+        throw new Error(`Unsupported Avro schema: ${safeStringify(schema)}`);
+    }
+    const logicalType = schema.logicalType;
+    if (logicalType !== undefined) {
+        return createLogicalType(schema, logicalType, context);
+    }
+    const { type } = schema;
+    if (typeof type === "string") {
+        if (isRecordTypeName(type)) {
+            return createRecordType(schema, type, context);
+        }
+        if (type === "enum") {
+            return createEnumType(schema, context);
+        }
+        if (type === "fixed") {
+            return createFixedType(schema, context);
+        }
+        if (type === "array") {
+            return createArrayType(schema, context);
+        }
+        if (type === "map") {
+            return createMapType(schema, context);
+        }
+        if (isPrimitiveTypeName(type)) {
+            return PRIMITIVE_FACTORIES[type]();
+        }
+        return createFromTypeName(type, {
+            namespace: extractNamespace(schema, context.namespace),
+            registry: context.registry,
+        });
+    }
+    if (Array.isArray(type)) {
+        // When we're dealing with an array as a schema, it is a Union.
+        // > https://avro.apache.org/docs/1.12.0/specification/#unions
+        // > `Unions, as mentioned above, are represented using JSON arrays`.
+        return createUnionType(type, context);
+    }
+    if (type && typeof type === "object") {
+        return constructType(type, context);
+    }
+    throw new Error(`Schema is missing a valid "type" property: ${safeStringify(schema)}`);
+}
+function createLogicalType(schema, logicalType, context) {
+    const buildUnderlying = () => {
+        const underlyingSchema = { ...schema };
+        delete underlyingSchema.logicalType;
+        return constructType(underlyingSchema, context);
+    };
+    if (typeof logicalType !== "string") {
+        return buildUnderlying();
+    }
+    const underlying = buildUnderlying();
+    const replaceIfNamed = (logical) => {
+        if (underlying instanceof NamedType) {
+            context.registry.set(underlying.getFullName(), logical);
+        }
+        return logical;
+    };
+    try {
+        switch (logicalType) {
+            case "decimal": {
+                if (underlying instanceof BytesType || underlying instanceof FixedType) {
+                    const precision = schema.precision;
+                    const scaleValue = schema.scale;
+                    if (typeof precision !== "number") {
+                        return underlying;
+                    }
+                    if (scaleValue !== undefined && typeof scaleValue !== "number") {
+                        return underlying;
+                    }
+                    const logical = new DecimalLogicalType(underlying, {
+                        precision,
+                        scale: scaleValue,
+                    });
+                    return replaceIfNamed(logical);
+                }
+                return underlying;
+            }
+            case "uuid": {
+                if (underlying instanceof StringType || underlying instanceof FixedType) {
+                    const logical = new UuidLogicalType(underlying);
+                    return replaceIfNamed(logical);
+                }
+                return underlying;
+            }
+            case "date": {
+                if (underlying instanceof IntType) {
+                    return new DateLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "time-millis": {
+                if (underlying instanceof IntType) {
+                    return new TimeMillisLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "time-micros": {
+                if (underlying instanceof LongType) {
+                    return new TimeMicrosLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "timestamp-millis": {
+                if (underlying instanceof LongType) {
+                    return new TimestampMillisLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "timestamp-micros": {
+                if (underlying instanceof LongType) {
+                    return new TimestampMicrosLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "timestamp-nanos": {
+                if (underlying instanceof LongType) {
+                    return new TimestampNanosLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "local-timestamp-millis": {
+                if (underlying instanceof LongType) {
+                    return new LocalTimestampMillisLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "local-timestamp-micros": {
+                if (underlying instanceof LongType) {
+                    return new LocalTimestampMicrosLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "local-timestamp-nanos": {
+                if (underlying instanceof LongType) {
+                    return new LocalTimestampNanosLogicalType(underlying);
+                }
+                return underlying;
+            }
+            case "duration": {
+                if (underlying instanceof FixedType) {
+                    const logical = new DurationLogicalType(underlying);
+                    return replaceIfNamed(logical);
+                }
+                return underlying;
+            }
+            default:
+                return underlying;
+        }
+    }
+    catch {
+        return underlying;
+    }
+}
+function createFromTypeName(name, context) {
+    if (isPrimitiveTypeName(name)) {
+        return PRIMITIVE_FACTORIES[name]();
+    }
+    const fullName = qualifyReference(name, context.namespace);
+    const found = context.registry.get(fullName);
+    if (found) {
+        return found;
+    }
+    materializeLazyRecordFields(context.registry);
+    const materialized = context.registry.get(fullName);
+    if (materialized) {
+        return materialized;
+    }
+    throw new Error(`Undefined Avro type reference: ${name}`);
+}
+function createRecordType(schema, typeName, context) {
+    const name = schema.name;
+    if (typeof name !== "string" || name.length === 0) {
+        throw new Error(`Record schema requires a non-empty name: ${safeStringify(schema)}`);
+    }
+    const aliases = toStringArray(schema.aliases);
+    const resolved = resolveNames({
+        name,
+        namespace: extractNamespace(schema, context.namespace),
+        aliases,
+    });
+    const childContext = {
+        namespace: resolved.namespace || undefined,
+        registry: context.registry,
+    };
+    const fieldsValue = schema.fields;
+    if (!Array.isArray(fieldsValue)) {
+        throw new Error(`Record schema requires a fields array: ${safeStringify(schema)}`);
+    }
+    const buildFields = () => {
+        return fieldsValue.map((field) => {
+            if (field === null || typeof field !== "object") {
+                throw new Error(`Invalid record field definition: ${safeStringify(field)}`);
+            }
+            const fieldName = field.name;
+            if (typeof fieldName !== "string" || fieldName.length === 0) {
+                throw new Error(`Record field requires a non-empty name: ${safeStringify(field)}`);
+            }
+            if (!("type" in field)) {
+                throw new Error(`Record field "${fieldName}" is missing a type definition.`);
+            }
+            const fieldType = constructType(field.type, childContext);
+            const fieldAliases = toStringArray(field.aliases);
+            const order = field.order;
+            const fieldParams = {
+                name: fieldName,
+                type: fieldType,
+            };
+            if (fieldAliases.length > 0) {
+                fieldParams.aliases = fieldAliases;
+            }
+            if (order === "ascending" || order === "descending" || order === "ignore") {
+                fieldParams.order = order;
+            }
+            if (field.default !== undefined) {
+                fieldParams.default = field.default;
+            }
+            return fieldParams;
+        });
+    };
+    /*
+    The Avro spec (section 2.8 "Protocols") treats the implicit "request" type
+    declared on each RPC message as a record-like structure that is not a
+    standalone named type; it exists solely within that message's scope. Record
+    and error types are bona fide named types that can be reused elsewhere, so
+    only those should be registered in the shared registry. Skipping "request"
+    avoids polluting the registry with per-message-only definitions.
+    */
+    const shouldRegister = typeName !== "request";
+    if (shouldRegister && context.registry.has(resolved.fullName)) {
+        throw new Error(`Duplicate Avro type name: ${resolved.fullName}`);
+    }
+    const params = {
+        ...resolved,
+        fields: buildFields,
+    };
+    const record = new RecordType(params);
+    if (shouldRegister) {
+        context.registry.set(resolved.fullName, record);
+    }
+    return record;
+}
+function createEnumType(schema, context) {
+    const name = schema.name;
+    if (typeof name !== "string" || name.length === 0) {
+        throw new Error(`Enum schema requires a non-empty name: ${safeStringify(schema)}`);
+    }
+    const aliases = toStringArray(schema.aliases);
+    const resolved = resolveNames({
+        name,
+        namespace: extractNamespace(schema, context.namespace),
+        aliases,
+    });
+    const symbols = schema.symbols;
+    if (!Array.isArray(symbols) || symbols.some((s) => typeof s !== "string")) {
+        throw new Error(`Enum schema requires an array of string symbols: ${safeStringify(schema)}`);
+    }
+    if (context.registry.has(resolved.fullName)) {
+        throw new Error(`Duplicate Avro type name: ${resolved.fullName}`);
+    }
+    const params = {
+        ...resolved,
+        symbols: symbols.slice(),
+    };
+    if (schema.default !== undefined) {
+        params.default = schema.default;
+    }
+    const enumType = new EnumType(params);
+    context.registry.set(resolved.fullName, enumType);
+    return enumType;
+}
+function createFixedType(schema, context) {
+    const name = schema.name;
+    if (typeof name !== "string" || name.length === 0) {
+        throw new Error(`Fixed schema requires a non-empty name: ${safeStringify(schema)}`);
+    }
+    const aliases = toStringArray(schema.aliases);
+    const resolved = resolveNames({
+        name,
+        namespace: extractNamespace(schema, context.namespace),
+        aliases,
+    });
+    if (context.registry.has(resolved.fullName)) {
+        throw new Error(`Duplicate Avro type name: ${resolved.fullName}`);
+    }
+    const params = {
+        ...resolved,
+        size: schema.size,
+    };
+    const fixed = new FixedType(params);
+    context.registry.set(resolved.fullName, fixed);
+    return fixed;
+}
+function createArrayType(schema, context) {
+    if (!("items" in schema)) {
+        throw new Error(`Array schema requires an "items" definition: ${safeStringify(schema)}`);
+    }
+    const itemsType = constructType(schema.items, context);
+    return new ArrayType({ items: itemsType });
+}
+function createMapType(schema, context) {
+    if (!("values" in schema)) {
+        throw new Error(`Map schema requires a "values" definition: ${safeStringify(schema)}`);
+    }
+    const valuesType = constructType(schema.values, context);
+    return new MapType({ values: valuesType });
+}
+function createUnionType(schemas, context) {
+    if (schemas.length === 0) {
+        throw new Error("Union schema requires at least one branch type.");
+    }
+    const types = schemas.map((branch) => constructType(branch, context));
+    return new UnionType({ types });
+}
+function isPrimitiveTypeName(value) {
+    return typeof value === "string" && value in PRIMITIVE_FACTORIES;
+}
+function materializeLazyRecordFields(registry) {
+    for (const type of registry.values()) {
+        if (type instanceof RecordType) {
+            // Ensures nested named types defined inside record fields are registered.
+            type.getFields();
+        }
+    }
+}
+function isRecordTypeName(value) {
+    return value === "record" || value === "error" || value === "request";
+}
+function toStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === "string");
+}
+function extractNamespace(schema, fallback) {
+    const namespace = schema.namespace;
+    if (typeof namespace === "string") {
+        return namespace.length > 0 ? namespace : undefined;
+    }
+    return fallback;
+}
+function qualifyReference(name, namespace) {
+    if (!namespace || name.includes(".")) {
+        return name;
+    }
+    return `${namespace}.${name}`;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sachitv/avro-typescript",
+  "version": "0.4.0",
+  "description": "Avro schema parsing, serialization, and RPC helpers for TypeScript runtimes.",
+  "homepage": "https://github.com/sachitv/avro-typescript",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sachitv/avro-typescript"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/sachitv/avro-typescript/issues"
+  },
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.mjs",
+      "types": "./esm/mod.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@0.40.0"
+}