[PRD-525] [PRD-956] Rely on PouchDB for search

eslint.config.js

@@ -101,13 +101,13 @@ const config = [
       '@typescript-eslint': tseslint.plugin
     },
     rules: {
-      '@typescript-eslint/no-unsafe-argument': 'error',
-      '@typescript-eslint/no-unsafe-assignment': 'error',
-      '@typescript-eslint/no-unsafe-call': 'error',
-      '@typescript-eslint/no-unsafe-member-access': 'error',
-      '@typescript-eslint/no-unsafe-return': 'error',
+      '@typescript-eslint/no-unsafe-argument': 'warn',
+      '@typescript-eslint/no-unsafe-assignment': 'warn',
+      '@typescript-eslint/no-unsafe-call': 'warn',
+      '@typescript-eslint/no-unsafe-member-access': 'warn',
+      '@typescript-eslint/no-unsafe-return': 'warn',
       '@typescript-eslint/explicit-function-return-type': 'error',
-      '@typescript-eslint/no-explicit-any': 'error',
+      '@typescript-eslint/no-explicit-any': 'warn',
       '@typescript-eslint/no-unused-vars': [
         'error',
         { ignoreRestSiblings: true }

package.json

@@ -19,9 +19,12 @@
     "cozy-flags": "^4.0.0",
     "cozy-logger": "^1.10.4",
     "cozy-minilog": "^3.3.1",
+    "cozy-pouch-link": "^49.8.0",
+    "cozy-realtime": "^5.0.2",
     "cozy-tsconfig": "^1.2.0",
     "flexsearch": "^0.7.43",
     "lodash": "^4.17.21",
+    "pouchdb-browser": "^9.0.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1"
   },

src/@types/cozy-client.d.ts

@@ -170,6 +170,7 @@
   }
 
   export default class CozyClient {
+    plugins: any
     constructor(rawOptions?: ClientOptions)
     getStackClient(): StackClient
     getInstanceOptions(): InstanceOptions

src/dataproxy/common/DataProxyInterface.ts

@@ -1,7 +1,7 @@
 import type { InstanceOptions } from 'cozy-client'
 import type { ClientCapabilities } from 'cozy-client/types/types'
 
-export type { SearchIndex } from '@/search/types'
+export type { SearchIndexes } from '@/search/types'
 
 export interface DataProxyWorker {
   search: (query: string) => Promise<unknown>

src/dataproxy/worker/platformWorker.ts

@@ -0,0 +1,110 @@
+import PouchDB from 'pouchdb-browser'
+
+const dbName = 'sharedWorkerStorage'
+let db: IDBDatabase | null = null
+
+const openDB = (): Promise<IDBDatabase> => {
+  return new Promise((resolve, reject) => {
+    if (db) {
+      return resolve(db)
+    }
+
+    const request = indexedDB.open(dbName, 1)
+
+    request.onupgradeneeded = (event: IDBVersionChangeEvent): void => {
+      const database = (event.target as IDBOpenDBRequest).result
+      db = database
+      if (!db.objectStoreNames.contains('store')) {
+        db.createObjectStore('store', { keyPath: 'key' })
+      }
+    }
+
+    request.onsuccess = (event: Event): void => {
+      db = (event.target as IDBOpenDBRequest).result
+      resolve(db)
+    }
+
+    request.onerror = (event: Event): void => {
+      reject((event.target as IDBOpenDBRequest).error)
+    }
+  })
+}
+
+const storage = {
+  getItem: async (key: string): Promise<any> => {
+    const db = await openDB()
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction('store', 'readonly')
+      const store = transaction.objectStore('store')
+      const request = store.get(key)
+
+      request.onsuccess = (): void => {
+        resolve(request.result ? request.result.value : null)
+      }
+
+      request.onerror = (): void => {
+        reject(request.error)
+      }
+    })
+  },
+
+  setItem: async (key: string, value: any): Promise<void> => {
+    const db = await openDB()
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction('store', 'readwrite')
+      const store = transaction.objectStore('store')
+      const request = store.put({ key, value })
+
+      request.onsuccess = (): void => {
+        resolve()
+      }
+
+      request.onerror = (): void => {
+        reject(request.error)
+      }
+    })
+  },
+
+  removeItem: async (key: string): Promise<void> => {
+    const db = await openDB()
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction('store', 'readwrite')
+      const store = transaction.objectStore('store')
+      const request = store.delete(key)
+
+      request.onsuccess = (): void => {
+        resolve()
+      }
+
+      request.onerror = (): void => {
+        reject(request.error)
+      }
+    })
+  }
+}
+
+const events = {
+  addEventListener: (
+    eventName: string,
+    handler: EventListenerOrEventListenerObject
+  ): void => {
+    self.addEventListener(eventName, handler)
+  },
+  removeEventListener: (
+    eventName: string,
+    handler: EventListenerOrEventListenerObject
+  ): void => {
+    self.removeEventListener(eventName, handler)
+  }
+}
+
+const isOnline = async (): Promise<boolean> => {
+  return self.navigator.onLine
+}
+
+export const platformWorker = {
+  storage,
+  events,
+  pouchAdapter: PouchDB,
+  isOnline
+}

src/dataproxy/worker/shared-worker.ts

@@ -2,30 +2,51 @@ import * as Comlink from 'comlink'
 
 import CozyClient from 'cozy-client'
 import Minilog from 'cozy-minilog'
+import PouchLink from 'cozy-pouch-link'
 
 import {
   ClientData,
   DataProxyWorker,
-  DataProxyWorkerPartialState,
-  SearchIndex
+  DataProxyWorkerPartialState
 } from '@/dataproxy/common/DataProxyInterface'
+import { platformWorker } from '@/dataproxy/worker/platformWorker'
 import schema from '@/doctypes'
-import { initIndexes } from '@/search/initIndexes'
-import { search } from '@/search/search'
+import SearchEngine from '@/search/SearchEngine'
+import { FILES_DOCTYPE, CONTACTS_DOCTYPE, APPS_DOCTYPE } from '@/search/consts'
 
 const log = Minilog('👷‍♂️ [shared-worker]')
 Minilog.enable()
 
 let client: CozyClient | undefined = undefined
-let searchIndexes: SearchIndex[] | undefined = undefined
+let searchEngine: SearchEngine
 
 const broadcastChannel = new BroadcastChannel('DATA_PROXY_BROADCAST_CHANANEL')
 
 const dataProxy: DataProxyWorker = {
+  // FIXME: change setClient name
   setClient: async (clientData: ClientData) => {
     log.debug('Received data for setting client')
     if (client) return
     updateState()
+
+    const pouchLinkOptions = {
+      doctypes: [FILES_DOCTYPE, CONTACTS_DOCTYPE, APPS_DOCTYPE],
+      initialSync: true,
+      periodicSync: false,
+      platform: { ...platformWorker },
+      doctypesReplicationOptions: {
+        [FILES_DOCTYPE]: {
+          strategy: 'fromRemote'
+        },
+        [CONTACTS_DOCTYPE]: {
+          strategy: 'fromRemote'
+        },
+        [APPS_DOCTYPE]: {
+          strategy: 'fromRemote'
+        }
+      }
+    }
+
     client = new CozyClient({
       uri: clientData.uri,
       token: clientData.token,
@@ -34,43 +55,45 @@ const dataProxy: DataProxyWorker = {
         version: '1'
       },
       schema,
-      store: true
+      store: true,
+      links: [new PouchLink(pouchLinkOptions)]
     })
     client.instanceOptions = clientData.instanceOptions
     client.capabilities = clientData.capabilities
-    if (!searchIndexes) {
-      const indexes = await initIndexes(client)
-      searchIndexes = indexes
-      updateState()
-    }
+
+    searchEngine = new SearchEngine(client)
+
+    updateState()
   },
+
   search: async (query: string) => {
-    log.debug('Received data for search')
     if (!client) {
       throw new Error(
-        'Client is required to execute a seach, please initialize CozyClient'
+        'Client is required to execute a search, please initialize CozyClient'
       )
     }
-
-    if (!searchIndexes) {
-      return []
+    if (!searchEngine) {
+      throw new Error('SearchEngine is not initialized')
     }
 
-    return search(query, searchIndexes, client)
+    return searchEngine.search(query)
   }
 }
 
 const updateState = (): void => {
   const state = {} as DataProxyWorkerPartialState
 
-  if (client && searchIndexes) {
+  if (client && searchEngine && searchEngine.searchIndexes) {
     state.status = 'Ready'
-    state.indexLength = searchIndexes.map(searchIndex => ({
-      doctype: searchIndex.doctype,
-      // @ts-expect-error index.store is not TS typed
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      count: Object.keys(searchIndex.index.store).length
-    }))
+    state.indexLength = Object.keys(searchEngine.searchIndexes).map(
+      (indexKey: string) => ({
+        doctype: indexKey,
+        // @ts-expect-error index.store is not TS typed
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        count: Object.keys(searchEngine.searchIndexes[indexKey].index.store)
+          .length
+      })
+    )
     broadcastChannel.postMessage(state)
     return
   }