cozy-client 60.45.0 → 61.0.1

package/dist/models/file.js

@@ -189,21 +189,23 @@ exports.isEncryptedFileOrFolder = isEncryptedFileOrFolder;
 
 var isOnlyOfficeFile = function isOnlyOfficeFile(file) {
   return isFile(file) && !isNote(file) && (file.class === 'text' || file.class === 'spreadsheet' || file.class === 'slide');
-};
+}; // text/* types OnlyOffice can edit, from https://github.com/ONLYOFFICE/document-formats
+
+
+exports.isOnlyOfficeFile = isOnlyOfficeFile;
+var ONLY_OFFICE_TEXT_MIME_TYPES = ['text/rtf', 'text/csv', 'text/x-csv', 'text/x-comma-separated-values', 'text/tab-separated-values', 'text/fb2+xml'];
 /**
  * Whether the file should be opened by only office
  * We want to be consistent with the stack so we check the class attributes
- * But we want to exclude .txt and .md because the CozyUI Viewer can already show them
+ * But we want to exclude .txt, .md and other plain text files not supported
+ * by only office (.vcf, .ics...) because the CozyUI Viewer can already show them
  *
  * @param {import("../types").IOCozyFile} file - io.cozy.file document
  * @returns {boolean}
  */
 
-
-exports.isOnlyOfficeFile = isOnlyOfficeFile;
-
 var shouldBeOpenedByOnlyOffice = function shouldBeOpenedByOnlyOffice(file) {
-  return isOnlyOfficeFile(file) && !file.name.endsWith('.txt') && !file.name.endsWith('.md');
+  return isOnlyOfficeFile(file) && !file.name.endsWith('.txt') && !file.name.endsWith('.md') && (!isPlainText(file.mime, file.name) || ONLY_OFFICE_TEXT_MIME_TYPES.includes(file.mime));
 };
 /**
  *

package/dist/models/file.spec.js

@@ -163,6 +163,28 @@ describe('File Model', () => {
     expect(fileModel.shouldBeOpenedByOnlyOffice(mdFile)).toBe(false)
   })
 
+  it.each`
+    name             | mime                                                                         | result
+    ${'test.docx'}   | ${'application/vnd.openxmlformats-officedocument.wordprocessingml.document'} | ${true}
+    ${'test.odt'}    | ${'application/vnd.oasis.opendocument.text'}                                 | ${true}
+    ${'test.rtf'}    | ${'text/rtf'}                                                                | ${true}
+    ${'test.csv'}    | ${'text/csv'}                                                                | ${true}
+    ${'test.csv'}    | ${'text/x-csv'}                                                              | ${true}
+    ${'test.tsv'}    | ${'text/tab-separated-values'}                                               | ${true}
+    ${'test.txt'}    | ${'text/plain'}                                                              | ${false}
+    ${'test.md'}     | ${'text/markdown'}                                                           | ${false}
+    ${'contact.vcf'} | ${'text/vcard'}                                                              | ${false}
+    ${'contact.vcf'} | ${'text/x-vcard'}                                                            | ${false}
+    ${'event.ics'}   | ${'text/calendar'}                                                           | ${false}
+    ${'server.log'}  | ${'text/plain'}                                                              | ${false}
+  `(
+    'should return $result for $name ($mime) with only office',
+    ({ name, mime, result }) => {
+      const file = { type: 'file', class: 'text', name, mime }
+      expect(fileModel.shouldBeOpenedByOnlyOffice(file)).toBe(result)
+    }
+  )
+
   it('should test if a file has a specific metadata', () => {
     const doc = {
       metadata: {

package/dist/queries/dsl.js

@@ -554,11 +554,12 @@ exports.Q = Q;
 var isAGetByIdQuery = function isAGetByIdQuery(queryDefinition) {
   if (!queryDefinition) return false;
   var attributes = Object.values(queryDefinition);
-  if (attributes.length === 0) return false; // 2 attrs because we check if id and doctype are not undefined
+  if (attributes.length === 0) return false; // File drive scope does not turn an ID lookup into a selector query.
 
+  var expectedAttributes = queryDefinition.doctype === _const.DOCTYPE_FILES && queryDefinition.sharingId !== undefined ? 3 : 2;
   return attributes.filter(function (attr) {
     return attr !== undefined;
-  }).length === 2 && queryDefinition.id !== undefined;
+  }).length === expectedAttributes && queryDefinition.id !== undefined;
 }; // Mutations
 
 

package/dist/store/queries.js

@@ -422,9 +422,11 @@ var executeQueryFromState = function executeQueryFromState(state, queryDefinitio
 
   if (queryDefinition.id) {
     var doc = (0, _stateHelpers.getDocumentFromState)(state, queryDefinition.doctype, queryDefinition.id);
-    res = doc ? [doc] : [];
+    res = doc && isDocumentInQueryScope(queryDefinition, doc) ? [doc] : [];
   } else if (queryDefinition.ids) {
-    res = (0, _stateHelpers.getDocumentsFromState)(state, queryDefinition.doctype, queryDefinition.ids);
+    res = (0, _stateHelpers.getDocumentsFromState)(state, queryDefinition.doctype, queryDefinition.ids).filter(function (doc) {
+      return isDocumentInQueryScope(queryDefinition, doc);
+    });
   } else {
     var documents = (0, _stateHelpers.getCollectionFromState)(state, queryDefinition.doctype);
     res = documents === null || documents === void 0 ? void 0 : documents.filter(makeFilterDocumentFn(queryDefinition));
@@ -448,24 +450,39 @@ var executeQueryFromState = function executeQueryFromState(state, queryDefinitio
     data: sortedDocuments
   };
 };
+
+exports.executeQueryFromState = executeQueryFromState;
+
+function isDocumentInQueryScope(definition, document) {
+  var _definition$selector, _definition$partialFi;
+
+  if (definition.doctype !== _const.DOCTYPE_FILES) return true;
+  if (definition.sharingId) return document.driveId === definition.sharingId; // Offline folder queries can select a drive explicitly without sharingById().
+
+  if (((_definition$selector = definition.selector) === null || _definition$selector === void 0 ? void 0 : _definition$selector.driveId) !== undefined || ((_definition$partialFi = definition.partialFilter) === null || _definition$partialFi === void 0 ? void 0 : _definition$partialFi.driveId) !== undefined) {
+    return true;
+  }
+
+  return !document.driveId;
+}
 /**
  *
  * Returns a predicate function that checks if a document should be
  * included in the result of the query.
  *
  * @param  {QueryDefinition} queryDefinition - Definition of the query
- * @returns {function(import("../types").CozyClientDocument): boolean} Predicate function
+ * @returns {function(import("../types").CozyClientDocument): boolean|null} Predicate function; null means another drive
  */
 
 
-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 (ddoctype !== qdoctype) return false; // Another drive is ignored, not treated as a removal from this query.
+
+    if (!isDocumentInQueryScope(queryDefinition, datum)) return null;
     if (datum._deleted) return false;
     if (!selectorFilterFn) return true; // no selector: query all the docs
 
@@ -527,7 +544,7 @@ var dedupCache = null;
 var dedupIdIndex = null;
 
 var makeDefinitionKey = function makeDefinitionKey(def) {
-  return JSON.stringify([def.doctype, def.selector, def.partialFilter, def.id, def.ids]);
+  return JSON.stringify([def.doctype, def.sharingId, def.selector, def.partialFilter, def.id, def.ids]);
 };
 
 var getDedupIdIndex = function getDedupIdIndex(newData) {
@@ -587,6 +604,10 @@ var computeMatchPartition = function computeMatchPartition(definition, newData)
         var doc = idx.get(id);
 
         if (doc) {
+          if (doc._type === definition.doctype && !isDocumentInQueryScope(definition, doc)) {
+            continue;
+          }
+
           if (!doc._deleted && doc._type === definition.doctype) {
             matchedIds.push((0, _helpers.properId)(doc));
           } else {
@@ -937,8 +958,9 @@ var QueryIDGenerator = /*#__PURE__*/function () {
         return this.generateRandomId();
       } else {
         var id = queryDefinition.id,
-            doctype = queryDefinition.doctype;
-        return "".concat(doctype, "/").concat(id);
+            doctype = queryDefinition.doctype,
+            sharingId = queryDefinition.sharingId;
+        return doctype === _const.DOCTYPE_FILES && sharingId ? "".concat(doctype, "/drive/").concat(sharingId, "/").concat(id) : "".concat(doctype, "/").concat(id);
       }
     }
   }]);

package/dist/store/queries.spec.js

@@ -707,6 +707,57 @@ describe('updateData', () => {
 })
 
 describe('computeMatchPartition', () => {
+  it('ignores other drives instead of removing their documents from the query', () => {
+    const makeFile = (_id, driveId, name = 'Wanted') => ({
+      _id,
+      _type: 'io.cozy.files',
+      driveId,
+      name
+    })
+    const data = [
+      makeFile('personal', null),
+      makeFile('a-match', 'drive-a'),
+      makeFile('a-renamed', 'drive-a', 'Renamed'),
+      makeFile('b-match', 'drive-b')
+    ]
+    const definition = Q('io.cozy.files').where({ name: 'Wanted' })
+
+    expect(
+      computeMatchPartition(definition.sharingById('drive-a'), data)
+    ).toEqual({
+      matchedIds: ['a-match'],
+      unmatchedIds: ['a-renamed']
+    })
+    expect(
+      computeMatchPartition(definition.sharingById('drive-b'), data)
+    ).toEqual({
+      matchedIds: ['b-match'],
+      unmatchedIds: []
+    })
+    expect(computeMatchPartition(definition, data)).toEqual({
+      matchedIds: ['personal'],
+      unmatchedIds: []
+    })
+  })
+
+  it.each([false, true])(
+    'ignores another drive for an id query (multiple: %s)',
+    multiple => {
+      const definition = Q('io.cozy.files').sharingById('drive-b')
+      const query = multiple
+        ? definition.getByIds(['same-id'])
+        : definition.getById('same-id')
+      const data = [
+        { _id: 'same-id', _type: 'io.cozy.files', driveId: 'drive-a' }
+      ]
+
+      expect(computeMatchPartition(query, data)).toEqual({
+        matchedIds: [],
+        unmatchedIds: []
+      })
+    }
+  )
+
   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)

package/dist/store/realtime.js

@@ -15,6 +15,8 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _dsl = require("../queries/dsl");
 
+var _const = require("../const");
+
 var _mutations = require("./mutations");
 
 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; }
@@ -29,13 +31,16 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
  * @public
  * @param {import("../types").CouchDBDocument} couchDBDoc - object representing the document
  * @param {string} doctype - Doctype of the document
+ * @param {string} [driveId] - Shared drive that emitted this event
  * @returns {import("../types").CozyClientDocument} full normalized document
  */
-var normalizeDoc = function normalizeDoc(couchDBDoc, doctype) {
-  return _objectSpread({
+var normalizeDoc = function normalizeDoc(couchDBDoc, doctype, driveId) {
+  return _objectSpread(_objectSpread({
     id: couchDBDoc._id,
     _type: doctype
-  }, couchDBDoc);
+  }, doctype === _const.DOCTYPE_FILES && driveId ? {
+    driveId: driveId
+  } : {}), couchDBDoc);
 };
 /**
  * Enhances a document with additional attributes
@@ -103,6 +108,7 @@ var dispatchChange = function dispatchChange(client, document, mutationDefinitio
 /**
  * @typedef {Object} DispatchOptions
  * @property {function} [enhanceDocFn] Optional function to enhance the document attributes before dispatch
+ * @property {string} [driveId] Shared drive that emitted this event
  */
 
 /**
@@ -126,7 +132,7 @@ var dispatchCreate = /*#__PURE__*/function () {
         switch (_context2.prev = _context2.next) {
           case 0:
             options = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : {};
-            normalizedDoc = normalizeDoc(couchDBDoc, doctype);
+            normalizedDoc = normalizeDoc(couchDBDoc, doctype, options.driveId);
             _context2.next = 4;
             return enhanceDoc(normalizedDoc, {
               client: client,
@@ -172,7 +178,7 @@ var dispatchUpdate = /*#__PURE__*/function () {
         switch (_context3.prev = _context3.next) {
           case 0:
             options = _args3.length > 3 && _args3[3] !== undefined ? _args3[3] : {};
-            normalizedDoc = normalizeDoc(couchDBDoc, doctype);
+            normalizedDoc = normalizeDoc(couchDBDoc, doctype, options.driveId);
             _context3.next = 4;
             return enhanceDoc(normalizedDoc, {
               client: client,
@@ -220,7 +226,7 @@ var dispatchDelete = /*#__PURE__*/function () {
             options = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {};
             normalizedDoc = normalizeDoc(_objectSpread(_objectSpread({}, couchDBDoc), {}, {
               _deleted: true
-            }), doctype);
+            }), doctype, options.driveId);
             _context4.next = 4;
             return enhanceDoc(normalizedDoc, {
               client: client,

package/dist/types.js

@@ -304,6 +304,7 @@ var _dsl = require("./queries/dsl");
 /**
  * @typedef {object} QueryOptions
  * @property {string} [as] - Name of the query
+ * @property {string} [driveId] - Shared-drive scope for io.cozy.files queries; equivalent to sharingById()
  * @property {Function} [fetchPolicy] - Fetch policy to bypass fetching based on what's already inside the state. See "Fetch policies"
  * @property {AutoUpdateOptions} [autoUpdate] - Options for the query auto update
  * @property {string} [update] - Does not seem to be used
@@ -408,9 +409,12 @@ var _dsl = require("./queries/dsl");
 
 /**
  * @typedef {object} MutationOptions
+ * @property {string} [driveId] - Shared drive scope for io.cozy.files creation through StackLink only
+ * @property {string} [forceLink] - Use 'stack' for online-only file creation when an offline link is configured
+ * @property {boolean} [forceStack] - Deprecated: use forceLink:'stack' instead
  * @property {string} as - Mutation id
    @property  {Function} update - Function to update the document
- * @property  {Function} updateQueries - Function to update queries
+ * @property {Object.<string, Function>} updateQueries - Query update functions indexed by query id
  */
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "60.45.0",
+  "version": "61.0.1",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -19,7 +19,7 @@
     "@types/jest": "^26.0.20",
     "@types/lodash": "^4.14.170",
     "btoa": "^1.2.1",
-    "cozy-stack-client": "^60.45.0",
+    "cozy-stack-client": "^61.0.0",
     "date-fns": "^2.30.0",
     "fast-deep-equal": "^3.1.3",
     "json-stable-stringify": "^1.0.1",
@@ -74,5 +74,5 @@
     "react-native-ios11-devicecheck": "^0.0.3"
   },
   "sideEffects": false,
-  "gitHead": "0b14a9be7b03613a8e041f3f99110204e0942963"
+  "gitHead": "0619509d0618d695c92265c1f0cfecba3225aeb6"
 }

package/types/CozyClient.d.ts

@@ -382,7 +382,7 @@ declare class CozyClient {
      * @param  {import("./types").ReferenceMap} [references] - References are a special kind of relationship
      * that is not stored inside the referencer document, they are used for example between a photo
      * and its album. You should not need to use it normally.
-     * @param  {object} options - Mutation options
+     * @param {Partial<import('./types').MutationOptions>} [options] - Mutation options
      *
      * @example
      * ```js
@@ -398,7 +398,7 @@ declare class CozyClient {
      *
      * @returns {Promise}
      */
-    create(type: string, doc: object, references?: import("./types").ReferenceMap, options?: object): Promise<any>;
+    create(type: string, doc: object, references?: import("./types").ReferenceMap, options?: Partial<import('./types').MutationOptions>): Promise<any>;
     /**
      * Create multiple documents in one batch.
      * WARNING: this method is currently not supported by the stack, but
@@ -543,18 +543,11 @@ declare class CozyClient {
      * Mutate a document
      *
      * @param  {object} mutationDefinition - Describe the mutation
-     * @param {object} [params] The mutation params
-     * @param {function} [params.update] - update function from MutationOptions
-     * @param {function} [params.updateQueries] - updateQueries function from MutationOptions
-     * @param {string} [params.as] - Mutation id
-     * @param {Object} [params.options={}] - Additional options
+     * @param {Partial<import('./types').MutationOptions> & { options?: object }} [params] - Mutation options
      * @returns {Promise}
      */
-    mutate(mutationDefinition: object, { update, updateQueries, ...options }?: {
-        update?: Function;
-        updateQueries?: Function;
-        as?: string;
-        options?: any;
+    mutate(mutationDefinition: object, { update, updateQueries, ...options }?: Partial<import("./types").MutationOptions> & {
+        options?: object;
     }): Promise<any>;
     /**
      * Executes a query through links and fetches relationships

package/types/store/realtime.d.ts

@@ -6,4 +6,8 @@ export type DispatchOptions = {
      * Optional function to enhance the document attributes before dispatch
      */
     enhanceDocFn?: Function;
+    /**
+     * Shared drive that emitted this event
+     */
+    driveId?: string;
 };

package/types/types.d.ts

@@ -528,6 +528,10 @@ export type QueryOptions = {
      * - Name of the query
      */
     as?: string;
+    /**
+     * - Shared-drive scope for io.cozy.files queries; equivalent to sharingById()
+     */
+    driveId?: string;
     /**
      * - Fetch policy to bypass fetching based on what's already inside the state. See "Fetch policies"
      */
@@ -666,6 +670,18 @@ export type ReferenceMap = {
     [x: string]: Reference[];
 };
 export type MutationOptions = {
+    /**
+     * - Shared drive scope for io.cozy.files creation through StackLink only
+     */
+    driveId?: string;
+    /**
+     * - Use 'stack' for online-only file creation when an offline link is configured
+     */
+    forceLink?: string;
+    /**
+     * - Deprecated: use forceLink:'stack' instead
+     */
+    forceStack?: boolean;
     /**
      * - Mutation id
      */
@@ -675,9 +691,11 @@ export type MutationOptions = {
      */
     update: Function;
     /**
-     * - Function to update queries
+     * - Query update functions indexed by query id
      */
-    updateQueries: Function;
+    updateQueries: {
+        [x: string]: Function;
+    };
 };
 export type UpdatedByApp = {
     /**