feat: prepare for rxdb migration

packages/web/src/books/effects.ts

@@ -62,7 +62,7 @@ const useUpsertBookLinkActionEffect = () => {
                 )
                 if (book) {
                   return from(
-                    book.atomicUpdate((oldData) => ({
+                    book.incrementalModify((oldData) => ({
                       ...oldData,
                       links: [existingLink._id]
                     }))
@@ -120,7 +120,7 @@ const useUpsertBookLinkActionEffect = () => {
                 filter(isDefined),
                 switchMap((book) =>
                   from(
-                    book.atomicUpdate((data) => ({
+                    book.incrementalModify((data) => ({
                       ...data,
                       isNotInterested
                     }))

packages/web/src/books/helpers.ts

@@ -101,7 +101,7 @@ export const useAtomicUpdateBook = () => {
         .findOne({ selector: { _id: id } })
         .exec()
 
-      return await book?.atomicUpdate(mutationFunction)
+      return await book?.incrementalModify(mutationFunction)
     },
     [database]
   )

packages/web/src/dataSources/helpers.ts

@@ -126,7 +126,7 @@ export const useAtomicUpdateDataSource = () => {
           from(db.datasource.findOne({ selector: { _id: id } }).exec())
         ),
         filter(isDefined),
-        switchMap((item) => from(item.atomicUpdate(mutationFunction)))
+        switchMap((item) => from(item.incrementalModify(mutationFunction)))
       ),
     [database]
   )

packages/web/src/problems/useDuplicateBooksTitles.ts

@@ -77,7 +77,7 @@ export const useFixDuplicatedBookTitles = () => {
               const { _id, _rev, ...safeMergedDoc } = mergedDoc
 
               // we update the first entry with the all merged data
-              await docsWithSameTitle[0]?.atomicUpdate((oldData) => ({
+              await docsWithSameTitle[0]?.incrementalModify((oldData) => ({
                 ...oldData,
                 ...safeMergedDoc
               }))

packages/web/src/problems/useFixBookReferences.ts

@@ -27,7 +27,7 @@ export const useFixBookReferences = () => {
       )
 
       if (toRemove.length > 0) {
-        await doc.atomicUpdate((data) => ({
+        await doc.incrementalModify((data) => ({
           ...data,
           collections: data.collections.filter((id) => !toRemove.includes(id))
         }))

packages/web/src/problems/useFixBooksDanglingLinks.ts

@@ -27,7 +27,7 @@ export const useFixBooksDanglingLinks = () => {
       )
 
       if (toRemove.length > 0) {
-        await doc.atomicUpdate((data) => ({
+        await doc.incrementalModify((data) => ({
           ...data,
           links: data.links.filter((id) => !toRemove.includes(id))
         }))

packages/web/src/problems/useFixCollections.ts

@@ -48,7 +48,7 @@ export const useFixCollections = () => {
               const { _id, _rev, ...safeMergedDoc } = mergedDoc
 
               // we update the first entry with the all merged data
-              await docsWithSameResourceId[0]?.atomicUpdate((oldData) => ({
+              await docsWithSameResourceId[0]?.incrementalModify((oldData) => ({
                 ...oldData,
                 ...safeMergedDoc
               }))

packages/web/src/problems/useFixLinks.ts

@@ -46,7 +46,7 @@ export const useFixLinks = () => {
               const { _id, _rev, ...safeMergedDoc } = mergedDoc
 
               // we update the first entry with the all merged data
-              await docsWithSameResourceId[0]?.atomicUpdate((oldData) => ({
+              await docsWithSameResourceId[0]?.incrementalModify((oldData) => ({
                 ...oldData,
                 ...safeMergedDoc
               }))
@@ -60,7 +60,7 @@ export const useFixLinks = () => {
 
               await Promise.all(
                 bookDocs.map(async (doc) => {
-                  await doc.atomicUpdate((old) => ({
+                  await doc.incrementalModify((old) => ({
                     ...old,
                     links: [...new Set([...old.links, mergedDoc._id])]
                   }))

packages/web/src/reader/bookHelpers.ts

@@ -23,7 +23,7 @@ export const useUpdateBookState = (bookId: string) => {
               .findOne({ selector: { _id: bookId } })
               .exec()
 
-            book?.atomicUpdate((old) => {
+            book?.incrementalModify((old) => {
               return {
                 ...old,
                 // cfi will be undefined at the beginning until pagination stabilize

packages/web/src/rxdb/collections/book.ts

@@ -3,14 +3,24 @@ import {
   DeprecatedBookDocType,
   InsertAbleBookDocType
 } from "@oboku/shared"
-import { RxCollection, RxDocument, RxJsonSchema, RxQuery } from "rxdb"
+import {
+  AtomicUpdateFunction,
+  RxCollection,
+  RxDocument,
+  RxJsonSchema,
+  RxQuery
+} from "rxdb"
 import { MongoUpdateSyntax } from "../../types"
 import { getReplicationProperties } from "../rxdb-plugins/replication"
 import { SafeMangoQuery, SafeUpdateMongoUpdateSyntax } from "../types"
 import { generateId } from "./utils"
 
 type BookDocMethods = {
   safeUpdate: (updateObj: MongoUpdateSyntax<BookDocType>) => Promise<any>
+  incrementalModify: (
+    mutationFunction: AtomicUpdateFunction<BookDocType>,
+    context?: string | undefined
+  ) => Promise<RxDocument<BookDocType, BookDocMethods>>
 }
 
 export type BookDocument = RxDocument<BookDocType, BookDocMethods>
@@ -40,6 +50,9 @@ export type BookCollection = RxCollection<
 export const bookDocMethods: BookDocMethods = {
   safeUpdate: function (this: BookDocument, updateObj) {
     return this.update(updateObj)
+  },
+  incrementalModify: function (this: BookDocument, mutationFunction) {
+    return this.atomicUpdate(mutationFunction)
   }
 }
 

packages/web/src/rxdb/collections/collection.ts

@@ -1,10 +1,21 @@
-import { RxCollection, RxDocument, RxJsonSchema, RxQuery } from "rxdb"
+import {
+  AtomicUpdateFunction,
+  RxCollection,
+  RxDocument,
+  RxJsonSchema,
+  RxQuery
+} from "rxdb"
 import { getReplicationProperties } from "../rxdb-plugins/replication"
 import { SafeMangoQuery, SafeUpdateMongoUpdateSyntax } from "../types"
 import { CollectionDocType } from "@oboku/shared"
 import { generateId } from "./utils"
 
-export type CollectionDocMethods = {}
+export type CollectionDocMethods = {
+  incrementalModify: (
+    mutationFunction: AtomicUpdateFunction<CollectionDocType>,
+    context?: string | undefined
+  ) => Promise<RxDocument<CollectionDocType, CollectionDocMethods>>
+}
 
 export type CollectionDocument = RxDocument<
   CollectionDocType,
@@ -29,7 +40,7 @@ type CollectionCollectionMethods = {
 
 export type CollectionCollection = RxCollection<
   CollectionDocType,
-  {},
+  CollectionDocMethods,
   CollectionCollectionMethods
 >
 
@@ -55,6 +66,12 @@ export const collectionSchema: RxJsonSchema<
 
 export const collectionMigrationStrategies = {}
 
+export const collectionDocMethods: CollectionDocMethods = {
+  incrementalModify: function (this: CollectionDocument, mutationFunction) {
+    return this.atomicUpdate(mutationFunction)
+  }
+}
+
 export const collectionCollectionMethods: CollectionCollectionMethods = {
   post: async function (this: CollectionCollection, json) {
     return this.insert({ _id: generateId(), ...json } as CollectionDocType)

packages/web/src/rxdb/collections/dataSource.ts

@@ -3,14 +3,20 @@ import {
   RxJsonSchema,
   RxQuery,
   RxCollection,
-  MigrationStrategies
+  MigrationStrategies,
+  AtomicUpdateFunction
 } from "rxdb"
 import { DataSourceDocType } from "@oboku/shared"
 import { SafeUpdateMongoUpdateSyntax } from "../types"
 import { getReplicationProperties } from "../rxdb-plugins/replication"
 import { generateId } from "./utils"
 
-export type DataSourceDocMethods = {}
+export type DataSourceDocMethods = {
+  incrementalModify: (
+    mutationFunction: AtomicUpdateFunction<DataSourceDocType>,
+    context?: string | undefined
+  ) => Promise<RxDocument<DataSourceDocType, DataSourceDocMethods>>
+}
 
 export type DataSourceDocument = RxDocument<
   DataSourceDocType,
@@ -29,10 +35,16 @@ type DataSourceCollectionMethods = {
 
 export type DataSourceCollection = RxCollection<
   DataSourceDocType,
-  {},
+  DataSourceDocMethods,
   DataSourceCollectionMethods
 >
 
+export const collectionDocMethods: DataSourceDocMethods = {
+  incrementalModify: function (this: DataSourceDocument, mutationFunction) {
+    return this.atomicUpdate(mutationFunction)
+  }
+}
+
 export const dataSourceSchema: RxJsonSchema<
   Omit<DataSourceDocType, "rx_model" | "_rev" | `rxdbMeta`>
 > = {

packages/web/src/rxdb/collections/link.ts

@@ -1,5 +1,5 @@
 import { LinkDocType, SafeMangoQuery } from "@oboku/shared"
-import { RxCollection, RxDocument, RxJsonSchema, RxQuery } from "rxdb"
+import { AtomicUpdateFunction, RxCollection, RxDocument, RxJsonSchema, RxQuery } from "rxdb"
 import { MongoUpdateSyntax } from "../../types"
 import { getReplicationProperties } from "../rxdb-plugins/replication"
 import { SafeUpdateMongoUpdateSyntax } from "../types"
@@ -14,8 +14,14 @@ export type LinkCollection = RxCollection<
 
 type LinkDocMethods = {
   safeUpdate: (updateObj: MongoUpdateSyntax<LinkDocType>) => Promise<any>
+  incrementalModify: (
+    mutationFunction: AtomicUpdateFunction<LinkDocType>,
+    context?: string | undefined
+  ) => Promise<RxDocument<LinkDocType, LinkDocMethods>>
 }
+
 type LinkDocument = RxDocument<LinkDocType, LinkDocMethods>
+
 type LinkCollectionMethods = {
   safeInsert: (
     json: Omit<LinkDocType, "_id" | "rx_model" | "_rev" | `rxdbMeta`>
@@ -56,6 +62,9 @@ const linkSchemaMigrationStrategies = {}
 const linkDocMethods: LinkDocMethods = {
   safeUpdate: async function (this: LinkDocument, updateObj) {
     return this.update(updateObj)
+  },
+  incrementalModify: function (this: LinkDocument, mutationFunction) {
+    return this.atomicUpdate(mutationFunction)
   }
 }
 

packages/web/src/rxdb/collections/tags.ts

@@ -1,5 +1,6 @@
 import { TagsDocType } from "@oboku/shared"
 import {
+  AtomicUpdateFunction,
   MigrationStrategies,
   RxCollection,
   RxDocument,
@@ -13,6 +14,10 @@ import { generateId } from "./utils"
 
 type DocMethods = {
   updateSafe: (updateObj: MongoUpdateSyntax<TagsDocType>) => Promise<any>
+  incrementalModify: (
+    mutationFunction: AtomicUpdateFunction<TagsDocType>,
+    context?: string | undefined
+  ) => Promise<RxDocument<TagsDocType, DocMethods>>
 }
 
 type CollectionMethods = {
@@ -57,6 +62,9 @@ const schema: RxJsonSchema<Omit<TagsDocType, `_rev` | `rxdbMeta`>> = {
 const docMethods: DocMethods = {
   updateSafe: function (this: TagsDocument, updateObj) {
     return this.update(updateObj)
+  },
+  incrementalModify: function (this: TagsDocument, mutationFunction) {
+    return this.atomicUpdate(mutationFunction)
   }
 }
 

packages/web/src/rxdb/databases.ts

@@ -4,14 +4,16 @@ import {
   CollectionCollection,
   collectionCollectionMethods,
   collectionSchema,
-  collectionMigrationStrategies
+  collectionMigrationStrategies,
+  collectionDocMethods as collectionCollectionDocMethods
 } from "./collections/collection"
 import { applyHooks } from "./middleware"
 import {
   dataSourceSchema,
   dataSourceCollectionMethods,
   DataSourceCollection,
-  migrationStrategies as dataSourceMigrationStrategies
+  migrationStrategies as dataSourceMigrationStrategies,
+  collectionDocMethods as dataSourceCollectionDocMethods
 } from "./collections/dataSource"
 import { BookDocType, LinkDocType, TagsDocType } from "@oboku/shared"
 import { RxDBQueryBuilderPlugin } from "rxdb/plugins/query-builder"
@@ -124,11 +126,13 @@ const createCollections = async (db: Database) => {
     obokucollection: {
       schema: collectionSchema,
       statics: collectionCollectionMethods,
-      migrationStrategies: collectionMigrationStrategies
+      migrationStrategies: collectionMigrationStrategies,
+      methods: collectionCollectionDocMethods
     },
     datasource: {
       schema: dataSourceSchema,
       statics: dataSourceCollectionMethods,
+      methods: dataSourceCollectionDocMethods,
       migrationStrategies: dataSourceMigrationStrategies
     }
   })

packages/web/src/tags/helpers.ts

@@ -35,7 +35,7 @@ export const useUpdateTag = () => {
         .findOne({ selector: { _id } })
         .exec()
         .then((doc) =>
-          doc?.atomicUpdate((doc) => ({
+          doc?.incrementalModify((doc) => ({
             ...doc,
             ...rest
           }))