hadron-type-checker/src/type-checker.js

'use strict';

const isPlainObject = require('lodash.isplainobject');
const isArray = require('lodash.isarray');
const isString = require('lodash.isstring');
const isNumber = require('lodash.isnumber');
const has = require('lodash.has');
const keys = require('lodash.keys');
const without = require('lodash.without');
const toNumber = require('lodash.tonumber');
const toString = require('lodash.tostring');
const includes = require('lodash.includes');
const bson = require('bson');
const MinKey = bson.MinKey;
const MaxKey = bson.MaxKey;
const Long = bson.Long;
const Double = bson.Double;
const Int32 = bson.Int32;
const Decimal128 = bson.Decimal128;
const Binary = bson.Binary;
const BSONRegExp = bson.BSONRegExp;
const Code = bson.Code;
const Symbol = bson.Symbol;
const Timestamp = bson.Timestamp;

/**
 * The object string.
 */
const OBJECT = 'Object';

/**
 * The array type string.
 */
const ARRAY = 'Array';

/**
 * True constant.
 */
const TRUE = 'true';

/**
 * False constant.
 */
const FALSE = 'false';

/**
 * Long constant.
 */
const LONG = 'Long';

const INT_32 = 'Int32';
const INT_64 = 'Int64';
const DOUBLE = 'Double';
const DECIMAL_128 = 'Decimal128';
const OBJECT_TYPE = '[object Object]';
const EMPTY = '';
const OBJECT_ID = 'ObjectID';

/**
 * The bson type field.
 */
const BSON_TYPE = '_bsontype';

/**
 * The match regex.
 */
const MATCH = /\[object (\w+)\]/;

/**
 * The max int 32 value.
 */
const BSON_INT32_MAX = 0x7FFFFFFF;

/**
 * The min int 32 value.
 */
const BSON_INT32_MIN = -0x80000000;

const BSON_INT64_MAX = Math.pow(2, 63) - 1;
const BSON_INT64_MIN = -(BSON_INT64_MAX);

/**
 * The number regex.
 */
const NUMBER_REGEX = /^-?\d+$/;

/**
 * All bson types that are numbers.
 */
const NUMBER_TYPES = [
  'Long',
  'Int32',
  'Double',
  'Decimal128'
];

const toDate = (object) => {
  return new Date(object);
};

const toMinKey = () => {
  return new MinKey();
};

const toMaxKey = () => {
  return new MaxKey();
};

const toUndefined = () => {
  return undefined;
};

const toNull = () => {
  return null;
};

const toBoolean = (object) => {
  if (isString(object)) {
    if (object.toLowerCase() === TRUE) {
      return true;
    } else if (object.toLowerCase() === FALSE) {
      return false;
    }
    throw new Error(`'${object}' is not a valid boolean string`);
  }
  if (object) {
    return true;
  }
  return false;
};

const toObject = (object) => {
  if (isPlainObject(object)) {
    return object;
  }
  return {};
};

const toArray = (object) => {
  if (isArray(object)) {
    return object;
  }
  if (isPlainObject(object)) {
    return [];
  }
  return [ object ];
};

const toInt32 = (object) => {
  if (object === '-' || object === '') {
    throw new Error(`Value '${object}' is not a valid Int32 value`);
  }
  const number = toNumber(object);
  if (number >= BSON_INT32_MIN && number <= BSON_INT32_MAX) {
    return new Int32(number);
  }
  throw new Error(`Value ${number} is outside the valid Int32 range`);
};

const toInt64 = (object) => {
  if (object === '-' || object === '') {
    throw new Error(`Value '${object}' is not a valid Int64 value`);
  }
  const number = toNumber(object);
  if (number >= BSON_INT64_MIN && number <= BSON_INT64_MAX) {
    return Long.fromNumber(number);
  }
  throw new Error(`Value ${number} is outside the valid Int64 range`);
};

const toDouble = (object) => {
  if (object === '-' || object === '') {
    throw new Error(`Value '${object}' is not a valid Double value`);
  }
  if (isString(object) && object.endsWith('.')) {
    throw new Error('Please enter at least one digit after the decimal');
  }
  const number = toNumber(object);
  return new Double(number);
};

const toDecimal128 = (object) => {
  /*
   If converting a BSON Object, extract the value before converting to a string.
   */
  if (has(object, BSON_TYPE) && includes(NUMBER_TYPES, object._bsontype)) {
    object = object._bsontype === LONG ? object.toNumber() : object.valueOf();
  }
  return Decimal128.fromString(String(object));
};

const toObjectID = (object) => {
  if (!isString(object) || object === '') {
    return new bson.ObjectID();
  }
  return bson.ObjectID.createFromHexString(object);
};

const toBinary = (object) => {
  return new Binary(String(object), Binary.SUBTYPE_DEFAULT);
};

const toRegex = (object) => {
  return new BSONRegExp(String(object));
};

const toCode = (object) => {
  return new Code(String(object), {});
};

const toSymbol = (object) => {
  return new Symbol(String(object));
};

const toTimestamp = (object) => {
  const number = toNumber(object);
  return Timestamp.fromNumber(number);
};

/**
 * The functions to cast to a type.
 */
const CASTERS = {
  'Array': toArray,
  'Binary': toBinary,
  'Boolean': toBoolean,
  'Code': toCode,
  'Date': toDate,
  'Decimal128': toDecimal128,
  'Double': toDouble,
  'Int32': toInt32,
  'Int64': toInt64,
  'MaxKey': toMaxKey,
  'MinKey': toMinKey,
  'Null': toNull,
  'Object': toObject,
  'ObjectId': toObjectID,
  'BSONRegexp': toRegex,
  'String': toString,
  'Symbol': toSymbol,
  'Timestamp': toTimestamp,
  'Undefined': toUndefined
};

/**
 * An array of all bson types.
 */
const TYPES = keys(CASTERS);

/**
 * Checks if a string is an int32.
 */
class Int32Check {
  test(string) {
    if (NUMBER_REGEX.test(string)) {
      var value = toNumber(string);
      return value >= BSON_INT32_MIN && value <= BSON_INT32_MAX;
    }
    return false;
  }
}

/**
 * Checks if a string is an int64.
 */
class Int64Check {
  test(string) {
    if (NUMBER_REGEX.test(string)) {
      return Number.isSafeInteger(toNumber(string));
    }
    return false;
  }
}

const INT32_CHECK = new Int32Check();
const INT64_CHECK = new Int64Check();

/**
 * Gets the BSON type for a JS number.
 *
 * @param {Number} number - The number.
 *
 * @returns {String} The BSON type.
 */
const numberToBsonType = (number) => {
  var string = toString(number);
  if (INT32_CHECK.test(string)) {
    return INT_32;
  } else if (INT64_CHECK.test(string)) {
    return INT_64;
  }
  return DOUBLE;
};

/**
 * Checks the types of objects and returns them as readable strings.
 */
class TypeChecker {

  /**
   * Cast the provided object to the desired type.
   *
   * @param {Object} object - The object to cast.
   * @param {String} type - The type.
   *
   * @returns {Object} The cast object.
   */
  cast(object, type) {
    var caster = CASTERS[type];
    var result = object;
    if (caster) {
      result = caster(object);
    }
    return result === OBJECT_TYPE ? EMPTY : result;
  }

  /**
   * Get the type for the object.
   *
   * @param {Object} object - The object.
   *
   * @returns {String} The object type.
   */
  type(object) {
    if (isNumber(object)) {
      return numberToBsonType(object);
    }
    if (isPlainObject(object)) {
      return OBJECT;
    }
    if (isArray(object)) {
      return ARRAY;
    }
    if (has(object, BSON_TYPE)) {
      if (object._bsontype === LONG) {
        return INT_64;
      }
      if (object._bsontype === OBJECT_ID) {
        return 'ObjectId';
      }
      return object._bsontype;
    }
    return Object.prototype.toString.call(object).replace(MATCH, '$1');
  }

  /**
   * Get a list of types the object can be cast to.
   *
   * @param {Boolean} highPrecisionSupport - If Decimal128 is supported or not.
   *
   * @returns {Array} The available types.
   */
  castableTypes(highPrecisionSupport = false) {
    if (highPrecisionSupport === true) {
      return TYPES;
    }
    return without(TYPES, DECIMAL_128);
  }
}

module.exports = new TypeChecker();