spice-js 2.7.31 → 2.7.32

package/build/models/SpiceModel.js

@@ -712,17 +712,44 @@ class SpiceModel {
       }
     })();
   }
-  query(query, scope) {
+  query(query, scope, options) {
     var _this5 = this;
     return _asyncToGenerator(function* () {
       try {
-        var results = yield _this5.database.query(query, scope);
+        var results = yield _this5.database.query(query, scope, options);
         return results;
       } catch (error) {
         throw error;
       }
     })();
   }
+  getQueryOptions(args) {
+    if (args === void 0) {
+      args = {};
+    }
+    var scanConsistency = args.scan_consistency;
+
+    // Backward compatibility for callers that already use statement_consistent.
+    // The adapter accepts the SDK-style value as well as these snake_case keys.
+    if (scanConsistency === undefined && args.statement_consistent !== undefined) {
+      var legacyValue = args.statement_consistent;
+      var isRequestPlus = legacyValue === true || typeof legacyValue === "string" && ["true", "request_plus"].includes(legacyValue.toLowerCase());
+      scanConsistency = isRequestPlus ? "request_plus" : "not_bounded";
+    }
+    return {
+      scan_consistency: scanConsistency,
+      consistent_with: args.consistent_with,
+      scan_wait: args.scan_wait
+    };
+  }
+  requiresFreshQuery(args) {
+    if (args === void 0) {
+      args = {};
+    }
+    var options = this.getQueryOptions(args);
+    var scanConsistency = options.scan_consistency;
+    return options.consistent_with !== undefined || scanConsistency === true || typeof scanConsistency === "string" && ["true", "request_plus"].includes(scanConsistency.toLowerCase());
+  }
   getMulti(args) {
     var _this6 = this;
     return _asyncToGenerator(function* () {
@@ -1409,9 +1436,9 @@ class SpiceModel {
           if (args.skip_hooks !== true) {
             yield _this10.run_hook(_this10, "list", "before");
           }
-          var cacheKey = "list::" + _this10.type + "::" + args._join + "::" + query + "::" + args.limit + "::" + args.offset + "::" + args.sort + "::" + args.do_count + "::" + args.statement_consistent + "::" + args.columns + "::" + args.is_full_text + "::" + args.is_custom_query;
+          var cacheKey = "list::" + _this10.type + "::" + args._join + "::" + query + "::" + args.limit + "::" + args.offset + "::" + args.sort + "::" + args.do_count + "::" + args.query_scope + "::" + args.scan_consistency + "::" + args.statement_consistent + "::" + args.scan_wait + "::" + args.columns + "::" + args.is_full_text + "::" + args.is_custom_query;
           var results;
-          if (_this10.shouldUseCache(_this10.type)) {
+          if (_this10.shouldUseCache(_this10.type) && !_this10.requiresFreshQuery(args)) {
             var cached = yield _this10.getCacheProviderObject(_this10.type).get(cacheKey);
             results = cached == null ? void 0 : cached.value;
             var isEmpty = (cached == null ? void 0 : cached.value) === undefined;
@@ -1494,14 +1521,15 @@ class SpiceModel {
       var p = (_this11$_ctx = _this11[_ctx]) == null ? void 0 : _this11$_ctx.profiler;
       var doFetch = /*#__PURE__*/function () {
         var _ref17 = _asyncToGenerator(function* () {
+          var queryOptions = _this11.getQueryOptions(args);
           if (args.is_custom_query === "true" && args.ids.length > 0) {
             console.log("Fetching results from database", _this11.type, args, query, mappedNestings);
-            return yield _this11.database.query(query);
+            return yield _this11.database.query(query, args.query_scope, queryOptions);
           } else if (args.is_full_text === "true") {
             return yield _this11.database.full_text_search(_this11.type, query || "", args.limit, args.offset, args._join);
           } else {
             var correctedColumns = _this11.correctColumns(args.columns, mappedNestings);
-            var result = yield _this11.database.search(_this11.type, correctedColumns || args.columns || "", query || "", args.limit, args.offset, args.sort, args.do_count, args.statement_consistent, args._join);
+            var result = yield _this11.database.search(_this11.type, correctedColumns || args.columns || "", query || "", args.limit, args.offset, args.sort, args.do_count, args.query_scope, args._join, queryOptions);
             return result;
           }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-js",
-  "version": "2.7.31",
+  "version": "2.7.32",
   "description": "spice",
   "main": "build/index.js",
   "repository": {

package/src/models/SpiceModel.js

@@ -783,15 +783,47 @@ export default class SpiceModel {
     }
   }
 
-  async query(query, scope) {
+  async query(query, scope, options) {
     try {
-      let results = await this.database.query(query, scope);
+      let results = await this.database.query(query, scope, options);
       return results;
     } catch (error) {
       throw error;
     }
   }
 
+  getQueryOptions(args = {}) {
+    let scanConsistency = args.scan_consistency;
+
+    // Backward compatibility for callers that already use statement_consistent.
+    // The adapter accepts the SDK-style value as well as these snake_case keys.
+    if (scanConsistency === undefined && args.statement_consistent !== undefined) {
+      const legacyValue = args.statement_consistent;
+      const isRequestPlus =
+        legacyValue === true ||
+        (typeof legacyValue === "string" &&
+          ["true", "request_plus"].includes(legacyValue.toLowerCase()));
+      scanConsistency = isRequestPlus ? "request_plus" : "not_bounded";
+    }
+
+    return {
+      scan_consistency: scanConsistency,
+      consistent_with: args.consistent_with,
+      scan_wait: args.scan_wait,
+    };
+  }
+
+  requiresFreshQuery(args = {}) {
+    const options = this.getQueryOptions(args);
+    const scanConsistency = options.scan_consistency;
+    return (
+      options.consistent_with !== undefined ||
+      scanConsistency === true ||
+      (typeof scanConsistency === "string" &&
+        ["true", "request_plus"].includes(scanConsistency.toLowerCase()))
+    );
+  }
+
   async getMulti(args) {
     // ⚡ Profiling: use track() for proper async context forking
     const p = this[_ctx]?.profiler;
@@ -1569,10 +1601,10 @@ export default class SpiceModel {
         await this.run_hook(this, "list", "before");
       }
 
-      const cacheKey = `list::${this.type}::${args._join}::${query}::${args.limit}::${args.offset}::${args.sort}::${args.do_count}::${args.statement_consistent}::${args.columns}::${args.is_full_text}::${args.is_custom_query}`;
+      const cacheKey = `list::${this.type}::${args._join}::${query}::${args.limit}::${args.offset}::${args.sort}::${args.do_count}::${args.query_scope}::${args.scan_consistency}::${args.statement_consistent}::${args.scan_wait}::${args.columns}::${args.is_full_text}::${args.is_custom_query}`;
       let results;
 
-      if (this.shouldUseCache(this.type)) {
+      if (this.shouldUseCache(this.type) && !this.requiresFreshQuery(args)) {
         const cached = await this.getCacheProviderObject(this.type).get(
           cacheKey,
         );
@@ -1671,6 +1703,7 @@ export default class SpiceModel {
     const p = this[_ctx]?.profiler;
 
     const doFetch = async () => {
+      const queryOptions = this.getQueryOptions(args);
       if (args.is_custom_query === "true" && args.ids.length > 0) {
         console.log(
           "Fetching results from database",
@@ -1679,7 +1712,7 @@ export default class SpiceModel {
           query,
           mappedNestings,
         );
-        return await this.database.query(query);
+        return await this.database.query(query, args.query_scope, queryOptions);
       } else if (args.is_full_text === "true") {
         return await this.database.full_text_search(
           this.type,
@@ -1701,8 +1734,9 @@ export default class SpiceModel {
           args.offset,
           args.sort,
           args.do_count,
-          args.statement_consistent,
+          args.query_scope,
           args._join,
+          queryOptions,
         );
         return result;
       }

package/tests/models/SpiceModel.query-consistency.test.js

@@ -0,0 +1,114 @@
+const { createTestModel } = require("../helpers/modelFactory");
+
+describe("SpiceModel query consistency", () => {
+  test("keeps query scope separate from query consistency", async () => {
+    const model = createTestModel({ type: "application" });
+    model.database.search = jest.fn(async () => ({ data: [], total: null }));
+
+    await model.fetchResults(
+      {
+        ids: [],
+        query_scope: "cluster",
+        scan_consistency: "request_plus",
+        scan_wait: 2500,
+        _join: "",
+      },
+      "",
+      [],
+    );
+
+    expect(model.database.search).toHaveBeenCalledWith(
+      "application",
+      "",
+      "",
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      "cluster",
+      "",
+      {
+        scan_consistency: "request_plus",
+        consistent_with: undefined,
+        scan_wait: 2500,
+      },
+    );
+  });
+
+  test.each([true, "true", "request_plus"])(
+    "maps legacy statement_consistent=%s to request_plus",
+    (legacyValue) => {
+      const model = createTestModel({ type: "application" });
+
+      expect(
+        model.getQueryOptions({ statement_consistent: legacyValue }),
+      ).toEqual(
+        expect.objectContaining({ scan_consistency: "request_plus" }),
+      );
+    },
+  );
+
+  test.each([false, "false"])(
+    "maps legacy statement_consistent=%s to not_bounded",
+    (legacyValue) => {
+      const model = createTestModel({ type: "application" });
+
+      expect(
+        model.getQueryOptions({ statement_consistent: legacyValue }),
+      ).toEqual(
+        expect.objectContaining({ scan_consistency: "not_bounded" }),
+      );
+    },
+  );
+
+  test("explicit scan_consistency takes precedence over the legacy flag", () => {
+    const model = createTestModel({ type: "application" });
+
+    expect(
+      model.getQueryOptions({
+        scan_consistency: "not_bounded",
+        statement_consistent: true,
+      }),
+    ).toEqual(expect.objectContaining({ scan_consistency: "not_bounded" }));
+  });
+
+  test("strongly consistent reads bypass the model query cache", () => {
+    const model = createTestModel({ type: "application" });
+
+    expect(model.requiresFreshQuery({ scan_consistency: "request_plus" })).toBe(
+      true,
+    );
+    expect(model.requiresFreshQuery({ statement_consistent: true })).toBe(true);
+    expect(model.requiresFreshQuery({ consistent_with: {} })).toBe(true);
+    expect(model.requiresFreshQuery({ scan_consistency: "not_bounded" })).toBe(
+      false,
+    );
+  });
+
+  test("custom queries receive the same query options", async () => {
+    const model = createTestModel({ type: "application" });
+    model.database.query = jest.fn(async () => ({ rows: [] }));
+    const mutationState = { token: "test-token" };
+
+    await model.fetchResults(
+      {
+        ids: ["application-1"],
+        is_custom_query: "true",
+        query_scope: "scope",
+        consistent_with: mutationState,
+      },
+      "SELECT 1",
+      [],
+    );
+
+    expect(model.database.query).toHaveBeenCalledWith(
+      "SELECT 1",
+      "scope",
+      {
+        scan_consistency: undefined,
+        consistent_with: mutationState,
+        scan_wait: undefined,
+      },
+    );
+  });
+});