chore: update lint

Author: avallete

packages/pg/lib/native/client.js

@@ -104,7 +104,7 @@ Client.prototype._connect = function (cb) {
       self._connected = true
 
       // Add a reference to the client for error bubbling
-      self.native.connection = self;
+      self.native.connection = self
 
       // handle connection errors from the native layer
       self.native.on('error', function (err) {
@@ -202,7 +202,7 @@ Client.prototype.query = function (config, values, callback) {
 
       // we already returned an error,
       // just do nothing if query completes
-      query.callback = () => { }
+      query.callback = () => {}
 
       // Remove from queue
       var index = this._queryQueue.indexOf(query)
@@ -295,14 +295,14 @@ Client.prototype._pulseQueryQueue = function (initialConnection) {
 // attempt to cancel an in-progress query
 Client.prototype.cancel = function (query) {
   if (this._activeQuery === query) {
-    this.native.cancel(function () { })
+    this.native.cancel(function () {})
   } else if (this._queryQueue.indexOf(query) !== -1) {
     this._queryQueue.splice(this._queryQueue.indexOf(query), 1)
   }
 }
 
-Client.prototype.ref = function () { }
-Client.prototype.unref = function () { }
+Client.prototype.ref = function () {}
+Client.prototype.unref = function () {}
 
 Client.prototype.setTypeParser = function (oid, format, parseFn) {
   return this._types.setTypeParser(oid, format, parseFn)

packages/pg/lib/native/query.js

@@ -62,8 +62,8 @@ NativeQuery.prototype.handleError = function (err) {
     if (this.native && this.native.connection) {
       // Need to emit the error on the client/connection level too
       process.nextTick(() => {
-        this.native.connection.emit('error', err);
-      });
+        this.native.connection.emit('error', err)
+      })
     }
   }
 
@@ -117,24 +117,24 @@ NativeQuery.prototype.submit = function (client) {
     // Check the result size if maxResultSize is configured
     if (self._maxResultSize) {
       // Calculate result size (rough approximation)
-      let resultSize = 0;
+      let resultSize = 0
 
       // For multiple result sets
       if (results.length > 1) {
         for (let i = 0; i < rows.length; i++) {
-          resultSize += self._calculateResultSize(rows[i]);
+          resultSize += self._calculateResultSize(rows[i])
         }
       } else if (rows.length > 0) {
-        resultSize = self._calculateResultSize(rows);
+        resultSize = self._calculateResultSize(rows)
       }
 
       // If the size limit is exceeded, generate an error
       if (resultSize > self._maxResultSize) {
-        const error = new Error('Query result size exceeded the configured limit');
-        error.code = 'RESULT_SIZE_EXCEEDED';
-        error.resultSize = resultSize;
-        error.maxResultSize = self._maxResultSize;
-        return self.handleError(error);
+        const error = new Error('Query result size exceeded the configured limit')
+        error.code = 'RESULT_SIZE_EXCEEDED'
+        error.resultSize = resultSize
+        error.maxResultSize = self._maxResultSize
+        return self.handleError(error)
       }
     }
 
@@ -207,56 +207,56 @@ NativeQuery.prototype.submit = function (client) {
 
 // Helper method to estimate the size of a result set
 NativeQuery.prototype._calculateResultSize = function (rows) {
-  let size = 0;
+  let size = 0
 
   // For empty results, return 0
   if (!rows || rows.length === 0) {
-    return 0;
+    return 0
   }
 
   // For array mode, calculate differently
   if (this._arrayMode) {
     // Just use a rough approximation based on number of rows
-    return rows.length * 100;
+    return rows.length * 100
   }
 
   // For each row, approximate its size
   for (let i = 0; i < rows.length; i++) {
-    const row = rows[i];
+    const row = rows[i]
 
     // Add base row size
-    size += 24; // Overhead per row
+    size += 24 // Overhead per row
 
     // Add size of each column
     for (const key in row) {
       if (Object.prototype.hasOwnProperty.call(row, key)) {
-        const value = row[key];
+        const value = row[key]
 
         // Add key size
-        size += key.length * 2; // Assume 2 bytes per character
+        size += key.length * 2 // Assume 2 bytes per character
 
         // Add value size based on type
         if (value === null || value === undefined) {
-          size += 8;
+          size += 8
         } else if (typeof value === 'string') {
-          size += value.length * 2; // Assume 2 bytes per character
+          size += value.length * 2 // Assume 2 bytes per character
         } else if (typeof value === 'number') {
-          size += 8;
+          size += 8
         } else if (typeof value === 'boolean') {
-          size += 4;
+          size += 4
         } else if (value instanceof Date) {
-          size += 8;
+          size += 8
         } else if (Buffer.isBuffer(value)) {
-          size += value.length;
+          size += value.length
         } else if (Array.isArray(value)) {
-          size += 16 + value.length * 8;
+          size += 16 + value.length * 8
         } else {
           // For objects, use a rough estimate
-          size += 32 + JSON.stringify(value).length * 2;
+          size += 32 + JSON.stringify(value).length * 2
         }
       }
     }
   }
 
-  return size;
+  return size
 }

packages/pg/test/integration/client/max-result-size-tests.js

@@ -35,8 +35,7 @@ suite.test('maxResultSize limit triggers error', (cb) => {
         console.log('Client error event:', err.message, err.code)
 
         // If we get any size exceeded error, mark it
-        if (err.code === 'RESULT_SIZE_EXCEEDED' ||
-          err.message === 'Query result size exceeded the configured limit') {
+        if (err.code === 'RESULT_SIZE_EXCEEDED' || err.message === 'Query result size exceeded the configured limit') {
           sizeExceededErrorSeen = true
         }
       })