@sachitv/avro-typescript 0.4.1 → 0.5.0

package/esm/type/create_type.js

@@ -20,16 +20,26 @@ 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(),
-};
+function createPrimitiveType(name, validate) {
+    switch (name) {
+        case "null":
+            return new NullType(validate);
+        case "boolean":
+            return new BooleanType(validate);
+        case "int":
+            return new IntType(validate);
+        case "long":
+            return new LongType(validate);
+        case "float":
+            return new FloatType(validate);
+        case "double":
+            return new DoubleType(validate);
+        case "bytes":
+            return new BytesType(validate);
+        case "string":
+            return new StringType(validate);
+    }
+}
 /**
  * Constructs an Avro {@link Type} from a schema definition.
  */
@@ -38,6 +48,8 @@ export function createType(schema, options = {}) {
     const context = {
         namespace: options.namespace,
         registry,
+        validate: options.validate ?? true,
+        writerStrategy: options.writerStrategy,
     };
     return constructType(schema, context);
 }
@@ -76,11 +88,12 @@ function constructType(schema, context) {
             return createMapType(schema, context);
         }
         if (isPrimitiveTypeName(type)) {
-            return PRIMITIVE_FACTORIES[type]();
+            return createPrimitiveType(type, context.validate);
         }
         return createFromTypeName(type, {
             namespace: extractNamespace(schema, context.namespace),
             registry: context.registry,
+            validate: context.validate,
         });
     }
     if (Array.isArray(type)) {
@@ -125,75 +138,75 @@ function createLogicalType(schema, logicalType, context) {
                     const logical = new DecimalLogicalType(underlying, {
                         precision,
                         scale: scaleValue,
-                    });
+                    }, context.validate);
                     return replaceIfNamed(logical);
                 }
                 return underlying;
             }
             case "uuid": {
                 if (underlying instanceof StringType || underlying instanceof FixedType) {
-                    const logical = new UuidLogicalType(underlying);
+                    const logical = new UuidLogicalType(underlying, context.validate);
                     return replaceIfNamed(logical);
                 }
                 return underlying;
             }
             case "date": {
                 if (underlying instanceof IntType) {
-                    return new DateLogicalType(underlying);
+                    return new DateLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "time-millis": {
                 if (underlying instanceof IntType) {
-                    return new TimeMillisLogicalType(underlying);
+                    return new TimeMillisLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "time-micros": {
                 if (underlying instanceof LongType) {
-                    return new TimeMicrosLogicalType(underlying);
+                    return new TimeMicrosLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "timestamp-millis": {
                 if (underlying instanceof LongType) {
-                    return new TimestampMillisLogicalType(underlying);
+                    return new TimestampMillisLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "timestamp-micros": {
                 if (underlying instanceof LongType) {
-                    return new TimestampMicrosLogicalType(underlying);
+                    return new TimestampMicrosLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "timestamp-nanos": {
                 if (underlying instanceof LongType) {
-                    return new TimestampNanosLogicalType(underlying);
+                    return new TimestampNanosLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "local-timestamp-millis": {
                 if (underlying instanceof LongType) {
-                    return new LocalTimestampMillisLogicalType(underlying);
+                    return new LocalTimestampMillisLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "local-timestamp-micros": {
                 if (underlying instanceof LongType) {
-                    return new LocalTimestampMicrosLogicalType(underlying);
+                    return new LocalTimestampMicrosLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "local-timestamp-nanos": {
                 if (underlying instanceof LongType) {
-                    return new LocalTimestampNanosLogicalType(underlying);
+                    return new LocalTimestampNanosLogicalType(underlying, context.validate);
                 }
                 return underlying;
             }
             case "duration": {
                 if (underlying instanceof FixedType) {
-                    const logical = new DurationLogicalType(underlying);
+                    const logical = new DurationLogicalType(underlying, context.validate);
                     return replaceIfNamed(logical);
                 }
                 return underlying;
@@ -208,7 +221,7 @@ function createLogicalType(schema, logicalType, context) {
 }
 function createFromTypeName(name, context) {
     if (isPrimitiveTypeName(name)) {
-        return PRIMITIVE_FACTORIES[name]();
+        return createPrimitiveType(name, context.validate);
     }
     const fullName = qualifyReference(name, context.namespace);
     const found = context.registry.get(fullName);
@@ -236,6 +249,8 @@ function createRecordType(schema, typeName, context) {
     const childContext = {
         namespace: resolved.namespace || undefined,
         registry: context.registry,
+        validate: context.validate,
+        writerStrategy: context.writerStrategy,
     };
     const fieldsValue = schema.fields;
     if (!Array.isArray(fieldsValue)) {
@@ -287,6 +302,8 @@ function createRecordType(schema, typeName, context) {
     const params = {
         ...resolved,
         fields: buildFields,
+        validate: context.validate,
+        writerStrategy: context.writerStrategy,
     };
     const record = new RecordType(params);
     if (shouldRegister) {
@@ -315,6 +332,7 @@ function createEnumType(schema, context) {
     const params = {
         ...resolved,
         symbols: symbols.slice(),
+        validate: context.validate,
     };
     if (schema.default !== undefined) {
         params.default = schema.default;
@@ -340,6 +358,7 @@ function createFixedType(schema, context) {
     const params = {
         ...resolved,
         size: schema.size,
+        validate: context.validate,
     };
     const fixed = new FixedType(params);
     context.registry.set(resolved.fullName, fixed);
@@ -350,24 +369,26 @@ function createArrayType(schema, context) {
         throw new Error(`Array schema requires an "items" definition: ${safeStringify(schema)}`);
     }
     const itemsType = constructType(schema.items, context);
-    return new ArrayType({ items: itemsType });
+    return new ArrayType({ items: itemsType, validate: context.validate });
 }
 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 });
+    return new MapType({ values: valuesType, validate: context.validate });
 }
 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 });
+    return new UnionType({ types, validate: context.validate });
 }
 function isPrimitiveTypeName(value) {
-    return typeof value === "string" && value in PRIMITIVE_FACTORIES;
+    return value === "null" || value === "boolean" || value === "int" ||
+        value === "long" || value === "float" || value === "double" ||
+        value === "bytes" || value === "string";
 }
 function materializeLazyRecordFields(registry) {
     for (const type of registry.values()) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@sachitv/avro-typescript",
-  "version": "0.4.1",
+  "version": "0.5.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"
+    "url": "git+https://github.com/sachitv/avro-typescript"
   },
   "license": "MIT",
   "bugs": {

package/esm/serialization/manipulate_bytes.d.ts

@@ -1,6 +0,0 @@
-/**
- * Inverts the bits of the bytes in a Uint8Array up to a specified length.
- * @param arr The Uint8Array to invert.
- * @param len The number of bytes to invert from the beginning of the array.
- */
-export declare function invert(arr: Uint8Array, len: number): void;

package/esm/serialization/manipulate_bytes.js

@@ -1,13 +0,0 @@
-/**
- * Inverts the bits of the bytes in a Uint8Array up to a specified length.
- * @param arr The Uint8Array to invert.
- * @param len The number of bytes to invert from the beginning of the array.
- */
-export function invert(arr, len) {
-    const view = new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-    let remaining = Math.min(Math.max(len, 0), arr.length);
-    while (remaining--) {
-        const current = view.getUint8(remaining);
-        view.setUint8(remaining, (~current) & 0xff);
-    }
-}

package/esm/serialization/read_uint_le.d.ts

@@ -1,4 +0,0 @@
-/**
- * Reads an unsigned little-endian integer from a buffer at a specified offset and byte length.
- */
-export declare function readUIntLE(view: DataView, offset: number, byteLength: number): number;

package/esm/serialization/read_uint_le.js

@@ -1,14 +0,0 @@
-/**
- * Reads an unsigned little-endian integer from a buffer at a specified offset and byte length.
- */
-export function readUIntLE(view, offset, byteLength) {
-    let value = 0;
-    for (let i = 0; i < byteLength; i++) {
-        const index = offset + i;
-        if (index >= view.byteLength) {
-            break;
-        }
-        value |= view.getUint8(index) << (8 * i);
-    }
-    return value >>> 0;
-}