pr feedback

Author: PavelSafronov

src/bson.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-restricted-imports */
-import { BSON, type DeserializeOptions, type SerializeOptions } from 'bson';
+import { BSON, type DeserializeOptions, NumberUtils, type SerializeOptions } from 'bson';
 
 export {
   Binary,
@@ -39,41 +39,10 @@ export function parseToElementsToArray(bytes: Uint8Array, offset?: number): BSON
   return Array.isArray(res) ? res : [...res];
 }
 
-export const getInt32LE = BSON.NumberUtils.getInt32LE;
-export const getFloat64LE = BSON.NumberUtils.getFloat64LE;
-export const getBigInt64LE = BSON.NumberUtils.getBigInt64LE;
-export const toUTF8 = BSON.ByteUtils.toUTF8;
-export const fromUTF8 = BSON.ByteUtils.fromUTF8;
-export const fromBase64 = BSON.ByteUtils.fromBase64;
-export const fromNumberArray = BSON.ByteUtils.fromNumberArray;
-export const concatBuffers = BSON.ByteUtils.concat;
-export const allocateBuffer = BSON.ByteUtils.allocate;
-export const allocateUnsafeBuffer = BSON.ByteUtils.allocateUnsafe;
-
 // writeInt32LE, same order of arguments as Buffer.writeInt32LE
 export const writeInt32LE = (destination: Uint8Array, value: number, offset: number) =>
   BSON.NumberUtils.setInt32LE(destination, offset, value);
 
-// copyBuffer: copies from source buffer to target buffer, returns number of bytes copied
-// inputs are explicitly named to avoid confusion
-export const copyBuffer = (input: {
-  source: Uint8Array;
-  target: Uint8Array;
-  targetStart?: number;
-  sourceStart?: number;
-  sourceEnd?: number;
-}): number => {
-  const { source, target, targetStart = 0, sourceStart = 0, sourceEnd } = input;
-  const sourceEndActual = sourceEnd ?? source.length;
-  const srcSlice = source.subarray(sourceStart, sourceEndActual);
-  const maxLen = Math.min(srcSlice.length, target.length - targetStart);
-  if (maxLen <= 0) {
-    return 0;
-  }
-  target.set(srcSlice.subarray(0, maxLen), targetStart);
-  return maxLen;
-};
-
 // validates buffer inputs, used for read operations
 const validateBufferInputs = (buffer: Uint8Array, offset: number, length: number) => {
   if (offset < 0 || offset + length > buffer.length) {
@@ -87,7 +56,7 @@ const validateBufferInputs = (buffer: Uint8Array, offset: number, length: number
 // throws if offset is out of bounds
 export const readInt32LE = (buffer: Uint8Array, offset: number): number => {
   validateBufferInputs(buffer, offset, 4);
-  return getInt32LE(buffer, offset);
+  return NumberUtils.getInt32LE(buffer, offset);
 };
 
 /**

src/cmap/auth/plain.ts

@@ -1,4 +1,4 @@
-import { Binary, fromUTF8 } from '../../bson';
+import { Binary, ByteUtils } from '../../bson';
 import { MongoMissingCredentialsError } from '../../error';
 import { ns } from '../../utils';
 import { type AuthContext, AuthProvider } from './auth_provider';
@@ -12,7 +12,7 @@ export class Plain extends AuthProvider {
 
     const { username, password } = credentials;
 
-    const payload = new Binary(fromUTF8(`\x00${username}\x00${password}`));
+    const payload = new Binary(ByteUtils.fromUTF8(`\x00${username}\x00${password}`));
     const command = {
       saslStart: 1,
       mechanism: 'PLAIN',

src/cmap/auth/scram.ts

@@ -1,16 +1,7 @@
 import { saslprep } from '@mongodb-js/saslprep';
 import * as crypto from 'crypto';
 
-import {
-  allocateBuffer,
-  Binary,
-  ByteUtils,
-  concatBuffers,
-  type Document,
-  fromBase64,
-  fromNumberArray,
-  fromUTF8
-} from '../../bson';
+import { Binary, ByteUtils, type Document } from '../../bson';
 import {
   MongoInvalidArgumentError,
   MongoMissingCredentialsError,
@@ -77,11 +68,11 @@ function cleanUsername(username: string) {
 function clientFirstMessageBare(username: string, nonce: Uint8Array) {
   // NOTE: This is done b/c Javascript uses UTF-16, but the server is hashing in UTF-8.
   // Since the username is not sasl-prep-d, we need to do this here.
-  return concatBuffers([
-    fromUTF8('n='),
-    fromUTF8(username),
-    fromUTF8(',r='),
-    fromUTF8(ByteUtils.toBase64(nonce))
+  return ByteUtils.concat([
+    ByteUtils.fromUTF8('n='),
+    ByteUtils.fromUTF8(username),
+    ByteUtils.fromUTF8(',r='),
+    ByteUtils.fromUTF8(ByteUtils.toBase64(nonce))
   ]);
 }
 
@@ -99,7 +90,9 @@ function makeFirstMessage(
   return {
     saslStart: 1,
     mechanism,
-    payload: new Binary(concatBuffers([fromUTF8('n,,'), clientFirstMessageBare(username, nonce)])),
+    payload: new Binary(
+      ByteUtils.concat([ByteUtils.fromUTF8('n,,'), clientFirstMessageBare(username, nonce)])
+    ),
     autoAuthorize: 1,
     options: { skipEmptyExchange: true }
   };
@@ -164,7 +157,12 @@ async function continueScramConversation(
 
   // Set up start of proof
   const withoutProof = `c=biws,r=${rnonce}`;
-  const saltedPassword = HI(processedPassword, fromBase64(salt), iterations, cryptoMethod);
+  const saltedPassword = HI(
+    processedPassword,
+    ByteUtils.fromBase64(salt),
+    iterations,
+    cryptoMethod
+  );
 
   const clientKey = HMAC(cryptoMethod, saltedPassword, 'Client Key');
   const serverKey = HMAC(cryptoMethod, saltedPassword, 'Server Key');
@@ -183,13 +181,13 @@ async function continueScramConversation(
   const saslContinueCmd = {
     saslContinue: 1,
     conversationId: response.conversationId,
-    payload: new Binary(fromUTF8(clientFinal))
+    payload: new Binary(ByteUtils.fromUTF8(clientFinal))
   };
 
   const r = await connection.command(ns(`${db}.$cmd`), saslContinueCmd, undefined);
   const parsedResponse = parsePayload(r.payload);
 
-  if (!compareDigest(fromBase64(parsedResponse.v), serverSignature)) {
+  if (!compareDigest(ByteUtils.fromBase64(parsedResponse.v), serverSignature)) {
     throw new MongoRuntimeError('Server returned an invalid signature');
   }
 
@@ -201,7 +199,7 @@ async function continueScramConversation(
   const retrySaslContinueCmd = {
     saslContinue: 1,
     conversationId: r.conversationId,
-    payload: allocateBuffer(0)
+    payload: ByteUtils.allocate(0)
   };
 
   await connection.command(ns(`${db}.$cmd`), retrySaslContinueCmd, undefined);
@@ -255,7 +253,7 @@ function xor(a: Uint8Array, b: Uint8Array) {
     res.push(a[i] ^ b[i]);
   }
 
-  return ByteUtils.toBase64(fromNumberArray(res));
+  return ByteUtils.toBase64(ByteUtils.fromNumberArray(res));
 }
 
 function H(method: CryptoMethod, text: Uint8Array): Uint8Array {

src/cmap/commands.ts

@@ -1,10 +1,7 @@
 import {
-  allocateBuffer,
-  allocateUnsafeBuffer,
   BSON,
   type BSONSerializeOptions,
   ByteUtils,
-  concatBuffers,
   type Document,
   type Long,
   readInt32LE,
@@ -192,7 +189,7 @@ export class OpQueryRequest {
     if (this.batchSize !== this.numberToReturn) this.numberToReturn = this.batchSize;
 
     // Allocate write protocol header buffer
-    const header = allocateBuffer(
+    const header = ByteUtils.allocate(
       4 * 4 + // Header
         4 + // Flags
         ByteUtils.utf8ByteLength(this.ns) +
@@ -456,7 +453,7 @@ export class DocumentSequence {
     this.serializedDocumentsLength = 0;
     // Document sequences starts with type 1 at the first byte.
     // Field strings must always be UTF-8.
-    const buffer = allocateUnsafeBuffer(1 + 4 + this.field.length + 1);
+    const buffer = ByteUtils.allocateUnsafe(1 + 4 + this.field.length + 1);
     buffer[0] = 1;
     // Third part is the field name at offset 5 with trailing null byte.
     encodeUTF8Into(buffer, `${this.field}\0`, 5);
@@ -494,7 +491,7 @@ export class DocumentSequence {
    * @returns The section bytes.
    */
   toBin(): Uint8Array {
-    return concatBuffers(this.chunks);
+    return ByteUtils.concat(this.chunks);
   }
 }
 
@@ -559,7 +556,7 @@ export class OpMsgRequest {
       flags |= OPTS_EXHAUST_ALLOWED;
     }
 
-    const header = allocateBuffer(
+    const header = ByteUtils.allocate(
       4 * 4 + // Header
         4 // Flags
     );
@@ -583,7 +580,7 @@ export class OpMsgRequest {
    */
   makeSections(buffers: Uint8Array[], document: Document): number {
     const sequencesBuffer = this.extractDocumentSequences(document);
-    const payloadTypeBuffer = allocateUnsafeBuffer(1);
+    const payloadTypeBuffer = ByteUtils.allocateUnsafe(1);
     payloadTypeBuffer[0] = 0;
 
     const documentBuffer = this.serializeBson(document);
@@ -618,11 +615,11 @@ export class OpMsgRequest {
       }
     }
     if (chunks.length > 0) {
-      return concatBuffers(chunks);
+      return ByteUtils.concat(chunks);
     }
     // If we have no document sequences we return an empty buffer for nothing to add
     // to the payload.
-    return allocateBuffer(0);
+    return ByteUtils.allocate(0);
   }
 
   serializeBson(document: Document): Uint8Array {
@@ -771,7 +768,7 @@ export class OpCompressedRequest {
   }
 
   async toBin(): Promise<Uint8Array[]> {
-    const concatenatedOriginalCommandBuffer = concatBuffers(this.command.toBin());
+    const concatenatedOriginalCommandBuffer = ByteUtils.concat(this.command.toBin());
     // otherwise, compress the message
     const messageToBeCompressed = concatenatedOriginalCommandBuffer.slice(MESSAGE_HEADER_SIZE);
 
@@ -781,7 +778,7 @@ export class OpCompressedRequest {
     // Compress the message body
     const compressedMessage = await compress(this.options, messageToBeCompressed);
     // Create the msgHeader of OP_COMPRESSED
-    const msgHeader = allocateBuffer(MESSAGE_HEADER_SIZE);
+    const msgHeader = ByteUtils.allocate(MESSAGE_HEADER_SIZE);
     writeInt32LE(
       msgHeader,
       MESSAGE_HEADER_SIZE + COMPRESSION_DETAILS_SIZE + compressedMessage.length,
@@ -791,7 +788,7 @@ export class OpCompressedRequest {
     writeInt32LE(msgHeader, 0, 8); // responseTo (zero)
     writeInt32LE(msgHeader, OP_COMPRESSED, 12); // opCode
     // Create the compression details of OP_COMPRESSED
-    const compressionDetails = allocateBuffer(COMPRESSION_DETAILS_SIZE);
+    const compressionDetails = ByteUtils.allocate(COMPRESSION_DETAILS_SIZE);
     writeInt32LE(compressionDetails, originalCommandOpCode, 0); // originalOpcode
     writeInt32LE(compressionDetails, messageToBeCompressed.length, 4); // Size of the uncompressed compressedMessage, excluding the MsgHeader
     writeInt32LE(compressionDetails, Compressor[this.options.agreedCompressor], 8); // compressorID

src/cmap/connection.ts

@@ -4,7 +4,7 @@ import { clearTimeout, setTimeout } from 'timers';
 import {
   BSON,
   type BSONSerializeOptions,
-  concatBuffers,
+  ByteUtils,
   deserialize,
   type DeserializeOptions,
   type Document,
@@ -698,7 +698,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
             zlibCompressionLevel: options.zlibCompressionLevel ?? 0
           });
 
-    const buffer = concatBuffers(await finalCommand.toBin());
+    const buffer = ByteUtils.concat(await finalCommand.toBin());
 
     if (options.timeoutContext?.csotEnabled()) {
       if (

src/cmap/handshake/client_metadata.ts

@@ -1,7 +1,7 @@
 import * as os from 'os';
 import * as process from 'process';
 
-import { BSON, type Document, fromUTF8, Int32, toUTF8 } from '../../bson';
+import { BSON, ByteUtils, type Document, Int32 } from '../../bson';
 import { MongoInvalidArgumentError } from '../../error';
 import type { DriverInfo, MongoOptions } from '../../mongo_client';
 import { fileIsAccessible } from '../../utils';
@@ -116,7 +116,7 @@ export async function makeClientMetadata(
     const name =
       BSON.ByteUtils.utf8ByteLength(appName) <= 128
         ? appName
-        : toUTF8(fromUTF8(appName), 0, 128, false);
+        : ByteUtils.toUTF8(ByteUtils.fromUTF8(appName), 0, 128, false);
     metadataDocument.ifItFitsItSits('application', { name });
   }
 

src/cmap/wire_protocol/compression.ts

@@ -1,6 +1,6 @@
 import * as zlib from 'zlib';
 
-import { concatBuffers, readInt32LE } from '../../bson';
+import { ByteUtils, readInt32LE } from '../../bson';
 import { LEGACY_HELLO_COMMAND } from '../../constants';
 import { getSnappy, getZstdLibrary, type SnappyLib, type ZStandard } from '../../deps';
 import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
@@ -172,7 +172,7 @@ export async function compressCommand(
           zlibCompressionLevel: description.zlibCompressionLevel ?? 0
         });
   const data = await finalCommand.toBin();
-  return concatBuffers(data);
+  return ByteUtils.concat(data);
 }
 
 /**

src/cmap/wire_protocol/on_demand/document.ts

@@ -3,15 +3,13 @@ import {
   type BSONElement,
   BSONError,
   BSONType,
+  ByteUtils,
   deserialize,
   type DeserializeOptions,
-  getBigInt64LE,
-  getFloat64LE,
-  getInt32LE,
+  NumberUtils,
   ObjectId,
   parseToElementsToArray,
-  Timestamp,
-  toUTF8
+  Timestamp
 } from '../../../bson';
 
 const BSONElementOffset = {
@@ -183,25 +181,25 @@ export class OnDemandDocument {
       case BSONType.undefined:
         return null;
       case BSONType.double:
-        return getFloat64LE(this.bson, offset);
+        return NumberUtils.getFloat64LE(this.bson, offset);
       case BSONType.int:
-        return getInt32LE(this.bson, offset);
+        return NumberUtils.getInt32LE(this.bson, offset);
       case BSONType.long:
-        return getBigInt64LE(this.bson, offset);
+        return NumberUtils.getBigInt64LE(this.bson, offset);
       case BSONType.bool:
         return Boolean(this.bson[offset]);
       case BSONType.objectId:
         return new ObjectId(this.bson.subarray(offset, offset + 12));
       case BSONType.timestamp:
-        return new Timestamp(getBigInt64LE(this.bson, offset));
+        return new Timestamp(NumberUtils.getBigInt64LE(this.bson, offset));
       case BSONType.string:
-        return toUTF8(this.bson, offset + 4, offset + length - 1, false);
+        return ByteUtils.toUTF8(this.bson, offset + 4, offset + length - 1, false);
       case BSONType.binData: {
-        const totalBinarySize = getInt32LE(this.bson, offset);
+        const totalBinarySize = NumberUtils.getInt32LE(this.bson, offset);
         const subType = this.bson[offset + 4];
 
         if (subType === 2) {
-          const subType2BinarySize = getInt32LE(this.bson, offset + 1 + 4);
+          const subType2BinarySize = NumberUtils.getInt32LE(this.bson, offset + 1 + 4);
           if (subType2BinarySize < 0)
             throw new BSONError('Negative binary type element size found for subtype 0x02');
           if (subType2BinarySize > totalBinarySize - 4)
@@ -221,7 +219,7 @@ export class OnDemandDocument {
       }
       case BSONType.date:
         // Pretend this is correct.
-        return new Date(Number(getBigInt64LE(this.bson, offset)));
+        return new Date(Number(NumberUtils.getBigInt64LE(this.bson, offset)));
 
       case BSONType.object:
         return new OnDemandDocument(this.bson, offset);
@@ -352,7 +350,7 @@ export class OnDemandDocument {
 
   /** Returns this document's bytes only */
   toBytes() {
-    const size = getInt32LE(this.bson, this.offset);
+    const size = NumberUtils.getInt32LE(this.bson, this.offset);
     return this.bson.subarray(this.offset, this.offset + size);
   }
 }