cozy-pouch-link 60.15.2 → 60.16.0

package/dist/startReplication.spec.js

@@ -1,8 +1,12 @@
 import MicroEE from 'microee'
 import { fetchRemoteLastSequence, fetchRemoteInstance } from './remote'
 
-import { replicateAllDocs, startReplication } from './startReplication'
-import { insertBulkDocs } from './helpers'
+import {
+  replicateAllDocs,
+  startReplication,
+  sharedDriveReplicateAllDocs
+} from './startReplication'
+import helpers from './helpers'
 
 jest.mock('./remote', () => ({
   fetchRemoteLastSequence: jest.fn(),
@@ -14,6 +18,8 @@ jest.mock('./helpers', () => ({
   insertBulkDocs: jest.fn()
 }))
 
+const { insertBulkDocs } = helpers
+
 const url = 'http://test.local'
 
 const generateDocs = nDocs => {
@@ -124,7 +130,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
 
       expect(fetchRemoteInstance).toHaveBeenCalledWith(
@@ -151,7 +158,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
       mockReplicationOn.emit('complete')
       await promise
@@ -179,7 +187,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
       mockReplicationOn.emit('complete')
       await promise
@@ -206,7 +215,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
       mockReplicationOn.emit('error', 'some_error_message')
       await expect(promise).rejects.toEqual('some_error_message')
@@ -225,7 +235,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
       // Sync format
       mockReplicationOn.emit('change', {
@@ -275,7 +286,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
       mockReplicationOn.emit('change', {
         change: {
@@ -315,7 +327,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
       mockReplicationOn.emit('change', {
         change: {
@@ -356,7 +369,8 @@ describe('startReplication', () => {
         pouch,
         replicationOptions,
         getReplicationURL,
-        storage
+        storage,
+        null
       )
 
       expect(promise.cancel).toBeDefined()
@@ -385,6 +399,366 @@ describe('startReplication', () => {
       expect(result).toStrictEqual([])
     })
   })
+
+  describe('sharedDriveReplicateAllDocs', () => {
+    const driveId = 'test-drive-123'
+    const doctype = 'io.cozy.files'
+
+    const mockClient = {
+      collection: jest.fn()
+    }
+
+    const mockCollection = {
+      fetchChanges: jest.fn()
+    }
+
+    const mockPouch = {
+      get: jest.fn(),
+      remove: jest.fn(),
+      bulkGet: jest.fn(),
+      bulkDocs: jest.fn()
+    }
+
+    const mockStorage = {
+      getLastReplicatedDocID: jest.fn(),
+      persistLastReplicatedDocID: jest.fn(),
+      getDoctypeLastSequence: jest.fn(),
+      persistDoctypeLastSequence: jest.fn()
+    }
+
+    beforeEach(() => {
+      jest.resetAllMocks()
+      mockClient.collection.mockReturnValue(mockCollection)
+      insertBulkDocs.mockResolvedValue()
+    })
+
+    it('should throw error when driveId is not provided', async () => {
+      await expect(
+        sharedDriveReplicateAllDocs({
+          pouch: mockPouch,
+          storage: mockStorage,
+          doctype,
+          client: mockClient,
+          initialReplication: false
+        })
+      ).rejects.toThrow('sharedDriveReplicateAllDocs: driveId is required')
+    })
+
+    it('should handle initial replication with empty results', async () => {
+      mockStorage.getDoctypeLastSequence.mockResolvedValue(null)
+      mockCollection.fetchChanges.mockResolvedValue({
+        newLastSeq: 'seq-1',
+        results: [],
+        pending: false
+      })
+
+      const result = await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: true
+      })
+
+      expect(result).toEqual([])
+      expect(mockCollection.fetchChanges).toHaveBeenCalledWith(
+        { include_docs: true },
+        {
+          includeFilePath: false,
+          skipDeleted: true,
+          skipTrashed: true,
+          limit: 1000
+        }
+      )
+      expect(insertBulkDocs).toHaveBeenCalledWith(mockPouch, [])
+      expect(mockStorage.persistDoctypeLastSequence).toHaveBeenCalledWith(
+        doctype,
+        'seq-1'
+      )
+    })
+
+    it('should handle initial replication with single batch of documents', async () => {
+      mockStorage.getDoctypeLastSequence.mockResolvedValue(null)
+      const mockDocs = [
+        { doc: { _id: 'doc-1', name: 'file1.txt' } },
+        { doc: { _id: 'doc-2', name: 'file2.txt' } }
+      ]
+      mockCollection.fetchChanges.mockResolvedValue({
+        newLastSeq: 'seq-2',
+        results: mockDocs,
+        pending: false
+      })
+
+      const result = await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: true
+      })
+
+      const expectedDocs = [
+        { _id: 'doc-1', name: 'file1.txt', driveId },
+        { _id: 'doc-2', name: 'file2.txt', driveId }
+      ]
+
+      expect(result).toEqual(expectedDocs)
+      expect(mockCollection.fetchChanges).toHaveBeenCalledWith(
+        { include_docs: true },
+        {
+          includeFilePath: false,
+          skipDeleted: true,
+          skipTrashed: true,
+          limit: 1000
+        }
+      )
+      expect(insertBulkDocs).toHaveBeenCalledWith(mockPouch, expectedDocs)
+      expect(mockStorage.persistDoctypeLastSequence).toHaveBeenCalledWith(
+        doctype,
+        'seq-2'
+      )
+    })
+
+    it('should handle incremental replication from last saved doc ID', async () => {
+      mockStorage.getDoctypeLastSequence.mockResolvedValue('seq-1')
+      const mockDocs = [{ doc: { _id: 'doc-3', name: 'file3.txt' } }]
+      mockCollection.fetchChanges.mockResolvedValue({
+        newLastSeq: 'seq-3',
+        results: mockDocs,
+        pending: false
+      })
+
+      const result = await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: false
+      })
+
+      const expectedDocs = [{ _id: 'doc-3', name: 'file3.txt', driveId }]
+
+      expect(result).toEqual(expectedDocs)
+      expect(mockCollection.fetchChanges).toHaveBeenCalledWith(
+        { include_docs: true, since: 'seq-1' },
+        {
+          includeFilePath: false,
+          skipDeleted: false,
+          skipTrashed: false,
+          limit: 1000
+        }
+      )
+      expect(insertBulkDocs).toHaveBeenCalledWith(mockPouch, expectedDocs)
+      expect(mockStorage.persistDoctypeLastSequence).toHaveBeenCalledWith(
+        doctype,
+        'seq-3'
+      )
+    })
+
+    it('should handle replication with multiple batches (pagination)', async () => {
+      mockStorage.getDoctypeLastSequence.mockResolvedValue(null)
+
+      // First batch
+      mockCollection.fetchChanges.mockResolvedValueOnce({
+        newLastSeq: 'seq-1',
+        results: [{ doc: { _id: 'doc-1', name: 'file1.txt' } }],
+        pending: true
+      })
+
+      // Second batch
+      mockCollection.fetchChanges.mockResolvedValueOnce({
+        newLastSeq: 'seq-2',
+        results: [{ doc: { _id: 'doc-2', name: 'file2.txt' } }],
+        pending: false
+      })
+
+      const result = await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: true
+      })
+
+      const expectedDocs = [
+        { _id: 'doc-1', name: 'file1.txt', driveId },
+        { _id: 'doc-2', name: 'file2.txt', driveId }
+      ]
+
+      expect(result).toEqual(expectedDocs)
+      expect(mockCollection.fetchChanges).toHaveBeenCalledTimes(2)
+      expect(insertBulkDocs).toHaveBeenCalledTimes(2)
+      expect(mockStorage.persistDoctypeLastSequence).toHaveBeenCalledTimes(2)
+    })
+
+    it('should handle deleted documents by removing them from local pouch', async () => {
+      mockStorage.getDoctypeLastSequence.mockResolvedValue(null)
+      const mockDocs = [
+        { doc: { _id: 'doc-1', name: 'file1.txt' } },
+        { doc: { _id: 'doc-2', name: 'file2.txt', _deleted: true } }
+      ]
+      mockCollection.fetchChanges.mockResolvedValue({
+        newLastSeq: 'seq-1',
+        results: mockDocs,
+        pending: false
+      })
+
+      // Mock that doc-2 exists in local pouch
+      mockPouch.bulkGet.mockResolvedValue({
+        results: [
+          {
+            docs: [
+              {
+                ok: { _id: 'doc-2', _rev: '1-abc', name: 'file2.txt' }
+              }
+            ]
+          }
+        ]
+      })
+      mockPouch.bulkDocs.mockResolvedValue([{ ok: true, id: 'doc-2' }])
+
+      const result = await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: true
+      })
+
+      const expectedDocs = [
+        { _id: 'doc-1', name: 'file1.txt', driveId },
+        { _id: 'doc-2', name: 'file2.txt', _deleted: true, driveId }
+      ]
+
+      expect(result).toEqual(expectedDocs)
+      expect(mockPouch.bulkGet).toHaveBeenCalledWith({
+        docs: [{ id: 'doc-2' }]
+      })
+      expect(mockPouch.bulkDocs).toHaveBeenCalledWith([
+        {
+          _id: 'doc-2',
+          _rev: '1-abc',
+          name: 'file2.txt',
+          _deleted: true
+        }
+      ])
+      expect(insertBulkDocs).toHaveBeenCalledWith(
+        mockPouch,
+        expectedDocs.filter(doc => !doc._deleted)
+      )
+    })
+
+    it('should handle deleted documents when they do not exist in local pouch', async () => {
+      mockStorage.getDoctypeLastSequence.mockResolvedValue(null)
+      const mockDocs = [{ doc: { _id: 'doc-1', _deleted: true } }]
+      mockCollection.fetchChanges.mockResolvedValue({
+        newLastSeq: 'seq-1',
+        results: mockDocs,
+        pending: false
+      })
+
+      // Mock that doc-1 does not exist in local pouch (bulkGet returns error)
+      mockPouch.bulkGet.mockResolvedValue({
+        results: [
+          {
+            docs: [
+              {
+                error: {
+                  status: 404,
+                  name: 'not_found',
+                  message: 'missing'
+                }
+              }
+            ]
+          }
+        ]
+      })
+      mockPouch.bulkDocs.mockResolvedValue([])
+
+      const result = await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: true
+      })
+
+      const expectedDocs = [{ _id: 'doc-1', _deleted: true, driveId }]
+
+      expect(result).toEqual(expectedDocs)
+      expect(mockPouch.bulkGet).toHaveBeenCalledWith({
+        docs: [{ id: 'doc-1' }]
+      })
+      expect(mockPouch.bulkDocs).not.toHaveBeenCalled()
+      expect(insertBulkDocs).toHaveBeenCalledWith(
+        mockPouch,
+        expectedDocs.filter(doc => !doc._deleted)
+      )
+    })
+
+    it('should use correct options for initial vs incremental replication', async () => {
+      mockStorage.getDoctypeLastSequence.mockResolvedValue('seq-1')
+      mockCollection.fetchChanges.mockResolvedValue({
+        newLastSeq: 'seq-2',
+        results: [],
+        pending: false
+      })
+
+      // Test initial replication
+      await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: true
+      })
+
+      expect(mockCollection.fetchChanges).toHaveBeenCalledWith(
+        { include_docs: true, since: 'seq-1' },
+        {
+          includeFilePath: false,
+          skipDeleted: true,
+          skipTrashed: true,
+          limit: 1000
+        }
+      )
+
+      jest.clearAllMocks()
+      mockStorage.getDoctypeLastSequence.mockResolvedValue('seq-1')
+      mockCollection.fetchChanges.mockResolvedValue({
+        newLastSeq: 'seq-3',
+        results: [],
+        pending: false
+      })
+
+      // Test incremental replication
+      await sharedDriveReplicateAllDocs({
+        driveId,
+        pouch: mockPouch,
+        storage: mockStorage,
+        doctype,
+        client: mockClient,
+        initialReplication: false
+      })
+
+      expect(mockCollection.fetchChanges).toHaveBeenCalledWith(
+        { include_docs: true, since: 'seq-1' },
+        {
+          includeFilePath: false,
+          skipDeleted: false,
+          skipTrashed: false,
+          limit: 1000
+        }
+      )
+    })
+  })
 })
 
 const getPouchMock = () => {
@@ -405,6 +779,6 @@ const getPouchMock = () => {
 const getReplicationOptionsMock = () => ({
   strategy: 'fromRemote',
   initialReplication: false,
-  warmupQueries: {},
+  warmupQueries: [],
   doctype: 'io.cozy.files'
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-pouch-link",
-  "version": "60.15.2",
+  "version": "60.16.0",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -41,5 +41,5 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "34f198a7cb619bdfba442fe94c3b41beec424e6a"
+  "gitHead": "fef043f6cf4ee1bb86f73388a33a7afce8d66b38"
 }

package/types/CozyPouchLink.d.ts

@@ -1,4 +1,6 @@
-export function getReplicationURL(uri: any, token: any, doctype: any): string;
+export function getReplicationURL(uri: string, token: any, doctype: string, replicationOptions?: {
+    driveId: string;
+}): string;
 export default PouchLink;
 export type CozyPouchDocument = any;
 export type ReplicationStatus = "idle" | "replicating";
@@ -96,7 +98,17 @@ declare class PouchLink extends CozyLink {
     private startReplicationDebounced;
     /** @type {import('cozy-client/src/performances/types').PerformanceAPI} */
     performanceApi: any;
-    getReplicationURL(doctype: any): string;
+    /**
+     * Get the authenticated replication URL for a specific doctype
+     *
+     * @param {string} doctype - The document type to replicate (e.g., 'io.cozy.files')
+     * @param {object} [replicationOptions={}] - Replication options
+     * @param {string} [replicationOptions.driveId] - The ID of the shared drive to replicate (for shared drives)
+     * @returns {string} The authenticated replication URL
+     */
+    getReplicationURL(doctype: string, replicationOptions?: {
+        driveId: string;
+    }): string;
     registerClient(client: any): Promise<void>;
     client: any;
     /**
@@ -239,6 +251,26 @@ declare class PouchLink extends CozyLink {
     addReferencesTo(mutation: any): Promise<void>;
     dbMethod(method: any, mutation: any): Promise<any>;
     syncImmediately(): Promise<void>;
+    /**
+     * Adds a new doctype to the list of managed doctypes, sets its replication options,
+     * adds it to the pouches, and starts replication.
+     *
+     * @param {string} doctype - The name of the doctype to add.
+     * @param {Object} replicationOptions - The replication options for the doctype.
+     * @param {Object} options - The replication options for the doctype.
+     * @param {boolean} [options.shouldStartReplication=true] - Whether the replication should be started.
+     */
+    addDoctype(doctype: string, replicationOptions: any, options: {
+        shouldStartReplication: boolean;
+    }): Promise<void>;
+    /**
+     * Removes a doctype from the list of managed doctypes, deletes its replication options,
+     * and removes it from the pouches.
+     *
+     * @param {string} doctype - The name of the doctype to remove.
+     */
+    removeDoctype(doctype: string): Promise<void>;
+    getSharedDriveDoctypes(): string[];
 }
 import { CozyLink } from "cozy-client";
 import { PouchLocalStorage } from "./localStorage";

package/types/PouchManager.d.ts

@@ -17,12 +17,12 @@ declare class PouchManager {
     events: any;
     dbQueryEngines: Map<any, any>;
     init(): Promise<void>;
-    pouches: import("lodash").Dictionary<any>;
+    pouches: {};
+    doctypesReplicationOptions: any;
     /** @type {Record<string, import('./types').SyncInfo>} - Stores synchronization info per doctype */
     syncedDoctypes: Record<string, import('./types').SyncInfo>;
     warmedUpQueries: any;
     getReplicationURL: any;
-    doctypesReplicationOptions: any;
     listenerLaunched: boolean;
     ensureDatabasesExistDone: boolean;
     /**
@@ -94,6 +94,32 @@ declare class PouchManager {
     checkToWarmupDoctype(doctype: any, replicationOptions: any): void;
     areQueriesWarmedUp(doctype: any, queries: any): Promise<any>;
     clearWarmedUpQueries(): Promise<void>;
+    /**
+     * Adds a new doctype to the list of managed doctypes, sets its replication options,
+     * creates a new PouchDB instance for it, and sets up the query engine.
+     *
+     * @param {string} doctype - The name of the doctype to add.
+     * @param {Object} replicationOptions - The replication options for the doctype.
+     */
+    addDoctype(doctype: string, replicationOptions: any): Promise<void>;
+    /**
+     * Removes a doctype from the list of managed doctypes, deletes its replication options,
+     * destroys its PouchDB instance, and removes it from the pouches.
+     *
+     * @param {string} doctype - The name of the doctype to remove.
+     */
+    removeDoctype(doctype: string): Promise<void>;
+    /**
+     * Persists the names of the PouchDB databases.
+     *
+     * This method is primarily used to ensure that database names are saved for
+     * old browsers that do not support `indexeddb.databases()`. This persistence
+     * facilitates cleanup processes. Note that PouchDB automatically adds the
+     * `_pouch_` prefix to database names.
+     *
+     * @returns {Promise<void>}
+     */
+    persistDatabasesNames(): Promise<void>;
 }
 import { PouchLocalStorage } from "./localStorage";
 import Loop from "./loop";

package/types/startReplication.d.ts

@@ -1,12 +1,22 @@
 export function startReplication(pouch: object, replicationOptions: {
     strategy: string;
     initialReplication: boolean;
+    driveId: string;
     doctype: string;
     warmupQueries: import('cozy-client/types/types').Query[];
-}, getReplicationURL: Function, storage: import('./localStorage').PouchLocalStorage): import('./types').CancelablePromise;
+}, getReplicationURL: Function, storage: import('./localStorage').PouchLocalStorage, client: CozyClient): import('./types').CancelablePromise;
 export function replicateAllDocs({ db, baseUrl, doctype, storage }: {
     db: object;
     baseUrl: string;
     doctype: string;
     storage: import('./localStorage').PouchLocalStorage;
 }): Promise<any[]>;
+export function sharedDriveReplicateAllDocs({ driveId, pouch, storage, initialReplication, doctype, client }: {
+    driveId: string;
+    pouch: any;
+    storage: any;
+    doctype: string;
+    initialReplication: boolean;
+    client: CozyClient;
+}): Promise<any[]>;
+import CozyClient from "cozy-client";