feat(NODE-5861): optimize parsing basic latin strings

Author: nbbeeken

src/utils/node_byte_utils.ts

@@ -126,6 +126,33 @@ export const nodeJsByteUtils = {
   },
 
   toUTF8(buffer: Uint8Array, start: number, end: number): string {
+    if (buffer.length === 0) {
+      return '';
+    }
+
+    const stringByteLength = end - start;
+    if (stringByteLength === 0) {
+      return '';
+    }
+
+    if (stringByteLength < 200) {
+      let basicLatin = true;
+      const latinBytes = [];
+      for (let i = start; i < end; i++) {
+        const byte = buffer[i];
+        if (byte > 127) {
+          basicLatin = false;
+          break;
+        }
+        latinBytes.push(byte);
+      }
+
+      if (basicLatin) {
+        // eslint-disable-next-line prefer-spread
+        return String.fromCharCode.apply(String, latinBytes);
+      }
+    }
+
     return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
   },
 

src/utils/web_byte_utils.ts

@@ -173,6 +173,33 @@ export const webByteUtils = {
   },
 
   toUTF8(uint8array: Uint8Array, start: number, end: number): string {
+    if (uint8array.length === 0) {
+      return '';
+    }
+
+    const stringByteLength = end - start;
+    if (stringByteLength === 0) {
+      return '';
+    }
+
+    if (stringByteLength < 200) {
+      let basicLatin = true;
+      const latinBytes = [];
+      for (let i = start; i < end; i++) {
+        const byte = uint8array[i];
+        if (byte > 127) {
+          basicLatin = false;
+          break;
+        }
+        latinBytes.push(byte);
+      }
+
+      if (basicLatin) {
+        // eslint-disable-next-line prefer-spread
+        return String.fromCharCode.apply(String, latinBytes);
+      }
+    }
+
     return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));
   },
 

test/node/byte_utils.test.ts

@@ -400,15 +400,15 @@ const fromUTF8Tests: ByteUtilTest<'fromUTF8'>[] = [
 const toUTF8Tests: ByteUtilTest<'toUTF8'>[] = [
   {
     name: 'should create utf8 string from buffer input',
-    inputs: [Buffer.from('abc\u{1f913}', 'utf8')],
+    inputs: [Buffer.from('abc\u{1f913}', 'utf8'), 0, 7],
     expectation({ output, error }) {
       expect(error).to.be.null;
       expect(output).to.deep.equal(Buffer.from('abc\u{1f913}', 'utf8').toString('utf8'));
     }
   },
   {
     name: 'should return empty string for empty buffer input',
-    inputs: [Buffer.alloc(0)],
+    inputs: [Buffer.alloc(0), 0, 1],
     expectation({ output, error }) {
       expect(error).to.be.null;
       expect(output).to.be.a('string').with.lengthOf(0);
@@ -596,6 +596,29 @@ describe('ByteUtils', () => {
     });
   });
 
+  describe('toUTF8 basic latin optimization', () => {
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    context('Given a basic latin string', () => {
+      it('should not invoke Buffer.toString', () => {
+        const buffer = Buffer.from('abcdef', 'utf8');
+        const spy = sinon.spy(buffer, 'toString');
+        nodeJsByteUtils.toUTF8(buffer, 0, 6);
+        expect(spy).to.not.have.been.called;
+      });
+
+      it('should not invoke TextDecoder.decode', () => {
+        const utf8Bytes = Buffer.from('abcdef', 'utf8');
+        const buffer = new Uint8Array(utf8Bytes.buffer, utf8Bytes.byteOffset, utf8Bytes.byteLength);
+        const spy = sinon.spy(TextDecoder.prototype, 'decode');
+        webByteUtils.toUTF8(buffer, 0, 6);
+        expect(spy).to.not.have.been.called;
+      });
+    });
+  });
+
   describe('randomBytes fallback case when crypto is not present', () => {
     describe('web', function () {
       let bsonWithNoCryptoCtx;