musora-content-services 2.90.0 → 2.92.3

package/src/services/sync/resolver.ts

@@ -0,0 +1,84 @@
+import { RecordId } from "@nozbe/watermelondb";
+import { SyncEntry, SyncEntryNonDeleted } from ".";
+import BaseModel from "./models/Base";
+
+export type SyncResolution = {
+  entriesForCreate: SyncEntry[]
+  tuplesForUpdate: [BaseModel, SyncEntry][]
+  tuplesForRestore: [BaseModel, SyncEntry][]
+  idsForDestroy: RecordId[]
+}
+
+export type SyncResolverComparator<T extends BaseModel = BaseModel> = (serverEntry: SyncEntryNonDeleted<T>, localModel: T) => 'SERVER' | 'LOCAL'
+
+export const updatedAtComparator: SyncResolverComparator = (server, local) => {
+  return server.meta.lifecycle.updated_at >= local.updated_at ? 'SERVER' : 'LOCAL'
+}
+export default class SyncResolver {
+  private resolution: SyncResolution
+  private comparator: SyncResolverComparator
+
+  constructor(comparator?: SyncResolverComparator) {
+    this.comparator = comparator || updatedAtComparator
+    this.resolution = {
+      entriesForCreate: [],
+      tuplesForUpdate: [],
+      tuplesForRestore: [],
+      idsForDestroy: []
+    }
+  }
+
+  get result() {
+    return { ...this.resolution }
+  }
+
+  againstNone(server: SyncEntry) {
+    if (!server.meta.lifecycle.deleted_at) {
+      this.resolution.entriesForCreate.push(server)
+    }
+  }
+
+  againstSynced(local: BaseModel, server: SyncEntry) {
+    if (server.meta.lifecycle.deleted_at) {
+      this.resolution.idsForDestroy.push(local.id)
+    }
+    // take care that the server stamp isn't older than the current local
+    // (imagine a race condition where a pull request resolves long after a second one)
+    else if (this.comparator(server as SyncEntryNonDeleted<BaseModel>, local) !== 'LOCAL') {
+      this.resolution.tuplesForUpdate.push([local, server])
+    }
+  }
+
+  // can happen if one tab notifies another of a created record, pushes to server, and other tab pulls
+  againstCreated(local: BaseModel, server: SyncEntry) {
+    if (server.meta.lifecycle.deleted_at) {
+      // delete local even though user has newer changes
+      // (we don't ever try to resurrect records here)
+      this.resolution.idsForDestroy.push(local.id)
+    } else if (this.comparator(server as SyncEntryNonDeleted<BaseModel>, local) !== 'LOCAL') {
+      // local is older, so update it with server's
+      this.resolution.tuplesForUpdate.push([local, server])
+    }
+  }
+
+  againstUpdated(local: BaseModel, server: SyncEntry) {
+    if (server.meta.lifecycle.deleted_at) {
+      // delete local even though user has newer changes
+      // (we don't ever try to resurrect records here)
+      this.resolution.idsForDestroy.push(local.id);
+    } else if (this.comparator(server as SyncEntryNonDeleted<BaseModel>, local) !== 'LOCAL') {
+      // local is older, so update it with server's
+      this.resolution.tuplesForUpdate.push([local, server])
+    }
+  }
+
+  againstDeleted(local: BaseModel, server: SyncEntry) {
+    if (server.meta.lifecycle.deleted_at) {
+      this.resolution.idsForDestroy.push(local.id)
+    } else if (server.meta.lifecycle.updated_at >= local.updated_at) {
+      this.resolution.tuplesForRestore.push([local, server])
+    } else {
+      this.resolution.idsForDestroy.push(local.id);
+    }
+  }
+}

package/src/services/sync/retry.ts

@@ -0,0 +1,88 @@
+import SyncContext from "./context"
+import { SyncResponse } from "./fetch"
+import { SyncTelemetry, Span, StartSpanOptions } from "./telemetry/index"
+
+export default class SyncRetry {
+  private readonly BASE_BACKOFF = 1_000
+  private readonly MAX_BACKOFF = 8_000
+  private readonly MAX_ATTEMPTS = 4
+
+  private paused = false
+  private backoffUntil = 0
+  private failureCount = 0
+
+  private unsubscribeConnectivity: () => void
+
+  constructor(private readonly context: SyncContext, private readonly telemetry: SyncTelemetry) {}
+
+  start() {
+    this.unsubscribeConnectivity = this.context.connectivity.subscribe(isOnline => {
+      if (isOnline && this.paused) {
+        this.paused = false
+        this.resetBackoff()
+      }
+    })
+  }
+
+  stop() {
+    this.unsubscribeConnectivity?.()
+  }
+
+  /**
+   * Runs the given syncFn with automatic retries.
+   * Returns the first successful result or the last failed result after retries.
+   */
+  async request<T extends SyncResponse>(spanOpts: StartSpanOptions, syncFn: (span: Span) => Promise<T>) {
+    let attempt = 0
+
+    while (true) {
+      if (!this.context.connectivity.getValue()) {
+        this.telemetry.debug('[Retry] No connectivity - skipping')
+        this.paused = true
+        return { ok: false } as T
+      }
+
+      const now = Date.now()
+      if (now < this.backoffUntil) {
+        await this.sleep(this.backoffUntil - now)
+      }
+
+      attempt++
+
+      const spanOptions = { ...spanOpts, name: `${spanOpts.name}:attempt:${attempt}/${this.MAX_ATTEMPTS}`, op: `${spanOpts.op}:attempt` }
+      const result = await this.telemetry.trace(spanOptions, span => syncFn(span))
+
+      if (result.ok) {
+        this.resetBackoff()
+        return result
+      } else {
+        this.scheduleBackoff()
+        if (attempt >= this.MAX_ATTEMPTS) return result
+      }
+    }
+  }
+
+  private resetBackoff() {
+    if (this.backoffUntil !== 0 || this.failureCount !== 0) {
+      this.telemetry.debug('[Retry] Resetting backoff')
+      this.backoffUntil = 0
+      this.failureCount = 0
+    }
+  }
+
+  private scheduleBackoff() {
+    this.failureCount++
+
+    const exponentialDelay = this.BASE_BACKOFF * Math.pow(2, this.failureCount - 1)
+    const jitter = exponentialDelay * 0.25 * (Math.random() - 0.5)
+    const delayWithJitter = exponentialDelay + jitter
+
+    this.backoffUntil = Date.now() + Math.min(this.MAX_BACKOFF, delayWithJitter)
+
+    this.telemetry.debug('[Retry] Scheduling backoff', { failureCount: this.failureCount, backoffUntil: this.backoffUntil })
+  }
+
+  private sleep(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+}

package/src/services/sync/run-scope.ts

@@ -0,0 +1,30 @@
+export default class SyncRunScope {
+  private abortController: AbortController
+
+  constructor() {
+    this.abortController = new AbortController()
+  }
+
+  get signal(): AbortSignal {
+    return this.abortController.signal
+  }
+
+  abort(): void {
+    this.abortController.abort()
+  }
+
+  abortable<T>(fn: () => Promise<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      if (this.signal.aborted) {
+        reject(this.signal.reason)
+        return
+      }
+
+      fn().then(resolve).catch(reject)
+
+      this.signal.addEventListener('abort', () => {
+        reject(this.signal.reason)
+      })
+    })
+  }
+}

package/src/services/sync/schema/index.ts

@@ -0,0 +1,66 @@
+import { appSchema, tableSchema } from '@nozbe/watermelondb'
+
+export const SYNC_TABLES = {
+  CONTENT_LIKES: 'content_likes',
+  CONTENT_PROGRESS: 'progress',
+  PRACTICES: 'practices',
+  PRACTICE_DAY_NOTES: 'practice_day_notes'
+}
+
+const contentLikesTable = tableSchema({
+  name: SYNC_TABLES.CONTENT_LIKES,
+  columns: [
+    { name: 'content_id', type: 'number', isIndexed: true },
+    { name: 'created_at', type: 'number' },
+    { name: 'updated_at', type: 'number' }
+  ]
+})
+const contentProgressTable = tableSchema({
+  name: SYNC_TABLES.CONTENT_PROGRESS,
+  columns: [
+    { name: 'content_id', type: 'number', isIndexed: true },
+    { name: 'content_brand', type: 'string', isIndexed: true },
+    { name: 'collection_type', type: 'string', isOptional: true, isIndexed: true },
+    { name: 'collection_id', type: 'number', isOptional: true, isIndexed: true },
+    { name: 'state', type: 'string', isIndexed: true },
+    { name: 'progress_percent', type: 'number' },
+    { name: 'resume_time_seconds', type: 'number' },
+    { name: 'created_at', type: 'number' },
+    { name: 'updated_at', type: 'number', isIndexed: true }
+  ]
+})
+const practicesTable = tableSchema({
+  name: SYNC_TABLES.PRACTICES,
+  columns: [
+    { name: 'manual_id', type: 'string', isOptional: true },
+    { name: 'content_id', type: 'number', isOptional: true, isIndexed: true },
+    { name: 'date', type: 'string', isIndexed: true },
+    { name: 'auto', type: 'boolean', isIndexed: true },
+    { name: 'duration_seconds', type: 'number' },
+    { name: 'title', type: 'string', isOptional: true },
+    { name: 'thumbnail_url', type: 'string', isOptional: true },
+    { name: 'category_id', type: 'number', isOptional: true },
+    { name: 'instrument_id', type: 'number', isOptional: true },
+    { name: 'created_at', type: 'number' },
+    { name: 'updated_at', type: 'number', isIndexed: true }
+  ]
+})
+const practiceDayNotesTable = tableSchema({
+  name: SYNC_TABLES.PRACTICE_DAY_NOTES,
+  columns: [
+    { name: 'date', type: 'string', isIndexed: true },
+    { name: 'notes', type: 'string' },
+    { name: 'created_at', type: 'number' },
+    { name: 'updated_at', type: 'number', isIndexed: true }
+  ]
+})
+
+export default appSchema({
+  version: 1,
+  tables: [
+    contentLikesTable,
+    contentProgressTable,
+    practicesTable,
+    practiceDayNotesTable
+  ]
+})

package/src/services/sync/serializers/index.ts

@@ -0,0 +1,2 @@
+export { default as RawSerializer, type RawSerialized } from './raw'
+export { default as ModelSerializer, type ModelSerialized } from './model'

package/src/services/sync/serializers/model.ts

@@ -0,0 +1,32 @@
+import { Model, RecordId } from "@nozbe/watermelondb"
+import BaseModel from "../models/Base"
+
+export type ModelSerialized<TModel extends Model> = ExtractGetters<TModel>
+type ExtractGetters<T> = {
+  [K in keyof T as T[K] extends Function ? never : K]: T[K];
+} & { id: RecordId }
+
+// serializes a record to a POJO based on its model getters
+// (essentially strips out all watermelon properties)
+// useful for consumption in components, etc.
+
+export default class ModelSerializer<TModel extends Model = Model> {
+  toPlainObject(record: TModel) {
+    const proto = Object.getPrototypeOf(record)
+    const keys = [
+      ...Object.getOwnPropertyNames(proto),
+      ...Object.getOwnPropertyNames(BaseModel.prototype)
+    ]
+
+    const result = {}
+    for (const key of keys) {
+      const desc = Object.getOwnPropertyDescriptor(proto, key) || Object.getOwnPropertyDescriptor(BaseModel.prototype, key)
+      if (desc?.get) {
+        result[key] = desc.get.call(record)
+      }
+    }
+    result['id'] = record.id
+
+    return result as ModelSerialized<TModel>
+  }
+}

package/src/services/sync/serializers/raw.ts

@@ -0,0 +1,21 @@
+import { Model } from "@nozbe/watermelondb"
+
+export type RawSerialized<TModel extends Model> = Omit<TModel['_raw'], '_changed' | '_status'>
+
+// serializes a record to a POJO based on its _raw attributes
+// useful for sending to back-end for sync
+
+export default class RawSerializer<TModel extends Model = Model> {
+  toPlainObject(model: TModel) {
+    const result = {}
+    const raw = model._raw
+
+    for (const key in raw) {
+      if (key !== '_changed' && key !== '_status') {
+        result[key] = raw[key]
+      }
+    }
+
+    return result as RawSerialized<TModel>
+  }
+}