refactor: application dependency management (#2363)

packages/snjs/lib/Services/Sync/Account/Operation.ts

@@ -2,7 +2,7 @@ import { ServerSyncPushContextualPayload } from '@standardnotes/models'
 import { arrayByDifference, nonSecureRandomIdentifier, subtractFromArray } from '@standardnotes/utils'
 import { ServerSyncResponse } from '@Lib/Services/Sync/Account/Response'
 import { ResponseSignalReceiver, SyncSignal } from '@Lib/Services/Sync/Signals'
-import { SNApiService } from '../../Api/ApiService'
+import { LegacyApiService } from '../../Api/ApiService'
 
 export const SyncUpDownLimit = 150
 
@@ -23,7 +23,7 @@ export class AccountSyncOperation {
   constructor(
     public readonly payloads: ServerSyncPushContextualPayload[],
     private receiver: ResponseSignalReceiver<ServerSyncResponse>,
-    private apiService: SNApiService,
+    private apiService: LegacyApiService,
     public readonly options: {
       syncToken?: string
       paginationToken?: string

packages/snjs/lib/Services/Sync/SyncClientInterface.ts

@@ -1,14 +0,0 @@
-import { SyncOpStatus } from './SyncOpStatus'
-import { AbstractService, SyncEvent, SyncOptions } from '@standardnotes/services'
-
-export interface SyncClientInterface extends AbstractService<SyncEvent> {
-  setLaunchPriorityUuids(launchPriorityUuids: string[]): void
-  sync(options?: Partial<SyncOptions>): Promise<unknown>
-  isOutOfSync(): boolean
-  getLastSyncDate(): Date | undefined
-  getSyncStatus(): SyncOpStatus
-  lockSyncing(): void
-  unlockSyncing(): void
-
-  completedOnlineDownloadFirstSync: boolean
-}

packages/snjs/lib/Services/Sync/SyncOpStatus.ts

@@ -1,125 +0,0 @@
-import { SyncEvent, SyncEventReceiver } from '@standardnotes/services'
-
-const HEALTHY_SYNC_DURATION_THRESHOLD_S = 5
-const TIMING_MONITOR_POLL_FREQUENCY_MS = 500
-
-export class SyncOpStatus {
-  error?: any
-  private interval: any
-  private receiver: SyncEventReceiver
-  private completedUpload = 0
-  private totalUpload = 0
-  private downloaded = 0
-  private databaseLoadCurrent = 0
-  private databaseLoadTotal = 0
-  private databaseLoadDone = false
-  private syncing = false
-  private syncStart!: Date
-  private timingMonitor?: any
-
-  constructor(interval: any, receiver: SyncEventReceiver) {
-    this.interval = interval
-    this.receiver = receiver
-  }
-
-  public deinit() {
-    this.stopTimingMonitor()
-  }
-
-  public setUploadStatus(completed: number, total: number) {
-    this.completedUpload = completed
-    this.totalUpload = total
-    this.receiver(SyncEvent.StatusChanged)
-  }
-
-  public setDownloadStatus(downloaded: number) {
-    this.downloaded += downloaded
-    this.receiver(SyncEvent.StatusChanged)
-  }
-
-  public setDatabaseLoadStatus(current: number, total: number, done: boolean) {
-    this.databaseLoadCurrent = current
-    this.databaseLoadTotal = total
-    this.databaseLoadDone = done
-    if (done) {
-      this.receiver(SyncEvent.LocalDataLoaded)
-    } else {
-      this.receiver(SyncEvent.LocalDataIncrementalLoad)
-    }
-  }
-
-  public getStats() {
-    return {
-      uploadCompletionCount: this.completedUpload,
-      uploadTotalCount: this.totalUpload,
-      downloadCount: this.downloaded,
-      localDataDone: this.databaseLoadDone,
-      localDataCurrent: this.databaseLoadCurrent,
-      localDataTotal: this.databaseLoadTotal,
-    }
-  }
-
-  public setDidBegin() {
-    this.syncing = true
-    this.syncStart = new Date()
-  }
-
-  public setDidEnd() {
-    this.syncing = false
-  }
-
-  get syncInProgress() {
-    return this.syncing === true
-  }
-
-  get secondsSinceSyncStart() {
-    return (new Date().getTime() - this.syncStart.getTime()) / 1000
-  }
-
-  /**
-   * Notifies receiver if current sync request is taking too long to complete.
-   */
-  startTimingMonitor(): void {
-    if (this.timingMonitor) {
-      this.stopTimingMonitor()
-    }
-
-    this.timingMonitor = this.interval(() => {
-      if (this.secondsSinceSyncStart > HEALTHY_SYNC_DURATION_THRESHOLD_S) {
-        this.receiver(SyncEvent.SyncTakingTooLong)
-        this.stopTimingMonitor()
-      }
-    }, TIMING_MONITOR_POLL_FREQUENCY_MS)
-  }
-
-  stopTimingMonitor(): void {
-    if (Object.prototype.hasOwnProperty.call(this.interval, 'cancel')) {
-      this.interval.cancel(this.timingMonitor)
-    } else {
-      clearInterval(this.timingMonitor)
-    }
-    this.timingMonitor = null
-  }
-
-  hasError(): boolean {
-    return !!this.error
-  }
-
-  setError(error: any): void {
-    this.error = error
-  }
-
-  clearError() {
-    this.error = null
-  }
-
-  reset() {
-    this.downloaded = 0
-    this.completedUpload = 0
-    this.totalUpload = 0
-    this.syncing = false
-    this.error = null
-    this.stopTimingMonitor()
-    this.receiver(SyncEvent.StatusChanged)
-  }
-}

packages/snjs/lib/Services/Sync/SyncService.ts

@@ -13,14 +13,12 @@ import {
 import { ItemManager } from '@Lib/Services/Items/ItemManager'
 import { OfflineSyncOperation } from '@Lib/Services/Sync/Offline/Operation'
 import { PayloadManager } from '../Payloads/PayloadManager'
-import { SNApiService } from '../Api/ApiService'
-import { SNHistoryManager } from '../History/HistoryManager'
+import { LegacyApiService } from '../Api/ApiService'
+import { HistoryManager } from '../History/HistoryManager'
 import { SNLog } from '@Lib/Log'
-import { SNSessionManager } from '../Session/SessionManager'
+import { SessionManager } from '../Session/SessionManager'
 import { DiskStorageService } from '../Storage/DiskStorageService'
-import { SyncClientInterface } from './SyncClientInterface'
 import { SyncPromise } from './Types'
-import { SyncOpStatus } from '@Lib/Services/Sync/SyncOpStatus'
 import { ServerSyncResponse } from '@Lib/Services/Sync/Account/Response'
 import { ServerSyncResponseResolver } from '@Lib/Services/Sync/Account/ResponseResolver'
 import { SyncSignal, SyncStats } from '@Lib/Services/Sync/Signals'
@@ -84,6 +82,7 @@ import {
   SyncEventReceivedRemoteSharedVaultsData,
   SyncEventReceivedUserEventsData,
   SyncEventReceivedAsymmetricMessagesData,
+  SyncOpStatus,
 } from '@standardnotes/services'
 import { OfflineSyncResponse } from './Offline/Response'
 import {
@@ -121,9 +120,9 @@ const ContentTypeLocalLoadPriorty = [
  * After each sync request, any changes made or retrieved are also persisted locally.
  * The sync service largely does not perform any task unless it is called upon.
  */
-export class SNSyncService
+export class SyncService
   extends AbstractService<SyncEvent>
-  implements SyncServiceInterface, InternalEventHandlerInterface, SyncClientInterface
+  implements SyncServiceInterface, InternalEventHandlerInterface
 {
   private dirtyIndexAtLastPresyncSave?: number
   private lastSyncDate?: Date
@@ -152,12 +151,12 @@ export class SNSyncService
 
   constructor(
     private itemManager: ItemManager,
-    private sessionManager: SNSessionManager,
+    private sessionManager: SessionManager,
     private encryptionService: EncryptionService,
     private storageService: DiskStorageService,
     private payloadManager: PayloadManager,
-    private apiService: SNApiService,
-    private historyService: SNHistoryManager,
+    private apiService: LegacyApiService,
+    private historyService: HistoryManager,
     private device: DeviceInterface,
     private identifier: string,
     private readonly options: ApplicationSyncOptions,
@@ -968,25 +967,25 @@ export class SNSyncService
 
     const historyMap = this.historyService.getHistoryMapCopy()
 
-    if (response.userEvents) {
+    if (response.userEvents && response.userEvents.length > 0) {
       await this.notifyEventSync(SyncEvent.ReceivedUserEvents, response.userEvents as SyncEventReceivedUserEventsData)
     }
 
-    if (response.asymmetricMessages) {
+    if (response.asymmetricMessages && response.asymmetricMessages.length > 0) {
       await this.notifyEventSync(
         SyncEvent.ReceivedAsymmetricMessages,
         response.asymmetricMessages as SyncEventReceivedAsymmetricMessagesData,
       )
     }
 
-    if (response.vaults) {
+    if (response.vaults && response.vaults.length > 0) {
       await this.notifyEventSync(
         SyncEvent.ReceivedRemoteSharedVaults,
         response.vaults as SyncEventReceivedRemoteSharedVaultsData,
       )
     }
 
-    if (response.vaultInvites) {
+    if (response.vaultInvites && response.vaultInvites.length > 0) {
       await this.notifyEventSync(
         SyncEvent.ReceivedSharedVaultInvites,
         response.vaultInvites as SyncEventReceivedSharedVaultInvitesData,

packages/snjs/lib/Services/Sync/index.ts

@@ -1,7 +1,5 @@
 export * from './SyncService'
 export * from './Types'
-export * from './SyncOpStatus'
-export * from './SyncClientInterface'
 export * from './Account/Operation'
 export * from './Account/ResponseResolver'
 export * from './Offline/Operation'