cozy-client 48.12.1 → 48.13.1

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.1";
 
 _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() {
@@ -55,7 +61,49 @@ Object.defineProperty(exports, "receiveMutationError", {
     return _mutations.receiveMutationError;
   }
 });
-exports.resetState = exports.isQueryExisting = exports.getRawQueryFromState = exports.getQueryFromState = exports.getQueryFromStore = exports.getDocumentFromState = exports.getCollectionFromState = exports.getStateRoot = exports.createStore = exports.default = exports.StoreProxy = void 0;
+Object.defineProperty(exports, "getStateRoot", {
+  enumerable: true,
+  get: function get() {
+    return _stateHelpers.getStateRoot;
+  }
+});
+Object.defineProperty(exports, "getCollectionFromState", {
+  enumerable: true,
+  get: function get() {
+    return _stateHelpers.getCollectionFromState;
+  }
+});
+Object.defineProperty(exports, "getDocumentFromState", {
+  enumerable: true,
+  get: function get() {
+    return _stateHelpers.getDocumentFromState;
+  }
+});
+Object.defineProperty(exports, "getQueryFromStore", {
+  enumerable: true,
+  get: function get() {
+    return _stateHelpers.getQueryFromStore;
+  }
+});
+Object.defineProperty(exports, "getQueryFromState", {
+  enumerable: true,
+  get: function get() {
+    return _stateHelpers.getQueryFromState;
+  }
+});
+Object.defineProperty(exports, "getRawQueryFromState", {
+  enumerable: true,
+  get: function get() {
+    return _stateHelpers.getRawQueryFromState;
+  }
+});
+Object.defineProperty(exports, "isQueryExisting", {
+  enumerable: true,
+  get: function get() {
+    return _stateHelpers.isQueryExisting;
+  }
+});
+exports.resetState = exports.createStore = exports.default = exports.StoreProxy = void 0;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
@@ -69,12 +117,14 @@ var _redux = require("redux");
 
 var _reduxThunk = _interopRequireDefault(require("redux-thunk"));
 
-var _documents = _interopRequireWildcard(require("./documents"));
+var _documents = _interopRequireDefault(require("./documents"));
 
 var _queries = _interopRequireWildcard(require("./queries"));
 
 var _mutations = require("./mutations");
 
+var _stateHelpers = require("./stateHelpers");
+
 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; }
@@ -172,46 +222,4 @@ var createStore = function createStore() {
   }), composedEnhancer((0, _redux.applyMiddleware)(_reduxThunk.default)));
 };
 
-exports.createStore = createStore;
-
-var getStateRoot = function getStateRoot(state) {
-  return state.cozy || {};
-};
-
-exports.getStateRoot = getStateRoot;
-
-var getCollectionFromState = function getCollectionFromState(state, doctype) {
-  return (0, _documents.getCollectionFromSlice)(getStateRoot(state).documents, doctype);
-};
-
-exports.getCollectionFromState = getCollectionFromState;
-
-var getDocumentFromState = function getDocumentFromState(state, doctype, id) {
-  return (0, _documents.getDocumentFromSlice)(getStateRoot(state).documents, doctype, id);
-};
-
-exports.getDocumentFromState = getDocumentFromState;
-
-var getQueryFromStore = function getQueryFromStore(store, queryId) {
-  return getQueryFromState(store.getState(), queryId);
-};
-
-exports.getQueryFromStore = getQueryFromStore;
-
-var getQueryFromState = function getQueryFromState(state, queryId) {
-  return (0, _queries.getQueryFromSlice)(getStateRoot(state).queries, queryId, getStateRoot(state).documents);
-};
-
-exports.getQueryFromState = getQueryFromState;
-
-var getRawQueryFromState = function getRawQueryFromState(state, queryId) {
-  return (0, _queries.getQueryFromSlice)(getStateRoot(state).queries, queryId);
-};
-
-exports.getRawQueryFromState = getRawQueryFromState;
-
-var isQueryExisting = function isQueryExisting(state, queryId) {
-  return getStateRoot(state).queries[queryId] !== undefined;
-};
-
-exports.isQueryExisting = isQueryExisting;
+exports.createStore = createStore;

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"));
 
@@ -51,6 +51,8 @@ var _dsl = require("../queries/dsl");
 
 var _logger = _interopRequireDefault(require("../logger"));
 
+var _stateHelpers = require("./stateHelpers");
+
 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; }
@@ -357,25 +359,59 @@ var getSelectorFilterFn = function getSelectorFilterFn(queryDefinition) {
     return null;
   }
 };
+/**
+ * Execute the given query against the document state.
+ *
+ * @param {import('../types').CozyStore} state - The cozy 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, _stateHelpers.getCollectionFromState)(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 +475,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,130 @@ 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'
+      }
+    }
+  }
+  const state = {
+    cozy: {
+      documents: {
+        ...docState
+      },
+      queries: {}
+    }
+  }
+
+  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(state, 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(state, 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(state, 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(state, 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(state, query1)
+    expect(res1.data).toEqual(docState['io.cozy.files']['123'])
+
+    const query2 = {
+      doctype: 'io.cozy.files',
+      ids: ['123', '789']
+    }
+    const res2 = executeQueryFromState(state, 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(state, 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(state, 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/store/stateHelpers.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isQueryExisting = exports.getRawQueryFromState = exports.getQueryFromState = exports.getQueryFromStore = exports.getDocumentFromState = exports.getCollectionFromState = exports.getStateRoot = void 0;
+
+var _documents = require("./documents");
+
+var _queries = require("./queries");
+
+var getStateRoot = function getStateRoot(state) {
+  return state.cozy || {};
+};
+
+exports.getStateRoot = getStateRoot;
+
+var getCollectionFromState = function getCollectionFromState(state, doctype) {
+  return (0, _documents.getCollectionFromSlice)(getStateRoot(state).documents, doctype);
+};
+
+exports.getCollectionFromState = getCollectionFromState;
+
+var getDocumentFromState = function getDocumentFromState(state, doctype, id) {
+  return (0, _documents.getDocumentFromSlice)(getStateRoot(state).documents, doctype, id);
+};
+
+exports.getDocumentFromState = getDocumentFromState;
+
+var getQueryFromStore = function getQueryFromStore(store, queryId) {
+  return getQueryFromState(store.getState(), queryId);
+};
+
+exports.getQueryFromStore = getQueryFromStore;
+
+var getQueryFromState = function getQueryFromState(state, queryId) {
+  return (0, _queries.getQueryFromSlice)(getStateRoot(state).queries, queryId, getStateRoot(state).documents);
+};
+
+exports.getQueryFromState = getQueryFromState;
+
+var getRawQueryFromState = function getRawQueryFromState(state, queryId) {
+  return (0, _queries.getQueryFromSlice)(getStateRoot(state).queries, queryId);
+};
+
+exports.getRawQueryFromState = getRawQueryFromState;
+
+var isQueryExisting = function isQueryExisting(state, queryId) {
+  return getStateRoot(state).queries[queryId] !== undefined;
+};
+
+exports.isQueryExisting = isQueryExisting;

package/dist/types.js

@@ -220,6 +220,17 @@ var _dsl = require("./queries/dsl");
  * @property {Boolean} [encrypted] - encrypted value of the field (legacy)
  */
 
+/**
+ * @typedef {object} CozyState
+ * @property {DocumentsStateSlice} documents
+ * @property {QueriesStateSlice} queries
+ */
+
+/**
+ * @typedef {object} CozyStore
+ * @property {CozyState} cozy
+ */
+
 /**
  * @typedef {{
  *   [key: string]: ManifestField;
@@ -297,6 +308,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.1",
   "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": "594fe6381a442bd4e96a9cbba55ffc7eed6f078a"
 }

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

@@ -8,13 +8,6 @@ export class StoreProxy {
 }
 export default combinedReducer;
 export function createStore(): any;
-export function getStateRoot(state: any): any;
-export function getCollectionFromState(state: any, doctype: any): any[];
-export function getDocumentFromState(state: any, doctype: any, id: any): any;
-export function getQueryFromStore(store: any, queryId: any): any;
-export function getQueryFromState(state: any, queryId: any): any;
-export function getRawQueryFromState(state: any, queryId: any): any;
-export function isQueryExisting(state: any, queryId: any): boolean;
 declare function combinedReducer(state: {
     documents: {};
     queries: {};
@@ -25,5 +18,6 @@ declare function combinedReducer(state: {
 export function resetState(): {
     type: string;
 };
-export { initQuery, loadQuery, resetQuery, receiveQueryResult, receiveQueryError } from "./queries";
+export { getStateRoot, getCollectionFromState, getDocumentFromState, getQueryFromStore, getQueryFromState, getRawQueryFromState, isQueryExisting } from "./stateHelpers";
+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').CozyStore, 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/store/stateHelpers.d.ts

@@ -0,0 +1,7 @@
+export function getStateRoot(state: any): any;
+export function getCollectionFromState(state: any, doctype: any): any[];
+export function getDocumentFromState(state: any, doctype: any, id: any): any;
+export function getQueryFromStore(store: any, queryId: any): any;
+export function getQueryFromState(state: any, queryId: any): any;
+export function getRawQueryFromState(state: any, queryId: any): any;
+export function isQueryExisting(state: any, queryId: any): boolean;

package/types/types.d.ts

@@ -467,6 +467,13 @@ export type ManifestField = {
      */
     encrypted?: boolean;
 };
+export type CozyState = {
+    documents: DocumentsStateSlice;
+    queries: QueriesStateSlice;
+};
+export type CozyStore = {
+    cozy: CozyState;
+};
 export type ManifestFields = {
     [key: string]: ManifestField;
 };
@@ -542,6 +549,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;