bson 4.6.5 → 5.0.0-alpha.0

package/src/code.ts

@@ -2,7 +2,7 @@ import type { Document } from './bson';
 
 /** @public */
 export interface CodeExtended {
-  $code: string | Function;
+  $code: string;
   $scope?: Document;
 }
 
@@ -12,23 +12,35 @@ export interface CodeExtended {
  * @category BSONType
  */
 export class Code {
-  _bsontype!: 'Code';
+  get _bsontype(): 'Code' {
+    return 'Code';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
+
+  code: string;
+
+  // a code instance having a null scope is what determines whether
+  // it is BSONType 0x0D (just code) / 0x0F (code with scope)
+  scope: Document | null;
 
-  code!: string | Function;
-  scope?: Document;
   /**
    * @param code - a string or function.
    * @param scope - an optional scope for the function.
    */
-  constructor(code: string | Function, scope?: Document) {
-    if (!(this instanceof Code)) return new Code(code, scope);
-
-    this.code = code;
-    this.scope = scope;
+  constructor(code: string | Function, scope?: Document | null) {
+    this.code = code.toString();
+    this.scope = scope ?? null;
   }
 
-  toJSON(): { code: string | Function; scope?: Document } {
-    return { code: this.code, scope: this.scope };
+  toJSON(): { code: string; scope?: Document } {
+    if (this.scope != null) {
+      return { code: this.code, scope: this.scope };
+    }
+
+    return { code: this.code };
   }
 
   /** @internal */
@@ -53,9 +65,7 @@ export class Code {
   inspect(): string {
     const codeJson = this.toJSON();
     return `new Code("${String(codeJson.code)}"${
-      codeJson.scope ? `, ${JSON.stringify(codeJson.scope)}` : ''
+      codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''
     })`;
   }
 }
-
-Object.defineProperty(Code.prototype, '_bsontype', { value: 'Code' });

package/src/constants.ts

@@ -108,3 +108,31 @@ export const BSON_BINARY_SUBTYPE_COLUMN = 7;
 
 /** Binary User Defined Type @internal */
 export const BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
+
+/** @public */
+export const BSONType = Object.freeze({
+  double: 1,
+  string: 2,
+  object: 3,
+  array: 4,
+  binData: 5,
+  undefined: 6,
+  objectId: 7,
+  bool: 8,
+  date: 9,
+  null: 10,
+  regex: 11,
+  dbPointer: 12,
+  javascript: 13,
+  symbol: 14,
+  javascriptWithScope: 15,
+  int: 16,
+  timestamp: 17,
+  long: 18,
+  decimal: 19,
+  minKey: -1,
+  maxKey: 127
+} as const);
+
+/** @public */
+export type BSONType = typeof BSONType[keyof typeof BSONType];

package/src/db_ref.ts

@@ -1,7 +1,6 @@
 import type { Document } from './bson';
 import type { EJSONOptions } from './extended_json';
 import type { ObjectId } from './objectid';
-import { isObjectLike } from './parser/utils';
 
 /** @public */
 export interface DBRefLike {
@@ -13,10 +12,14 @@ export interface DBRefLike {
 /** @internal */
 export function isDBRefLike(value: unknown): value is DBRefLike {
   return (
-    isObjectLike(value) &&
+    value != null &&
+    typeof value === 'object' &&
+    '$id' in value &&
     value.$id != null &&
+    '$ref' in value &&
     typeof value.$ref === 'string' &&
-    (value.$db == null || typeof value.$db === 'string')
+    // If '$db' is defined it MUST be a string, otherwise it should be absent
+    (!('$db' in value) || ('$db' in value && typeof value.$db === 'string'))
   );
 }
 
@@ -26,7 +29,13 @@ export function isDBRefLike(value: unknown): value is DBRefLike {
  * @category BSONType
  */
 export class DBRef {
-  _bsontype!: 'DBRef';
+  get _bsontype(): 'DBRef' {
+    return 'DBRef';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
   collection!: string;
   oid!: ObjectId;
@@ -39,8 +48,6 @@ export class DBRef {
    * @param db - optional db name, if omitted the reference is local to the current db.
    */
   constructor(collection: string, oid: ObjectId, db?: string, fields?: Document) {
-    if (!(this instanceof DBRef)) return new DBRef(collection, oid, db, fields);
-
     // check if namespace has been provided
     const parts = collection.split('.');
     if (parts.length === 2) {
@@ -120,5 +127,3 @@ export class DBRef {
     })`;
   }
 }
-
-Object.defineProperty(DBRef.prototype, '_bsontype', { value: 'DBRef' });

package/src/decimal128.ts

@@ -1,7 +1,7 @@
-import { Buffer } from 'buffer';
 import { BSONTypeError } from './error';
 import { Long } from './long';
 import { isUint8Array } from './parser/utils';
+import { ByteUtils } from './utils/byte_utils';
 
 const PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/;
 const PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i;
@@ -13,16 +13,22 @@ const EXPONENT_BIAS = 6176;
 const MAX_DIGITS = 34;
 
 // Nan value bits as 32 bit values (due to lack of longs)
-const NAN_BUFFER = [
-  0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-].reverse();
+const NAN_BUFFER = ByteUtils.fromNumberArray(
+  [
+    0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  ].reverse()
+);
 // Infinity value bits 32 bit values (due to lack of longs)
-const INF_NEGATIVE_BUFFER = [
-  0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-].reverse();
-const INF_POSITIVE_BUFFER = [
-  0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-].reverse();
+const INF_NEGATIVE_BUFFER = ByteUtils.fromNumberArray(
+  [
+    0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  ].reverse()
+);
+const INF_POSITIVE_BUFFER = ByteUtils.fromNumberArray(
+  [
+    0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  ].reverse()
+);
 
 const EXPONENT_REGEX = /^([-+])?(\d+)?$/;
 
@@ -121,17 +127,21 @@ export interface Decimal128Extended {
  * @category BSONType
  */
 export class Decimal128 {
-  _bsontype!: 'Decimal128';
+  get _bsontype(): 'Decimal128' {
+    return 'Decimal128';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
-  readonly bytes!: Buffer;
+  readonly bytes!: Uint8Array;
 
   /**
    * @param bytes - a buffer containing the raw Decimal128 bytes in little endian order,
    *                or a string representation as returned by .toString()
    */
-  constructor(bytes: Buffer | string) {
-    if (!(this instanceof Decimal128)) return new Decimal128(bytes);
-
+  constructor(bytes: Uint8Array | string) {
     if (typeof bytes === 'string') {
       this.bytes = Decimal128.fromString(bytes).bytes;
     } else if (isUint8Array(bytes)) {
@@ -239,9 +249,9 @@ export class Decimal128 {
     // Check if user passed Infinity or NaN
     if (!isDigit(representation[index]) && representation[index] !== '.') {
       if (representation[index] === 'i' || representation[index] === 'I') {
-        return new Decimal128(Buffer.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
+        return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
       } else if (representation[index] === 'N') {
-        return new Decimal128(Buffer.from(NAN_BUFFER));
+        return new Decimal128(NAN_BUFFER);
       }
     }
 
@@ -285,7 +295,7 @@ export class Decimal128 {
       const match = representation.substr(++index).match(EXPONENT_REGEX);
 
       // No digits read
-      if (!match || !match[2]) return new Decimal128(Buffer.from(NAN_BUFFER));
+      if (!match || !match[2]) return new Decimal128(NAN_BUFFER);
 
       // Get exponent
       exponent = parseInt(match[0], 10);
@@ -295,7 +305,7 @@ export class Decimal128 {
     }
 
     // Return not a number
-    if (representation[index]) return new Decimal128(Buffer.from(NAN_BUFFER));
+    if (representation[index]) return new Decimal128(NAN_BUFFER);
 
     // Done reading input
     // Find first non-zero digit in digits
@@ -423,9 +433,7 @@ export class Decimal128 {
                 exponent = exponent + 1;
                 digits[dIdx] = 1;
               } else {
-                return new Decimal128(
-                  Buffer.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER)
-                );
+                return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
               }
             }
           }
@@ -503,7 +511,7 @@ export class Decimal128 {
     }
 
     // Encode into a buffer
-    const buffer = Buffer.alloc(16);
+    const buffer = ByteUtils.allocate(16);
     index = 0;
 
     // Encode the low 64 bits of the decimal
@@ -769,5 +777,3 @@ export class Decimal128 {
     return `new Decimal128("${this.toString()}")`;
   }
 }
-
-Object.defineProperty(Decimal128.prototype, '_bsontype', { value: 'Decimal128' });

package/src/double.ts

@@ -11,7 +11,13 @@ export interface DoubleExtended {
  * @category BSONType
  */
 export class Double {
-  _bsontype!: 'Double';
+  get _bsontype(): 'Double' {
+    return 'Double';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
   value!: number;
   /**
@@ -20,8 +26,6 @@ export class Double {
    * @param value - the number we want to represent as a double.
    */
   constructor(value: number) {
-    if (!(this instanceof Double)) return new Double(value);
-
     if ((value as unknown) instanceof Number) {
       value = value.valueOf();
     }
@@ -87,5 +91,3 @@ export class Double {
     return `new Double(${eJSON.$numberDouble})`;
   }
 }
-
-Object.defineProperty(Double.prototype, '_bsontype', { value: 'Double' });

package/src/error.ts

@@ -2,7 +2,6 @@
 export class BSONError extends Error {
   constructor(message: string) {
     super(message);
-    Object.setPrototypeOf(this, BSONError.prototype);
   }
 
   get name(): string {
@@ -14,7 +13,6 @@ export class BSONError extends Error {
 export class BSONTypeError extends TypeError {
   constructor(message: string) {
     super(message);
-    Object.setPrototypeOf(this, BSONTypeError.prototype);
   }
 
   get name(): string {