spice-couchbase 2.0.55 → 2.0.57

package/build/index.js

@@ -704,10 +704,15 @@ module.exports = class Database {
 
         if (query) {
           conditions.push(query);
-        }
+        } // The conditions are folded into `where_clause` itself so that both queries below are built
+        // from one string. Previously this held the bare literal " WHERE " and only the data query
+        // appended `conditions.join(" AND ")`, which left the count query emitting a dangling
+        // `WHERE` — Couchbase answered "syntax error - at end of input" and every `do_count=true`
+        // request failed with a 400, on every resource.
+
 
-        var where_clause = conditions.length ? " WHERE " : "";
-        query = front_query + where_clause + conditions.join(" AND ");
+        var where_clause = conditions.length ? " WHERE ".concat(conditions.join(" AND ")) : "";
+        query = front_query + where_clause;
         var count_query = "SELECT count(meta(".concat(bucket, ").id) as count FROM ").concat(bucket, " ").concat(join, " ").concat(where_clause); //console.log("Cound Query::", count_query);
 
         var order_by_clause = order_by ? " ORDER BY ".concat(order_by) : "";

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.55",
+  "version": "2.0.57",
   "description": "",
   "main": "build/index.js",
   "scripts": {
     "test": "node src/utility.test.js",
-    "test:query-consistency": "node src/index.query-consistency.test.js"
+    "test:query-consistency": "node src/index.query-consistency.test.js",
+    "test:count-query": "node src/index.count-query.test.js"
   },
   "author": "Chad Fraser <chad@sonover.com> (http://sonover.com)",
   "license": "ISC",

package/src/index.count-query.test.js

@@ -0,0 +1,129 @@
+"use strict";
+
+/**
+ * Regression tests for the WHERE clause shared by the data and count queries in `search()`.
+ *
+ * The count query used to be built from a `where_clause` that held the bare literal `" WHERE "`,
+ * while the conditions were appended only to the data query. Every `do_count` request therefore
+ * emitted `... FROM \`bucket\`   WHERE` and Couchbase answered
+ * "syntax error - at end of input" (code 3000) with a 400 — on every resource, for every caller.
+ *
+ * It survived the existing suite because nothing exercised the count statement.
+ */
+
+const assert = require("assert");
+const Database = require("./index");
+
+let passed = 0;
+let failed = 0;
+
+/** Captures the two statements `search()` produces without touching a cluster. */
+function createSearchDb() {
+  const statements = { data: null, count: null };
+  const db = Object.create(Database.prototype);
+
+  db.use_bucket_name = false;
+  db.bucket = "test";
+  db.scope_name = "scope";
+  db.collection_name = "platformtask";
+
+  db.getData = async (statement) => {
+    statements.data = statement;
+    return [];
+  };
+  db.getCount = async (statement) => {
+    statements.count = statement;
+    return 0;
+  };
+  db.optimize = () => {};
+
+  return { db, statements };
+}
+
+async function test(name, fn) {
+  try {
+    await fn();
+    console.log(`✓ ${name}`);
+    passed += 1;
+  } catch (error) {
+    console.log(`✗ ${name}`);
+    console.log(`  Error: ${error.stack || error.message}`);
+    failed += 1;
+  }
+}
+
+async function run() {
+  console.log("\n--- count query tests ---");
+
+  await test("the count query carries the predicates, not a dangling WHERE", async () => {
+    const { db, statements } = createSearchDb();
+
+    await db.search("platformtask", "id", `status = "pending"`, 1, 0, null, "true");
+
+    assert.ok(
+      statements.count.includes(`status = "pending"`),
+      `count query lost its predicate: ${statements.count}`
+    );
+    assert.ok(
+      !/WHERE\s*$/.test(statements.count.trim()),
+      `count query ends in a dangling WHERE: ${statements.count}`
+    );
+  });
+
+  await test("multiple conditions are joined with AND in the count query", async () => {
+    const { db, statements } = createSearchDb();
+
+    await db.search(
+      "platformtask",
+      "id",
+      `status = "pending" AND assignee_type = "user"`,
+      1,
+      0,
+      null,
+      "true"
+    );
+
+    assert.ok(statements.count.includes(`status = "pending"`));
+    assert.ok(statements.count.includes(`assignee_type = "user"`));
+  });
+
+  await test("an unfiltered count emits no WHERE at all", async () => {
+    const { db, statements } = createSearchDb();
+
+    await db.search("platformtask", "id", "", 1, 0, null, "true");
+
+    assert.ok(
+      !/WHERE/i.test(statements.count),
+      `unfiltered count should have no WHERE: ${statements.count}`
+    );
+  });
+
+  await test("the data and count queries agree on the WHERE clause", async () => {
+    const { db, statements } = createSearchDb();
+
+    await db.search("platformtask", "id", `status = "blocked"`, 1, 0, null, "true");
+
+    const whereOf = (sql) => {
+      const m = sql.match(/WHERE\s+(.*?)(?:\s+ORDER BY|\s+LIMIT|\s+OFFSET|$)/is);
+      return m ? m[1].trim() : null;
+    };
+    assert.strictEqual(whereOf(statements.data), whereOf(statements.count));
+  });
+
+  await test("no count statement is produced when do_count is off", async () => {
+    const { db, statements } = createSearchDb();
+
+    await db.search("platformtask", "id", `status = "pending"`, 1, 0, null, "false");
+
+    assert.strictEqual(statements.count, null);
+    assert.ok(statements.data.includes(`status = "pending"`));
+  });
+
+  console.log("\n========================================");
+  console.log(`Tests: ${passed + failed} | Passed: ${passed} | Failed: ${failed}`);
+  console.log("========================================");
+
+  if (failed > 0) process.exit(1);
+}
+
+run();

package/src/index.js

@@ -671,8 +671,15 @@ module.exports = class Database {
         conditions.push(query);
       }
 
-      const where_clause = conditions.length ? " WHERE " : "";
-      query = front_query + where_clause + conditions.join(" AND ");
+      // The conditions are folded into `where_clause` itself so that both queries below are built
+      // from one string. Previously this held the bare literal " WHERE " and only the data query
+      // appended `conditions.join(" AND ")`, which left the count query emitting a dangling
+      // `WHERE` — Couchbase answered "syntax error - at end of input" and every `do_count=true`
+      // request failed with a 400, on every resource.
+      const where_clause = conditions.length
+        ? ` WHERE ${conditions.join(" AND ")}`
+        : "";
+      query = front_query + where_clause;
 
       const count_query = `SELECT count(meta(${bucket}).id) as count FROM ${bucket} ${join} ${where_clause}`;
       //console.log("Cound Query::", count_query);