feat!(NODE-4440): bump TS target version to es2020 (#520)

nbbeeken · web-flow · commit 491d8b7c717d · 2022-11-22T14:24:27.000-05:00
diff --git a/docs/upgrade-to-v5.md b/docs/upgrade-to-v5.md
@@ -44,3 +44,9 @@ new TextDecoder('utf-16le').decode(bin.value(true));
 > **TL;DR**: TODO
 
 TODO(NODE-4771): serializeFunctions bug fix makes function names outside the ascii range get serialized correctly
+
+### TS "target" set to es2020
+
+We have set our typescript compilation target to `es2020` which aligns with our minimum supported Node.js version 14+. The following is from the typescript release notes on es2020 support, so it's some of the syntax that can be expected to be preserved after compilation:
+
+> This will preserve newer ECMAScript 2020 features like optional chaining, nullish coalescing, export * as ns, and dynamic import(...) syntax. It also means bigint literals now have a stable target below esnext.
diff --git a/rollup.config.mjs b/rollup.config.mjs
@@ -12,10 +12,10 @@ const tsConfig = {
   checkJs: false,
   strict: true,
   alwaysStrict: true,
-  target: 'es5',
+  target: 'es2020',
   module: 'esnext',
   moduleResolution: 'node',
-  lib: ['ES2017', 'ES2020.BigInt', 'ES2017.TypedArrays'],
+  lib: ['es2020'],
   // We don't make use of tslib helpers
   importHelpers: true,
   noEmitHelpers: false,
diff --git a/src/binary.ts b/src/binary.ts
@@ -28,7 +28,9 @@ export interface BinaryExtended {
  * @category BSONType
  */
 export class Binary {
-  _bsontype!: 'Binary';
+  get _bsontype(): 'Binary' {
+    return 'Binary';
+  }
 
   /**
    * Binary default subtype
@@ -73,8 +75,6 @@ export class Binary {
    * @param subType - the option binary type.
    */
   constructor(buffer?: string | BinarySequence, subType?: number) {
-    if (!(this instanceof Binary)) return new Binary(buffer, subType);
-
     if (
       !(buffer == null) &&
       !(typeof buffer === 'string') &&
@@ -294,8 +294,6 @@ export class Binary {
   }
 }
 
-Object.defineProperty(Binary.prototype, '_bsontype', { value: 'Binary' });
-
 /** @public */
 export type UUIDExtended = {
   $uuid: string;
diff --git a/src/code.ts b/src/code.ts
@@ -12,7 +12,9 @@ export interface CodeExtended {
  * @category BSONType
  */
 export class Code {
-  _bsontype!: 'Code';
+  get _bsontype(): 'Code' {
+    return 'Code';
+  }
 
   code!: string | Function;
   scope?: Document;
@@ -21,8 +23,6 @@ export class Code {
    * @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;
   }
@@ -57,5 +57,3 @@ export class Code {
     })`;
   }
 }
-
-Object.defineProperty(Code.prototype, '_bsontype', { value: 'Code' });
diff --git a/src/db_ref.ts b/src/db_ref.ts
@@ -26,7 +26,9 @@ export function isDBRefLike(value: unknown): value is DBRefLike {
  * @category BSONType
  */
 export class DBRef {
-  _bsontype!: 'DBRef';
+  get _bsontype(): 'DBRef' {
+    return 'DBRef';
+  }
 
   collection!: string;
   oid!: ObjectId;
@@ -39,8 +41,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 +120,3 @@ export class DBRef {
     })`;
   }
 }
-
-Object.defineProperty(DBRef.prototype, '_bsontype', { value: 'DBRef' });
diff --git a/src/decimal128.ts b/src/decimal128.ts
@@ -127,7 +127,9 @@ export interface Decimal128Extended {
  * @category BSONType
  */
 export class Decimal128 {
-  _bsontype!: 'Decimal128';
+  get _bsontype(): 'Decimal128' {
+    return 'Decimal128';
+  }
 
   readonly bytes!: Uint8Array;
 
@@ -136,8 +138,6 @@ export class Decimal128 {
    *                or a string representation as returned by .toString()
    */
   constructor(bytes: Uint8Array | string) {
-    if (!(this instanceof Decimal128)) return new Decimal128(bytes);
-
     if (typeof bytes === 'string') {
       this.bytes = Decimal128.fromString(bytes).bytes;
     } else if (isUint8Array(bytes)) {
@@ -773,5 +773,3 @@ export class Decimal128 {
     return `new Decimal128("${this.toString()}")`;
   }
 }
-
-Object.defineProperty(Decimal128.prototype, '_bsontype', { value: 'Decimal128' });
diff --git a/src/double.ts b/src/double.ts
@@ -11,7 +11,9 @@ export interface DoubleExtended {
  * @category BSONType
  */
 export class Double {
-  _bsontype!: 'Double';
+  get _bsontype(): 'Double' {
+    return 'Double';
+  }
 
   value!: number;
   /**
@@ -20,8 +22,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 +87,3 @@ export class Double {
     return `new Double(${eJSON.$numberDouble})`;
   }
 }
-
-Object.defineProperty(Double.prototype, '_bsontype', { value: 'Double' });
diff --git a/src/error.ts b/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 {
diff --git a/src/int_32.ts b/src/int_32.ts
@@ -11,7 +11,9 @@ export interface Int32Extended {
  * @category BSONType
  */
 export class Int32 {
-  _bsontype!: 'Int32';
+  get _bsontype(): 'Int32' {
+    return 'Int32';
+  }
 
   value!: number;
   /**
@@ -20,8 +22,6 @@ export class Int32 {
    * @param value - the number we want to represent as an int32.
    */
   constructor(value: number | string) {
-    if (!(this instanceof Int32)) return new Int32(value);
-
     if ((value as unknown) instanceof Number) {
       value = value.valueOf();
     }
@@ -66,5 +66,3 @@ export class Int32 {
     return `new Int32(${this.valueOf()})`;
   }
 }
-
-Object.defineProperty(Int32.prototype, '_bsontype', { value: 'Int32' });
diff --git a/src/long.ts b/src/long.ts
@@ -100,10 +100,14 @@ export interface LongExtended {
  * Common constant values ZERO, ONE, NEG_ONE, etc. are found as static properties on this class.
  */
 export class Long {
-  _bsontype!: 'Long';
+  get _bsontype(): 'Long' {
+    return 'Long';
+  }
 
   /** An indicator used to reliably determine if an object is a Long or not. */
-  __isLong__!: true;
+  get __isLong__(): boolean {
+    return true;
+  }
 
   /**
    * The high 32 bits as a signed value.
@@ -134,8 +138,6 @@ export class Long {
    * @param unsigned - Whether unsigned or not, defaults to signed
    */
   constructor(low: number | bigint | string = 0, high?: number | boolean, unsigned?: boolean) {
-    if (!(this instanceof Long)) return new Long(low, high, unsigned);
-
     if (typeof low === 'bigint') {
       Object.assign(this, Long.fromBigInt(low, !!high));
     } else if (typeof low === 'string') {
@@ -145,13 +147,6 @@ export class Long {
       this.high = (high as number) | 0;
       this.unsigned = !!unsigned;
     }
-
-    Object.defineProperty(this, '__isLong__', {
-      value: true,
-      configurable: false,
-      writable: false,
-      enumerable: false
-    });
   }
 
   static TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
@@ -1035,6 +1030,3 @@ export class Long {
     return `new Long("${this.toString()}"${this.unsigned ? ', true' : ''})`;
   }
 }
-
-Object.defineProperty(Long.prototype, '__isLong__', { value: true });
-Object.defineProperty(Long.prototype, '_bsontype', { value: 'Long' });
diff --git a/src/max_key.ts b/src/max_key.ts
@@ -9,10 +9,8 @@ export interface MaxKeyExtended {
  * @category BSONType
  */
 export class MaxKey {
-  _bsontype!: 'MaxKey';
-
-  constructor() {
-    if (!(this instanceof MaxKey)) return new MaxKey();
+  get _bsontype(): 'MaxKey' {
+    return 'MaxKey';
   }
 
   /** @internal */
@@ -34,5 +32,3 @@ export class MaxKey {
     return 'new MaxKey()';
   }
 }
-
-Object.defineProperty(MaxKey.prototype, '_bsontype', { value: 'MaxKey' });
diff --git a/src/min_key.ts b/src/min_key.ts
@@ -9,10 +9,8 @@ export interface MinKeyExtended {
  * @category BSONType
  */
 export class MinKey {
-  _bsontype!: 'MinKey';
-
-  constructor() {
-    if (!(this instanceof MinKey)) return new MinKey();
+  get _bsontype(): 'MinKey' {
+    return 'MinKey';
   }
 
   /** @internal */
@@ -34,5 +32,3 @@ export class MinKey {
     return 'new MinKey()';
   }
 }
-
-Object.defineProperty(MinKey.prototype, '_bsontype', { value: 'MinKey' });
diff --git a/src/objectid.ts b/src/objectid.ts
@@ -28,7 +28,9 @@ const kId = Symbol('id');
  * @category BSONType
  */
 export class ObjectId {
-  _bsontype!: 'ObjectID';
+  get _bsontype(): 'ObjectID' {
+    return 'ObjectID';
+  }
 
   /** @internal */
   static index = Math.floor(Math.random() * 0xffffff);
@@ -46,8 +48,6 @@ export class ObjectId {
    * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
    */
   constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array) {
-    if (!(this instanceof ObjectId)) return new ObjectId(inputId);
-
     // workingId is set based on type of input and whether valid id exists for the input
     let workingId;
     if (typeof inputId === 'object' && inputId && 'id' in inputId) {
@@ -350,5 +350,3 @@ Object.defineProperty(ObjectId.prototype, 'get_inc', {
 Object.defineProperty(ObjectId, 'get_inc', {
   value: deprecate(() => ObjectId.getInc(), 'Please use the static `ObjectId.getInc()` instead')
 });
-
-Object.defineProperty(ObjectId.prototype, '_bsontype', { value: 'ObjectID' });
diff --git a/src/regexp.ts b/src/regexp.ts
@@ -25,7 +25,9 @@ export interface BSONRegExpExtended {
  * @category BSONType
  */
 export class BSONRegExp {
-  _bsontype!: 'BSONRegExp';
+  get _bsontype(): 'BSONRegExp' {
+    return 'BSONRegExp';
+  }
 
   pattern!: string;
   options!: string;
@@ -34,8 +36,6 @@ export class BSONRegExp {
    * @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 = alphabetize(options ?? '');
 
@@ -101,5 +101,3 @@ export class BSONRegExp {
     throw new BSONTypeError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
   }
 }
-
-Object.defineProperty(BSONRegExp.prototype, '_bsontype', { value: 'BSONRegExp' });
diff --git a/src/symbol.ts b/src/symbol.ts
@@ -9,15 +9,15 @@ export interface BSONSymbolExtended {
  * @category BSONType
  */
 export class BSONSymbol {
-  _bsontype!: 'Symbol';
+  get _bsontype(): 'Symbol' {
+    return 'Symbol';
+  }
 
   value!: string;
   /**
    * @param value - the string representing the symbol.
    */
   constructor(value: string) {
-    if (!(this instanceof BSONSymbol)) return new BSONSymbol(value);
-
     this.value = value;
   }
 
@@ -54,5 +54,3 @@ export class BSONSymbol {
     return this.inspect();
   }
 }
-
-Object.defineProperty(BSONSymbol.prototype, '_bsontype', { value: 'Symbol' });
diff --git a/src/timestamp.ts b/src/timestamp.ts
@@ -24,7 +24,9 @@ export interface TimestampExtended {
  * @category BSONType
  * */
 export class Timestamp extends LongWithoutOverridesClass {
-  _bsontype!: 'Timestamp';
+  get _bsontype(): 'Timestamp' {
+    return 'Timestamp';
+  }
 
   static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 
@@ -43,23 +45,13 @@ export class Timestamp extends LongWithoutOverridesClass {
    */
   constructor(low: number, high: number);
   constructor(low: number | Long | { t: number; i: number }, 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 if (isObjectLike(low) && typeof low.t !== 'undefined' && typeof low.i !== 'undefined') {
       super(low.i, low.t, true);
     } else {
       super(low, high, true);
     }
-    Object.defineProperty(this, '_bsontype', {
-      value: 'Timestamp',
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
   }
 
   toJSON(): { $timestamp: string } {
diff --git a/test/node/bson_types_construction_tests.js b/test/node/bson_types_construction_tests.js
diff --git a/test/node/type_identifier_tests.js b/test/node/type_identifier_tests.js
diff --git a/tsconfig.json b/tsconfig.json

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`export class BSONError extends Error {`
`3`	`3`	`constructor(message: string) {`
`4`	`4`	`super(message);`
`5`		`- Object.setPrototypeOf(this, BSONError.prototype);`
`6`	`5`	`}`
`7`	`6`
`8`	`7`	`get name(): string {`
`@@ -14,7 +13,6 @@ export class BSONError extends Error {`
`14`	`13`	`export class BSONTypeError extends TypeError {`
`15`	`14`	`constructor(message: string) {`
`16`	`15`	`super(message);`
`17`		`- Object.setPrototypeOf(this, BSONTypeError.prototype);`
`18`	`16`	`}`
`19`	`17`
`20`	`18`	`get name(): string {`