bson 4.0.4 → 4.2.2

package/src/double.ts

@@ -0,0 +1,85 @@
+import type { EJSONOptions } from './extended_json';
+
+/** @public */
+export interface DoubleExtended {
+  $numberDouble: string;
+}
+
+/**
+ * A class representation of the BSON Double type.
+ * @public
+ */
+export class Double {
+  _bsontype!: 'Double';
+
+  value: number;
+  /**
+   * Create a Double type
+   *
+   * @param value - the number we want to represent as a double.
+   */
+  constructor(value: number) {
+    if ((value as unknown) instanceof Number) {
+      value = value.valueOf();
+    }
+
+    this.value = +value;
+  }
+
+  /**
+   * Access the number value.
+   *
+   * @returns returns the wrapped double number.
+   */
+  valueOf(): number {
+    return this.value;
+  }
+
+  /** @internal */
+  toJSON(): number {
+    return this.value;
+  }
+
+  /** @internal */
+  toExtendedJSON(options?: EJSONOptions): number | DoubleExtended {
+    if (options && (options.legacy || (options.relaxed && isFinite(this.value)))) {
+      return this.value;
+    }
+
+    // NOTE: JavaScript has +0 and -0, apparently to model limit calculations. If a user
+    // explicitly provided `-0` then we need to ensure the sign makes it into the output
+    if (Object.is(Math.sign(this.value), -0)) {
+      return { $numberDouble: `-${this.value.toFixed(1)}` };
+    }
+
+    let $numberDouble: string;
+    if (Number.isInteger(this.value)) {
+      $numberDouble = this.value.toFixed(1);
+      if ($numberDouble.length >= 13) {
+        $numberDouble = this.value.toExponential(13).toUpperCase();
+      }
+    } else {
+      $numberDouble = this.value.toString();
+    }
+
+    return { $numberDouble };
+  }
+
+  /** @internal */
+  static fromExtendedJSON(doc: DoubleExtended, options?: EJSONOptions): number | Double {
+    const doubleValue = parseFloat(doc.$numberDouble);
+    return options && options.relaxed ? doubleValue : new Double(doubleValue);
+  }
+
+  /** @internal */
+  [Symbol.for('nodejs.util.inspect.custom')](): string {
+    return this.inspect();
+  }
+
+  inspect(): string {
+    const eJSON = this.toExtendedJSON() as DoubleExtended;
+    return `Double(${eJSON.$numberDouble})`;
+  }
+}
+
+Object.defineProperty(Double.prototype, '_bsontype', { value: 'Double' });

package/src/ensure_buffer.ts

@@ -0,0 +1,26 @@
+import { Buffer } from 'buffer';
+import { isBuffer } from './parser/utils';
+
+/**
+ * Makes sure that, if a Uint8Array is passed in, it is wrapped in a Buffer.
+ *
+ * @param potentialBuffer - The potential buffer
+ * @returns Buffer the input if potentialBuffer is a buffer, or a buffer that
+ * wraps a passed in Uint8Array
+ * @throws TypeError If anything other than a Buffer or Uint8Array is passed in
+ */
+export function ensureBuffer(potentialBuffer: Buffer | ArrayBufferView | ArrayBuffer): Buffer {
+  if (isBuffer(potentialBuffer)) {
+    return potentialBuffer;
+  }
+
+  if (ArrayBuffer.isView(potentialBuffer)) {
+    return Buffer.from(potentialBuffer.buffer);
+  }
+
+  if (potentialBuffer instanceof ArrayBuffer) {
+    return Buffer.from(potentialBuffer);
+  }
+
+  throw new TypeError('Must use either Buffer or TypedArray');
+}

package/src/extended_json.ts

@@ -0,0 +1,395 @@
+import { Binary } from './binary';
+import type { Document } from './bson';
+import { Code } from './code';
+import { DBRef } from './db_ref';
+import { Decimal128 } from './decimal128';
+import { Double } from './double';
+import { Int32 } from './int_32';
+import { Long } from './long';
+import { MaxKey } from './max_key';
+import { MinKey } from './min_key';
+import { ObjectId } from './objectid';
+import { isObjectLike } from './parser/utils';
+import { BSONRegExp } from './regexp';
+import { BSONSymbol } from './symbol';
+import { Timestamp } from './timestamp';
+
+/** @public */
+export type EJSONOptions = EJSON.Options;
+
+/** @internal */
+type BSONType =
+  | Binary
+  | Code
+  | DBRef
+  | Decimal128
+  | Double
+  | Int32
+  | Long
+  | MaxKey
+  | MinKey
+  | ObjectId
+  | BSONRegExp
+  | BSONSymbol
+  | Timestamp;
+
+export function isBSONType(value: unknown): value is BSONType {
+  return (
+    isObjectLike(value) && Reflect.has(value, '_bsontype') && typeof value._bsontype === 'string'
+  );
+}
+
+// INT32 boundaries
+const BSON_INT32_MAX = 0x7fffffff;
+const BSON_INT32_MIN = -0x80000000;
+// INT64 boundaries
+const BSON_INT64_MAX = 0x7fffffffffffffff;
+const BSON_INT64_MIN = -0x8000000000000000;
+
+// all the types where we don't need to do any special processing and can just pass the EJSON
+//straight to type.fromExtendedJSON
+const keysToCodecs = {
+  $oid: ObjectId,
+  $binary: Binary,
+  $uuid: Binary,
+  $symbol: BSONSymbol,
+  $numberInt: Int32,
+  $numberDecimal: Decimal128,
+  $numberDouble: Double,
+  $numberLong: Long,
+  $minKey: MinKey,
+  $maxKey: MaxKey,
+  $regex: BSONRegExp,
+  $regularExpression: BSONRegExp,
+  $timestamp: Timestamp
+} as const;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function deserializeValue(value: any, options: EJSON.Options = {}) {
+  if (typeof value === 'number') {
+    if (options.relaxed || options.legacy) {
+      return value;
+    }
+
+    // if it's an integer, should interpret as smallest BSON integer
+    // that can represent it exactly. (if out of range, interpret as double.)
+    if (Math.floor(value) === value) {
+      if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) return new Int32(value);
+      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) return Long.fromNumber(value);
+    }
+
+    // If the number is a non-integer or out of integer range, should interpret as BSON Double.
+    return new Double(value);
+  }
+
+  // from here on out we're looking for bson types, so bail if its not an object
+  if (value == null || typeof value !== 'object') return value;
+
+  // upgrade deprecated undefined to null
+  if (value.$undefined) return null;
+
+  const keys = Object.keys(value).filter(
+    k => k.startsWith('$') && value[k] != null
+  ) as (keyof typeof keysToCodecs)[];
+  for (let i = 0; i < keys.length; i++) {
+    const c = keysToCodecs[keys[i]];
+    if (c) return c.fromExtendedJSON(value, options);
+  }
+
+  if (value.$date != null) {
+    const d = value.$date;
+    const date = new Date();
+
+    if (options.legacy) {
+      if (typeof d === 'number') date.setTime(d);
+      else if (typeof d === 'string') date.setTime(Date.parse(d));
+    } else {
+      if (typeof d === 'string') date.setTime(Date.parse(d));
+      else if (Long.isLong(d)) date.setTime(d.toNumber());
+      else if (typeof d === 'number' && options.relaxed) date.setTime(d);
+    }
+    return date;
+  }
+
+  if (value.$code != null) {
+    const copy = Object.assign({}, value);
+    if (value.$scope) {
+      copy.$scope = deserializeValue(value.$scope);
+    }
+
+    return Code.fromExtendedJSON(value);
+  }
+
+  if (value.$ref != null || value.$dbPointer != null) {
+    const v = value.$ref ? value : value.$dbPointer;
+
+    // we run into this in a "degenerate EJSON" case (with $id and $ref order flipped)
+    // because of the order JSON.parse goes through the document
+    if (v instanceof DBRef) return v;
+
+    const dollarKeys = Object.keys(v).filter(k => k.startsWith('$'));
+    let valid = true;
+    dollarKeys.forEach(k => {
+      if (['$ref', '$id', '$db'].indexOf(k) === -1) valid = false;
+    });
+
+    // only make DBRef if $ keys are all valid
+    if (valid) return DBRef.fromExtendedJSON(v);
+  }
+
+  return value;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function serializeArray(array: any[], options: EJSON.Options): any[] {
+  return array.map((v: unknown) => serializeValue(v, options));
+}
+
+function getISOString(date: Date) {
+  const isoStr = date.toISOString();
+  // we should only show milliseconds in timestamp if they're non-zero
+  return date.getUTCMilliseconds() !== 0 ? isoStr : isoStr.slice(0, -5) + 'Z';
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function serializeValue(value: any, options: EJSON.Options): any {
+  if (Array.isArray(value)) return serializeArray(value, options);
+
+  if (value === undefined) return null;
+
+  if (value instanceof Date) {
+    const dateNum = value.getTime(),
+      // is it in year range 1970-9999?
+      inRange = dateNum > -1 && dateNum < 253402318800000;
+
+    if (options.legacy) {
+      return options.relaxed && inRange
+        ? { $date: value.getTime() }
+        : { $date: getISOString(value) };
+    }
+    return options.relaxed && inRange
+      ? { $date: getISOString(value) }
+      : { $date: { $numberLong: value.getTime().toString() } };
+  }
+
+  if (typeof value === 'number' && !options.relaxed) {
+    // it's an integer
+    if (Math.floor(value) === value) {
+      const int32Range = value >= BSON_INT32_MIN && value <= BSON_INT32_MAX,
+        int64Range = value >= BSON_INT64_MIN && value <= BSON_INT64_MAX;
+
+      // interpret as being of the smallest BSON integer type that can represent the number exactly
+      if (int32Range) return { $numberInt: value.toString() };
+      if (int64Range) return { $numberLong: value.toString() };
+    }
+    return { $numberDouble: value.toString() };
+  }
+
+  if (value instanceof RegExp) {
+    let flags = value.flags;
+    if (flags === undefined) {
+      const match = value.toString().match(/[gimuy]*$/);
+      if (match) {
+        flags = match[0];
+      }
+    }
+
+    const rx = new BSONRegExp(value.source, flags);
+    return rx.toExtendedJSON(options);
+  }
+
+  if (value != null && typeof value === 'object') return serializeDocument(value, options);
+  return value;
+}
+
+const BSON_TYPE_MAPPINGS = {
+  Binary: (o: Binary) => new Binary(o.value(), o.sub_type),
+  Code: (o: Code) => new Code(o.code, o.scope),
+  DBRef: (o: DBRef) => new DBRef(o.collection || o.namespace, o.oid, o.db, o.fields), // "namespace" for 1.x library backwards compat
+  Decimal128: (o: Decimal128) => new Decimal128(o.bytes),
+  Double: (o: Double) => new Double(o.value),
+  Int32: (o: Int32) => new Int32(o.value),
+  Long: (
+    o: Long & {
+      low_: number;
+      high_: number;
+      unsigned_: boolean | undefined;
+    }
+  ) =>
+    Long.fromBits(
+      // underscore variants for 1.x backwards compatibility
+      o.low != null ? o.low : o.low_,
+      o.low != null ? o.high : o.high_,
+      o.low != null ? o.unsigned : o.unsigned_
+    ),
+  MaxKey: () => new MaxKey(),
+  MinKey: () => new MinKey(),
+  ObjectID: (o: ObjectId) => new ObjectId(o),
+  ObjectId: (o: ObjectId) => new ObjectId(o), // support 4.0.0/4.0.1 before _bsontype was reverted back to ObjectID
+  BSONRegExp: (o: BSONRegExp) => new BSONRegExp(o.pattern, o.options),
+  Symbol: (o: BSONSymbol) => new BSONSymbol(o.value),
+  Timestamp: (o: Timestamp) => Timestamp.fromBits(o.low, o.high)
+} as const;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function serializeDocument(doc: any, options: EJSON.Options) {
+  if (doc == null || typeof doc !== 'object') throw new Error('not an object instance');
+
+  const bsontype: BSONType['_bsontype'] = doc._bsontype;
+  if (typeof bsontype === 'undefined') {
+    // It's a regular object. Recursively serialize its property values.
+    const _doc: Document = {};
+    for (const name in doc) {
+      _doc[name] = serializeValue(doc[name], options);
+    }
+    return _doc;
+  } else if (isBSONType(doc)) {
+    // the "document" is really just a BSON type object
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let outDoc: any = doc;
+    if (typeof outDoc.toExtendedJSON !== 'function') {
+      // There's no EJSON serialization function on the object. It's probably an
+      // object created by a previous version of this library (or another library)
+      // that's duck-typing objects to look like they were generated by this library).
+      // Copy the object into this library's version of that type.
+      const mapper = BSON_TYPE_MAPPINGS[doc._bsontype];
+      if (!mapper) {
+        throw new TypeError('Unrecognized or invalid _bsontype: ' + doc._bsontype);
+      }
+      outDoc = mapper(outDoc);
+    }
+
+    // Two BSON types may have nested objects that may need to be serialized too
+    if (bsontype === 'Code' && outDoc.scope) {
+      outDoc = new Code(outDoc.code, serializeValue(outDoc.scope, options));
+    } else if (bsontype === 'DBRef' && outDoc.oid) {
+      outDoc = new DBRef(
+        outDoc.collection,
+        serializeValue(outDoc.oid, options),
+        outDoc.db,
+        outDoc.fields
+      );
+    }
+
+    return outDoc.toExtendedJSON(options);
+  } else {
+    throw new Error('_bsontype must be a string, but was: ' + typeof bsontype);
+  }
+}
+
+/**
+ * EJSON parse / stringify API
+ * @public
+ */
+// the namespace here is used to emulate `export * as EJSON from '...'`
+// which as of now (sept 2020) api-extractor does not support
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace EJSON {
+  export interface Options {
+    /** Output using the Extended JSON v1 spec */
+    legacy?: boolean;
+    /** Enable Extended JSON's `relaxed` mode, which attempts to return native JS types where possible, rather than BSON types */
+    relaxed?: boolean;
+    /**
+     * Disable Extended JSON's `relaxed` mode, which attempts to return BSON types where possible, rather than native JS types
+     * @deprecated Please use the relaxed property instead
+     */
+    strict?: boolean;
+  }
+
+  /**
+   * Parse an Extended JSON string, constructing the JavaScript value or object described by that
+   * string.
+   *
+   * @example
+   * ```js
+   * const { EJSON } = require('bson');
+   * const text = '{ "int32": { "$numberInt": "10" } }';
+   *
+   * // prints { int32: { [String: '10'] _bsontype: 'Int32', value: '10' } }
+   * console.log(EJSON.parse(text, { relaxed: false }));
+   *
+   * // prints { int32: 10 }
+   * console.log(EJSON.parse(text));
+   * ```
+   */
+  export function parse(text: string, options?: EJSON.Options): SerializableTypes {
+    const finalOptions = Object.assign({}, { relaxed: true, legacy: false }, options);
+
+    // relaxed implies not strict
+    if (typeof finalOptions.relaxed === 'boolean') finalOptions.strict = !finalOptions.relaxed;
+    if (typeof finalOptions.strict === 'boolean') finalOptions.relaxed = !finalOptions.strict;
+
+    return JSON.parse(text, (_key, value) => deserializeValue(value, finalOptions));
+  }
+
+  export type JSONPrimitive = string | number | boolean | null;
+  export type SerializableTypes = Document | Array<JSONPrimitive | Document> | JSONPrimitive;
+
+  /**
+   * Converts a BSON document to an Extended JSON string, optionally replacing values if a replacer
+   * function is specified or optionally including only the specified properties if a replacer array
+   * is specified.
+   *
+   * @param value - The value to convert to extended JSON
+   * @param replacer - A function that alters the behavior of the stringification process, or an array of String and Number objects that serve as a whitelist for selecting/filtering the properties of the value object to be included in the JSON string. If this value is null or not provided, all properties of the object are included in the resulting JSON string
+   * @param space - A String or Number object that's used to insert white space into the output JSON string for readability purposes.
+   * @param options - Optional settings
+   *
+   * @example
+   * ```js
+   * const { EJSON } = require('bson');
+   * const Int32 = require('mongodb').Int32;
+   * const doc = { int32: new Int32(10) };
+   *
+   * // prints '{"int32":{"$numberInt":"10"}}'
+   * console.log(EJSON.stringify(doc, { relaxed: false }));
+   *
+   * // prints '{"int32":10}'
+   * console.log(EJSON.stringify(doc));
+   * ```
+   */
+  export function stringify(
+    value: SerializableTypes,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (number | string)[] | ((this: any, key: string, value: any) => any) | EJSON.Options,
+    space?: string | number,
+    options?: EJSON.Options
+  ): string {
+    if (space != null && typeof space === 'object') {
+      options = space;
+      space = 0;
+    }
+    if (replacer != null && typeof replacer === 'object' && !Array.isArray(replacer)) {
+      options = replacer;
+      replacer = undefined;
+      space = 0;
+    }
+    options = Object.assign({}, { relaxed: true, legacy: false }, options);
+
+    const doc = serializeValue(value, options);
+    return JSON.stringify(doc, replacer as Parameters<JSON['stringify']>[1], space);
+  }
+
+  /**
+   * Serializes an object to an Extended JSON string, and reparse it as a JavaScript object.
+   *
+   * @param value - The object to serialize
+   * @param options - Optional settings passed to the `stringify` function
+   */
+  export function serialize(value: SerializableTypes, options?: EJSON.Options): Document {
+    options = options || {};
+    return JSON.parse(stringify(value, options));
+  }
+
+  /**
+   * Deserializes an Extended JSON object into a plain JavaScript object with native/BSON types
+   *
+   * @param ejson - The Extended JSON object to deserialize
+   * @param options - Optional settings passed to the parse method
+   */
+  export function deserialize(ejson: Document, options?: EJSON.Options): SerializableTypes {
+    options = options || {};
+    return parse(JSON.stringify(ejson), options);
+  }
+}

package/src/float_parser.ts

@@ -0,0 +1,152 @@
+// Copyright (c) 2008, Fair Oaks Labs, Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//  * Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimer.
+//
+//  * Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+//  * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//
+// Modifications to writeIEEE754 to support negative zeroes made by Brian White
+
+type NumericalSequence = { [index: number]: number };
+
+export function readIEEE754(
+  buffer: NumericalSequence,
+  offset: number,
+  endian: 'big' | 'little',
+  mLen: number,
+  nBytes: number
+): number {
+  let e: number;
+  let m: number;
+  const bBE = endian === 'big';
+  const eLen = nBytes * 8 - mLen - 1;
+  const eMax = (1 << eLen) - 1;
+  const eBias = eMax >> 1;
+  let nBits = -7;
+  let i = bBE ? 0 : nBytes - 1;
+  const d = bBE ? 1 : -1;
+  let s = buffer[offset + i];
+
+  i += d;
+
+  e = s & ((1 << -nBits) - 1);
+  s >>= -nBits;
+  nBits += eLen;
+  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+  m = e & ((1 << -nBits) - 1);
+  e >>= -nBits;
+  nBits += mLen;
+  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+  if (e === 0) {
+    e = 1 - eBias;
+  } else if (e === eMax) {
+    return m ? NaN : (s ? -1 : 1) * Infinity;
+  } else {
+    m = m + Math.pow(2, mLen);
+    e = e - eBias;
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+}
+
+export function writeIEEE754(
+  buffer: NumericalSequence,
+  value: number,
+  offset: number,
+  endian: 'big' | 'little',
+  mLen: number,
+  nBytes: number
+): void {
+  let e: number;
+  let m: number;
+  let c: number;
+  const bBE = endian === 'big';
+  let eLen = nBytes * 8 - mLen - 1;
+  const eMax = (1 << eLen) - 1;
+  const eBias = eMax >> 1;
+  const rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+  let i = bBE ? nBytes - 1 : 0;
+  const d = bBE ? -1 : 1;
+  const s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+  value = Math.abs(value);
+
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0;
+    e = eMax;
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2);
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--;
+      c *= 2;
+    }
+    if (e + eBias >= 1) {
+      value += rt / c;
+    } else {
+      value += rt * Math.pow(2, 1 - eBias);
+    }
+    if (value * c >= 2) {
+      e++;
+      c /= 2;
+    }
+
+    if (e + eBias >= eMax) {
+      m = 0;
+      e = eMax;
+    } else if (e + eBias >= 1) {
+      m = (value * c - 1) * Math.pow(2, mLen);
+      e = e + eBias;
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+      e = 0;
+    }
+  }
+
+  if (isNaN(value)) m = 0;
+
+  while (mLen >= 8) {
+    buffer[offset + i] = m & 0xff;
+    i += d;
+    m /= 256;
+    mLen -= 8;
+  }
+
+  e = (e << mLen) | m;
+
+  if (isNaN(value)) e += 8;
+
+  eLen += mLen;
+
+  while (eLen > 0) {
+    buffer[offset + i] = e & 0xff;
+    i += d;
+    e /= 256;
+    eLen -= 8;
+  }
+
+  buffer[offset + i - d] |= s * 128;
+}