feat: add snjs package

2022-07-06 14:04:18 +02:00
parent 321a055bae
commit 0e40469e2f
296 changed files with 46109 additions and 187 deletions
--- a/packages/snjs/lib/Services/Mutator/MutatorClientInterface.ts
+++ b/packages/snjs/lib/Services/Mutator/MutatorClientInterface.ts
@@ -0,0 +1,183 @@
+import { ContentType } from '@standardnotes/common'
+import { ChallengeReason, SyncOptions } from '@standardnotes/services'
+import { TransactionalMutation } from '../Items'
+import * as Models from '@standardnotes/models'
+import { ClientDisplayableError } from '@standardnotes/responses'
+import { BackupFile } from '@standardnotes/encryption'
+
+export interface MutatorClientInterface {
+  /**
+   * Inserts the input item by its payload properties, and marks the item as dirty.
+   * A sync is not performed after an item is inserted. This must be handled by the caller.
+   */
+  insertItem(item: Models.DecryptedItemInterface): Promise<Models.DecryptedItemInterface>
+
+  /**
+   * Mutates a pre-existing item, marks it as dirty, and syncs it
+   */
+  changeAndSaveItem<M extends Models.DecryptedItemMutator = Models.DecryptedItemMutator>(
+    itemToLookupUuidFor: Models.DecryptedItemInterface,
+    mutate: (mutator: M) => void,
+    updateTimestamps?: boolean,
+    emitSource?: Models.PayloadEmitSource,
+    syncOptions?: SyncOptions,
+  ): Promise<Models.DecryptedItemInterface | undefined>
+
+  /**
+   * Mutates pre-existing items, marks them as dirty, and syncs
+   */
+  changeAndSaveItems<M extends Models.DecryptedItemMutator = Models.DecryptedItemMutator>(
+    itemsToLookupUuidsFor: Models.DecryptedItemInterface[],
+    mutate: (mutator: M) => void,
+    updateTimestamps?: boolean,
+    emitSource?: Models.PayloadEmitSource,
+    syncOptions?: SyncOptions,
+  ): Promise<void>
+
+  /**
+   * Mutates a pre-existing item and marks it as dirty. Does not sync changes.
+   */
+  changeItem<M extends Models.DecryptedItemMutator>(
+    itemToLookupUuidFor: Models.DecryptedItemInterface,
+    mutate: (mutator: M) => void,
+    updateTimestamps?: boolean,
+  ): Promise<Models.DecryptedItemInterface | undefined>
+
+  /**
+   * Mutates a pre-existing items and marks them as dirty. Does not sync changes.
+   */
+  changeItems<M extends Models.DecryptedItemMutator = Models.DecryptedItemMutator>(
+    itemsToLookupUuidsFor: Models.DecryptedItemInterface[],
+    mutate: (mutator: M) => void,
+    updateTimestamps?: boolean,
+  ): Promise<(Models.DecryptedItemInterface | undefined)[]>
+
+  /**
+   * Run unique mutations per each item in the array, then only propagate all changes
+   * once all mutations have been run. This differs from `changeItems` in that changeItems
+   * runs the same mutation on all items.
+   */
+  runTransactionalMutations(
+    transactions: TransactionalMutation[],
+    emitSource?: Models.PayloadEmitSource,
+    payloadSourceKey?: string,
+  ): Promise<(Models.DecryptedItemInterface | undefined)[]>
+
+  runTransactionalMutation(
+    transaction: TransactionalMutation,
+    emitSource?: Models.PayloadEmitSource,
+    payloadSourceKey?: string,
+  ): Promise<Models.DecryptedItemInterface | undefined>
+
+  protectItems<
+    _M extends Models.DecryptedItemMutator<Models.ItemContent>,
+    I extends Models.DecryptedItemInterface<Models.ItemContent>,
+  >(
+    items: I[],
+  ): Promise<I[]>
+
+  unprotectItems<
+    _M extends Models.DecryptedItemMutator<Models.ItemContent>,
+    I extends Models.DecryptedItemInterface<Models.ItemContent>,
+  >(
+    items: I[],
+    reason: ChallengeReason,
+  ): Promise<I[] | undefined>
+
+  protectNote(note: Models.SNNote): Promise<Models.SNNote>
+
+  unprotectNote(note: Models.SNNote): Promise<Models.SNNote | undefined>
+
+  protectNotes(notes: Models.SNNote[]): Promise<Models.SNNote[]>
+
+  unprotectNotes(notes: Models.SNNote[]): Promise<Models.SNNote[]>
+
+  protectFile(file: Models.FileItem): Promise<Models.FileItem>
+
+  unprotectFile(file: Models.FileItem): Promise<Models.FileItem | undefined>
+
+  /**
+   * Takes the values of the input item and emits it onto global state.
+   */
+  mergeItem(
+    item: Models.DecryptedItemInterface,
+    source: Models.PayloadEmitSource,
+  ): Promise<Models.DecryptedItemInterface>
+
+  /**
+   * Creates an unmanaged item that can be added later.
+   */
+  createTemplateItem<
+    C extends Models.ItemContent = Models.ItemContent,
+    I extends Models.DecryptedItemInterface<C> = Models.DecryptedItemInterface<C>,
+  >(
+    contentType: ContentType,
+    content?: C,
+  ): I
+
+  /**
+   * @param isUserModified  Whether to change the modified date the user
+   * sees of the item.
+   */
+  setItemNeedsSync(
+    item: Models.DecryptedItemInterface,
+    isUserModified?: boolean,
+  ): Promise<Models.DecryptedItemInterface | undefined>
+
+  setItemsNeedsSync(items: Models.DecryptedItemInterface[]): Promise<(Models.DecryptedItemInterface | undefined)[]>
+
+  deleteItem(item: Models.DecryptedItemInterface | Models.EncryptedItemInterface): Promise<void>
+
+  deleteItems(items: (Models.DecryptedItemInterface | Models.EncryptedItemInterface)[]): Promise<void>
+
+  emptyTrash(): Promise<void>
+
+  duplicateItem<T extends Models.DecryptedItemInterface>(item: T, additionalContent?: Partial<T['content']>): Promise<T>
+
+  /**
+   * Migrates any tags containing a '.' character to sa chema-based heirarchy, removing
+   * the dot from the tag's title.
+   */
+  migrateTagsToFolders(): Promise<unknown>
+
+  /**
+   * Establishes a hierarchical relationship between two tags.
+   */
+  setTagParent(parentTag: Models.SNTag, childTag: Models.SNTag): Promise<void>
+
+  /**
+   * Remove the tag parent.
+   */
+  unsetTagParent(childTag: Models.SNTag): Promise<void>
+
+  findOrCreateTag(title: string): Promise<Models.SNTag>
+
+  /** Creates and returns the tag but does not run sync. Callers must perform sync. */
+  createTagOrSmartView(title: string): Promise<Models.SNTag | Models.SmartView>
+
+  /**
+   * Activates or deactivates a component, depending on its
+   * current state, and syncs.
+   */
+  toggleComponent(component: Models.SNComponent): Promise<void>
+
+  toggleTheme(theme: Models.SNComponent): Promise<void>
+
+  /**
+   * @returns
+   * .affectedItems: Items that were either created or dirtied by this import
+   * .errorCount: The number of items that were not imported due to failure to decrypt.
+   */
+  importData(
+    data: BackupFile,
+    awaitSync?: boolean,
+  ): Promise<
+    | {
+        affectedItems: Models.DecryptedItemInterface[]
+        errorCount: number
+      }
+    | {
+        error: ClientDisplayableError
+      }
+  >
+}
--- a/packages/snjs/lib/Services/Mutator/MutatorService.spec.ts
+++ b/packages/snjs/lib/Services/Mutator/MutatorService.spec.ts
@@ -0,0 +1,83 @@
+import { SNHistoryManager } from './../History/HistoryManager'
+import { NoteContent, SNNote, FillItemContent, DecryptedPayload, PayloadTimestampDefaults } from '@standardnotes/models'
+import { EncryptionService } from '@standardnotes/encryption'
+import { ContentType } from '@standardnotes/common'
+import { InternalEventBusInterface } from '@standardnotes/services'
+import {
+  ChallengeService,
+  MutatorService,
+  PayloadManager,
+  SNComponentManager,
+  SNProtectionService,
+  ItemManager,
+  SNSyncService,
+} from '../'
+import { UuidGenerator } from '@standardnotes/utils'
+
+const setupRandomUuid = () => {
+  UuidGenerator.SetGenerator(() => String(Math.random()))
+}
+
+describe('mutator service', () => {
+  let mutatorService: MutatorService
+  let payloadManager: PayloadManager
+  let itemManager: ItemManager
+  let syncService: SNSyncService
+  let protectionService: SNProtectionService
+  let protocolService: EncryptionService
+  let challengeService: ChallengeService
+  let componentManager: SNComponentManager
+  let historyService: SNHistoryManager
+
+  let internalEventBus: InternalEventBusInterface
+
+  beforeEach(() => {
+    setupRandomUuid()
+    internalEventBus = {} as jest.Mocked<InternalEventBusInterface>
+    internalEventBus.publish = jest.fn()
+
+    payloadManager = new PayloadManager(internalEventBus)
+    itemManager = new ItemManager(payloadManager, { supportsFileNavigation: false }, internalEventBus)
+
+    mutatorService = new MutatorService(
+      itemManager,
+      syncService,
+      protectionService,
+      protocolService,
+      payloadManager,
+      challengeService,
+      componentManager,
+      historyService,
+      internalEventBus,
+    )
+  })
+
+  const insertNote = (title: string) => {
+    const note = new SNNote(
+      new DecryptedPayload({
+        uuid: String(Math.random()),
+        content_type: ContentType.Note,
+        content: FillItemContent<NoteContent>({
+          title: title,
+        }),
+        ...PayloadTimestampDefaults(),
+      }),
+    )
+    return mutatorService.insertItem(note)
+  }
+
+  describe('note modifications', () => {
+    it('pinning should not update timestamps', async () => {
+      const note = await insertNote('hello')
+      const pinnedNote = await mutatorService.changeItem(
+        note,
+        (mutator) => {
+          mutator.pinned = true
+        },
+        false,
+      )
+
+      expect(note.userModifiedDate).toEqual(pinnedNote?.userModifiedDate)
+    })
+  })
+})
--- a/packages/snjs/lib/Services/Mutator/MutatorService.ts
+++ b/packages/snjs/lib/Services/Mutator/MutatorService.ts
@@ -0,0 +1,386 @@
+import { SNHistoryManager } from './../History/HistoryManager'
+import {
+  AbstractService,
+  InternalEventBusInterface,
+  SyncOptions,
+  ChallengeValidation,
+  ChallengePrompt,
+  ChallengeReason,
+} from '@standardnotes/services'
+import { BackupFile, EncryptionProvider } from '@standardnotes/encryption'
+import { ClientDisplayableError } from '@standardnotes/responses'
+import { ContentType, ProtocolVersion, compareVersions } from '@standardnotes/common'
+import { ItemManager, TransactionalMutation } from '../Items'
+import { MutatorClientInterface } from './MutatorClientInterface'
+import { PayloadManager } from '../Payloads/PayloadManager'
+import { SNComponentManager } from '../ComponentManager/ComponentManager'
+import { SNProtectionService } from '../Protection/ProtectionService'
+import { SNSyncService } from '../Sync'
+import { Strings } from '../../Strings'
+import { TagsToFoldersMigrationApplicator } from '@Lib/Migrations/Applicators/TagsToFolders'
+import * as Models from '@standardnotes/models'
+import { Challenge, ChallengeService } from '../Challenge'
+import {
+  CreateDecryptedBackupFileContextPayload,
+  CreateEncryptedBackupFileContextPayload,
+  isDecryptedPayload,
+  isEncryptedTransferPayload,
+} from '@standardnotes/models'
+
+export class MutatorService extends AbstractService implements MutatorClientInterface {
+  constructor(
+    private itemManager: ItemManager,
+    private syncService: SNSyncService,
+    private protectionService: SNProtectionService,
+    private encryption: EncryptionProvider,
+    private payloadManager: PayloadManager,
+    private challengeService: ChallengeService,
+    private componentManager: SNComponentManager,
+    private historyService: SNHistoryManager,
+    protected override internalEventBus: InternalEventBusInterface,
+  ) {
+    super(internalEventBus)
+  }
+
+  override deinit() {
+    super.deinit()
+    ;(this.itemManager as unknown) = undefined
+    ;(this.syncService as unknown) = undefined
+    ;(this.protectionService as unknown) = undefined
+    ;(this.encryption as unknown) = undefined
+    ;(this.payloadManager as unknown) = undefined
+    ;(this.challengeService as unknown) = undefined
+    ;(this.componentManager as unknown) = undefined
+    ;(this.historyService as unknown) = undefined
+  }
+
+  public async insertItem(item: Models.DecryptedItemInterface): Promise<Models.DecryptedItemInterface> {
+    const mutator = Models.CreateDecryptedMutatorForItem(item, Models.MutationType.UpdateUserTimestamps)
+    const dirtiedPayload = mutator.getResult()
+    const insertedItem = await this.itemManager.emitItemFromPayload(
+      dirtiedPayload,
+      Models.PayloadEmitSource.LocalInserted,
+    )
+    return insertedItem
+  }
+
+  public async changeAndSaveItem<M extends Models.DecryptedItemMutator = Models.DecryptedItemMutator>(
+    itemToLookupUuidFor: Models.DecryptedItemInterface,
+    mutate: (mutator: M) => void,
+    updateTimestamps = true,
+    emitSource?: Models.PayloadEmitSource,
+    syncOptions?: SyncOptions,
+  ): Promise<Models.DecryptedItemInterface | undefined> {
+    await this.itemManager.changeItems(
+      [itemToLookupUuidFor],
+      mutate,
+      updateTimestamps ? Models.MutationType.UpdateUserTimestamps : Models.MutationType.NoUpdateUserTimestamps,
+      emitSource,
+    )
+    await this.syncService.sync(syncOptions)
+    return this.itemManager.findItem(itemToLookupUuidFor.uuid)
+  }
+
+  public async changeAndSaveItems<M extends Models.DecryptedItemMutator = Models.DecryptedItemMutator>(
+    itemsToLookupUuidsFor: Models.DecryptedItemInterface[],
+    mutate: (mutator: M) => void,
+    updateTimestamps = true,
+    emitSource?: Models.PayloadEmitSource,
+    syncOptions?: SyncOptions,
+  ): Promise<void> {
+    await this.itemManager.changeItems(
+      itemsToLookupUuidsFor,
+      mutate,
+      updateTimestamps ? Models.MutationType.UpdateUserTimestamps : Models.MutationType.NoUpdateUserTimestamps,
+      emitSource,
+    )
+    await this.syncService.sync(syncOptions)
+  }
+
+  public async changeItem<M extends Models.DecryptedItemMutator>(
+    itemToLookupUuidFor: Models.DecryptedItemInterface,
+    mutate: (mutator: M) => void,
+    updateTimestamps = true,
+  ): Promise<Models.DecryptedItemInterface | undefined> {
+    await this.itemManager.changeItems(
+      [itemToLookupUuidFor],
+      mutate,
+      updateTimestamps ? Models.MutationType.UpdateUserTimestamps : Models.MutationType.NoUpdateUserTimestamps,
+    )
+    return this.itemManager.findItem(itemToLookupUuidFor.uuid)
+  }
+
+  public async changeItems<M extends Models.DecryptedItemMutator = Models.DecryptedItemMutator>(
+    itemsToLookupUuidsFor: Models.DecryptedItemInterface[],
+    mutate: (mutator: M) => void,
+    updateTimestamps = true,
+  ): Promise<(Models.DecryptedItemInterface | undefined)[]> {
+    return this.itemManager.changeItems(
+      itemsToLookupUuidsFor,
+      mutate,
+      updateTimestamps ? Models.MutationType.UpdateUserTimestamps : Models.MutationType.NoUpdateUserTimestamps,
+    )
+  }
+
+  public async runTransactionalMutations(
+    transactions: TransactionalMutation[],
+    emitSource = Models.PayloadEmitSource.LocalChanged,
+    payloadSourceKey?: string,
+  ): Promise<(Models.DecryptedItemInterface | undefined)[]> {
+    return this.itemManager.runTransactionalMutations(transactions, emitSource, payloadSourceKey)
+  }
+
+  public async runTransactionalMutation(
+    transaction: TransactionalMutation,
+    emitSource = Models.PayloadEmitSource.LocalChanged,
+    payloadSourceKey?: string,
+  ): Promise<Models.DecryptedItemInterface | undefined> {
+    return this.itemManager.runTransactionalMutation(transaction, emitSource, payloadSourceKey)
+  }
+
+  async protectItems<M extends Models.DecryptedItemMutator, I extends Models.DecryptedItemInterface>(
+    items: I[],
+  ): Promise<I[]> {
+    const protectedItems = await this.itemManager.changeItems<M, I>(
+      items,
+      (mutator) => {
+        mutator.protected = true
+      },
+      Models.MutationType.NoUpdateUserTimestamps,
+    )
+
+    void this.syncService.sync()
+    return protectedItems
+  }
+
+  async unprotectItems<M extends Models.DecryptedItemMutator, I extends Models.DecryptedItemInterface>(
+    items: I[],
+    reason: ChallengeReason,
+  ): Promise<I[] | undefined> {
+    if (!(await this.protectionService.authorizeAction(reason))) {
+      return undefined
+    }
+
+    const unprotectedItems = await this.itemManager.changeItems<M, I>(
+      items,
+      (mutator) => {
+        mutator.protected = false
+      },
+      Models.MutationType.NoUpdateUserTimestamps,
+    )
+
+    void this.syncService.sync()
+    return unprotectedItems
+  }
+
+  public async protectNote(note: Models.SNNote): Promise<Models.SNNote> {
+    const result = await this.protectItems([note])
+    return result[0]
+  }
+
+  public async unprotectNote(note: Models.SNNote): Promise<Models.SNNote | undefined> {
+    const result = await this.unprotectItems([note], ChallengeReason.UnprotectNote)
+    return result ? result[0] : undefined
+  }
+
+  public async protectNotes(notes: Models.SNNote[]): Promise<Models.SNNote[]> {
+    return this.protectItems(notes)
+  }
+
+  public async unprotectNotes(notes: Models.SNNote[]): Promise<Models.SNNote[]> {
+    const results = await this.unprotectItems(notes, ChallengeReason.UnprotectNote)
+    return results || []
+  }
+
+  async protectFile(file: Models.FileItem): Promise<Models.FileItem> {
+    const result = await this.protectItems([file])
+    return result[0]
+  }
+
+  async unprotectFile(file: Models.FileItem): Promise<Models.FileItem | undefined> {
+    const result = await this.unprotectItems([file], ChallengeReason.UnprotectFile)
+    return result ? result[0] : undefined
+  }
+
+  public async mergeItem(
+    item: Models.DecryptedItemInterface,
+    source: Models.PayloadEmitSource,
+  ): Promise<Models.DecryptedItemInterface> {
+    return this.itemManager.emitItemFromPayload(item.payloadRepresentation(), source)
+  }
+
+  public createTemplateItem<
+    C extends Models.ItemContent = Models.ItemContent,
+    I extends Models.DecryptedItemInterface<C> = Models.DecryptedItemInterface<C>,
+  >(contentType: ContentType, content?: C): I {
+    return this.itemManager.createTemplateItem(contentType, content)
+  }
+
+  public async setItemNeedsSync(
+    item: Models.DecryptedItemInterface,
+    updateTimestamps = false,
+  ): Promise<Models.DecryptedItemInterface | undefined> {
+    return this.itemManager.setItemDirty(item, updateTimestamps)
+  }
+
+  public async setItemsNeedsSync(
+    items: Models.DecryptedItemInterface[],
+  ): Promise<(Models.DecryptedItemInterface | undefined)[]> {
+    return this.itemManager.setItemsDirty(items)
+  }
+
+  public async deleteItem(item: Models.DecryptedItemInterface | Models.EncryptedItemInterface): Promise<void> {
+    return this.deleteItems([item])
+  }
+
+  public async deleteItems(items: (Models.DecryptedItemInterface | Models.EncryptedItemInterface)[]): Promise<void> {
+    await this.itemManager.setItemsToBeDeleted(items)
+    await this.syncService.sync()
+  }
+
+  public async emptyTrash(): Promise<void> {
+    await this.itemManager.emptyTrash()
+    await this.syncService.sync()
+  }
+
+  public duplicateItem<T extends Models.DecryptedItemInterface>(
+    item: T,
+    additionalContent?: Partial<T['content']>,
+  ): Promise<T> {
+    const duplicate = this.itemManager.duplicateItem<T>(item, false, additionalContent)
+    void this.syncService.sync()
+    return duplicate
+  }
+
+  public async migrateTagsToFolders(): Promise<unknown> {
+    await TagsToFoldersMigrationApplicator.run(this.itemManager)
+    return this.syncService.sync()
+  }
+
+  public async setTagParent(parentTag: Models.SNTag, childTag: Models.SNTag): Promise<void> {
+    await this.itemManager.setTagParent(parentTag, childTag)
+  }
+
+  public async unsetTagParent(childTag: Models.SNTag): Promise<void> {
+    await this.itemManager.unsetTagParent(childTag)
+  }
+
+  public async findOrCreateTag(title: string): Promise<Models.SNTag> {
+    return this.itemManager.findOrCreateTagByTitle(title)
+  }
+
+  /** Creates and returns the tag but does not run sync. Callers must perform sync. */
+  public async createTagOrSmartView(title: string): Promise<Models.SNTag | Models.SmartView> {
+    return this.itemManager.createTagOrSmartView(title)
+  }
+
+  public async toggleComponent(component: Models.SNComponent): Promise<void> {
+    await this.componentManager.toggleComponent(component.uuid)
+    await this.syncService.sync()
+  }
+
+  public async toggleTheme(theme: Models.SNComponent): Promise<void> {
+    await this.componentManager.toggleTheme(theme.uuid)
+    await this.syncService.sync()
+  }
+
+  public async importData(
+    data: BackupFile,
+    awaitSync = false,
+  ): Promise<
+    | {
+        affectedItems: Models.DecryptedItemInterface[]
+        errorCount: number
+      }
+    | {
+        error: ClientDisplayableError
+      }
+  > {
+    if (data.version) {
+      /**
+       * Prior to 003 backup files did not have a version field so we cannot
+       * stop importing if there is no backup file version, only if there is
+       * an unsupported version.
+       */
+      const version = data.version as ProtocolVersion
+
+      const supportedVersions = this.encryption.supportedVersions()
+      if (!supportedVersions.includes(version)) {
+        return { error: new ClientDisplayableError(Strings.Info.UnsupportedBackupFileVersion) }
+      }
+
+      const userVersion = this.encryption.getUserVersion()
+      if (userVersion && compareVersions(version, userVersion) === 1) {
+        /** File was made with a greater version than the user's account */
+        return { error: new ClientDisplayableError(Strings.Info.BackupFileMoreRecentThanAccount) }
+      }
+    }
+
+    let password: string | undefined
+
+    if (data.auth_params || data.keyParams) {
+      /** Get import file password. */
+      const challenge = new Challenge(
+        [new ChallengePrompt(ChallengeValidation.None, Strings.Input.FileAccountPassword, undefined, true)],
+        ChallengeReason.DecryptEncryptedFile,
+        true,
+      )
+      const passwordResponse = await this.challengeService.promptForChallengeResponse(challenge)
+      if (passwordResponse == undefined) {
+        /** Challenge was canceled */
+        return { error: new ClientDisplayableError('Import aborted') }
+      }
+      this.challengeService.completeChallenge(challenge)
+      password = passwordResponse?.values[0].value as string
+    }
+
+    if (!(await this.protectionService.authorizeFileImport())) {
+      return { error: new ClientDisplayableError('Import aborted') }
+    }
+
+    data.items = data.items.map((item) => {
+      if (isEncryptedTransferPayload(item)) {
+        return CreateEncryptedBackupFileContextPayload(item)
+      } else {
+        return CreateDecryptedBackupFileContextPayload(item as Models.BackupFileDecryptedContextualPayload)
+      }
+    })
+
+    const decryptedPayloadsOrError = await this.encryption.decryptBackupFile(data, password)
+
+    if (decryptedPayloadsOrError instanceof ClientDisplayableError) {
+      return { error: decryptedPayloadsOrError }
+    }
+
+    const validPayloads = decryptedPayloadsOrError.filter(isDecryptedPayload).map((payload) => {
+      /* Don't want to activate any components during import process in
+       * case of exceptions breaking up the import proccess */
+      if (payload.content_type === ContentType.Component && (payload.content as Models.ComponentContent).active) {
+        const typedContent = payload as Models.DecryptedPayloadInterface<Models.ComponentContent>
+        return Models.CopyPayloadWithContentOverride(typedContent, {
+          active: false,
+        })
+      } else {
+        return payload
+      }
+    })
+
+    const affectedUuids = await this.payloadManager.importPayloads(
+      validPayloads,
+      this.historyService.getHistoryMapCopy(),
+    )
+
+    const promise = this.syncService.sync()
+
+    if (awaitSync) {
+      await promise
+    }
+
+    const affectedItems = this.itemManager.findItems(affectedUuids) as Models.DecryptedItemInterface[]
+
+    return {
+      affectedItems: affectedItems,
+      errorCount: decryptedPayloadsOrError.length - validPayloads.length,
+    }
+  }
+}
--- a/packages/snjs/lib/Services/Mutator/index.ts
+++ b/packages/snjs/lib/Services/Mutator/index.ts
@@ -0,0 +1,2 @@
+export * from './MutatorClientInterface'
+export * from './MutatorService'