cozy-pouch-link 48.25.0 → 49.0.0

package/dist/startReplication.spec.js

@@ -1,12 +1,8 @@
+import MicroEE from 'microee'
 import { fetchRemoteLastSequence, fetchRemoteInstance } from './remote'
-import { getLastReplicatedDocID } from './localStorage'
 
-import { replicateAllDocs } from './startReplication'
-
-jest.mock('./localStorage', () => ({
-  getLastReplicatedDocID: jest.fn(),
-  persistLastReplicatedDocID: jest.fn()
-}))
+import { replicateAllDocs, startReplication } from './startReplication'
+import { insertBulkDocs } from './helpers'
 
 jest.mock('./remote', () => ({
   fetchRemoteLastSequence: jest.fn(),
@@ -14,6 +10,7 @@ jest.mock('./remote', () => ({
 }))
 
 jest.mock('./helpers', () => ({
+  ...jest.requireActual('./helpers').default,
   insertBulkDocs: jest.fn()
 }))
 
@@ -27,49 +24,387 @@ const generateDocs = nDocs => {
   return docs
 }
 
-describe('replication through _all_docs', () => {
+const storage = {
+  getLastReplicatedDocID: jest.fn(),
+  persistLastReplicatedDocID: jest.fn()
+}
+
+function ReplicationOnMock() {}
+MicroEE.mixin(ReplicationOnMock)
+const mockReplicationOn = new ReplicationOnMock()
+mockReplicationOn.cancel = () => {
+  mockReplicationOn.emit('complete')
+}
+
+describe('startReplication', () => {
   beforeEach(() => {
+    jest.resetAllMocks()
     fetchRemoteLastSequence.mockResolvedValue('10-xyz')
   })
-  it('should replicate all docs', async () => {
-    getLastReplicatedDocID.mockReturnValue(null)
-    const dummyDocs = generateDocs(2)
-    fetchRemoteInstance.mockResolvedValue({ rows: dummyDocs })
-
-    const rep = await replicateAllDocs(null, url)
-    const expectedDocs = dummyDocs.map(doc => doc.doc)
-    expect(rep).toEqual(expectedDocs)
-  })
 
-  it('should replicate all docs when it gets more docs than the batch limit', async () => {
-    getLastReplicatedDocID.mockReturnValue(null)
-    const dummyDocs = generateDocs(1002)
-    fetchRemoteInstance.mockResolvedValueOnce({
-      rows: dummyDocs.slice(0, 1001)
+  describe('replication through _all_docs', () => {
+    it('should replicate all docs', async () => {
+      storage.getLastReplicatedDocID.mockReturnValue(null)
+      const dummyDocs = generateDocs(2)
+      fetchRemoteInstance.mockResolvedValue({ rows: dummyDocs })
+
+      const rep = await replicateAllDocs({
+        db: null,
+        baseUrl: url,
+        doctype: undefined,
+        storage
+      })
+      const expectedDocs = dummyDocs.map(doc => doc.doc)
+      expect(rep).toEqual(expectedDocs)
+      expect(fetchRemoteInstance).toHaveBeenCalledTimes(1)
+      expect(insertBulkDocs).toHaveBeenCalledTimes(1)
     })
-    fetchRemoteInstance.mockResolvedValueOnce({
-      rows: dummyDocs.slice(1000, 1002)
+
+    it('should replicate all docs when it gets more docs than the batch limit', async () => {
+      storage.getLastReplicatedDocID.mockReturnValue(null)
+      const dummyDocs = generateDocs(1002)
+      fetchRemoteInstance.mockResolvedValueOnce({
+        rows: dummyDocs.slice(0, 1001)
+      })
+      fetchRemoteInstance.mockResolvedValueOnce({
+        rows: dummyDocs.slice(1000, 1002)
+      })
+
+      const rep = await replicateAllDocs({
+        db: null,
+        baseUrl: url,
+        doctype: undefined,
+        storage
+      })
+      const expectedDocs = dummyDocs.map(doc => doc.doc)
+      expect(rep).toEqual(expectedDocs)
+      expect(fetchRemoteInstance).toHaveBeenCalledTimes(2)
+      expect(insertBulkDocs).toHaveBeenCalledTimes(2)
     })
 
-    const rep = await replicateAllDocs(null, url)
-    const expectedDocs = dummyDocs.map(doc => doc.doc)
-    expect(rep).toEqual(expectedDocs)
+    it('should replicate from the last saved doc id', async () => {
+      storage.getLastReplicatedDocID.mockReturnValue('5')
+      const dummyDocs = generateDocs(10)
+      fetchRemoteInstance.mockResolvedValue({ rows: dummyDocs.slice(5, 11) })
+
+      const rep = await replicateAllDocs({
+        db: null,
+        baseUrl: url,
+        doctype: undefined,
+        storage
+      })
+
+      const calledUrl = new URL(`${url}/_all_docs`)
+      expect(fetchRemoteInstance).toHaveBeenCalledWith(calledUrl, {
+        include_docs: true,
+        limit: 1000,
+        startkey_docid: '5'
+      })
+      expect(fetchRemoteInstance).toHaveBeenCalledTimes(1)
+      expect(insertBulkDocs).toHaveBeenCalledTimes(1)
+      const expectedDocs = dummyDocs.map(doc => doc.doc).slice(6, 11)
+      expect(rep).toEqual(expectedDocs)
+    })
   })
 
-  it('should replicate from the last saved doc id', async () => {
-    getLastReplicatedDocID.mockReturnValue('5')
-    const dummyDocs = generateDocs(10)
-    fetchRemoteInstance.mockResolvedValue({ rows: dummyDocs.slice(5, 11) })
+  describe('startReplication', () => {
+    it('should call replicateAllDocs on initial replication', async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = true
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
 
-    const rep = await replicateAllDocs(null, url)
+      const dummyDocs = generateDocs(2)
+      fetchRemoteInstance.mockResolvedValue({ rows: dummyDocs })
 
-    const calledUrl = new URL(`${url}/_all_docs`)
-    expect(fetchRemoteInstance).toHaveBeenCalledWith(calledUrl, {
-      include_docs: true,
-      limit: 1000,
-      startkey_docid: '5'
+      const pouch = getPouchMock()
+
+      await startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+
+      expect(fetchRemoteInstance).toHaveBeenCalledWith(
+        new URL(
+          'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files/_all_docs'
+        ),
+        { include_docs: true, limit: 1000 }
+      )
+      expect(pouch.replicate.from).not.toHaveBeenCalled()
+      expect(pouch.replicate.to).not.toHaveBeenCalled()
+      expect(pouch.sync).not.toHaveBeenCalled()
+    })
+
+    it('should call Pouch replication on non-initial replications', async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = false
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
+
+      const pouch = getPouchMock()
+
+      const promise = startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+      mockReplicationOn.emit('complete')
+      await promise
+
+      expect(fetchRemoteInstance).not.toHaveBeenCalled()
+      expect(pouch.replicate.to).not.toHaveBeenCalled()
+      expect(pouch.sync).not.toHaveBeenCalled()
+      expect(pouch.replicate.from).toHaveBeenCalledWith(
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files',
+        { batch_size: 1000, selector: { cozyLocalOnly: { $exists: false } } }
+      )
+    })
+
+    it(`should call Pouch replication on initial replications AND strategy is 'toRemote'`, async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = true
+      replicationOptions.strategy = 'toRemote'
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
+
+      const pouch = getPouchMock()
+
+      const promise = startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+      mockReplicationOn.emit('complete')
+      await promise
+
+      expect(fetchRemoteInstance).not.toHaveBeenCalled()
+      expect(pouch.replicate.from).not.toHaveBeenCalled()
+      expect(pouch.sync).not.toHaveBeenCalled()
+      expect(pouch.replicate.to).toHaveBeenCalledWith(
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files',
+        { batch_size: 1000, selector: { cozyLocalOnly: { $exists: false } } }
+      )
+    })
+
+    it(`should handle error result when Pouch replication`, async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = false
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
+
+      const pouch = getPouchMock()
+
+      const promise = startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+      mockReplicationOn.emit('error', 'some_error_message')
+      await expect(promise).rejects.toEqual('some_error_message')
+    })
+
+    it(`should handle change event with Sync format and Replication format when Pouch replication`, async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = false
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
+
+      const pouch = getPouchMock()
+
+      const promise = startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+      // Sync format
+      mockReplicationOn.emit('change', {
+        change: {
+          docs: [
+            {
+              _id: 'SOME_DOCUMENT_ID_1',
+              some_property: 'some_value'
+            }
+          ]
+        }
+      })
+      // Replicaiton format
+      mockReplicationOn.emit('change', {
+        docs: [
+          {
+            _id: 'SOME_DOCUMENT_ID_2',
+            some_property: 'some_value'
+          }
+        ]
+      })
+      mockReplicationOn.emit('complete')
+      const result = await promise
+
+      expect(result).toStrictEqual([
+        {
+          _id: 'SOME_DOCUMENT_ID_1',
+          some_property: 'some_value'
+        },
+        {
+          _id: 'SOME_DOCUMENT_ID_2',
+          some_property: 'some_value'
+        }
+      ])
+    })
+
+    it(`should filter design document from change event when Pouch replication`, async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = false
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
+
+      const pouch = getPouchMock()
+
+      const promise = startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+      mockReplicationOn.emit('change', {
+        change: {
+          docs: [
+            {
+              _id: 'SOME_DOCUMENT_ID_1',
+              some_property: 'some_value'
+            },
+            {
+              _id: '_design_SOME_DOCUMENT_ID_2',
+              some_property: 'some_value'
+            }
+          ]
+        }
+      })
+      mockReplicationOn.emit('complete')
+      const result = await promise
+
+      expect(result).toStrictEqual([
+        {
+          _id: 'SOME_DOCUMENT_ID_1',
+          some_property: 'some_value'
+        }
+      ])
+    })
+
+    it(`should filter deleted document from change event when Pouch replication`, async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = false
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
+
+      const pouch = getPouchMock()
+
+      const promise = startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+      mockReplicationOn.emit('change', {
+        change: {
+          docs: [
+            {
+              _id: 'SOME_DOCUMENT_ID_1',
+              some_property: 'some_value'
+            },
+            {
+              _id: 'SOME_DOCUMENT_ID_2',
+              some_property: 'some_value',
+              _deleted: true
+            }
+          ]
+        }
+      })
+      mockReplicationOn.emit('complete')
+      const result = await promise
+
+      expect(result).toStrictEqual([
+        {
+          _id: 'SOME_DOCUMENT_ID_1',
+          some_property: 'some_value'
+        }
+      ])
+    })
+
+    it(`should allow to cancel promise when Pouch replication`, async () => {
+      const replicationOptions = getReplicationOptionsMock()
+      replicationOptions.initialReplication = false
+
+      const getReplicationURL = () =>
+        'https://user:SOME_TOKEN@claude.mycozy.cloud/data/io.cozy.files'
+
+      const pouch = getPouchMock()
+
+      const promise = startReplication(
+        pouch,
+        replicationOptions,
+        getReplicationURL,
+        storage
+      )
+
+      expect(promise.cancel).toBeDefined()
+
+      promise.cancel()
+
+      // this change should be ignored
+      mockReplicationOn.emit('change', {
+        change: {
+          docs: [
+            {
+              _id: 'SOME_DOCUMENT_ID_1',
+              some_property: 'some_value'
+            },
+            {
+              _id: 'SOME_DOCUMENT_ID_2',
+              some_property: 'some_value',
+              _deleted: true
+            }
+          ]
+        }
+      })
+
+      const result = await promise
+
+      expect(result).toStrictEqual([])
     })
-    const expectedDocs = dummyDocs.map(doc => doc.doc).slice(6, 11)
-    expect(rep).toEqual(expectedDocs)
   })
 })
+
+const getPouchMock = () => {
+  const pouch = {
+    replicate: {
+      from: jest.fn(),
+      to: jest.fn()
+    },
+    sync: jest.fn()
+  }
+  pouch.replicate.from.mockReturnValue(mockReplicationOn)
+  pouch.replicate.to.mockReturnValue(mockReplicationOn)
+  pouch.sync.mockReturnValue(mockReplicationOn)
+
+  return pouch
+}
+
+const getReplicationOptionsMock = () => ({
+  strategy: 'fromRemote',
+  initialReplication: false,
+  warmupQueries: {},
+  doctype: 'io.cozy.files'
+})

package/dist/types.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * @typedef {Object} Cancelable
+ * @property {Function} [cancel] - Cancel the promise
+ */
+
+/**
+ * @typedef {Promise & Cancelable} CancelablePromise
+ */
+
+/**
+ * @typedef {CancelablePromise[] & Cancelable} CancelablePromises
+ */
+
+/**
+ * @typedef {"synced"|"not_synced"|"not_complete"} SyncStatus
+ */
+
+/**
+ * @typedef {object} SyncInfo
+ * @property {string} date - The date of the last synchronization
+ * @property {SyncStatus} status - The current synchronization status
+ */
+
+/**
+ * @typedef {object} LocalStorage
+ * @property {function(string): Promise<string | null>} getItem
+ * @property {function(string, string): Promise<void>} setItem
+ * @property {function(string): Promise<void>} removeItem
+ */
+
+/**
+ * @typedef {object} LinkPlatform
+ * @property {LocalStorage} storage Methods to access local storage
+ * @property {any} pouchAdapter PouchDB class (can be pouchdb-core or pouchdb-browser)
+ * @property {function(): Promise<boolean>} isOnline Method that check if the app is connected to internet
+ */
+
+/**
+ * @typedef {Object} MangoPartialFilter
+ */
+
+/**
+ * @typedef {object} MangoSelector
+ */
+
+/**
+ * @typedef {Array<object>} MangoSort
+ */
+
+/**
+ * @typedef {object} MangoQueryOptions
+ * @property {MangoSelector} [selector] Selector
+ * @property {MangoSort} [sort] The sorting parameters
+ * @property {Array<string>} [fields] The fields to return
+ * @property {Array<string>} [partialFilterFields] The partial filter fields
+ * @property {number|null} [limit] For pagination, the number of results to return
+ * @property {number|null} [skip] For skip-based pagination, the number of referenced files to skip
+ * @property {string|null} [indexId] The _id of the CouchDB index to use for this request
+ * @property {string|null} [bookmark] For bookmark-based pagination, the document _id to start from
+ * @property {Array<string>} [indexedFields]
+ * @property {string} [use_index] Name of the index to use
+ * @property {boolean} [execution_stats] If true, we request the stats from Couch
+ * @property {MangoPartialFilter|null} [partialFilter] An optional partial filter
+ */
+
+/**
+ * @typedef {object} PouchDbIndex
+ * @property {string} id - The ddoc's id
+ * @property {string} name - The ddoc's name
+ * @property {'exists'|'created'} result - If the index has been created or if it already exists
+ */
+var _default = {};
+exports.default = _default;

package/dist/utils.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getPrefix = exports.getDatabaseName = void 0;
+exports.formatAggregatedError = exports.getPrefix = exports.getDatabaseName = void 0;
 
 /**
  * Get the database name based on prefix and doctype
@@ -30,4 +30,13 @@ var getPrefix = function getPrefix(uri) {
   return uri.replace(/^https?:\/\//, '');
 };
 
-exports.getPrefix = getPrefix;
+exports.getPrefix = getPrefix;
+
+var formatAggregatedError = function formatAggregatedError(aggregatedError) {
+  var strings = aggregatedError.errors.map(function (e, index) {
+    return '\n[' + index + ']: ' + e.message + '\n' + e.stack;
+  });
+  return strings.join('\n');
+};
+
+exports.formatAggregatedError = formatAggregatedError;

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "cozy-pouch-link",
-  "version": "48.25.0",
+  "version": "49.0.0",
   "license": "MIT",
   "main": "dist/index.js",
+  "types": "types/index.d.ts",
   "files": [
+    "types",
     "dist"
   ],
   "repository": {
@@ -11,7 +13,7 @@
     "url": "git+https://github.com/cozy/cozy-client.git"
   },
   "dependencies": {
-    "cozy-client": "^48.25.0",
+    "cozy-client": "^49.0.0",
     "pouchdb-browser": "^7.2.2",
     "pouchdb-find": "^7.2.2"
   },
@@ -23,7 +25,8 @@
     "parcel": "1.12.4",
     "pouchdb-adapter-memory": "7.2.2",
     "react": "16.14.0",
-    "react-dom": "16.14.0"
+    "react-dom": "16.14.0",
+    "typescript": "4.1.5"
   },
   "peerDependencies": {
     "@cozy/minilog": "1.0.0",
@@ -32,8 +35,9 @@
   "scripts": {
     "build": "../../bin/build",
     "watch": "yarn run build --watch",
-    "prepublishOnly": "yarn run build"
+    "prepublishOnly": "yarn run build",
+    "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "2335cc461075ca1fc55519bcfce80d5a9dc74c0d"
+  "gitHead": "ddf825045c0640e383b7cf89f9937ef7d44e501d"
 }

package/types/AccessToken.d.ts

@@ -0,0 +1,16 @@
+export default class AccessToken {
+    static fromJSON(data: any): AccessToken;
+    constructor(opts: any);
+    tokenType: any;
+    accessToken: any;
+    refreshToken: any;
+    scope: any;
+    toAuthHeader(): string;
+    toBasicAuth(): string;
+    toJSON(): {
+        tokenType: any;
+        accessToken: any;
+        refreshToken: any;
+        scope: any;
+    };
+}