cozy-client 60.29.0 → 60.30.0

package/dist/CozyClient.js

@@ -3126,7 +3126,7 @@ var CozyClient = /*#__PURE__*/function () {
 CozyClient.hooks = CozyClient.hooks || {};
 CozyClient.fetchPolicies = _policies.default; //COZY_CLIENT_VERSION_PACKAGE in replaced by babel. See babel config
 
-CozyClient.version = "60.29.0";
+CozyClient.version = "60.30.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/store/queries.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.QueryIDGenerator = exports.getQueryFromSlice = exports.mapIdsToDocuments = exports.resetQuery = exports.receiveQueryError = exports.receiveQueryResult = exports.loadQuery = exports.initQuery = exports.default = exports.updateData = exports.makeSorterFromDefinition = exports.executeQueryFromState = exports.mergeSelectorAndPartialIndex = exports.convert$gtNullSelectors = exports.sortAndLimitDocsIds = exports.isReceivingData = exports.isQueryAction = void 0;
+exports.QueryIDGenerator = exports.getQueryFromSlice = exports.mapIdsToDocuments = exports.resetQuery = exports.receiveQueryError = exports.receiveQueryResult = exports.loadQuery = exports.initQuery = exports.default = exports.updateData = exports.computeMatchPartition = exports.makeSorterFromDefinition = exports.executeQueryFromState = exports.mergeSelectorAndPartialIndex = exports.convert$gtNullSelectors = exports.sortAndLimitDocsIds = exports.isReceivingData = exports.isQueryAction = void 0;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
@@ -53,6 +53,12 @@ var _logger = _interopRequireDefault(require("../logger"));
 
 var _stateHelpers = require("./stateHelpers");
 
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -497,6 +503,104 @@ var makeSorterFromDefinition = function makeSorterFromDefinition(definition) {
     };
   }
 };
+
+exports.makeSorterFromDefinition = makeSorterFromDefinition;
+var dedupNewData = null;
+var dedupCache = null;
+var dedupIdIndex = null;
+
+var makeDefinitionKey = function makeDefinitionKey(def) {
+  return JSON.stringify([def.doctype, def.selector, def.partialFilter, def.id, def.ids]);
+};
+
+var getDedupIdIndex = function getDedupIdIndex(newData) {
+  if (dedupIdIndex) return dedupIdIndex;
+  var idx = new Map();
+
+  var _iterator = _createForOfIteratorHelper(newData),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var doc = _step.value;
+      if (doc && doc._id != null) idx.set(doc._id, doc);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  dedupIdIndex = idx;
+  return idx;
+};
+/**
+ * Splits `newData` into the ids matching a query definition and the ids that do not
+ *
+ * @param  {QueryDefinition} definition - Definition of the query
+ * @param  {Array<import("../types").CozyClientDocument>} newData - New documents
+ * @returns {{ matchedIds: Array<string>, unmatchedIds: Array<string> }}
+ */
+
+
+var computeMatchPartition = function computeMatchPartition(definition, newData) {
+  if (dedupNewData !== newData) {
+    dedupNewData = newData;
+    dedupCache = {};
+    dedupIdIndex = null;
+  }
+
+  var key = makeDefinitionKey(definition);
+  var cached = dedupCache[key];
+  if (cached) return cached;
+  var partition;
+
+  if (definition.id || definition.ids) {
+    var idx = getDedupIdIndex(newData);
+    var wanted = definition.id ? [definition.id] : definition.ids;
+    var matchedIds = [];
+    var unmatchedIds = [];
+
+    var _iterator2 = _createForOfIteratorHelper(wanted),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var id = _step2.value;
+        var doc = idx.get(id);
+
+        if (doc) {
+          if (!doc._deleted && doc._type === definition.doctype) {
+            matchedIds.push((0, _helpers.properId)(doc));
+          } else {
+            unmatchedIds.push((0, _helpers.properId)(doc));
+          }
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    partition = {
+      matchedIds: matchedIds,
+      unmatchedIds: unmatchedIds
+    };
+  } else {
+    var belongsToQuery = makeFilterDocumentFn(definition);
+    var res = (0, _mapValues.default)((0, _groupBy.default)(newData, belongsToQuery), function (docs) {
+      return docs.map(_helpers.properId);
+    });
+    partition = {
+      matchedIds: res.true === undefined ? [] : res.true,
+      unmatchedIds: res.false === undefined ? [] : res.false
+    };
+  }
+
+  dedupCache[key] = partition;
+  return partition;
+};
 /**
  * Updates query state when new data comes in
  *
@@ -507,17 +611,13 @@ var makeSorterFromDefinition = function makeSorterFromDefinition(definition) {
  */
 
 
-exports.makeSorterFromDefinition = makeSorterFromDefinition;
+exports.computeMatchPartition = computeMatchPartition;
 
 var updateData = function updateData(query, newData, documents) {
-  var belongsToQuery = makeFilterDocumentFn(query.definition);
-  var res = (0, _mapValues.default)((0, _groupBy.default)(newData, belongsToQuery), function (docs) {
-    return docs.map(_helpers.properId);
-  });
-  var _res$true = res.true,
-      matchedIds = _res$true === void 0 ? [] : _res$true,
-      _res$false = res.false,
-      unmatchedIds = _res$false === void 0 ? [] : _res$false;
+  var _computeMatchPartitio = computeMatchPartition(query.definition, newData),
+      matchedIds = _computeMatchPartitio.matchedIds,
+      unmatchedIds = _computeMatchPartitio.unmatchedIds;
+
   var originalIds = query.data;
   var autoUpdate = query.options && query.options.autoUpdate;
   var shouldRemove = !autoUpdate || autoUpdate.remove !== false;

package/dist/store/queries.spec.js

@@ -9,6 +9,7 @@ import queries, {
   loadQuery,
   receiveQueryError,
   updateData,
+  computeMatchPartition,
   executeQueryFromState,
   mapIdsToDocuments
 } from './queries'
@@ -675,6 +676,64 @@ describe('updateData', () => {
   })
 })
 
+describe('computeMatchPartition', () => {
+  it('should resolve a getById query without scanning the whole newData', () => {
+    const newData = [TODO_1, TODO_2, TODO_3]
+    const definition = Q('io.cozy.todos').getById(TODO_2._id)
+    const { matchedIds, unmatchedIds } = computeMatchPartition(
+      definition,
+      newData
+    )
+    expect(matchedIds).toEqual([TODO_2._id])
+    expect(unmatchedIds).toEqual([])
+  })
+
+  it('should not match a getById query for a missing or wrong-doctype id', () => {
+    const newData = [TODO_1, { ...TODO_2, _type: 'io.cozy.other' }]
+    expect(
+      computeMatchPartition(Q('io.cozy.todos').getById('missing'), newData)
+    ).toEqual({ matchedIds: [], unmatchedIds: [] })
+    expect(
+      computeMatchPartition(Q('io.cozy.todos').getById(TODO_2._id), newData)
+    ).toEqual({ matchedIds: [], unmatchedIds: [TODO_2._id] })
+  })
+
+  it('should treat a deleted document as unmatched for a getById query', () => {
+    const newData = [{ ...TODO_1, _deleted: true }]
+    expect(
+      computeMatchPartition(Q('io.cozy.todos').getById(TODO_1._id), newData)
+    ).toEqual({ matchedIds: [], unmatchedIds: [TODO_1._id] })
+  })
+
+  it('should resolve a getByIds query', () => {
+    const newData = [TODO_1, TODO_2, TODO_3]
+    const definition = Q('io.cozy.todos').getByIds([TODO_1._id, 'missing'])
+    expect(computeMatchPartition(definition, newData)).toEqual({
+      matchedIds: [TODO_1._id],
+      unmatchedIds: []
+    })
+  })
+
+  it('should partition a selector query with the sift scan', () => {
+    const newData = [TODO_1, TODO_2, TODO_3]
+    const definition = Q('io.cozy.todos').where({ done: true })
+    const { matchedIds, unmatchedIds } = computeMatchPartition(
+      definition,
+      newData
+    )
+    expect(matchedIds).toEqual([TODO_3._id])
+    expect(unmatchedIds.sort()).toEqual([TODO_1._id, TODO_2._id].sort())
+  })
+
+  it('should memoize the partition per definition within the same newData', () => {
+    const newData = [TODO_1, TODO_2]
+    const definition = Q('io.cozy.todos').getById(TODO_1._id)
+    const first = computeMatchPartition(definition, newData)
+    const second = computeMatchPartition(definition, newData)
+    expect(second).toBe(first)
+  })
+})
+
 describe('execute query from state', () => {
   const docState = {
     'io.cozy.files': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "60.29.0",
+  "version": "60.30.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -74,5 +74,5 @@
     "react-native-ios11-devicecheck": "^0.0.3"
   },
   "sideEffects": false,
-  "gitHead": "0e624ae6b3ba93c2618ba9d26f4d4f48945bf5c8"
+  "gitHead": "7f9e5753cc1e0b1e1a46e983ec1a556c516a0fc2"
 }

package/types/store/queries.d.ts

@@ -8,6 +8,10 @@ export function convert$gtNullSelectors(selector: any): object;
 export function mergeSelectorAndPartialIndex(queryDefinition: object): object;
 export function executeQueryFromState(state: import('../types').CozyStore, queryDefinition: QueryDefinition): import("../types").QueryStateData;
 export function makeSorterFromDefinition(definition: QueryDefinition): (arg0: Array<import("../types").CozyClientDocument>) => Array<import("../types").CozyClientDocument>;
+export function computeMatchPartition(definition: QueryDefinition, newData: Array<import("../types").CozyClientDocument>): {
+    matchedIds: Array<string>;
+    unmatchedIds: Array<string>;
+};
 export function updateData(query: import("../types").QueryState, newData: Array<import("../types").CozyClientDocument>, documents: import("../types").DocumentsStateSlice): import("../types").QueryState;
 export default queries;
 export function initQuery(queryId: string, queryDefinition: QueryDefinition, options?: import("../types").QueryOptions): object;