musora-content-services 2.90.0 → 2.92.3

package/src/services/sync/models/Practice.ts

@@ -0,0 +1,72 @@
+import { SYNC_TABLES } from '../schema'
+import BaseModel from './Base'
+
+export default class Practice extends BaseModel<{
+  manual_id: string | null
+  content_id: number | null
+  date: string
+  auto: boolean
+  duration_seconds: number
+  title: string | null
+  thumbnail_url: string | null
+  category_id: number | null
+  instrument_id: number | null
+}> {
+  static table = SYNC_TABLES.PRACTICES
+
+  get manual_id() {
+    return this._getRaw('manual_id') as string | null
+  }
+  get content_id() {
+    return this._getRaw('content_id') as number | null
+  }
+  get date() {
+    return this._getRaw('date') as string
+  }
+  get auto() {
+    return this._getRaw('auto') as boolean
+  }
+  get duration_seconds() {
+    return this._getRaw('duration_seconds') as number
+  }
+  get title() {
+    return this._getRaw('title') as string | null
+  }
+  get thumbnail_url() {
+    return this._getRaw('thumbnail_url') as string | null
+  }
+  get category_id() {
+    return this._getRaw('category_id') as number | null
+  }
+  get instrument_id() {
+    return this._getRaw('instrument_id') as number | null
+  }
+
+  set manual_id(value: string | null) {
+    this._setRaw('manual_id', value)
+  }
+  set content_id(value: number | null) {
+    this._setRaw('content_id', value)
+  }
+  set date(value: string) {
+    this._setRaw('date', value)
+  }
+  set auto(value: boolean) {
+    this._setRaw('auto', value)
+  }
+  set duration_seconds(value: number) {
+    this._setRaw('duration_seconds', value)
+  }
+  set title(value: string | null) {
+    this._setRaw('title', value)
+  }
+  set thumbnail_url(value: string | null) {
+    this._setRaw('thumbnail_url', value)
+  }
+  set category_id(value: number | null) {
+    this._setRaw('category_id', value)
+  }
+  set instrument_id(value: number | null) {
+    this._setRaw('instrument_id', value)
+  }
+}

package/src/services/sync/models/PracticeDayNote.ts

@@ -0,0 +1,23 @@
+import { SYNC_TABLES } from '../schema'
+import BaseModel from './Base'
+
+export default class PracticeDayNote extends BaseModel<{
+  date: string
+  notes: string
+}> {
+  static table = SYNC_TABLES.PRACTICE_DAY_NOTES
+
+  get date() {
+    return this._getRaw('date') as string
+  }
+  get notes() {
+    return this._getRaw('notes') as string
+  }
+
+  set date(value: string) {
+    this._setRaw('date', value)
+  }
+  set notes(value: string) {
+    this._setRaw('notes', value)
+  }
+}

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

@@ -0,0 +1,4 @@
+export { default as ContentLike } from './ContentLike'
+export { default as ContentProgress } from './ContentProgress'
+export { default as Practice } from './Practice'
+export { default as PracticeDayNote } from './PracticeDayNote'

package/src/services/sync/repositories/base.ts

@@ -0,0 +1,247 @@
+import SyncStore from '../store'
+import SyncContext from '../context'
+import BaseModel from '../models/Base'
+import { RecordId } from '@nozbe/watermelondb'
+import type { Span } from '../telemetry/index'
+
+import { SyncError, SyncExistsDTO, SyncReadDTO, SyncReadData, SyncWriteDTO, SyncWriteIdData, SyncWriteRecordData, SyncRemoteWriteDTO} from '..'
+import { SyncPushResponse } from '../fetch'
+
+import { Q } from '@nozbe/watermelondb'
+export { Q }
+
+export default class SyncRepository<TModel extends BaseModel> {
+  context: SyncContext
+  store: SyncStore<TModel>
+
+  constructor(store: SyncStore<TModel>) {
+    this.context = store.context
+    this.store = store
+  }
+
+  protected async readOne(id: RecordId) {
+    return this._respondToRead(() => this.store.readOne(id))
+  }
+
+  protected async readSome(ids: RecordId[]) {
+    return this._respondToRead(() => this.store.readSome(ids))
+  }
+
+  protected async readAll() {
+    return this._respondToRead(() => this.store.readAll())
+  }
+
+  protected async queryOne(...args: Q.Clause[]) {
+    return this._respondToRead(() => this.store.queryOne(...args))
+  }
+
+  protected async queryOneId(...args: Q.Clause[]) {
+    return this._respondToRead(() => this.store.queryOneId(...args))
+  }
+
+  protected async queryAll(...args: Q.Clause[]) {
+    return this._respondToRead(() => this.store.queryAll(...args))
+  }
+
+  protected async queryAllIds(...args: Q.Clause[]) {
+    return this._respondToRead(() => this.store.queryAllIds(...args))
+  }
+
+  protected async fetchOne(id: RecordId) {
+    return this._fetch(() => this.store.readOne(id))
+  }
+
+  protected async fetchAll() {
+    return this._fetch(() => this.store.readAll())
+  }
+
+  protected async existOne(id: RecordId) {
+    const r = await this.readOne(id)
+    return {
+      ...r,
+      data: r.data !== null
+    }
+  }
+
+  protected async existSome(ids: RecordId[]) {
+    const read = await this.readSome(ids)
+    const map = new Map<RecordId, (typeof read.data)[0]>()
+    read.data.forEach((record) => map.set(record.id, record))
+
+    const result: SyncExistsDTO<TModel, boolean[]> = {
+      ...read,
+      data: ids.map((id) => map.has(id)),
+    }
+    return result
+  }
+
+  protected async insertOne(builder: (record: TModel) => void) {
+    return this.store.telemetry.trace(
+      { name: `insertOne:${this.store.model.table}`, op: 'insert' },
+      (span) => this._respondToWrite(() => this.store.insertOne(builder, span), span)
+    )
+  }
+
+  protected async updateOneId(id: RecordId, builder: (record: TModel) => void) {
+    return this.store.telemetry.trace(
+      { name: `updateOne:${this.store.model.table}`, op: 'update' },
+      (span) => this._respondToWrite(() => this.store.updateOneId(id, builder, span), span)
+    )
+  }
+
+  protected async upsertOneRemote(id: RecordId, builder: (record: TModel) => void) {
+    return this.store.telemetry.trace(
+      { name: `upsertOneRemote:${this.store.model.table}`, op: 'upsert' },
+      (span) => this._respondToRemoteWriteOne(() => this.store.upsertOneRemote(id, builder, span), id, span)
+    )
+  }
+
+  protected async upsertOne(id: RecordId, builder: (record: TModel) => void) {
+    return this.store.telemetry.trace(
+      { name: `upsertOne:${this.store.model.table}`, op: 'upsert' },
+      (span) => this._respondToWrite(() => this.store.upsertOne(id, builder, span), span)
+    )
+  }
+
+  protected async upsertOneTentative(id: RecordId, builder: (record: TModel) => void) {
+    return this.store.telemetry.trace(
+      { name: `upsertOneTentative:${this.store.model.table}`, op: 'upsert' },
+      (span) => this._respondToWrite(() => this.store.upsertOneTentative(id, builder, span), span)
+    )
+  }
+
+  protected async upsertSome(builders: Record<RecordId, (record: TModel) => void>) {
+    return this.store.telemetry.trace(
+      { name: `upsertSome:${this.store.model.table}`, op: 'upsert' },
+      (span) => this._respondToWrite(() => this.store.upsertSome(builders, span), span)
+    )
+  }
+
+  protected async upsertSomeTentative(builders: Record<RecordId, (record: TModel) => void>) {
+    return this.store.telemetry.trace(
+      { name: `upsertSomeTentative:${this.store.model.table}`, op: 'upsert' },
+      (span) => this._respondToWrite(() => this.store.upsertSomeTentative(builders, span), span)
+    )
+  }
+
+  protected async deleteOne(id: RecordId) {
+    return this.store.telemetry.trace(
+      { name: `delete:${this.store.model.table}`, op: 'delete' },
+      (span) => this._respondToWriteIds(() => this.store.deleteOne(id, span), span)
+    )
+  }
+
+  protected async deleteSome(ids: RecordId[]) {
+    return this.store.telemetry.trace(
+      { name: `deleteSome:${this.store.model.table}`, op: 'delete' },
+      (span) => this._respondToWriteIds(() => this.store.deleteSome(ids, span), span)
+    )
+  }
+
+  private async _respondToWrite<T extends SyncWriteRecordData<TModel>>(create: () => Promise<T>, span?: Span) {
+    const data = await create()
+
+    let response: SyncPushResponse | null = null
+    if (!this.context.durability.getValue()) {
+      response = await this.store.pushRecordIdsImpatiently('id' in data ? [data.id] : data.map(r => r.id), span)
+
+      if (!response.ok) {
+        throw new SyncError('Failed to push records', { response })
+      }
+    }
+
+    const ret: SyncWriteDTO<TModel, T> = {
+      data,
+      status: response ? 'synced' : 'unsynced',
+      pushStatus: response ? 'success' : 'pending',
+    }
+    return ret
+  }
+
+  private async _respondToWriteIds<T extends SyncWriteIdData<TModel>>(create: () => Promise<T>, span?: Span) {
+    const data = await create()
+
+    let response: SyncPushResponse | null = null
+    if (!this.context.durability.getValue()) {
+      response = await this.store.pushRecordIdsImpatiently(typeof data === 'string' ? [data] : data, span)
+
+      if (!response.ok) {
+        throw new SyncError('Failed to push records', { response })
+      }
+    }
+
+    const ret: SyncWriteDTO<TModel, T> = {
+      data,
+      status: response ? 'synced' : 'unsynced',
+      pushStatus: response ? 'success' : 'pending',
+    }
+    return ret
+  }
+
+  private async _respondToRemoteWriteOne<T extends SyncPushResponse>(push: () => Promise<T>, id: RecordId, span?: Span) {
+    const response = await push()
+
+    if (!response.ok) {
+      throw new SyncError('Failed to push records', { response })
+    }
+
+    const data = await this.store.readOne(id)
+
+    const ret: SyncRemoteWriteDTO<TModel> = {
+      data,
+      status: 'synced',
+      pushStatus: 'success'
+    }
+    return ret
+  }
+
+  // read from local db, but pull (and throw (!) if it fails) if it's never been synced before
+  private async _respondToRead<T extends SyncReadData<TModel>>(query: () => Promise<T>) {
+    const fetchToken = await this.store.getLastFetchToken()
+    const everPulled = !!fetchToken
+    let pull: Awaited<ReturnType<typeof this.store.pullRecords>> | null = null
+
+    if (!everPulled) {
+      pull = await this.store.pullRecords()
+      if (!pull.ok) {
+        throw new SyncError('Failed to pull records', { pull })
+      }
+    }
+
+    const data = await query()
+
+    const result: SyncReadDTO<TModel, T> = {
+      data,
+      status: pull?.ok ? 'fresh' : 'stale',
+      pullStatus: pull?.ok ? 'success' : 'failure',
+      lastFetchToken: fetchToken,
+    }
+    return result
+  }
+
+  private async _fetch<T extends SyncReadData<TModel>>(query: () => Promise<T>) {
+    const [response, fetchToken] = await Promise.all([
+      this.store.pullRecords(),
+      this.store.getLastFetchToken(),
+    ])
+    const data = await query()
+
+    if (!response.ok) {
+      const result: SyncReadDTO<TModel, T> = {
+        data,
+        status: 'stale',
+        pullStatus: 'failure',
+        lastFetchToken: fetchToken,
+      }
+      return result
+    }
+
+    const result: SyncReadDTO<TModel, T> = {
+      data,
+      status: 'fresh',
+      pullStatus: 'success',
+      lastFetchToken: response.token,
+    }
+    return result
+  }
+}

package/src/services/sync/repositories/content-likes.ts

@@ -0,0 +1,26 @@
+import SyncRepository from "./base";
+import ContentLike from "../models/ContentLike";
+
+export default class LikesRepository extends SyncRepository<ContentLike> {
+  async isLiked(contentId: number) {
+    return await this.existOne(LikesRepository.generateId(contentId))
+  }
+
+  async areLiked(contentIds: number[]) {
+    return await this.existSome(contentIds.map(LikesRepository.generateId))
+  }
+
+  async like(contentId: number) {
+    return await this.upsertOne(LikesRepository.generateId(contentId), r => {
+      r.content_id = contentId;
+    })
+  }
+
+  async unlike(contentId: number) {
+    return await this.deleteOne(LikesRepository.generateId(contentId))
+  }
+
+  private static generateId(contentId: number) {
+    return contentId.toString();
+  }
+}

package/src/services/sync/repositories/content-progress.ts

@@ -0,0 +1,160 @@
+import SyncRepository, { Q } from './base'
+import ContentProgress, { COLLECTION_TYPE, STATE } from '../models/ContentProgress'
+
+export default class ProgressRepository extends SyncRepository<ContentProgress> {
+  // null collection only
+  async startedIds(limit?: number) {
+    return this.queryAll(
+      Q.where('collection_type', null),
+      Q.where('collection_id', null),
+
+      Q.where('state', STATE.STARTED),
+      Q.sortBy('updated_at', 'desc'),
+      Q.take(limit || Infinity)
+    )
+  }
+
+  // null collection only
+  async completedIds(limit?: number) {
+    return this.queryAllIds(
+      Q.where('state', STATE.COMPLETED),
+      Q.sortBy('updated_at', 'desc'),
+      Q.take(limit || Infinity)
+    )
+  }
+
+  // null collection only
+  async startedOrCompleted(opts: Parameters<typeof this.startedOrCompletedClauses>[0] = {}) {
+    return this.queryAll(...this.startedOrCompletedClauses(opts))
+  }
+
+  // null collection only
+  async startedOrCompletedIds(opts: Parameters<typeof this.startedOrCompletedClauses>[0] = {}) {
+    return this.queryAllIds(...this.startedOrCompletedClauses(opts))
+  }
+
+  // null collection only
+  private startedOrCompletedClauses(
+    opts: {
+      brand?: string
+      updatedAfter?: number
+      limit?: number
+    } = {}
+  ) {
+    const clauses: Q.Clause[] = [
+      Q.where('collection_type', null),
+      Q.where('collection_id', null),
+
+      Q.or(Q.where('state', STATE.STARTED), Q.where('state', STATE.COMPLETED)),
+      Q.sortBy('updated_at', 'desc'),
+    ]
+
+    if (opts.updatedAfter) {
+      clauses.push(Q.where('updated_at', Q.gte(opts.updatedAfter)))
+    }
+
+    if (opts.brand) {
+      clauses.push(Q.where('content_brand', opts.brand))
+    }
+
+    if (opts.limit) {
+      clauses.push(Q.take(opts.limit))
+    }
+
+    return clauses
+  }
+
+  async mostRecentlyUpdatedId(contentIds: number[], collection: { type: COLLECTION_TYPE; id: number } | null = null) {
+    return this.queryOneId(
+      Q.where('content_id', Q.oneOf(contentIds)),
+      Q.where('collection_type', collection?.type ?? null),
+      Q.where('collection_id', collection?.id ?? null),
+
+      Q.sortBy('updated_at', 'desc')
+    )
+  }
+
+  async getOneProgressByContentId(
+    contentId: number,
+    { collection }: { collection?: { type: COLLECTION_TYPE; id: number } | null } = {}
+  ) {
+    const clauses = [Q.where('content_id', contentId)]
+    if (typeof collection != 'undefined') {
+      clauses.push(
+        ...[
+          Q.where('collection_type', collection?.type ?? null),
+          Q.where('collection_id', collection?.id ?? null),
+        ]
+      )
+    }
+
+    return await this.queryOne(...clauses)
+  }
+
+  async getSomeProgressByContentIds(
+    contentIds: number[],
+    collection: { type: COLLECTION_TYPE; id: number } | null = null
+  ) {
+    const clauses = [Q.where('content_id', Q.oneOf(contentIds))]
+    if (typeof collection != 'undefined') {
+      clauses.push(
+        ...[
+          Q.where('collection_type', collection?.type ?? null),
+          Q.where('collection_id', collection?.id ?? null),
+        ]
+      )
+    }
+
+    return await this.queryAll(...clauses)
+  }
+
+  recordProgressRemotely(contentId: number, collection: { type: COLLECTION_TYPE; id: number } | null, progressPct: number, resumeTime?: number) {
+    const id = ProgressRepository.generateId(contentId, collection)
+
+    return this.upsertOneRemote(id, (r) => {
+      r.content_id = contentId
+      r.collection_type = collection?.type ?? null
+      r.collection_id = collection?.id ?? null
+
+      r.state = progressPct === 100 ? STATE.COMPLETED : STATE.STARTED
+      r.progress_percent = progressPct
+
+      if (typeof resumeTime != 'undefined') {
+        r.resume_time_seconds = Math.floor(resumeTime)
+      }
+    })
+  }
+
+  recordProgressesTentative(contentProgresses: Map<number, number>, collection: { type: COLLECTION_TYPE; id: number } | null) {
+    return this.upsertSomeTentative(
+      Object.fromEntries(
+        Array.from(contentProgresses, ([contentId, progressPct]) => [
+          ProgressRepository.generateId(contentId, null),
+          (r) => {
+            r.content_id = contentId
+            r.collection_type = collection?.type ?? null
+            r.collection_id = collection?.id ?? null
+
+            r.state = progressPct === 100 ? STATE.COMPLETED : STATE.STARTED
+            r.progress_percent = progressPct
+          },
+        ])
+      )
+    )
+  }
+
+  eraseProgress(contentId: number, collection: { type: COLLECTION_TYPE; id: number } | null) {
+    return this.deleteOne(ProgressRepository.generateId(contentId, collection))
+  }
+
+  private static generateId(
+    contentId: number,
+    collection: { type: COLLECTION_TYPE; id: number } | null
+  ) {
+    if (collection) {
+      return `${contentId}:${collection.type}:${collection.id}`
+    } else {
+      return `${contentId}`
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+export { default as ContentLikesRepository } from './content-likes'
+export { default as ContentProgressRepository } from './content-progress'
+export { default as PracticesRepository } from './practices'
+export { default as PracticeDayNotesRepository } from './practice-day-notes'

package/src/services/sync/repositories/practice-day-notes.ts

@@ -0,0 +1,4 @@
+import SyncRepository from "./base";
+import PracticeDayNote from "../models/PracticeDayNote";
+
+export default class PracticeDayNotesRepository extends SyncRepository<PracticeDayNote> {}

package/src/services/sync/repositories/practices.ts

@@ -0,0 +1,52 @@
+import SyncRepository from "./base";
+import Practice from "../models/Practice";
+import { RecordId } from "@nozbe/watermelondb";
+
+export default class PracticesRepository extends SyncRepository<Practice> {
+  async trackAutoPractice(contentId: number, date: string, incrementalDurationSeconds: number) {
+    return await this.upsertOne(PracticesRepository.generateAutoId(contentId, date), r => {
+      r._raw.id = PracticesRepository.generateAutoId(contentId, date);
+      r.auto = true;
+      r.content_id = contentId;
+      r.date = date;
+
+      r.duration_seconds = Math.min((r.duration_seconds || 0) + incrementalDurationSeconds, 59999);
+    })
+  }
+
+  async recordManualPractice(date: string, durationSeconds: number, details: Partial<Pick<Practice, 'title' | 'instrument_id' | 'category_id' | 'thumbnail_url'>> = {}) {
+    return await this.insertOne((r) => {
+      const manualId = r._raw.id; // yoink watermelon's autogenerated id
+      r._raw.id = PracticesRepository.generateManualId(manualId);
+
+      r.manual_id = manualId;
+      r.auto = false;
+
+      r.date = date;
+      r.duration_seconds = Math.min(durationSeconds, 59999);
+
+      r.title = details.title ?? null;
+      r.thumbnail_url = details.thumbnail_url ?? null;
+      r.category_id = details.category_id ?? null;
+      r.instrument_id = details.instrument_id ?? null;
+    });
+  }
+
+  async updateDetails(id: RecordId, details: Partial<Pick<Practice, 'duration_seconds' | 'title' | 'thumbnail_url' | 'category_id' | 'instrument_id'>>) {
+    return await this.updateOneId(id, r => {
+      r.duration_seconds = Math.min(details.duration_seconds, 59999) ?? r.duration_seconds;
+      r.title = details.title ?? r.title;
+      r.thumbnail_url = details.thumbnail_url ?? r.thumbnail_url;
+      r.category_id = details.category_id ?? r.category_id;
+      r.instrument_id = details.instrument_id ?? r.instrument_id;
+    })
+  }
+
+  private static generateAutoId(contentId: number, date: string) {
+    return ['auto', contentId.toString(), date].join(':');
+  }
+
+  private static generateManualId(manualId: string) {
+    return `manual:${manualId}`;
+  }
+}

package/src/services/sync/repository-proxy.ts

@@ -0,0 +1,48 @@
+import SyncManager from "./manager"
+import { SyncError } from "./errors"
+
+import {
+  ContentLikesRepository,
+  ContentProgressRepository,
+  PracticesRepository,
+  PracticeDayNotesRepository
+} from "./repositories"
+import {
+  ContentLike,
+  ContentProgress,
+  Practice,
+  PracticeDayNote
+} from "./models"
+
+interface SyncRepositories {
+ likes: ContentLikesRepository
+ contentProgress: ContentProgressRepository
+ practices: PracticesRepository
+ practiceDayNotes: PracticeDayNotesRepository
+}
+
+export default new Proxy({} as SyncRepositories, {
+  get(target: SyncRepositories, prop: keyof SyncRepositories) {
+    if (!target[prop]) {
+      const manager = SyncManager.getInstance()
+
+      switch (prop) {
+        case 'likes':
+          target[prop] = new ContentLikesRepository(manager.getStore(ContentLike))
+          break
+        case 'contentProgress':
+          target[prop] = new ContentProgressRepository(manager.getStore(ContentProgress))
+          break
+        case 'practices':
+          target[prop] = new PracticesRepository(manager.getStore(Practice))
+          break
+        case 'practiceDayNotes':
+          target[prop] = new PracticeDayNotesRepository(manager.getStore(PracticeDayNote))
+          break
+        default:
+          throw new SyncError(`Repository '${prop}' not found`)
+      }
+    }
+    return target[prop]
+  }
+})