update sqlite limits to reset using Infinity instead of null

Author: mertcanaltin

doc/api/sqlite.md

@@ -481,14 +481,14 @@ console.log(db.limits.length);
 db.limits.sqlLength = 100000;
 
 // Reset a limit to its compile-time maximum
-db.limits.sqlLength = null;
+db.limits.sqlLength = Infinity;
 ```
 
 Available properties: `length`, `sqlLength`, `column`, `exprDepth`,
 `compoundSelect`, `vdbeOp`, `functionArg`, `attach`, `likePatternLength`,
 `variableNumber`, `triggerDepth`.
 
-Setting a property to `null` resets the limit to its compile-time maximum value.
+Setting a property to `Infinity` resets the limit to its compile-time maximum value.
 
 ### `database.open()`
 

src/node_sqlite.cc

@@ -14,7 +14,8 @@
 
 #include <array>
 #include <cinttypes>
-#include <climits>
+#include <cmath>
+#include <limits>
 
 namespace node {
 namespace sqlite {
@@ -794,22 +795,28 @@ Intercepted DatabaseSyncLimits::LimitsSetter(
     return Intercepted::kYes;
   }
 
+  if (!value->IsNumber()) {
+    THROW_ERR_INVALID_ARG_TYPE(
+        isolate, "Limit value must be a non-negative integer or Infinity.");
+    return Intercepted::kYes;
+  }
+
+  const double num_value = value.As<Number>()->Value();
   int new_value;
 
-  if (value->IsNull()) {
-    // null resets the limit to the compile-time maximum
-    new_value = INT_MAX;
-  } else if (value->IsInt32()) {
+  if (std::isinf(num_value) && num_value > 0) {
+    // Positive Infinity resets the limit to the compile-time maximum
+    new_value = std::numeric_limits<int>::max();
+  } else if (!value->IsInt32()) {
+    THROW_ERR_INVALID_ARG_TYPE(
+        isolate, "Limit value must be a non-negative integer or Infinity.");
+    return Intercepted::kYes;
+  } else {
     new_value = value.As<Int32>()->Value();
-    // Validate non-negative
     if (new_value < 0) {
       THROW_ERR_OUT_OF_RANGE(isolate, "Limit value must be non-negative.");
       return Intercepted::kYes;
     }
-  } else {
-    THROW_ERR_INVALID_ARG_TYPE(isolate,
-                               "Limit value must be an integer or null.");
-    return Intercepted::kYes;
   }
 
   sqlite3_limit(

test/parallel/test-sqlite-limits.js

@@ -80,16 +80,16 @@ suite('DatabaseSync limits', () => {
     t.assert.strictEqual(db.limits.column, 50);
   });
 
-  test('null resets limit to maximum', (t) => {
+  test('Infinity resets limit to maximum', (t) => {
     const db = new DatabaseSync(':memory:');
     const originalLength = db.limits.length;
 
     // Set to a lower value
     db.limits.length = 100;
     t.assert.strictEqual(db.limits.length, 100);
 
-    // Reset to maximum using null
-    db.limits.length = null;
+    // Reset to maximum using Infinity
+    db.limits.length = Infinity;
     t.assert.strictEqual(db.limits.length, originalLength);
   });
 
@@ -99,7 +99,7 @@ suite('DatabaseSync limits', () => {
       db.limits.length = 'invalid';
     }, {
       name: 'TypeError',
-      message: /Limit value must be an integer or null/,
+      message: /Limit value must be a non-negative integer or Infinity/,
     });
   });
 
@@ -113,6 +113,26 @@ suite('DatabaseSync limits', () => {
     });
   });
 
+  test('throws on null value', (t) => {
+    const db = new DatabaseSync(':memory:');
+    t.assert.throws(() => {
+      db.limits.length = null;
+    }, {
+      name: 'TypeError',
+      message: /Limit value must be a non-negative integer or Infinity/,
+    });
+  });
+
+  test('throws on negative Infinity', (t) => {
+    const db = new DatabaseSync(':memory:');
+    t.assert.throws(() => {
+      db.limits.length = -Infinity;
+    }, {
+      name: 'TypeError',
+      message: /Limit value must be a non-negative integer or Infinity/,
+    });
+  });
+
   test('throws on getter access after close', (t) => {
     const db = new DatabaseSync(':memory:');
     db.close();