musora-content-services 2.107.8 → 2.110.3

package/src/services/sync/context/providers/durability.ts

@@ -2,4 +2,5 @@ import BaseContextProvider from "./base";
 
 export default abstract class BaseDurabilityProvider extends BaseContextProvider {
   abstract getValue(): boolean
+  abstract failed(): void
 }

package/src/services/sync/database/factory.ts

@@ -2,9 +2,16 @@ import type { DatabaseAdapter } from '../adapters/factory'
 import { Database, } from '@nozbe/watermelondb'
 import * as modelClasses from '../models'
 
-export default function syncDatabaseFactory(adapter: () => DatabaseAdapter) {
-  return () => new Database({
-    adapter: adapter(),
-    modelClasses: Object.values(modelClasses)
-  })
+export default function syncDatabaseFactory(adapter: () => DatabaseAdapter, { onInitError }: { onInitError?: (error: Error) => void } = {}) {
+  return () => {
+    try {
+      return new Database({
+        adapter: adapter(),
+        modelClasses: Object.values(modelClasses)
+      })
+    } catch (error) {
+      onInitError?.(error as Error)
+      throw error
+    }
+  }
 }

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

@@ -0,0 +1,6 @@
+import type SyncContext from "../context"
+import type SyncStore from "../store"
+
+export type SyncEffect = (context: SyncContext, stores: SyncStore[]) => () => void
+
+export { default as createLogoutWarningEffect } from './logout-warning'

package/src/services/sync/effects/logout-warning.ts

@@ -0,0 +1,47 @@
+import { Subscription } from 'rxjs'
+import { Q } from '@nozbe/watermelondb'
+
+import { type SyncEffect } from '.'
+
+import { type ModelClass } from '../index'
+
+// notifies a subscriber that unsynced records exist
+// ideally used by a logout interrupt prompt to tell the user that logging out
+// now would make them lose data
+
+// we notify eagerly so that the prompt can be shown as soon as user clicks logout,
+// instead of waiting for a lazy query at that moment
+
+const createLogoutWarningEffect = (notifyCallback: (unsyncedModels: ModelClass[]) => void) => {
+  const logoutWarning: SyncEffect = function (context, stores) {
+    const unsyncedModels = new Set<ModelClass>()
+    const subscriptions: Subscription[] = []
+
+    const notifyFromAll = () => {
+      notifyCallback(Array.from(unsyncedModels))
+    }
+
+    stores.forEach((store) => {
+      const sub = store.collection
+        .query(Q.where('_status', Q.notEq('synced')), Q.take(1)) // todo - doesn't consider deleted records ??
+        .observe()
+        .subscribe((records) => {
+          if (records.length > 0) {
+            unsyncedModels.add(store.model)
+          } else {
+            unsyncedModels.delete(store.model)
+          }
+          notifyFromAll()
+        })
+      subscriptions.push(sub)
+    })
+
+    return () => {
+      subscriptions.forEach((sub) => sub.unsubscribe())
+    }
+  }
+
+  return logoutWarning
+}
+
+export default createLogoutWarningEffect

package/src/services/sync/errors/boundary.ts

@@ -28,18 +28,16 @@ export function inBoundary<T, TContext extends Record<string, any>>(fn: (context
 
     if (result instanceof Promise) {
       return result.catch((err: unknown) => {
-        const wrapped = err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context);
-        SyncTelemetry.getInstance()?.capture(wrapped)
+        SyncTelemetry.getInstance()?.capture(err as Error, context)
 
-        throw wrapped;
+        throw err;
       });
     }
 
     return result;
   } catch (err: unknown) {
-    const wrapped = err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context);
-    SyncTelemetry.getInstance()?.capture(wrapped);
+    SyncTelemetry.getInstance()?.capture(err as Error, context);
 
-    throw wrapped;
+    throw err;
   }
 }

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

@@ -38,6 +38,22 @@ export class SyncStoreError extends SyncError {
   }
 }
 
+export class SyncInitError extends SyncError {
+  constructor(error: unknown) {
+    super('initError', { cause: error })
+    this.name = 'SyncInitError'
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+export class SyncSetupError extends SyncError {
+  constructor(error: unknown) {
+    super('setupError', { cause: error })
+    this.name = 'SyncSetupError'
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
 // useful for transforming non-sync-related errors into one
 // that captures surrounding details (e.g., table name)
 export class SyncUnexpectedError extends SyncError {

package/src/services/sync/fetch.ts

@@ -34,18 +34,18 @@ type SyncPushFetchFailureResponse = SyncResponseBase & {
   failureType: 'fetch'
   isRetryable: boolean
 }
-export type SyncPushFailureResponse = SyncResponseBase & {
+type SyncPushFailureResponse = SyncResponseBase & {
   ok: false,
   failureType: 'error'
   originalError: Error
 }
 
-type SyncStorePushResult<TRecordKey extends string = 'id'> = SyncStorePushResultSuccess<TRecordKey> | SyncStorePushResultFailure<TRecordKey>
-type SyncStorePushResultSuccess<TRecordKey extends string = 'id'> = SyncStorePushResultBase & {
+export type SyncStorePushResult<TRecordKey extends string = 'id'> = SyncStorePushResultSuccess<TRecordKey> | SyncStorePushResultFailure<TRecordKey>
+export type SyncStorePushResultSuccess<TRecordKey extends string = 'id'> = SyncStorePushResultBase & {
   type: 'success'
   entry: SyncEntry<BaseModel, TRecordKey>
 }
-type SyncStorePushResultFailure<TRecordKey extends string = 'id'> = SyncStorePushResultProcessingFailure<TRecordKey> | SyncStorePushResultValidationFailure<TRecordKey>
+export type SyncStorePushResultFailure<TRecordKey extends string = 'id'> = SyncStorePushResultProcessingFailure<TRecordKey> | SyncStorePushResultValidationFailure<TRecordKey>
 type SyncStorePushResultProcessingFailure<TRecordKey extends string = 'id'> = SyncStorePushResultFailureBase<TRecordKey> & {
   failureType: 'processing'
   error: any
@@ -71,7 +71,7 @@ type SyncPullSuccessResponse = SyncResponseBase & {
   token: SyncToken
   previousToken: SyncToken | null
 }
-type SyncPullFetchFailureResponse = SyncResponseBase & {
+export type SyncPullFetchFailureResponse = SyncResponseBase & {
   ok: false,
   failureType: 'fetch'
   isRetryable: boolean

package/src/services/sync/manager.ts

@@ -1,5 +1,6 @@
 import BaseModel from './models/Base'
 import { Database } from '@nozbe/watermelondb'
+import { DatabaseAdapter } from '@nozbe/watermelondb/adapters/type'
 import SyncRunScope from './run-scope'
 import { SyncStrategy } from './strategies'
 import { default as SyncStore, SyncStoreConfig } from './store'
@@ -8,10 +9,9 @@ import { ModelClass } from './index'
 import SyncRetry from './retry'
 import SyncContext from './context'
 import { SyncError } from './errors'
-import { SyncConcurrencySafetyMechanism } from './concurrency-safety'
+import { SyncEffect } from './effects'
 import { SyncTelemetry } from './telemetry/index'
-import { inBoundary } from './errors/boundary'
-import createStoresFromConfig from './store-configs'
+import createStoreConfigs from './store-configs'
 import { contentProgressObserver } from '../awards/internal/content-progress-observer'
 
 export default class SyncManager {
@@ -22,11 +22,16 @@ export default class SyncManager {
     if (SyncManager.instance) {
       throw new SyncError('SyncManager already initialized')
     }
+
     SyncManager.instance = instance
     const teardown = instance.setup()
-    return async () => {
+
+    return (force = false) => {
       SyncManager.instance = null
-      await teardown()
+      return teardown(force).catch(error => {
+        SyncManager.instance = instance // restore instance on teardown failure
+        throw error
+      })
     }
   }
 
@@ -43,29 +48,34 @@ export default class SyncManager {
 
   private id: string
   public telemetry: SyncTelemetry
-  private database: Database
   private context: SyncContext
+  private storeConfigsRegistry: Record<string, SyncStoreConfig<any>>
   private storesRegistry: Record<string, SyncStore<any>>
   private runScope: SyncRunScope
   private retry: SyncRetry
-  private strategyMap: { stores: SyncStore<any>[]; strategies: SyncStrategy[] }[]
-  private safetyMap: { stores: SyncStore<any>[]; mechanisms: (() => void)[] }[]
+  private strategyMap: { models: ModelClass[]; strategies: SyncStrategy[] }[]
+  private effectMap: { models: ModelClass[]; effects: SyncEffect[] }[]
+
+  private initDatabase: () => Database
+  private destroyDatabase?: (dbName: string, adapter: DatabaseAdapter) => Promise<void>
 
-  constructor(context: SyncContext, initDatabase: () => Database) {
+  constructor(context: SyncContext, initDatabase: () => Database, destroyDatabase?: (dbName: string, adapter: DatabaseAdapter) => Promise<void>) {
     this.id = (SyncManager.counter++).toString()
 
     this.telemetry = SyncTelemetry.getInstance()!
     this.context = context
 
-    this.database = this.telemetry.trace({ name: 'db:init' }, () => inBoundary(initDatabase)) // todo - can cause undefined??
+    this.initDatabase = initDatabase
+    this.destroyDatabase = destroyDatabase
+
+    this.storeConfigsRegistry = this.registerStoreConfigs(createStoreConfigs())
+    this.storesRegistry = {}
 
     this.runScope = new SyncRunScope()
     this.retry = new SyncRetry(this.context, this.telemetry)
 
-    this.storesRegistry = this.registerStores(createStoresFromConfig(this.createStore.bind(this)))
-
     this.strategyMap = []
-    this.safetyMap = []
+    this.effectMap = []
   }
 
   /**
@@ -75,27 +85,23 @@ export default class SyncManager {
     return this.id
   }
 
-  createStore<TModel extends BaseModel>(config: SyncStoreConfig<TModel>) {
-    return new SyncStore<TModel>(
+  createStore(config: SyncStoreConfig, database: Database) {
+    return new SyncStore(
       config,
       this.context,
-      this.database,
+      database,
       this.retry,
       this.runScope,
       this.telemetry
     )
   }
 
-  registerStores<TModel extends BaseModel>(stores: SyncStore<TModel>[]) {
+  registerStoreConfigs(stores: SyncStoreConfig[]) {
     return Object.fromEntries(
       stores.map((store) => {
         return [store.model.table, store]
       })
-    ) as Record<string, SyncStore<TModel>>
-  }
-
-  storesForModels(models: ModelClass[]) {
-    return models.map((model) => this.storesRegistry[model.table])
+    ) as Record<string, SyncStoreConfig>
   }
 
   createStrategy<T extends SyncStrategy, U extends any[]>(
@@ -105,24 +111,32 @@ export default class SyncManager {
     return new strategyClass(this.context, ...args)
   }
 
-  syncStoresWithStrategies(stores: SyncStore<any>[], strategies: SyncStrategy[]) {
-    this.strategyMap.push({ stores, strategies })
+  registerStrategies(models: ModelClass[], strategies: SyncStrategy[]) {
+    this.strategyMap.push({ models, strategies })
   }
 
-  protectStores(stores: SyncStore<any>[], mechanisms: SyncConcurrencySafetyMechanism[]) {
-    const teardowns = mechanisms.map((mechanism) => mechanism(this.context, stores))
-    this.safetyMap.push({ stores, mechanisms: teardowns })
+  registerEffects(models: ModelClass[], effects: SyncEffect[]) {
+    this.effectMap.push({ models, effects })
   }
 
   setup() {
     this.telemetry.debug('[SyncManager] Setting up')
 
+    // can fail synchronously immediately (e.g., schema/migration validation errors)
+    // or asynchronously (e.g., indexedDB errors synchronously OR asynchronously (!))
+    const database = this.telemetry.trace({ name: 'db:init' }, this.initDatabase)
+
+    Object.entries(this.storeConfigsRegistry).forEach(([table, storeConfig]) => {
+      this.storesRegistry[table] = this.createStore(storeConfig, database)
+    })
+
     this.context.start()
     this.retry.start()
 
-    this.strategyMap.forEach(({ stores, strategies }) => {
+    this.strategyMap.forEach(({ models, strategies }) => {
       strategies.forEach((strategy) => {
-        stores.forEach((store) => {
+        models.forEach((model) => {
+          const store = this.storesRegistry[model.table]
           strategy.onTrigger(store, (reason) => {
             store.requestSync(reason)
           })
@@ -131,22 +145,48 @@ export default class SyncManager {
       })
     })
 
-    contentProgressObserver.start(this.database).catch((error) => {
+    const effectTeardowns = this.effectMap.flatMap(({ models, effects }) => {
+      return effects.map((effect) => effect(this.context, models.map(model => this.storesRegistry[model.table])))
+    });
+
+    contentProgressObserver.start(database).catch((error) => {
       this.telemetry.error('[SyncManager] Failed to start contentProgressObserver', error)
     })
 
-    const teardown = async () => {
+    const teardown = async (force = false) => {
       this.telemetry.debug('[SyncManager] Tearing down')
-      this.runScope.abort()
-      this.strategyMap.forEach(({ strategies }) =>
-        strategies.forEach((strategy) => strategy.stop())
-      )
-      this.safetyMap.forEach(({ mechanisms }) => mechanisms.forEach((mechanism) => mechanism()))
-      contentProgressObserver.stop()
-      this.retry.stop()
-      this.context.stop()
-      await this.database.write(() => this.database.unsafeResetDatabase())
+
+      const clear = (force = false) => {
+        if (force && this.destroyDatabase && database.adapter.dbName && database.adapter.underlyingAdapter) {
+          return this.destroyDatabase(database.adapter.dbName, database.adapter.underlyingAdapter)
+        } else {
+          return database.write(() => database.unsafeResetDatabase())
+        }
+      }
+
+      try {
+        this.runScope.abort()
+        this.strategyMap.forEach(({ strategies }) => strategies.forEach((strategy) => strategy.stop()))
+        effectTeardowns.forEach((teardown) => teardown())
+        this.retry.stop()
+        this.context.stop()
+
+        contentProgressObserver.stop()
+      } catch (error) {
+        // capture, but don't rethrow
+        this.telemetry.capture(error)
+      }
+
+      try {
+        return clear(force);
+      } catch (error) {
+        if (!force) {
+          return clear(true);
+        }
+        throw error
+      }
     }
+
     return teardown
   }
 

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

@@ -53,6 +53,9 @@ export default class ContentProgress extends BaseModel<{
   get resume_time_seconds() {
     return (this._getRaw('resume_time_seconds') as number) || null
   }
+  get hide_from_progress_row() {
+    return this._getRaw('hide_from_progress_row') as boolean
+  }
 
   set content_id(value: number) {
     // unsigned int
@@ -87,5 +90,8 @@ export default class ContentProgress extends BaseModel<{
     throwIfNotNullableNumber(value)
     this._setRaw('resume_time_seconds', value !== null ? throwIfOutsideRange(value, 0, 65535) : value)
   }
+  set hide_from_progress_row(value: boolean) {
+    this._setRaw('hide_from_progress_row', value)
+  }
 
 }

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

@@ -89,13 +89,6 @@ export default class SyncRepository<TModel extends BaseModel> {
     )
   }
 
-  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, { skipPush = false } = {}) {
     return this.store.telemetry.trace(
       { name: `upsertOne:${this.store.model.table}`, op: 'upsert' },
@@ -213,7 +206,7 @@ export default class SyncRepository<TModel extends BaseModel> {
     const result: SyncReadDTO<TModel, T> = {
       data,
       status: pull?.ok ? 'fresh' : 'stale',
-      pullStatus: pull?.ok ? 'success' : 'failure',
+      pullStatus: pull ? (pull.ok ? 'success' : 'failure') : null,
       lastFetchToken: fetchToken,
     }
     return result

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

@@ -62,6 +62,8 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
       Q.where('collection_type', COLLECTION_TYPE.SELF),
       Q.where('collection_id', COLLECTION_ID_SELF),
 
+      Q.where('hide_from_progress_row', false),
+
       Q.or(Q.where('state', STATE.STARTED), Q.where('state', STATE.COMPLETED)),
       Q.sortBy('updated_at', 'desc'),
     ]
@@ -133,7 +135,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     }
   }
 
-  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number, {skipPush = false} = {}) {
+  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number, {skipPush = false, hideFromProgressRow = false} = {}) {
     const id = ProgressRepository.generateId(contentId, collection)
 
     const result = this.upsertOne(id, (r) => {
@@ -146,6 +148,8 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
       if (typeof resumeTime != 'undefined') {
         r.resume_time_seconds = Math.floor(resumeTime)
       }
+
+      r.hide_from_progress_row = hideFromProgressRow
     }, { skipPush })
 
     // Emit event AFTER database write completes
@@ -176,7 +180,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
   recordProgressMany(
     contentProgresses: Record<string, number>, // Accept plain object
     collection: CollectionParameter | null,
-    { tentative = true, skipPush = false }: { tentative?: boolean; skipPush?: boolean } = {}
+    { tentative = true, skipPush = false, hideFromProgressRow = false }: { tentative?: boolean; skipPush?: boolean; hideFromProgressRow?: boolean } = {}
   ) {
 
     const data = Object.fromEntries(
@@ -188,6 +192,8 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
           r.collection_id = collection?.id ?? COLLECTION_ID_SELF
 
           r.progress_percent = progressPct
+
+          r.hide_from_progress_row = hideFromProgressRow
         },
       ])
     )

package/src/services/sync/retry.ts

@@ -1,5 +1,5 @@
 import SyncContext from "./context"
-import { SyncResponse } from "./fetch"
+import { SyncResponse, SyncPushResponse } from "./fetch"
 import { SyncTelemetry, Span, StartSpanOptions } from "./telemetry/index"
 
 export default class SyncRetry {
@@ -32,7 +32,7 @@ export default class SyncRetry {
    * 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 | void>) {
+  async request<T extends SyncResponse>(spanOpts: StartSpanOptions, syncFn: (span: Span) => Promise<T>) {
     let attempt = 0
 
     while (true) {
@@ -47,7 +47,7 @@ export default class SyncRetry {
       const result = await this.telemetry.trace(spanOptions, span => {
         if (!this.context.connectivity.getValue()) {
           this.telemetry.debug('[Retry] No connectivity - skipping')
-          return { ok: false } as T
+          return { ok: false, failureType: 'fetch', isRetryable: false } as T
         }
 
         return syncFn(span)
@@ -55,7 +55,7 @@ export default class SyncRetry {
 
       if (!result) return result
 
-      if (result.ok) {
+      if (result.ok === true) {
         this.resetBackoff()
         return result
       } else {

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

@@ -26,6 +26,7 @@ const contentProgressTable = tableSchema({
     { name: 'state', type: 'string', isIndexed: true },
     { name: 'progress_percent', type: 'number' },
     { name: 'resume_time_seconds', type: 'number', isOptional: true },
+    { name: 'hide_from_progress_row', type: 'boolean'},
     { name: 'created_at', type: 'number' },
     { name: 'updated_at', type: 'number', isIndexed: true }
   ]

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

@@ -1,7 +1,7 @@
 import { Database, Q, type Collection, type RecordId } from '@nozbe/watermelondb'
 import { RawSerializer, ModelSerializer } from '../serializers'
 import { ModelClass, SyncToken, SyncEntry,  SyncContext, EpochMs } from '..'
-import { SyncPullResponse, SyncPushResponse, SyncPushFailureResponse, PushPayload } from '../fetch'
+import { SyncPullResponse, SyncPushResponse, SyncPullFetchFailureResponse, PushPayload, SyncStorePushResultSuccess, SyncStorePushResultFailure } from '../fetch'
 import type SyncRetry from '../retry'
 import type SyncRunScope from '../run-scope'
 import EventEmitter from '../utils/event-emitter'
@@ -29,7 +29,7 @@ type SyncPush = (
   signal: AbortSignal
 ) => Promise<SyncPushResponse>
 
-export type SyncStoreConfig<TModel extends BaseModel> = {
+export type SyncStoreConfig<TModel extends BaseModel = BaseModel> = {
   model: ModelClass<TModel>
   comparator?: TModel extends BaseModel ? SyncResolverComparator<TModel> : SyncResolverComparator
   pull: SyncPull
@@ -122,6 +122,17 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     }, { table: this.model.table, reason })
   }
 
+  async requestPush(reason: string) {
+    inBoundary(ctx => {
+      this.telemetry.trace(
+        { name: `sync:${this.model.table}`, op: 'push', attributes: ctx },
+        async span => {
+          await this.pushUnsyncedWithRetry(span)
+        }
+      )
+    }, { table: this.model.table, reason })
+  }
+
   async getLastFetchToken() {
     return (await this.db.localStorage.get<SyncToken | null>(this.lastFetchTokenKey)) ?? null
   }
@@ -210,31 +221,6 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     })
   }
 
-  async upsertOneRemote(id: RecordId, builder: (record: TModel) => void, span?: Span) {
-    return await this.runScope.abortable(async () => {
-      let record: TModel
-      const existing = await this.queryMaybeDeletedRecords(Q.where('id', id)).then(r => r[0] || null)
-
-      if (existing) {
-        existing._isEditing = true
-        builder(existing)
-        existing._isEditing = false
-        record = existing
-      } else {
-        const attrs = new this.model(this.collection, { id })
-        attrs._isEditing = true
-        builder(attrs)
-        attrs._isEditing = false
-        record = this.collection.disposableFromDirtyRaw(attrs._raw)
-      }
-
-      return await this.pushCoalescer.push(
-        [record],
-        () => this.executePush([record], span)
-      )
-    })
-  }
-
   async upsertSome(builders: Record<RecordId, (record: TModel) => void>, span?: Span, { skipPush = false } = {}) {
     if (Object.keys(builders).length === 0) return []
 
@@ -501,9 +487,11 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
               const currentRecords = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(recordIds)))
               const recordsToPush = currentRecords.filter(r => r._raw.updated_at <= (updatedAtMap.get(r.id) || 0))
 
-              if (recordsToPush.length) {
-                return this.executePush(recordsToPush, span)
+              if (!recordsToPush.length) {
+                return { ok: true, results: [] }
               }
+
+              return this.executePush(recordsToPush, span)
             }
           )
         })
@@ -514,7 +502,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   private async executePull(span?: Span) {
     if (!this.context.connectivity.getValue()) {
       this.telemetry.debug('[Retry] No connectivity - skipping')
-      return { ok: false } as SyncPushFailureResponse
+      return { ok: false, failureType: 'fetch', isRetryable: false } as SyncPullFetchFailureResponse
     }
 
     return this.telemetry.trace(
@@ -570,7 +558,22 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
         )
 
         if (response.ok) {
-          const successfulResults = response.results.filter((result) => result.type === 'success')
+          const [failedResults, successfulResults] = response.results.reduce((acc, result) => {
+            if (result.type === 'success') {
+              acc[1].push(result)
+            } else {
+              acc[0].push(result)
+            }
+            return acc
+          }, [[], []] as [SyncStorePushResultFailure[], SyncStorePushResultSuccess[]])
+
+          if (failedResults.length) {
+            this.telemetry.warn(
+              `[store:${this.model.table}] Push completed with failed records`,
+              { results: failedResults }
+            )
+          }
+
           const successfulEntries = successfulResults.map((result) => result.entry)
           await this.writeEntries(successfulEntries, false, pushSpan)
 

package/src/services/sync/store/push-coalescer.ts

@@ -4,7 +4,7 @@ import { EpochMs } from ".."
 import { SyncPushResponse } from "../fetch"
 
 type PushIntent = {
-  promise: Promise<void | SyncPushResponse>
+  promise: Promise<SyncPushResponse>
   records: {
     id: RecordId
     updatedAt: EpochMs
@@ -18,7 +18,7 @@ export default class PushCoalescer {
     this.intents = []
   }
 
-  push(records: BaseModel[], pusher: (records: BaseModel[]) => Promise<void | SyncPushResponse>) {
+  push(records: BaseModel[], pusher: (records: BaseModel[]) => Promise<SyncPushResponse>) {
     const found = this.find(records)
 
     if (found) {
@@ -28,7 +28,7 @@ export default class PushCoalescer {
     return this.add(pusher(records), records)
   }
 
-  private add(promise: Promise<void | SyncPushResponse>, records: BaseModel[]) {
+  private add(promise: Promise<SyncPushResponse>, records: BaseModel[]) {
     const intent = {
       promise,
       records: records.map(record => ({