remove stash and store completely

client/lib/json-patch-lib.ts

@@ -39,21 +39,8 @@ export function getValueByPointer<T extends Record<string, T>>(
 export function applyOperation<T>(
   doc: DBCache<Record<string, any>>,
   { path, op, value }: Operation<T> & { value?: T },
-): Operation<T> | null {
-  const current = getValueByPointer(doc.data, path)
-  const remove = { op: PatchOp.REMOVE, path } as const
-  const add = { op: PatchOp.ADD, path, value: current } as const
-  const replace = { op: PatchOp.REPLACE, path, value: current } as const
-
+) {
   doc.data = recursiveApply(doc.data, jsonPathToKeyArray(path), op, value)
-
-  switch (op) {
-    case PatchOp.REMOVE:
-      return current === undefined ? null : add
-    case PatchOp.REPLACE:
-    case PatchOp.ADD:
-      return current === undefined ? remove : replace
-  }
 }
 
 function recursiveApply<T extends Record<string, any> | any[]>(

client/lib/patch-db.ts

@@ -1,18 +1,184 @@
-import { map, Observable, shareReplay } from 'rxjs'
-import { tap } from 'rxjs/operators'
-import { Store } from './store'
-import { DBCache, Update } from './types'
+import { Bootstrapper, DBCache, Dump, Revision, Update } from './types'
+import { BehaviorSubject, Observable, Subscription, withLatestFrom } from 'rxjs'
+import { applyOperation, getValueByPointer } from './json-patch-lib'
 
-export class PatchDB<T> {
-  public store: Store<T> = new Store(this.initialCache)
-  public cache$ = this.source$.pipe(
-    tap(res => this.store.update(res)),
-    map(_ => this.store.cache),
-    shareReplay(1),
-  )
+export class PatchDB<T extends { [key: string]: any }> {
+  private sub: Subscription | null = null
+  private watchedNodes: { [path: string]: BehaviorSubject<any> } = {}
 
-  constructor(
-    private readonly source$: Observable<Update<T>>,
-    private readonly initialCache: DBCache<T>,
-  ) {}
+  readonly cache$ = new BehaviorSubject({ sequence: 0, data: {} as T })
+
+  constructor(private readonly source$: Observable<Update<T>[]>) {}
+
+  async start(bootstrapper: Bootstrapper<T>) {
+    if (this.sub) return
+
+    const initialCache = await bootstrapper.init()
+    this.cache$.next(initialCache)
+
+    this.sub = this.source$
+      .pipe(withLatestFrom(this.cache$))
+      .subscribe(([updates, cache]) => {
+        this.proccessUpdates(updates, cache)
+        bootstrapper.update(cache)
+      })
+  }
+
+  stop() {
+    if (!this.sub) return
+
+    Object.values(this.watchedNodes).forEach(node => node.complete())
+    this.watchedNodes = {}
+    this.sub.unsubscribe()
+    this.sub = null
+    this.cache$.next({ sequence: 0, data: {} as T })
+  }
+
+  watch$(): Observable<T>
+  watch$<P1 extends keyof T>(p1: P1): Observable<NonNullable<T[P1]>>
+  watch$<P1 extends keyof T, P2 extends keyof NonNullable<T[P1]>>(
+    p1: P1,
+    p2: P2,
+  ): Observable<NonNullable<NonNullable<T[P1]>[P2]>>
+  watch$<
+    P1 extends keyof T,
+    P2 extends keyof NonNullable<T[P1]>,
+    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
+  >(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+  ): Observable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>>
+  watch$<
+    P1 extends keyof T,
+    P2 extends keyof NonNullable<T[P1]>,
+    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
+    P4 extends keyof NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>,
+  >(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+  ): Observable<
+    NonNullable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]>
+  >
+  watch$<
+    P1 extends keyof T,
+    P2 extends keyof NonNullable<T[P1]>,
+    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
+    P4 extends keyof NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>,
+    P5 extends keyof NonNullable<
+      NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]
+    >,
+  >(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+  ): Observable<
+    NonNullable<
+      NonNullable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]>[P5]
+    >
+  >
+  watch$<
+    P1 extends keyof T,
+    P2 extends keyof NonNullable<T[P1]>,
+    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
+    P4 extends keyof NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>,
+    P5 extends keyof NonNullable<
+      NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]
+    >,
+    P6 extends keyof NonNullable<
+      NonNullable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]>[P5]
+    >,
+  >(
+    p1: P1,
+    p2: P2,
+    p3: P3,
+    p4: P4,
+    p5: P5,
+    p6: P6,
+  ): Observable<
+    NonNullable<
+      NonNullable<
+        NonNullable<
+          NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]
+        >[P5]
+      >[P6]
+    >
+  >
+  watch$(...args: (string | number)[]): Observable<any> {
+    const path = `/${args.join('/')}`
+
+    return new Observable(subscriber => {
+      const data = this.cache$.value.data
+      const value = getValueByPointer(data, path)
+      const source = this.watchedNodes[path] || new BehaviorSubject(value)
+      const subscription = source.subscribe(subscriber)
+
+      this.watchedNodes[path] = source
+      this.updateWatchedNode(path, data)
+
+      return () => {
+        subscription.unsubscribe()
+
+        if (!source.observed) {
+          source.complete()
+          delete this.watchedNodes[path]
+        }
+      }
+    })
+  }
+
+  proccessUpdates(updates: Update<T>[], cache: DBCache<T>) {
+    updates.forEach(update => {
+      if (update.id <= cache.sequence) return
+
+      if (this.isRevision(update)) {
+        if (update.id > cache.sequence + 1) {
+          console.error(
+            `Received futuristic revision. Expected ${
+              cache.sequence + 1
+            }, got ${update.id}`,
+          )
+          return
+        }
+        this.handleRevision(update, cache)
+      } else {
+        this.handleDump(update, cache)
+      }
+      cache.sequence++
+    })
+    this.cache$.next(cache)
+  }
+
+  private handleRevision(revision: Revision, cache: DBCache<T>): void {
+    revision.patch.forEach(op => {
+      applyOperation(cache, op)
+      this.updateWatchedNodes(op.path, cache.data)
+    })
+  }
+
+  private handleDump(dump: Dump<T>, cache: DBCache<T>): void {
+    cache.data = { ...dump.value }
+    this.updateWatchedNodes('', cache.data)
+  }
+
+  private updateWatchedNodes(revisionPath: string, data: T) {
+    Object.keys(this.watchedNodes).forEach(path => {
+      if (path.includes(revisionPath) || revisionPath.includes(path)) {
+        this.updateWatchedNode(path, data)
+      }
+    })
+  }
+
+  private updateWatchedNode(path: string, data: T): void {
+    const value = getValueByPointer(data, path)
+    this.watchedNodes[path].next(value)
+  }
+
+  private isRevision(update: Update<T>): update is Revision {
+    return 'patch' in update
+  }
 }

client/lib/store.ts

@@ -1,222 +0,0 @@
-import { DBCache, Dump, Revision, Update } from './types'
-import { BehaviorSubject, Observable } from 'rxjs'
-import { applyOperation, getValueByPointer, Operation } from './json-patch-lib'
-import BTree from 'sorted-btree'
-
-export interface StashEntry {
-  revision: Revision
-  undo: Operation<unknown>[]
-}
-
-export class Store<T extends { [key: string]: any }> {
-  readonly sequence$ = new BehaviorSubject(this.cache.sequence)
-  private watchedNodes: { [path: string]: BehaviorSubject<any> } = {}
-  private stash = new BTree<number, StashEntry>()
-
-  constructor(public cache: DBCache<T>) {}
-
-  watch$(): Observable<T>
-  watch$<P1 extends keyof T>(p1: P1): Observable<NonNullable<T[P1]>>
-  watch$<P1 extends keyof T, P2 extends keyof NonNullable<T[P1]>>(
-    p1: P1,
-    p2: P2,
-  ): Observable<NonNullable<NonNullable<T[P1]>[P2]>>
-  watch$<
-    P1 extends keyof T,
-    P2 extends keyof NonNullable<T[P1]>,
-    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
-  >(
-    p1: P1,
-    p2: P2,
-    p3: P3,
-  ): Observable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>>
-  watch$<
-    P1 extends keyof T,
-    P2 extends keyof NonNullable<T[P1]>,
-    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
-    P4 extends keyof NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>,
-  >(
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-  ): Observable<
-    NonNullable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]>
-  >
-  watch$<
-    P1 extends keyof T,
-    P2 extends keyof NonNullable<T[P1]>,
-    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
-    P4 extends keyof NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>,
-    P5 extends keyof NonNullable<
-      NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]
-    >,
-  >(
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-  ): Observable<
-    NonNullable<
-      NonNullable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]>[P5]
-    >
-  >
-  watch$<
-    P1 extends keyof T,
-    P2 extends keyof NonNullable<T[P1]>,
-    P3 extends keyof NonNullable<NonNullable<T[P1]>[P2]>,
-    P4 extends keyof NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>,
-    P5 extends keyof NonNullable<
-      NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]
-    >,
-    P6 extends keyof NonNullable<
-      NonNullable<NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]>[P5]
-    >,
-  >(
-    p1: P1,
-    p2: P2,
-    p3: P3,
-    p4: P4,
-    p5: P5,
-    p6: P6,
-  ): Observable<
-    NonNullable<
-      NonNullable<
-        NonNullable<
-          NonNullable<NonNullable<NonNullable<T[P1]>[P2]>[P3]>[P4]
-        >[P5]
-      >[P6]
-    >
-  >
-  watch$(...args: (string | number)[]): Observable<any> {
-    const path = `/${args.join('/')}`
-
-    return new Observable(subscriber => {
-      const value = getValueByPointer(this.cache.data, path)
-      const source = this.watchedNodes[path] || new BehaviorSubject(value)
-      const subscription = source.subscribe(subscriber)
-
-      this.watchedNodes[path] = source
-      this.updateValue(path)
-
-      return () => {
-        subscription.unsubscribe()
-
-        if (!source.observed) {
-          source.complete()
-          delete this.watchedNodes[path]
-        }
-      }
-    })
-  }
-
-  update(update: Update<T>): void {
-    if (this.isRevision(update)) {
-      // Handle revision if new and not known
-      if (update.id > this.cache.sequence && !this.stash.get(update.id)) {
-        this.handleRevision(update)
-      }
-    } else {
-      this.handleDump(update)
-    }
-  }
-
-  reset(): void {
-    Object.values(this.watchedNodes).forEach(node => node.complete())
-    this.watchedNodes = {}
-    this.stash.clear()
-    this.sequence$.next(0)
-    this.cache = {
-      sequence: 0,
-      data: {} as any,
-    }
-  }
-
-  private updateValue(path: string): void {
-    const value = getValueByPointer(this.cache.data, path)
-
-    this.watchedNodes[path].next(value)
-  }
-
-  private handleRevision(revision: Revision): void {
-    this.stash.set(revision.id, { revision, undo: [] })
-    this.processStashed(revision.id)
-  }
-
-  private handleDump({ value, id }: Dump<T>): void {
-    this.cache.data = { ...value }
-    this.stash.deleteRange(this.cache.sequence, id, false)
-    this.updateWatchedNodes('')
-    this.updateSequence(id)
-    this.processStashed(id + 1)
-  }
-
-  private processStashed(id: number): void {
-    this.undoRevisions(id)
-    this.applyRevisions(id)
-  }
-
-  private undoRevisions(id: number): void {
-    let stashEntry = this.stash.get(this.stash.maxKey() as number)
-
-    while (stashEntry && stashEntry.revision.id > id) {
-      stashEntry.undo.forEach(u => applyOperation(this.cache, u))
-      stashEntry = this.stash.nextLowerPair(stashEntry.revision.id)?.[1]
-    }
-  }
-
-  private applyRevisions(id: number): void {
-    let revision = this.stash.get(id)?.revision
-    while (revision) {
-      let undo: Operation<unknown>[] = []
-      let success = false
-
-      try {
-        revision.patch.forEach(op => {
-          const u = applyOperation(this.cache, op)
-          if (u) undo.push(u)
-        })
-        success = true
-      } catch (e) {
-        undo.forEach(u => applyOperation(this.cache, u))
-        undo = []
-      }
-
-      if (success) {
-        revision.patch.forEach(op => {
-          this.updateWatchedNodes(op.path)
-        })
-      }
-
-      if (revision.id === this.cache.sequence + 1) {
-        this.updateSequence(revision.id)
-      } else {
-        this.stash.set(revision.id, { revision, undo })
-      }
-
-      // increment revision for next loop
-      revision = this.stash.nextHigherPair(revision.id)?.[1].revision
-    }
-
-    // delete all old stashed revisions
-    this.stash.deleteRange(0, this.cache.sequence, false)
-  }
-
-  private updateWatchedNodes(revisionPath: string) {
-    Object.keys(this.watchedNodes).forEach(path => {
-      if (path.includes(revisionPath) || revisionPath.includes(path)) {
-        this.updateValue(path)
-      }
-    })
-  }
-
-  private updateSequence(sequence: number): void {
-    this.cache.sequence = sequence
-    this.sequence$.next(sequence)
-  }
-
-  private isRevision(update: Update<T>): update is Revision {
-    return 'patch' in update
-  }
-}

client/lib/types.ts

@@ -4,11 +4,10 @@ import { Operation } from './json-patch-lib'
 export type Revision = {
   id: number
   patch: Operation<unknown>[]
-  expireId: string | null
 }
 
 // dump/replace the entire store with T
-export type Dump<T> = { id: number; value: T; expireId: string | null }
+export type Dump<T> = { id: number; value: T }
 
 export type Update<T> = Revision | Dump<T>