mtth/README.md

For DecimalType the calls to new Buffer() should be changed to Buffer.alloc()

The DecimalType should also allocate the buffer size according to the unscaled value, not the scaled value:

DecimalType.prototype._toValue = function (dec) {
  if (!(dec instanceof this.Decimal)) {
    throw new Error('invalid decimal');
  }

  var type = this.underlyingType;
  var unscaled = dec.unscaled;
  var buf;

  if (avro.Type.isType(type, 'fixed')) {
    buf = Buffer.alloc(type.size);
  } else {
    var size = Math.log(unscaled > 0 ? unscaled : - 2 * unscaled) / (Math.log(2) * 8) | 0;
    buf = Buffer.alloc(size + 1);
  }

  buf.writeIntBE(unscaled, 0, buf.length);
  return buf;
};

would it be possible to paste a helloworld nodejs code to use logicaltype decimal
for example, i am trying to generate avro from csv. the csv has decimals - for example, 10045.36. , as one of the columns.
But, not able to work my way through.
the date.js example works like a charm.

After playing around a bit, here is my version in Typescript. I've had to change the math formulas as I was getting some inaccurate results.
It seems to conform with lib's API but not sure if I missed sth. Any comments more than welcome

import * as avro from "avsc";
interface UnderLyingType {
    [key: string]: any;
}
export class Decimal {
  unscaled: number;
  precision: number;
  scale: number;

  constructor(unscaled: number, precision: number, scale: number) {
    this.unscaled = unscaled;
    this.precision = precision;
    this.scale = scale;
  }
  toNumber() {
    // return this.unscaled * Math.pow(10, -this.scale); <= this was producing decimals like that 123.56000007 instead of 123.56
    return this.unscaled / Math.pow(10, this.scale);
  }
}

export class DecimalType extends avro.types.LogicalType {
    decimal: Decimal;
    
  constructor(attrs, opts) {
    super(attrs, opts);

    const precision = attrs.precision;
    if (precision !== (Math.trunc(precision)) || precision <= 0) {
      throw new Error("invalid precision");
    }
    const scale = attrs.scale;
    if (scale !== (Math.trunc(scale)) || scale < 0 || scale > precision) {
      throw new Error("invalid scale");
    }
    const type = this.underlyingType as UnderLyingType;
    if (avro.Type.isType(type, "fixed")) {
      const size = type.size;
      const maxPrecision =
        Math.log(Math.pow(2, 8 * size - 1) - 1) / Math.log(10);
      if (precision > (Math.trunc(maxPrecision))) {
        throw new Error("fixed size too small to hold required precision");
      }
    }
    this.decimal = new Decimal(0, precision, scale);
  }

  _fromValue (buf) {
    return new Decimal(buf.readIntBE(0, buf.length), this.decimal.precision, this.decimal.scale).toNumber();
  }

  _toValue(dec) {
    if (!(dec instanceof Decimal)) {
    //   throw new TypeError("invalid decimal"); not sure what is the purpose of this check
        console.log("creating new decimal");
        const unscaled = Math.round(dec * Math.pow(10, this.decimal.scale));
        dec = new Decimal(unscaled, this.decimal.precision, this.decimal.scale);
    }
  
    const type = this.underlyingType as UnderLyingType;
    let buf: Buffer;
    if (avro.Type.isType(type, "fixed")) {
      buf = Buffer.alloc(type.size);
    } else {
      const absoluteValue = Math.abs(dec.unscaled);
      const logBase2 = Math.log2(absoluteValue);
      const numberOfBits = Math.floor(logBase2) + 2;
      const numberOfBytes = Math.ceil(numberOfBits / 8);  
      buf = Buffer.alloc(numberOfBytes);
    }
    buf.writeIntBE(dec.unscaled, 0, buf.length);
    return buf;
  }
}