cozy-pouch-link 60.24.0 → 60.24.2

package/dist/PouchManager.spec.js

@@ -235,7 +235,7 @@ describe('PouchManager', () => {
     manager.updateSyncInfo('io.cozy.todos')
     await manager.replicateOnce()
     expect(onSync).toHaveBeenCalledWith({
-      'cozy.tools__doctype__io.cozy.todos': [
+      'io.cozy.todos': [
         {
           _id: '1',
           name: 'Make replication work'

package/dist/files.js

@@ -23,19 +23,23 @@ exports.TYPE_FILE = TYPE_FILE;
 
 var queryFileById = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client, id) {
-    var queryOpts;
+    var definition, options;
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            queryOpts = {
+            definition = (0, _cozyClient.Q)('io.cozy.files').getById(id);
+            options = {
               as: "io.cozy.files/".concat(id),
               fetchPolicy: defaultFetchPolicy,
               singleDocData: true
             };
-            return _context.abrupt("return", client.query((0, _cozyClient.Q)('io.cozy.files').getById(id), queryOpts));
+            return _context.abrupt("return", client.fetchQueryAndGetFromState({
+              definition: definition,
+              options: options
+            }));
 
-          case 2:
+          case 3:
           case "end":
             return _context.stop();
         }

package/dist/files.spec.js

@@ -0,0 +1,25 @@
+import { Q } from 'cozy-client'
+
+import { queryFileById } from './files'
+
+describe('queryFileById', () => {
+  it('should call client.fetchQueryAndGetFromState with the expected definition and options', async () => {
+    const expectedResult = { data: { _id: 'parent', path: '/parent' } }
+    const client = {
+      fetchQueryAndGetFromState: jest.fn().mockResolvedValue(expectedResult)
+    }
+
+    const res = await queryFileById(client, 'parent')
+
+    expect(res).toBe(expectedResult)
+    expect(client.fetchQueryAndGetFromState).toHaveBeenCalledTimes(1)
+    expect(client.fetchQueryAndGetFromState).toHaveBeenCalledWith({
+      definition: expect.objectContaining(Q('io.cozy.files').getById('parent')),
+      options: {
+        as: 'io.cozy.files/parent',
+        fetchPolicy: expect.any(Function),
+        singleDocData: true
+      }
+    })
+  })
+})

package/dist/jsonapi.js

@@ -167,7 +167,7 @@ var buildPathWithName = function buildPathWithName(parentPath, fileName) {
 
 var computeFileFullpath = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client, file) {
-    var _file$path, newPath, filePath, parentPath, builtPath, path, _yield$queryFileById, parentDir, _path;
+    var _file$path, newPath, filePath, parentPath, builtPath, path, result, parentDir, _path;
 
     return _regenerator.default.wrap(function _callee$(_context) {
       while (1) {
@@ -246,8 +246,8 @@ var computeFileFullpath = /*#__PURE__*/function () {
             return (0, _files.queryFileById)(client, file.dir_id);
 
           case 27:
-            _yield$queryFileById = _context.sent;
-            parentDir = _yield$queryFileById.data;
+            result = _context.sent;
+            parentDir = result === null || result === void 0 ? void 0 : result.data;
 
             if (parentDir !== null && parentDir !== void 0 && parentDir.path) {
               _path = buildPathWithName(parentDir.path, file.name);

package/dist/jsonapi.spec.js

@@ -719,4 +719,35 @@ describe('computeFileFullpath', () => {
     const res2 = await computeFileFullpath(client, updFile)
     expect(res2.path).toEqual('ROOT/MYDIR/file3.1')
   })
+
+  it('should return the file unchanged when queryFileById resolves to undefined', async () => {
+    // This happens offline when the link chain returns nothing for the
+    // parent dir lookup. Before the fix, destructuring `.data` from
+    // `undefined` crashed with "Cannot read property 'data' of undefined".
+    queryFileById.mockResolvedValue(undefined)
+    const file = {
+      _id: 'offline-file-1',
+      _type: 'io.cozy.files',
+      type: 'file',
+      dir_id: 'unknown-dir',
+      name: 'offline.txt'
+    }
+    const res = await computeFileFullpath(client, file)
+    expect(res).toBe(file)
+    expect(res.path).toBeUndefined()
+  })
+
+  it('should return the file unchanged when queryFileById resolves with null data', async () => {
+    queryFileById.mockResolvedValue({ data: null })
+    const file = {
+      _id: 'offline-file-2',
+      _type: 'io.cozy.files',
+      type: 'file',
+      dir_id: 'unknown-dir',
+      name: 'offline2.txt'
+    }
+    const res = await computeFileFullpath(client, file)
+    expect(res).toBe(file)
+    expect(res.path).toBeUndefined()
+  })
 })

package/dist/replicateOnce.js

@@ -176,7 +176,9 @@ var replicateOnce = /*#__PURE__*/function () {
               };
             }()); // Waiting on each replication
 
-            doctypes = Object.keys(pouchManager.pouches);
+            doctypes = Object.keys(pouchManager.pouches).map(function (dbName) {
+              return (0, _utils.getDoctypeFromDatabaseName)(dbName);
+            });
             promises = Object.values(pouchManager.replications);
             _context2.prev = 9;
             _context2.next = 12;

package/dist/replicateOnce.spec.js

@@ -0,0 +1,104 @@
+/* global jest */
+
+jest.mock('./remote', () => ({
+  fetchRemoteLastSequence: jest.fn().mockResolvedValue('0'),
+  isDatabaseNotFoundError: jest.fn().mockReturnValue(false),
+  isDatabaseUnradableError: jest.fn().mockReturnValue(false)
+}))
+
+jest.mock('./startReplication', () => ({
+  startReplication: jest.fn()
+}))
+
+import { replicateOnce } from './replicateOnce'
+import { startReplication } from './startReplication'
+
+describe('replicateOnce', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should call onSync with clean doctype keys, not prefixed pouch dbNames', async () => {
+    const dbName = 'instance__doctype__io.cozy.todos'
+    const docs = [{ _id: 'doc-1', name: 'a' }]
+
+    startReplication.mockResolvedValue(docs)
+
+    const pouchManager = {
+      pouches: { [dbName]: { id: 'fake-pouch' } },
+      replications: {},
+      doctypesReplicationOptions: {},
+      options: {
+        onSync: jest.fn()
+      },
+      storage: {
+        persistDoctypeLastSequence: jest.fn().mockResolvedValue(),
+        getDoctypeLastSequence: jest.fn().mockResolvedValue(''),
+        destroyDoctypeLastSequence: jest.fn().mockResolvedValue()
+      },
+      client: {},
+      isOnline: jest.fn().mockResolvedValue(true),
+      getReplicationURL: jest.fn().mockReturnValue('http://example/db'),
+      getSyncStatus: jest.fn().mockReturnValue('synced'),
+      updateSyncInfo: jest.fn().mockResolvedValue(),
+      checkToWarmupDoctype: jest.fn(),
+      handleReplicationError: jest.fn(),
+      cancelCurrentReplications: jest.fn()
+    }
+
+    await replicateOnce(pouchManager)
+
+    expect(pouchManager.options.onSync).toHaveBeenCalledTimes(1)
+    const payload = pouchManager.options.onSync.mock.calls[0][0]
+
+    // The bug: payload was keyed by the full prefixed dbName
+    // The fix: payload must be keyed by the clean doctype
+    expect(Object.keys(payload)).toEqual(['io.cozy.todos'])
+    expect(Object.keys(payload)).not.toContain(dbName)
+    expect(payload['io.cozy.todos']).toEqual(docs)
+  })
+
+  it('should preserve clean doctype keys for multiple pouches', async () => {
+    const dbNameA = 'instance__doctype__io.cozy.todos'
+    const dbNameB = 'instance__doctype__io.cozy.files'
+    const docsA = [{ _id: 'a1' }]
+    const docsB = [{ _id: 'b1' }]
+
+    startReplication.mockImplementation(pouch => {
+      if (pouch === 'pouchA') return Promise.resolve(docsA)
+      if (pouch === 'pouchB') return Promise.resolve(docsB)
+      return Promise.resolve([])
+    })
+
+    const pouchManager = {
+      pouches: { [dbNameA]: 'pouchA', [dbNameB]: 'pouchB' },
+      replications: {},
+      doctypesReplicationOptions: {},
+      options: { onSync: jest.fn() },
+      storage: {
+        persistDoctypeLastSequence: jest.fn().mockResolvedValue(),
+        getDoctypeLastSequence: jest.fn().mockResolvedValue(''),
+        destroyDoctypeLastSequence: jest.fn().mockResolvedValue()
+      },
+      client: {},
+      isOnline: jest.fn().mockResolvedValue(true),
+      getReplicationURL: jest.fn().mockReturnValue('http://example/db'),
+      getSyncStatus: jest.fn().mockReturnValue('synced'),
+      updateSyncInfo: jest.fn().mockResolvedValue(),
+      checkToWarmupDoctype: jest.fn(),
+      handleReplicationError: jest.fn(),
+      cancelCurrentReplications: jest.fn()
+    }
+
+    await replicateOnce(pouchManager)
+
+    expect(pouchManager.options.onSync).toHaveBeenCalledTimes(1)
+    const payload = pouchManager.options.onSync.mock.calls[0][0]
+    expect(Object.keys(payload).sort()).toEqual([
+      'io.cozy.files',
+      'io.cozy.todos'
+    ])
+    expect(payload['io.cozy.todos']).toEqual(docsA)
+    expect(payload['io.cozy.files']).toEqual(docsB)
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-pouch-link",
-  "version": "60.24.0",
+  "version": "60.24.2",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -41,5 +41,5 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "72de2e80e0d0ac89d71b7fca60c2352b07136151"
+  "gitHead": "e621858d1b3d16f79d75bb79d3f183d204f2eabe"
 }