bson 4.1.0 → 4.2.3

package/src/parser/utils.ts

@@ -0,0 +1,93 @@
+import { Buffer } from 'buffer';
+
+/**
+ * Normalizes our expected stringified form of a function across versions of node
+ * @param fn - The function to stringify
+ */
+export function normalizedFunctionString(fn: Function): string {
+  return fn.toString().replace('function(', 'function (');
+}
+
+function insecureRandomBytes(size: number): Uint8Array {
+  const result = Buffer.alloc(size);
+  for (let i = 0; i < size; ++i) result[i] = Math.floor(Math.random() * 256);
+  return result;
+}
+
+/* We do not want to have to include DOM types just for this check */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare let window: any;
+declare let require: Function;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare let global: any;
+declare const self: unknown;
+
+export let randomBytes = insecureRandomBytes;
+if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
+  randomBytes = size => window.crypto.getRandomValues(Buffer.alloc(size));
+} else {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    randomBytes = require('crypto').randomBytes;
+  } catch (e) {
+    // keep the fallback
+  }
+
+  // NOTE: in transpiled cases the above require might return null/undefined
+  if (randomBytes == null) {
+    randomBytes = insecureRandomBytes;
+  }
+}
+
+export function isUint8Array(value: unknown): value is Uint8Array {
+  return Object.prototype.toString.call(value) === '[object Uint8Array]';
+}
+
+export function isBigInt64Array(value: unknown): value is BigInt64Array {
+  return Object.prototype.toString.call(value) === '[object BigInt64Array]';
+}
+
+export function isBigUInt64Array(value: unknown): value is BigUint64Array {
+  return Object.prototype.toString.call(value) === '[object BigUint64Array]';
+}
+
+/** Call to check if your environment has `Buffer` */
+export function haveBuffer(): boolean {
+  return typeof global !== 'undefined' && typeof global.Buffer !== 'undefined';
+}
+
+/** Callable in any environment to check if value is a Buffer */
+export function isBuffer(value: unknown): value is Buffer {
+  return typeof value === 'object' && value?.constructor?.name === 'Buffer';
+}
+
+// To ensure that 0.4 of node works correctly
+export function isDate(d: unknown): d is Date {
+  return isObjectLike(d) && Object.prototype.toString.call(d) === '[object Date]';
+}
+
+/**
+ * @internal
+ * this is to solve the `'someKey' in x` problem where x is unknown.
+ * https://github.com/typescript-eslint/typescript-eslint/issues/1071#issuecomment-541955753
+ */
+export function isObjectLike(candidate: unknown): candidate is Record<string, unknown> {
+  return typeof candidate === 'object' && candidate !== null;
+}
+
+declare let console: { warn(...message: unknown[]): void };
+export function deprecate<T extends Function>(fn: T, message: string): T {
+  if (typeof window === 'undefined' && typeof self === 'undefined') {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('util').deprecate(fn, message);
+  }
+  let warned = false;
+  function deprecated(this: unknown, ...args: unknown[]) {
+    if (!warned) {
+      console.warn(message);
+      warned = true;
+    }
+    return fn.apply(this, ...args);
+  }
+  return (deprecated as unknown) as T;
+}

package/src/regexp.ts

@@ -0,0 +1,94 @@
+import type { EJSONOptions } from './extended_json';
+
+function alphabetize(str: string): string {
+  return str.split('').sort().join('');
+}
+
+/** @public */
+export interface BSONRegExpExtendedLegacy {
+  $regex: string | BSONRegExp;
+  $options: string;
+}
+
+/** @public */
+export interface BSONRegExpExtended {
+  $regularExpression: {
+    pattern: string;
+    options: string;
+  };
+}
+
+/**
+ * A class representation of the BSON RegExp type.
+ * @public
+ */
+export class BSONRegExp {
+  _bsontype!: 'BSONRegExp';
+
+  pattern!: string;
+  options!: string;
+  /**
+   * @param pattern - The regular expression pattern to match
+   * @param options - The regular expression options
+   */
+  constructor(pattern: string, options?: string) {
+    if (!(this instanceof BSONRegExp)) return new BSONRegExp(pattern, options);
+
+    this.pattern = pattern;
+    this.options = options ?? '';
+    // Execute
+    alphabetize(this.options);
+
+    // Validate options
+    for (let i = 0; i < this.options.length; i++) {
+      if (
+        !(
+          this.options[i] === 'i' ||
+          this.options[i] === 'm' ||
+          this.options[i] === 'x' ||
+          this.options[i] === 'l' ||
+          this.options[i] === 's' ||
+          this.options[i] === 'u'
+        )
+      ) {
+        throw new Error(`The regular expression option [${this.options[i]}] is not supported`);
+      }
+    }
+  }
+
+  static parseOptions(options?: string): string {
+    return options ? options.split('').sort().join('') : '';
+  }
+
+  /** @internal */
+  toExtendedJSON(options?: EJSONOptions): BSONRegExpExtendedLegacy | BSONRegExpExtended {
+    options = options || {};
+    if (options.legacy) {
+      return { $regex: this.pattern, $options: this.options };
+    }
+    return { $regularExpression: { pattern: this.pattern, options: this.options } };
+  }
+
+  /** @internal */
+  static fromExtendedJSON(doc: BSONRegExpExtendedLegacy | BSONRegExpExtended): BSONRegExp {
+    if ('$regex' in doc) {
+      if (typeof doc.$regex !== 'string') {
+        // This is for $regex query operators that have extended json values.
+        if (doc.$regex._bsontype === 'BSONRegExp') {
+          return (doc as unknown) as BSONRegExp;
+        }
+      } else {
+        return new BSONRegExp(doc.$regex, BSONRegExp.parseOptions(doc.$options));
+      }
+    }
+    if ('$regularExpression' in doc) {
+      return new BSONRegExp(
+        doc.$regularExpression.pattern,
+        BSONRegExp.parseOptions(doc.$regularExpression.options)
+      );
+    }
+    throw new TypeError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
+  }
+}
+
+Object.defineProperty(BSONRegExp.prototype, '_bsontype', { value: 'BSONRegExp' });

package/src/symbol.ts

@@ -0,0 +1,59 @@
+/** @public */
+export interface BSONSymbolExtended {
+  $symbol: string;
+}
+
+/**
+ * A class representation of the BSON Symbol type.
+ * @public
+ */
+export class BSONSymbol {
+  _bsontype!: 'Symbol';
+
+  value!: string;
+  /**
+   * @param value - the string representing the symbol.
+   */
+  constructor(value: string) {
+    if (!(this instanceof BSONSymbol)) return new BSONSymbol(value);
+
+    this.value = value;
+  }
+
+  /** Access the wrapped string value. */
+  valueOf(): string {
+    return this.value;
+  }
+
+  /** @internal */
+  toString(): string {
+    return this.value;
+  }
+
+  /** @internal */
+  inspect(): string {
+    return `new BSONSymbol("${this.value}")`;
+  }
+
+  /** @internal */
+  toJSON(): string {
+    return this.value;
+  }
+
+  /** @internal */
+  toExtendedJSON(): BSONSymbolExtended {
+    return { $symbol: this.value };
+  }
+
+  /** @internal */
+  static fromExtendedJSON(doc: BSONSymbolExtended): BSONSymbol {
+    return new BSONSymbol(doc.$symbol);
+  }
+
+  /** @internal */
+  [Symbol.for('nodejs.util.inspect.custom')](): string {
+    return this.inspect();
+  }
+}
+
+Object.defineProperty(BSONSymbol.prototype, '_bsontype', { value: 'Symbol' });

package/src/timestamp.ts

@@ -0,0 +1,108 @@
+import { Long } from './long';
+
+/** @public */
+export type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromExtendedJSON' | 'inspect';
+/** @public */
+export type LongWithoutOverrides = new (low: number | Long, high?: number, unsigned?: boolean) => {
+  [P in Exclude<keyof Long, TimestampOverrides>]: Long[P];
+};
+/** @public */
+export const LongWithoutOverridesClass: LongWithoutOverrides = (Long as unknown) as LongWithoutOverrides;
+
+/** @public */
+export interface TimestampExtended {
+  $timestamp: {
+    t: number;
+    i: number;
+  };
+}
+
+/** @public */
+export class Timestamp extends LongWithoutOverridesClass {
+  _bsontype!: 'Timestamp';
+
+  static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
+
+  /**
+   * @param low - A 64-bit Long representing the Timestamp.
+   */
+  constructor(low: Long);
+  /**
+   * @param low - the low (signed) 32 bits of the Timestamp.
+   * @param high - the high (signed) 32 bits of the Timestamp.
+   */
+  constructor(low: Long);
+  constructor(low: number, high: number);
+  constructor(low: number | Long, high?: number) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    ///@ts-expect-error
+    if (!(this instanceof Timestamp)) return new Timestamp(low, high);
+
+    if (Long.isLong(low)) {
+      super(low.low, low.high, true);
+    } else {
+      super(low, high, true);
+    }
+    Object.defineProperty(this, '_bsontype', {
+      value: 'Timestamp',
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+
+  toJSON(): { $timestamp: string } {
+    return {
+      $timestamp: this.toString()
+    };
+  }
+
+  /** Returns a Timestamp represented by the given (32-bit) integer value. */
+  static fromInt(value: number): Timestamp {
+    return new Timestamp(Long.fromInt(value, true));
+  }
+
+  /** Returns a Timestamp representing the given number value, provided that it is a finite number. Otherwise, zero is returned. */
+  static fromNumber(value: number): Timestamp {
+    return new Timestamp(Long.fromNumber(value, true));
+  }
+
+  /**
+   * Returns a Timestamp for the given high and low bits. Each is assumed to use 32 bits.
+   *
+   * @param lowBits - the low 32-bits.
+   * @param highBits - the high 32-bits.
+   */
+  static fromBits(lowBits: number, highBits: number): Timestamp {
+    return new Timestamp(lowBits, highBits);
+  }
+
+  /**
+   * Returns a Timestamp from the given string, optionally using the given radix.
+   *
+   * @param str - the textual representation of the Timestamp.
+   * @param optRadix - the radix in which the text is written.
+   */
+  static fromString(str: string, optRadix: number): Timestamp {
+    return new Timestamp(Long.fromString(str, true, optRadix));
+  }
+
+  /** @internal */
+  toExtendedJSON(): TimestampExtended {
+    return { $timestamp: { t: this.high >>> 0, i: this.low >>> 0 } };
+  }
+
+  /** @internal */
+  static fromExtendedJSON(doc: TimestampExtended): Timestamp {
+    return new Timestamp(doc.$timestamp.i, doc.$timestamp.t);
+  }
+
+  /** @internal */
+  [Symbol.for('nodejs.util.inspect.custom')](): string {
+    return this.inspect();
+  }
+
+  inspect(): string {
+    return `new Timestamp(${this.getLowBits().toString()}, ${this.getHighBits().toString()})`;
+  }
+}

package/src/uuid.ts

@@ -0,0 +1,57 @@
+/**
+ * UUID regular expression pattern copied from `uuid` npm module.
+ * @see https://github.com/uuidjs/uuid/blob/master/src/regex.js
+ */
+const UUID_RX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+/** @public */
+export interface UUIDExtended {
+  $uuid: string;
+}
+
+/**
+ * Parser function copied from `uuid` npm module.
+ * @see https://github.com/uuidjs/uuid/blob/master/src/parse.js
+ * @internal
+ */
+export function parseUUID(uuid: string): Uint8Array {
+  if (typeof uuid !== 'string') {
+    throw new TypeError('Invalid type for UUID, expected string but got ' + typeof uuid);
+  }
+
+  if (!UUID_RX.test(uuid)) {
+    throw new TypeError('Invalid format for UUID: ' + uuid);
+  }
+
+  let v;
+  const arr = new Uint8Array(16);
+
+  // Parse ########-....-....-....-............
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = (v >>> 16) & 0xff;
+  arr[2] = (v >>> 8) & 0xff;
+  arr[3] = v & 0xff;
+
+  // Parse ........-####-....-....-............
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 0xff;
+
+  // Parse ........-....-####-....-............
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 0xff;
+
+  // Parse ........-....-....-####-............
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 0xff;
+
+  // Parse ........-....-....-....-############
+  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+  arr[10] = ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff;
+  arr[11] = (v / 0x100000000) & 0xff;
+  arr[12] = (v >>> 24) & 0xff;
+  arr[13] = (v >>> 16) & 0xff;
+  arr[14] = (v >>> 8) & 0xff;
+  arr[15] = v & 0xff;
+
+  return arr;
+}

package/src/validate_utf8.ts

@@ -0,0 +1,47 @@
+const FIRST_BIT = 0x80;
+const FIRST_TWO_BITS = 0xc0;
+const FIRST_THREE_BITS = 0xe0;
+const FIRST_FOUR_BITS = 0xf0;
+const FIRST_FIVE_BITS = 0xf8;
+
+const TWO_BIT_CHAR = 0xc0;
+const THREE_BIT_CHAR = 0xe0;
+const FOUR_BIT_CHAR = 0xf0;
+const CONTINUING_CHAR = 0x80;
+
+/**
+ * Determines if the passed in bytes are valid utf8
+ * @param bytes - An array of 8-bit bytes. Must be indexable and have length property
+ * @param start - The index to start validating
+ * @param end - The index to end validating
+ */
+export function validateUtf8(
+  bytes: { [index: number]: number },
+  start: number,
+  end: number
+): boolean {
+  let continuation = 0;
+
+  for (let i = start; i < end; i += 1) {
+    const byte = bytes[i];
+
+    if (continuation) {
+      if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {
+        return false;
+      }
+      continuation -= 1;
+    } else if (byte & FIRST_BIT) {
+      if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {
+        continuation = 1;
+      } else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {
+        continuation = 2;
+      } else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {
+        continuation = 3;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  return !continuation;
+}

package/lib/fnv1a.js

@@ -1,48 +0,0 @@
-'use strict';
-
-const Buffer = require('buffer').Buffer;
-const Long = require('./long');
-
-const MASK_8 = 0xff;
-const MASK_24 = 0xffffff;
-const MASK_32 = 0xffffffff;
-
-// See http://www.isthe.com/chongo/tech/comp/fnv/#FNV-param for the definition of these parameters;
-const FNV_PRIME = new Long(16777619, 0);
-const OFFSET_BASIS = new Long(2166136261, 0);
-const FNV_MASK = new Long(MASK_32, 0);
-
-/**
- * Implementation of the FNV-1a hash for a 32-bit hash value
- * Algorithm can be found here: http://www.isthe.com/chongo/tech/comp/fnv/#FNV-1a
- * @ignore
- */
-function fnv1a32(input, encoding) {
-  encoding = encoding || 'utf8';
-  const octets = Buffer.from(input, encoding);
-
-  let hash = OFFSET_BASIS;
-  for (let i = 0; i < octets.length; i += 1) {
-    hash = hash.xor(new Long(octets[i], 0));
-    hash = hash.multiply(FNV_PRIME);
-    hash = hash.and(FNV_MASK);
-  }
-  return hash.getLowBitsUnsigned();
-}
-
-/**
- * Implements FNV-1a to generate 32-bit hash, then uses xor-folding
- * to convert to a 24-bit hash. See here for more info:
- * http://www.isthe.com/chongo/tech/comp/fnv/#xor-fold
- * @ignore
- */
-function fnv1a24(input, encoding) {
-  const _32bit = fnv1a32(input, encoding);
-  const base = _32bit & MASK_24;
-  const top = (_32bit >>> 24) & MASK_8;
-  const final = (base ^ top) & MASK_24;
-
-  return final;
-}
-
-module.exports = { fnv1a24, fnv1a32 };