cozy-client 48.12.1 → 48.13.0

package/dist/CozyClient.js

@@ -1262,11 +1262,13 @@ var CozyClient = /*#__PURE__*/function () {
 
         var _ref5,
             update,
+            executeFromStore,
             options,
             queryId,
             existingQuery,
             shouldFetch,
             backgroundFetching,
+            requestFn,
             response,
             _args8 = arguments;
 
@@ -1275,7 +1277,7 @@ var CozyClient = /*#__PURE__*/function () {
             switch (_context8.prev = _context8.next) {
               case 0:
                 _ref5 = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : {};
-                update = _ref5.update, options = (0, _objectWithoutProperties2.default)(_ref5, ["update"]);
+                update = _ref5.update, executeFromStore = _ref5.executeFromStore, options = (0, _objectWithoutProperties2.default)(_ref5, ["update", "executeFromStore"]);
                 this.ensureStore();
                 queryId = options.as || this.queryIdGenerator.generateId(queryDefinition);
                 existingQuery = this.getQueryFromState(queryId, options);
@@ -1337,14 +1339,17 @@ var CozyClient = /*#__PURE__*/function () {
                 this.dispatch((0, _store.loadQuery)(queryId, {
                   backgroundFetching: backgroundFetching
                 }));
-                _context8.next = 23;
-                return this._promiseCache.exec(function () {
+                requestFn = executeFromStore ? function () {
+                  return Promise.resolve((0, _store.executeQueryFromState)(_this4.store.getState(), queryDefinition));
+                } : function () {
                   return _this4.requestQuery(queryDefinition);
-                }, function () {
+                };
+                _context8.next = 24;
+                return this._promiseCache.exec(requestFn, function () {
                   return (0, _jsonStableStringify.default)(queryDefinition);
                 });
 
-              case 23:
+              case 24:
                 response = _context8.sent;
                 this.dispatch((0, _store.receiveQueryResult)(queryId, response, {
                   update: update,
@@ -1352,40 +1357,40 @@ var CozyClient = /*#__PURE__*/function () {
                 }));
                 return _context8.abrupt("return", response);
 
-              case 28:
-                _context8.prev = 28;
+              case 29:
+                _context8.prev = 29;
                 _context8.t0 = _context8["catch"](18);
                 this.dispatch((0, _store.receiveQueryError)(queryId, _context8.t0)); // specific onError
 
                 if (!options.onError) {
-                  _context8.next = 35;
+                  _context8.next = 36;
                   break;
                 }
 
                 options.onError(_context8.t0); // defaulted onError
 
-                _context8.next = 40;
+                _context8.next = 41;
                 break;
 
-              case 35:
+              case 36:
                 if (!this.options.onError) {
-                  _context8.next = 39;
+                  _context8.next = 40;
                   break;
                 }
 
                 this.options.onError(_context8.t0);
-                _context8.next = 40;
+                _context8.next = 41;
                 break;
 
-              case 39:
+              case 40:
                 throw _context8.t0;
 
-              case 40:
+              case 41:
               case "end":
                 return _context8.stop();
             }
           }
-        }, _callee8, this, [[18, 28]]);
+        }, _callee8, this, [[18, 29]]);
       }));
 
       function query(_x9) {
@@ -2839,7 +2844,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 = "48.12.1";
+CozyClient.version = "48.13.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/CozyClient.spec.js

@@ -1,5 +1,4 @@
 import MockDate from 'mockdate'
-
 import {
   SCHEMA,
   TODO_1,
@@ -32,12 +31,14 @@ import {
   getRawQueryFromState,
   isQueryExisting,
   loadQuery,
-  resetQuery
+  resetQuery,
+  executeQueryFromState
 } from './store'
 import { HasManyFiles, Association, HasMany } from './associations'
 import mapValues from 'lodash/mapValues'
 import FileCollection from 'cozy-stack-client/dist/FileCollection'
 import logger from './logger'
+
 const normalizeData = data =>
   mapValues(data, (docs, doctype) => {
     return docs.map(doc => ({
@@ -54,7 +55,8 @@ jest.mock('./store', () => ({
   ...jest.requireActual('./store'),
   isQueryExisting: jest.fn().mockReturnValue(false),
   getQueryFromState: jest.fn().mockReturnValue({}),
-  getRawQueryFromState: jest.fn().mockReturnValue({})
+  getRawQueryFromState: jest.fn().mockReturnValue({}),
+  executeQueryFromState: jest.fn().mockReturnValue([])
 }))
 
 describe('CozyClient initialization', () => {
@@ -1228,6 +1230,7 @@ describe('CozyClient', () => {
     beforeEach(() => {
       query = Q('io.cozy.todos')
       fakeResponse = { data: 'FAKE!!!' }
+      jest.clearAllMocks()
     })
     it('should throw an error if the option.enabled is not a boolean', async () => {
       await expect(
@@ -1390,6 +1393,13 @@ describe('CozyClient', () => {
       expect(client.requestQuery).toHaveBeenCalledTimes(1)
     })
 
+    it('should handle the executeFromStore option', async () => {
+      executeQueryFromState.mockReturnValueOnce([])
+      await client.query(query, { executeFromStore: true })
+      expect(requestHandler).toHaveBeenCalledTimes(0)
+      expect(executeQueryFromState).toHaveBeenCalledTimes(1)
+    })
+
     describe('relationship with query failure', () => {
       beforeEach(() => {
         jest.spyOn(HasManyFiles, 'query').mockImplementation(() => {

package/dist/store/index.js

@@ -37,6 +37,12 @@ Object.defineProperty(exports, "receiveQueryError", {
     return _queries.receiveQueryError;
   }
 });
+Object.defineProperty(exports, "executeQueryFromState", {
+  enumerable: true,
+  get: function get() {
+    return _queries.executeQueryFromState;
+  }
+});
 Object.defineProperty(exports, "initMutation", {
   enumerable: true,
   get: function get() {

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.resetQuery = exports.receiveQueryError = exports.receiveQueryResult = exports.loadQuery = exports.initQuery = exports.default = exports.updateData = exports.makeSorterFromDefinition = exports.mergeSelectorAndPartialIndex = exports.convert$gtNullSelectors = exports.sortAndLimitDocsIds = exports.isReceivingData = exports.isQueryAction = void 0;
+exports.QueryIDGenerator = exports.getQueryFromSlice = 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;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
@@ -357,25 +357,59 @@ var getSelectorFilterFn = function getSelectorFilterFn(queryDefinition) {
     return null;
   }
 };
+/**
+ * Execute the given query against the document state.
+ *
+ * @param {import('../types').DocumentsStateSlice} state - The documents state
+ * @param {QueryDefinition} queryDefinition - The query definition to execute
+ * @returns {import("../types").QueryStateData} - The returned documents from the query
+ */
+
+
+var executeQueryFromState = function executeQueryFromState(state, queryDefinition) {
+  var documents = (0, _documents.getCollectionFromSlice)(state, queryDefinition.doctype);
+  var isSingleObjectResponse = !!queryDefinition.id;
+
+  if (!documents) {
+    return {
+      data: isSingleObjectResponse ? null : []
+    };
+  }
+
+  var res = documents.filter(makeFilterDocumentFn(queryDefinition));
+
+  if (isSingleObjectResponse) {
+    return {
+      data: res.length > 0 ? res[0] : null
+    };
+  }
+
+  return {
+    data: res
+  };
+};
 /**
  *
  * Returns a predicate function that checks if a document should be
  * included in the result of the query.
  *
- * @param  {import("../types").QueryState} query - Definition of the query
+ * @param  {QueryDefinition} queryDefinition - Definition of the query
  * @returns {function(import("../types").CozyClientDocument): boolean} Predicate function
  */
 
 
-var getQueryDocumentsChecker = function getQueryDocumentsChecker(query) {
-  var qdoctype = query.definition.doctype;
-  var selectorFilterFn = getSelectorFilterFn(query.definition);
+exports.executeQueryFromState = executeQueryFromState;
+
+var makeFilterDocumentFn = function makeFilterDocumentFn(queryDefinition) {
+  var qdoctype = queryDefinition.doctype;
+  var selectorFilterFn = getSelectorFilterFn(queryDefinition);
   return function (datum) {
     var ddoctype = datum._type;
     if (ddoctype !== qdoctype) return false;
     if (datum._deleted) return false;
-    if (!selectorFilterFn) return true;
-    return !!selectorFilterFn(datum);
+    if (!selectorFilterFn) return true; // no selector: query all the docs
+
+    return !!selectorFilterFn(datum); // evaluate the sift function
   };
 };
 
@@ -439,7 +473,7 @@ var makeSorterFromDefinition = function makeSorterFromDefinition(definition) {
 exports.makeSorterFromDefinition = makeSorterFromDefinition;
 
 var updateData = function updateData(query, newData, documents) {
-  var belongsToQuery = getQueryDocumentsChecker(query);
+  var belongsToQuery = makeFilterDocumentFn(query.definition);
   var res = (0, _mapValues.default)((0, _groupBy.default)(newData, belongsToQuery), function (docs) {
     return docs.map(_helpers.properId);
   });

package/dist/store/queries.spec.js

@@ -7,7 +7,8 @@ import queries, {
   sortAndLimitDocsIds,
   loadQuery,
   receiveQueryError,
-  updateData
+  updateData,
+  executeQueryFromState
 } from './queries'
 import { Q } from '../queries/dsl'
 import { TODO_1, TODO_2, TODO_3 } from '../__tests__/fixtures'
@@ -671,3 +672,121 @@ describe('updateData', () => {
     expect(updatedDataToCheck.count).toEqual(1)
   })
 })
+
+describe('execute query from state', () => {
+  const docState = {
+    'io.cozy.files': {
+      '123': {
+        _id: '123',
+        _type: 'io.cozy.files',
+        name: 'well',
+        created_at: '2024-01-01'
+      },
+      '456': {
+        _id: '456',
+        _type: 'io.cozy.files',
+        name: 'hello',
+        created_at: '2024-02-01'
+      },
+      '789': {
+        _id: '789',
+        _type: 'io.cozy.files',
+        name: 'there',
+        created_at: '2024-03-01'
+      }
+    }
+  }
+  it('should get the correct filtered results from state thanks to selector', () => {
+    const query1 = {
+      doctype: 'io.cozy.files',
+      selector: {
+        created_at: {
+          $gt: '2024-01-31'
+        }
+      }
+    }
+    const res1 = executeQueryFromState(docState, query1)
+    expect(res1.data.length).toEqual(2)
+    expect(res1.data[0]).toEqual(docState['io.cozy.files']['456'])
+    expect(res1.data[1]).toEqual(docState['io.cozy.files']['789'])
+
+    const query2 = {
+      doctype: 'io.cozy.files',
+      selector: {
+        name: 'well'
+      }
+    }
+    const res2 = executeQueryFromState(docState, query2)
+    expect(res2.data.length).toEqual(1)
+    expect(res2.data[0]).toEqual(docState['io.cozy.files']['123'])
+
+    const query3 = {
+      doctype: 'io.cozy.files',
+      selector: {
+        created_at: {
+          $gt: '2024-01-31'
+        },
+        name: 'hello'
+      }
+    }
+    const res3 = executeQueryFromState(docState, query3)
+    expect(res3.data.length).toEqual(1)
+    expect(res3.data[0]).toEqual(docState['io.cozy.files']['456'])
+
+    const query4 = {
+      doctype: 'io.cozy.files',
+      selector: {
+        created_at: {
+          $gt: '2024-01-30',
+          $lt: '2024-01-31'
+        }
+      }
+    }
+    const res4 = executeQueryFromState(docState, query4)
+    expect(res4.data.length).toEqual(0)
+  })
+
+  it('should get the correct filtered results from state thanks to id', () => {
+    const query1 = {
+      doctype: 'io.cozy.files',
+      id: '123'
+    }
+    const res1 = executeQueryFromState(docState, query1)
+    expect(res1.data).toEqual(docState['io.cozy.files']['123'])
+
+    const query2 = {
+      doctype: 'io.cozy.files',
+      ids: ['123', '789']
+    }
+    const res2 = executeQueryFromState(docState, query2)
+    expect(res2.data.length).toEqual(2)
+    expect(res2.data[0]).toEqual(docState['io.cozy.files']['123'])
+    expect(res2.data[1]).toEqual(docState['io.cozy.files']['789'])
+
+    const query3 = {
+      doctype: 'io.cozy.files',
+      id: '-1'
+    }
+    const res3 = executeQueryFromState(docState, query3)
+    expect(res3.data).toEqual(null)
+  })
+
+  it('should get all the docs from state for the doctype when no filter', () => {
+    const query1 = {
+      doctype: 'io.cozy.files'
+    }
+    const res1 = executeQueryFromState(docState, query1)
+    expect(res1.data.length).toEqual(3)
+  })
+
+  it('should correctly return when no doc is available', () => {
+    const res1 = executeQueryFromState({}, { doctype: 'io.cozy.files' })
+    expect(res1.data).toEqual([])
+
+    const res2 = executeQueryFromState(
+      {},
+      { doctype: 'io.cozy.files', id: '123' }
+    )
+    expect(res2.data).toEqual(null)
+  })
+})

package/dist/types.js

@@ -297,6 +297,7 @@ var _dsl = require("./queries/dsl");
  * @property {boolean} [singleDocData] - If true, the "data" returned will be
  * a single doc instead of an array for single doc queries. Defaults to false for backward
  * compatibility but will be set to true in the future.
+ * @property {boolean} [executeFromStore=false] - If set to true, the query will be run directly on the current store's state
  */
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "48.12.1",
+  "version": "48.13.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -75,5 +75,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "fd65271404d88a5851357225f1b5a3f48cec9f50"
+  "gitHead": "f010d354bd83022be6bfb94f9aff58bcba10f1e5"
 }

package/types/CozyClient.d.ts

@@ -422,7 +422,7 @@ declare class CozyClient {
      * @param  {import("./types").QueryOptions} [options] - Options
      * @returns {Promise<import("./types").QueryResult>}
      */
-    query(queryDefinition: QueryDefinition, { update, ...options }?: import("./types").QueryOptions): Promise<import("./types").QueryResult>;
+    query(queryDefinition: QueryDefinition, { update, executeFromStore, ...options }?: import("./types").QueryOptions): Promise<import("./types").QueryResult>;
     /**
      * Will fetch all documents for a `queryDefinition`, automatically fetching more
      * documents if the total of documents is superior to the pagination limit. Can

package/types/store/index.d.ts

@@ -25,5 +25,5 @@ declare function combinedReducer(state: {
 export function resetState(): {
     type: string;
 };
-export { initQuery, loadQuery, resetQuery, receiveQueryResult, receiveQueryError } from "./queries";
+export { initQuery, loadQuery, resetQuery, receiveQueryResult, receiveQueryError, executeQueryFromState } from "./queries";
 export { initMutation, receiveMutationResult, receiveMutationError } from "./mutations";

package/types/store/queries.d.ts

@@ -6,6 +6,7 @@ export function sortAndLimitDocsIds(queryState: import("../types").QueryState, d
 }): Array<string>;
 export function convert$gtNullSelectors(selector: any): object;
 export function mergeSelectorAndPartialIndex(queryDefinition: object): object;
+export function executeQueryFromState(state: import('../types').DocumentsStateSlice, queryDefinition: QueryDefinition): import("../types").QueryStateData;
 export function makeSorterFromDefinition(definition: QueryDefinition): (arg0: Array<import("../types").CozyClientDocument>) => Array<import("../types").CozyClientDocument>;
 export function updateData(query: import("../types").QueryState, newData: Array<import("../types").CozyClientDocument>, documents: import("../types").DocumentsStateSlice): import("../types").QueryState;
 export default queries;

package/types/types.d.ts

@@ -542,6 +542,10 @@ export type QueryOptions = {
      * compatibility but will be set to true in the future.
      */
     singleDocData?: boolean;
+    /**
+     * - If set to true, the query will be run directly on the current store's state
+     */
+    executeFromStore?: boolean;
 };
 export type Query = {
     definition: QueryDefinition;