Revert "wip: try revert all changes"

This reverts commit b92f0a7.

Author: avallete

packages/pg/lib/connection.js

@@ -110,12 +110,12 @@ class Connection extends EventEmitter {
   }
 
   attachListeners(stream) {
-    // // Use the appropriate implementation based on whether maxResultSize is enabled
-    // if (this._maxResultSize && this._maxResultSize > 0) {
-    //   this._attachListenersWithSizeLimit(stream)
-    // } else {
+    // Use the appropriate implementation based on whether maxResultSize is enabled
+    if (this._maxResultSize && this._maxResultSize > 0) {
+      this._attachListenersWithSizeLimit(stream)
+    } else {
       this._attachListenersStandard(stream)
-    // }
+    }
   }
 
   // Original implementation with no overhead

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

@@ -0,0 +1,95 @@
+'use strict'
+var helper = require('./test-helper')
+var assert = require('assert')
+const { Client } = helper.pg
+const suite = new helper.Suite()
+
+// Basic test to check if the _maxResultSize property is passed to Connection
+suite.test('client passes maxResultSize to connection', function (done) {
+  var client = new Client({
+    ...helper.args,
+    maxResultSize: 1024 * 1024, // 1MB limit
+  })
+
+  client.connect(
+    assert.success(function () {
+      assert.equal(client.connection._maxResultSize, 1024 * 1024, 'maxResultSize should be passed to the connection')
+      client.end(done)
+    })
+  )
+})
+
+// Check if the correct attachListeners method is being used based on maxResultSize
+suite.test('connection uses correct listener implementation', function (done) {
+  var client = new Client({
+    ...helper.args,
+    maxResultSize: 1024 * 1024, // 1MB limit
+  })
+
+  client.connect(
+    assert.success(function () {
+      // Just a simple check to see if our methods exist on the connection object
+      assert(typeof client.connection._attachListenersStandard === 'function', 'Standard listener method should exist')
+      assert(
+        typeof client.connection._attachListenersWithSizeLimit === 'function',
+        'Size-limiting listener method should exist'
+      )
+      client.end(done)
+    })
+  )
+})
+
+// Test that small result sets complete successfully with maxResultSize set
+suite.test('small result with maxResultSize', function (done) {
+  var client = new Client({
+    ...helper.args,
+    maxResultSize: 1024 * 1024, // 1MB limit
+  })
+
+  client.connect(
+    assert.success(function () {
+      client.query(
+        'SELECT generate_series(1, 10) as num',
+        assert.success(function (result) {
+          assert.equal(result.rows.length, 10)
+          client.end(done)
+        })
+      )
+    })
+  )
+})
+
+// Test for large result size
+// Using a separate test to avoid issue with callback being called twice
+suite.testAsync('large result triggers error', async () => {
+  const client = new Client({
+    ...helper.args,
+    maxResultSize: 500, // Very small limit
+  })
+
+  // Setup error handler
+  const errorPromise = new Promise((resolve) => {
+    client.on('error', (err) => {
+      assert.equal(err.message, 'Query result size exceeded the configured limit')
+      assert.equal(err.code, 'RESULT_SIZE_EXCEEDED')
+      resolve()
+    })
+  })
+
+  await client.connect()
+
+  // Start the query but don't await it (it will error)
+  const queryPromise = client.query("SELECT repeat('x', 1000) as data FROM generate_series(1, 100)").catch(() => {
+    // We expect this to error out, silence the rejection
+    return null
+  })
+
+  // Wait for error event
+  await errorPromise
+
+  // Make sure the query is done before we end
+  await queryPromise
+
+  // Clean up
+  await client.end().catch(() => {})
+})

packages/pg/test/integration/connection-pool/result-size-limit-tests.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const helper = require('../test-helper')
+const pg = helper.pg
+var assert = require('assert')
+
+const suite = new helper.Suite()
+
+suite.testAsync('large result triggers error', async () => {
+  const pool = new pg.Pool({
+    ...helper.args,
+    maxResultSize: 1024, // very small limit
+  })
+
+  const largeQuery = `
+    SELECT generate_series(1, 1000) as num,
+           repeat('x', 100) as data
+  `
+
+  pool.on('error', (err) => {
+    assert.equal(err.code, 'RESULT_SIZE_EXCEEDED')
+  })
+
+  try {
+    await pool.query(largeQuery)
+    throw new Error('should have raised RESULT_SIZE_EXCEEDED error')
+  } catch (err) {
+    assert.equal(err.code, 'RESULT_SIZE_EXCEEDED')
+  }
+})
+
+suite.test('pool query works with adequate maxResultSize', (done) => {
+  // Create a pool with a much larger limit
+  const pool = new pg.Pool({
+    ...helper.args,
+    maxResultSize: 100 * 1024,
+  })
+
+  // Use a very simple query that returns a single value
+  const simpleQuery = `SELECT 1 as num`
+
+  // This should succeed
+  pool.query(simpleQuery, (err, result) => {
+    if (err) {
+      return done(err)
+    }
+
+    // Verify we got the expected result
+    assert.deepEqual(result.rows, [{ num: 1 }])
+    // Test passed, clean up
+    pool.end(done)
+  })
+})