chore(release): publish new version

- @standardnotes/home-server@1.15.48
 - @standardnotes/revisions-server@1.33.17
 - @standardnotes/syncing-server@1.95.14

packages/auth/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.141.8](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.141.7...@standardnotes/auth-server@1.141.8) (2023-09-12)
+
+### Bug Fixes
+
+* **auth:** add transition role only if the items transition has completed ([f055e52](https://github.com/standardnotes/server/commit/f055e52e06b6e93501abd340dfce214d5363bc30))
+* **auth:** remove the transition role constraint ([afe385a](https://github.com/standardnotes/server/commit/afe385aed4ba5ca53d8ef429ae4154f4ccf81419))
+* imports ([54113ab](https://github.com/standardnotes/server/commit/54113abe2a961720a3561e5ff3a0069046ea8d25))
+
 ## [1.141.7](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.141.6...@standardnotes/auth-server@1.141.7) (2023-09-12)
 
 ### Bug Fixes

packages/auth/bin/transition.ts

@@ -10,7 +10,6 @@ import { Env } from '../src/Bootstrap/Env'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
 import { DomainEventFactoryInterface } from '../src/Domain/Event/DomainEventFactoryInterface'
 import { UserRepositoryInterface } from '../src/Domain/User/UserRepositoryInterface'
-import { RoleName } from '@standardnotes/domain-core'
 import { TransitionStatusRepositoryInterface } from '../src/Domain/Transition/TransitionStatusRepositoryInterface'
 
 const inputArgs = process.argv.slice(2)
@@ -33,12 +32,6 @@ const requestTransition = async (
 
   let usersTriggered = 0
   for (const user of users) {
-    const roles = await user.roles
-    const userHasTransitionUserRole = roles.some((role) => role.name === RoleName.NAMES.TransitionUser) === true
-    if (userHasTransitionUserRole === true) {
-      continue
-    }
-
     const transitionRequestedEvent = domainEventFactory.createTransitionRequestedEvent({
       userUuid: user.uuid,
       type: 'items',

packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/auth-server",
-  "version": "1.141.7",
+  "version": "1.141.8",
   "engines": {
     "node": ">=18.0.0 <21.0.0"
   },

packages/auth/src/Domain/UseCase/UpdateTransitionStatus/UpdateTransitionStatus.spec.ts

@@ -39,6 +39,23 @@ describe('UpdateTransitionStatus', () => {
     )
   })
 
+  it('should remove transition status', async () => {
+    const useCase = createUseCase()
+
+    const result = await useCase.execute({
+      userUuid: '00000000-0000-0000-0000-000000000000',
+      status: 'FINISHED',
+      transitionType: 'revisions',
+    })
+
+    expect(result.isFailed()).toBeFalsy()
+    expect(transitionStatusRepository.removeStatus).toHaveBeenCalledWith(
+      '00000000-0000-0000-0000-000000000000',
+      'revisions',
+    )
+    expect(roleService.addRoleToUser).not.toHaveBeenCalled()
+  })
+
   it('should update transition status', async () => {
     const useCase = createUseCase()
 

packages/auth/src/Domain/UseCase/UpdateTransitionStatus/UpdateTransitionStatus.ts

@@ -19,7 +19,9 @@ export class UpdateTransitionStatus implements UseCaseInterface<void> {
     if (dto.status === 'FINISHED') {
       await this.transitionStatusRepository.removeStatus(dto.userUuid, dto.transitionType)
 
-      await this.roleService.addRoleToUser(userUuid, RoleName.create(RoleName.NAMES.TransitionUser).getValue())
+      if (dto.transitionType === 'items') {
+        await this.roleService.addRoleToUser(userUuid, RoleName.create(RoleName.NAMES.TransitionUser).getValue())
+      }
 
       return Result.ok()
     }

packages/home-server/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.15.48](https://github.com/standardnotes/server/compare/@standardnotes/home-server@1.15.47...@standardnotes/home-server@1.15.48) (2023-09-13)
+
+**Note:** Version bump only for package @standardnotes/home-server
+
+## [1.15.47](https://github.com/standardnotes/server/compare/@standardnotes/home-server@1.15.46...@standardnotes/home-server@1.15.47) (2023-09-13)
+
+**Note:** Version bump only for package @standardnotes/home-server
+
+## [1.15.46](https://github.com/standardnotes/server/compare/@standardnotes/home-server@1.15.45...@standardnotes/home-server@1.15.46) (2023-09-12)
+
+**Note:** Version bump only for package @standardnotes/home-server
+
 ## [1.15.45](https://github.com/standardnotes/server/compare/@standardnotes/home-server@1.15.44...@standardnotes/home-server@1.15.45) (2023-09-12)
 
 **Note:** Version bump only for package @standardnotes/home-server

packages/home-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/home-server",
-  "version": "1.15.45",
+  "version": "1.15.48",
   "engines": {
     "node": ">=18.0.0 <21.0.0"
   },

packages/revisions/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.33.17](https://github.com/standardnotes/server/compare/@standardnotes/revisions-server@1.33.16...@standardnotes/revisions-server@1.33.17) (2023-09-13)
+
+### Bug Fixes
+
+* setting status for already migrated users ([9be4c00](https://github.com/standardnotes/server/commit/9be4c002b755fea057489b6077b297162223aefe))
+
+## [1.33.16](https://github.com/standardnotes/server/compare/@standardnotes/revisions-server@1.33.15...@standardnotes/revisions-server@1.33.16) (2023-09-13)
+
+### Bug Fixes
+
+* cleanup only for 0 new items ([b1d88b1](https://github.com/standardnotes/server/commit/b1d88b15be78a48224963e337a222fb675ed2692))
+
+## [1.33.15](https://github.com/standardnotes/server/compare/@standardnotes/revisions-server@1.33.14...@standardnotes/revisions-server@1.33.15) (2023-09-12)
+
+### Bug Fixes
+
+* sync between primary and secondary database with diff ([fab5d18](https://github.com/standardnotes/server/commit/fab5d180645e0a6fa0c9c67205d44f27c8a65c8b))
+
 ## [1.33.14](https://github.com/standardnotes/server/compare/@standardnotes/revisions-server@1.33.13...@standardnotes/revisions-server@1.33.14) (2023-09-12)
 
 ### Bug Fixes

packages/revisions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/revisions-server",
-  "version": "1.33.14",
+  "version": "1.33.17",
   "engines": {
     "node": ">=18.0.0 <21.0.0"
   },

packages/revisions/src/Bootstrap/Container.ts

@@ -443,6 +443,7 @@ export class ContainerConfigLoader {
       .bind<TransitionStatusUpdatedEventHandler>(TYPES.Revisions_TransitionStatusUpdatedEventHandler)
       .toConstantValue(
         new TransitionStatusUpdatedEventHandler(
+          container.get<RevisionRepositoryInterface>(TYPES.Revisions_SQLRevisionRepository),
           container.get<TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser>(
             TYPES.Revisions_TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser,
           ),

packages/revisions/src/Domain/Handler/TransitionStatusUpdatedEventHandler.ts

@@ -6,9 +6,12 @@ import {
 import { Logger } from 'winston'
 import { DomainEventFactoryInterface } from '../Event/DomainEventFactoryInterface'
 import { TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser } from '../UseCase/Transition/TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser/TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser'
+import { Uuid } from '@standardnotes/domain-core'
+import { RevisionRepositoryInterface } from '../Revision/RevisionRepositoryInterface'
 
 export class TransitionStatusUpdatedEventHandler implements DomainEventHandlerInterface {
   constructor(
+    private primaryRevisionsRepository: RevisionRepositoryInterface,
     private transitionRevisionsFromPrimaryToSecondaryDatabaseForUser: TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser,
     private domainEventPublisher: DomainEventPublisherInterface,
     private domainEventFactory: DomainEventFactoryInterface,
@@ -29,6 +32,36 @@ export class TransitionStatusUpdatedEventHandler implements DomainEventHandlerIn
     }
 
     if (event.payload.status === 'STARTED' && event.payload.transitionType === 'revisions') {
+      const userUuidOrError = Uuid.create(event.payload.userUuid)
+      if (userUuidOrError.isFailed()) {
+        this.logger.error(
+          `Failed to transition revisions for user ${event.payload.userUuid}: ${userUuidOrError.getError()}`,
+        )
+        await this.domainEventPublisher.publish(
+          this.domainEventFactory.createTransitionStatusUpdatedEvent({
+            userUuid: event.payload.userUuid,
+            status: 'FAILED',
+            transitionType: 'revisions',
+          }),
+        )
+
+        return
+      }
+
+      if (await this.isAlreadyMigrated(userUuidOrError.getValue())) {
+        this.logger.info(`Revisions for user ${event.payload.userUuid} are already migrated`)
+
+        await this.domainEventPublisher.publish(
+          this.domainEventFactory.createTransitionStatusUpdatedEvent({
+            userUuid: event.payload.userUuid,
+            status: 'FINISHED',
+            transitionType: 'revisions',
+          }),
+        )
+
+        return
+      }
+
       await this.domainEventPublisher.publish(
         this.domainEventFactory.createTransitionStatusUpdatedEvent({
           userUuid: event.payload.userUuid,
@@ -66,4 +99,16 @@ export class TransitionStatusUpdatedEventHandler implements DomainEventHandlerIn
       return
     }
   }
+
+  private async isAlreadyMigrated(userUuid: Uuid): Promise<boolean> {
+    const totalRevisionsCountForUserInPrimary = await this.primaryRevisionsRepository.countByUserUuid(userUuid)
+
+    if (totalRevisionsCountForUserInPrimary > 0) {
+      this.logger.info(
+        `User ${userUuid.value} has ${totalRevisionsCountForUserInPrimary} revisions in primary database.`,
+      )
+    }
+
+    return totalRevisionsCountForUserInPrimary === 0
+  }
 }

packages/revisions/src/Domain/UseCase/Transition/TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser/TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser.ts

@@ -29,22 +29,23 @@ export class TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser implements
     }
     const userUuid = userUuidOrError.getValue()
 
-    if (await this.isAlreadyMigrated(userUuid)) {
-      this.logger.info(`Revisions for user ${userUuid.value} are already migrated`)
-
-      return Result.ok()
-    }
-
     let newRevisionsInSecondaryCount = 0
     if (await this.hasAlreadyDataInSecondaryDatabase(userUuid)) {
       const newRevisions = await this.getNewRevisionsCreatedInSecondaryDatabase(userUuid)
       for (const existingRevision of newRevisions.alreadyExistingInPrimary) {
+        this.logger.info(`Removing revision ${existingRevision.id.toString()} from secondary database`)
         await (this.secondRevisionsRepository as RevisionRepositoryInterface).removeOneByUuid(
           Uuid.create(existingRevision.id.toString()).getValue(),
           userUuid,
         )
       }
 
+      if (newRevisions.newRevisionsInSecondary.length > 0) {
+        this.logger.info(
+          `Found ${newRevisions.newRevisionsInSecondary.length} new revisions in secondary database for user ${userUuid.value}`,
+        )
+      }
+
       newRevisionsInSecondaryCount = newRevisions.newRevisionsInSecondary.length
     }
 
@@ -56,11 +57,13 @@ export class TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser implements
 
     const migrationResult = await this.migrateRevisionsForUser(userUuid)
     if (migrationResult.isFailed()) {
-      const cleanupResult = await this.deleteRevisionsForUser(userUuid, this.secondRevisionsRepository)
-      if (cleanupResult.isFailed()) {
-        this.logger.error(
-          `Failed to clean up secondary database revisions for user ${userUuid.value}: ${cleanupResult.getError()}`,
-        )
+      if (newRevisionsInSecondaryCount === 0) {
+        const cleanupResult = await this.deleteRevisionsForUser(userUuid, this.secondRevisionsRepository)
+        if (cleanupResult.isFailed()) {
+          this.logger.error(
+            `Failed to clean up secondary database revisions for user ${userUuid.value}: ${cleanupResult.getError()}`,
+          )
+        }
       }
 
       return Result.fail(migrationResult.getError())
@@ -73,11 +76,13 @@ export class TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser implements
       newRevisionsInSecondaryCount,
     )
     if (integrityCheckResult.isFailed()) {
-      const cleanupResult = await this.deleteRevisionsForUser(userUuid, this.secondRevisionsRepository)
-      if (cleanupResult.isFailed()) {
-        this.logger.error(
-          `Failed to clean up secondary database revisions for user ${userUuid.value}: ${cleanupResult.getError()}`,
-        )
+      if (newRevisionsInSecondaryCount === 0) {
+        const cleanupResult = await this.deleteRevisionsForUser(userUuid, this.secondRevisionsRepository)
+        if (cleanupResult.isFailed()) {
+          this.logger.error(
+            `Failed to clean up secondary database revisions for user ${userUuid.value}: ${cleanupResult.getError()}`,
+          )
+        }
       }
 
       return Result.fail(integrityCheckResult.getError())
@@ -170,7 +175,14 @@ export class TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser implements
       this.secondRevisionsRepository as RevisionRepositoryInterface
     ).countByUserUuid(userUuid)
 
-    return totalRevisionsCountForUserInSecondary > 0
+    const hasAlreadyDataInSecondaryDatabase = totalRevisionsCountForUserInSecondary > 0
+    if (hasAlreadyDataInSecondaryDatabase) {
+      this.logger.info(
+        `User ${userUuid.value} has already ${totalRevisionsCountForUserInSecondary} revisions in secondary database`,
+      )
+    }
+
+    return hasAlreadyDataInSecondaryDatabase
   }
 
   private async getNewRevisionsCreatedInSecondaryDatabase(userUuid: Uuid): Promise<{
@@ -223,12 +235,6 @@ export class TransitionRevisionsFromPrimaryToSecondaryDatabaseForUser implements
     return true
   }
 
-  private async isAlreadyMigrated(userUuid: Uuid): Promise<boolean> {
-    const totalRevisionsCountForUserInPrimary = await this.primaryRevisionsRepository.countByUserUuid(userUuid)
-
-    return totalRevisionsCountForUserInPrimary === 0
-  }
-
   private async checkIntegrityBetweenPrimaryAndSecondaryDatabase(
     userUuid: Uuid,
     newRevisionsInSecondaryCount: number,

packages/syncing-server/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.95.14](https://github.com/standardnotes/syncing-server-js/compare/@standardnotes/syncing-server@1.95.13...@standardnotes/syncing-server@1.95.14) (2023-09-13)
+
+### Bug Fixes
+
+* setting status for already migrated users ([9be4c00](https://github.com/standardnotes/syncing-server-js/commit/9be4c002b755fea057489b6077b297162223aefe))
+
+## [1.95.13](https://github.com/standardnotes/syncing-server-js/compare/@standardnotes/syncing-server@1.95.12...@standardnotes/syncing-server@1.95.13) (2023-09-13)
+
+### Bug Fixes
+
+* cleanup only for 0 new items ([b1d88b1](https://github.com/standardnotes/syncing-server-js/commit/b1d88b15be78a48224963e337a222fb675ed2692))
+* **syncing-server:** add catch up timeout for secondary db ([ff78285](https://github.com/standardnotes/syncing-server-js/commit/ff78285e43db849bdc44caa36f602150562b4d81))
+* **syncing-server:** case insensitive integrity check ([d5536f5](https://github.com/standardnotes/syncing-server-js/commit/d5536f54304e2aecd59dbece7650254f7c2101bb))
+
+## [1.95.12](https://github.com/standardnotes/syncing-server-js/compare/@standardnotes/syncing-server@1.95.11...@standardnotes/syncing-server@1.95.12) (2023-09-12)
+
+### Bug Fixes
+
+* sync between primary and secondary database with diff ([fab5d18](https://github.com/standardnotes/syncing-server-js/commit/fab5d180645e0a6fa0c9c67205d44f27c8a65c8b))
+
 ## [1.95.11](https://github.com/standardnotes/syncing-server-js/compare/@standardnotes/syncing-server@1.95.10...@standardnotes/syncing-server@1.95.11) (2023-09-12)
 
 ### Bug Fixes

packages/syncing-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/syncing-server",
-  "version": "1.95.11",
+  "version": "1.95.14",
   "engines": {
     "node": ">=18.0.0 <21.0.0"
   },

packages/syncing-server/src/Bootstrap/Container.ts

@@ -952,6 +952,7 @@ export class ContainerConfigLoader {
       .bind<TransitionStatusUpdatedEventHandler>(TYPES.Sync_TransitionStatusUpdatedEventHandler)
       .toConstantValue(
         new TransitionStatusUpdatedEventHandler(
+          container.get<ItemRepositoryInterface>(TYPES.Sync_SQLItemRepository),
           container.get<TransitionItemsFromPrimaryToSecondaryDatabaseForUser>(
             TYPES.Sync_TransitionItemsFromPrimaryToSecondaryDatabaseForUser,
           ),

packages/syncing-server/src/Domain/Handler/TransitionStatusUpdatedEventHandler.ts

@@ -6,9 +6,11 @@ import {
 import { Logger } from 'winston'
 import { TransitionItemsFromPrimaryToSecondaryDatabaseForUser } from '../UseCase/Transition/TransitionItemsFromPrimaryToSecondaryDatabaseForUser/TransitionItemsFromPrimaryToSecondaryDatabaseForUser'
 import { DomainEventFactoryInterface } from '../Event/DomainEventFactoryInterface'
+import { ItemRepositoryInterface } from '../Item/ItemRepositoryInterface'
 
 export class TransitionStatusUpdatedEventHandler implements DomainEventHandlerInterface {
   constructor(
+    private primaryItemRepository: ItemRepositoryInterface,
     private transitionItemsFromPrimaryToSecondaryDatabaseForUser: TransitionItemsFromPrimaryToSecondaryDatabaseForUser,
     private domainEventPublisher: DomainEventPublisherInterface,
     private domainEventFactory: DomainEventFactoryInterface,
@@ -17,6 +19,20 @@ export class TransitionStatusUpdatedEventHandler implements DomainEventHandlerIn
 
   async handle(event: TransitionStatusUpdatedEvent): Promise<void> {
     if (event.payload.status === 'STARTED' && event.payload.transitionType === 'items') {
+      if (await this.isAlreadyMigrated(event.payload.userUuid)) {
+        this.logger.info(`Items for user ${event.payload.userUuid} are already migrated`)
+
+        await this.domainEventPublisher.publish(
+          this.domainEventFactory.createTransitionStatusUpdatedEvent({
+            userUuid: event.payload.userUuid,
+            status: 'FINISHED',
+            transitionType: 'items',
+          }),
+        )
+
+        return
+      }
+
       await this.domainEventPublisher.publish(
         this.domainEventFactory.createTransitionStatusUpdatedEvent({
           userUuid: event.payload.userUuid,
@@ -52,4 +68,14 @@ export class TransitionStatusUpdatedEventHandler implements DomainEventHandlerIn
       )
     }
   }
+
+  private async isAlreadyMigrated(userUuid: string): Promise<boolean> {
+    const totalItemsCountForUser = await this.primaryItemRepository.countAll({ userUuid })
+
+    if (totalItemsCountForUser > 0) {
+      this.logger.info(`User ${userUuid} has ${totalItemsCountForUser} items in primary database.`)
+    }
+
+    return totalItemsCountForUser === 0
+  }
 }

packages/syncing-server/src/Domain/UseCase/Syncing/CheckIntegrity/CheckIntegrity.spec.ts

@@ -22,7 +22,7 @@ describe('CheckIntegrity', () => {
         content_type: ContentType.TYPES.Note,
       },
       {
-        uuid: '2-3-4',
+        uuid: '2-3-4-a',
         updated_at_timestamp: 2,
         content_type: ContentType.TYPES.Note,
       },
@@ -56,7 +56,7 @@ describe('CheckIntegrity', () => {
           updated_at_timestamp: 1,
         },
         {
-          uuid: '2-3-4',
+          uuid: '2-3-4-A',
           updated_at_timestamp: 2,
         },
         {
@@ -82,7 +82,7 @@ describe('CheckIntegrity', () => {
           updated_at_timestamp: 1,
         },
         {
-          uuid: '2-3-4',
+          uuid: '2-3-4-A',
           updated_at_timestamp: 1,
         },
         {
@@ -98,7 +98,7 @@ describe('CheckIntegrity', () => {
     })
     expect(result.getValue()).toEqual([
       {
-        uuid: '2-3-4',
+        uuid: '2-3-4-A',
         updated_at_timestamp: 2,
       },
     ])
@@ -113,7 +113,7 @@ describe('CheckIntegrity', () => {
           updated_at_timestamp: 1,
         },
         {
-          uuid: '2-3-4',
+          uuid: '2-3-4-A',
           updated_at_timestamp: 2,
         },
         {
@@ -140,7 +140,7 @@ describe('CheckIntegrity', () => {
           updated_at_timestamp: 1,
         },
         {
-          uuid: '2-3-4',
+          uuid: '2-3-4-A',
           updated_at_timestamp: 2,
         },
         {

packages/syncing-server/src/Domain/UseCase/Syncing/CheckIntegrity/CheckIntegrity.ts

@@ -20,15 +20,17 @@ export class CheckIntegrity implements UseCaseInterface<IntegrityPayload[]> {
 
     const serverItemIntegrityPayloadsMap = new Map<string, ExtendedIntegrityPayload>()
     for (const serverItemIntegrityPayload of serverItemIntegrityPayloads) {
-      serverItemIntegrityPayloadsMap.set(serverItemIntegrityPayload.uuid, serverItemIntegrityPayload)
+      serverItemIntegrityPayloadsMap.set(serverItemIntegrityPayload.uuid.toLowerCase(), serverItemIntegrityPayload)
     }
 
     const clientItemIntegrityPayloadsMap = new Map<string, number>()
+    const caseInsensitiveUuidsMap = new Map<string, string>()
     for (const clientItemIntegrityPayload of dto.integrityPayloads) {
       clientItemIntegrityPayloadsMap.set(
-        clientItemIntegrityPayload.uuid,
+        clientItemIntegrityPayload.uuid.toLowerCase(),
         clientItemIntegrityPayload.updated_at_timestamp,
       )
+      caseInsensitiveUuidsMap.set(clientItemIntegrityPayload.uuid.toLowerCase(), clientItemIntegrityPayload.uuid)
     }
 
     const mismatches: IntegrityPayload[] = []
@@ -58,7 +60,7 @@ export class CheckIntegrity implements UseCaseInterface<IntegrityPayload[]> {
         serverItemIntegrityPayload.content_type !== ContentType.TYPES.ItemsKey
       ) {
         mismatches.unshift({
-          uuid: serverItemIntegrityPayloadUuid,
+          uuid: caseInsensitiveUuidsMap.get(serverItemIntegrityPayloadUuid) as string,
           updated_at_timestamp: serverItemIntegrityPayloadUpdatedAtTimestamp,
         })
       }

packages/syncing-server/src/Domain/UseCase/Transition/TransitionItemsFromPrimaryToSecondaryDatabaseForUser/TransitionItemsFromPrimaryToSecondaryDatabaseForUser.spec.ts

@@ -1,417 +0,0 @@
-import { Logger } from 'winston'
-
-import { ItemRepositoryInterface } from '../../../Item/ItemRepositoryInterface'
-import { TransitionItemsFromPrimaryToSecondaryDatabaseForUser } from './TransitionItemsFromPrimaryToSecondaryDatabaseForUser'
-import { Item } from '../../../Item/Item'
-import { ContentType, Dates, Timestamps, UniqueEntityId, Uuid } from '@standardnotes/domain-core'
-import { TimerInterface } from '@standardnotes/time'
-
-describe('TransitionItemsFromPrimaryToSecondaryDatabaseForUser', () => {
-  let primaryItemRepository: ItemRepositoryInterface
-  let secondaryItemRepository: ItemRepositoryInterface | null
-  let logger: Logger
-  let primaryItem1: Item
-  let primaryItem2: Item
-  let secondaryItem1: Item
-  let secondaryItem2: Item
-  let timer: TimerInterface
-
-  const createUseCase = () =>
-    new TransitionItemsFromPrimaryToSecondaryDatabaseForUser(
-      primaryItemRepository,
-      secondaryItemRepository,
-      timer,
-      logger,
-      1,
-    )
-
-  beforeEach(() => {
-    primaryItem1 = Item.create(
-      {
-        duplicateOf: null,
-        itemsKeyId: 'items-key-id=1',
-        content: 'content-1',
-        contentType: ContentType.create(ContentType.TYPES.Note).getValue(),
-        encItemKey: 'enc-item-key-1',
-        authHash: 'auth-hash-1',
-        userUuid: Uuid.create('00000000-0000-0000-0000-000000000000').getValue(),
-        deleted: false,
-        updatedWithSession: null,
-        dates: Dates.create(new Date(123), new Date(123)).getValue(),
-        timestamps: Timestamps.create(123, 123).getValue(),
-      },
-      new UniqueEntityId('00000000-0000-0000-0000-000000000000'),
-    ).getValue()
-
-    primaryItem2 = Item.create(
-      {
-        duplicateOf: null,
-        itemsKeyId: 'items-key-id=2',
-        content: 'content-2',
-        contentType: ContentType.create(ContentType.TYPES.Note).getValue(),
-        encItemKey: 'enc-item-key-2',
-        authHash: 'auth-hash-2',
-        userUuid: Uuid.create('00000000-0000-0000-0000-000000000000').getValue(),
-        deleted: true,
-        updatedWithSession: null,
-        dates: Dates.create(new Date(123), new Date(123)).getValue(),
-        timestamps: Timestamps.create(123, 123).getValue(),
-      },
-      new UniqueEntityId('00000000-0000-0000-0000-000000000001'),
-    ).getValue()
-
-    secondaryItem1 = Item.create(
-      {
-        duplicateOf: null,
-        itemsKeyId: 'items-key-id=1',
-        content: 'content-1',
-        contentType: ContentType.create(ContentType.TYPES.Note).getValue(),
-        encItemKey: 'enc-item-key-1',
-        authHash: 'auth-hash-1',
-        userUuid: Uuid.create('00000000-0000-0000-0000-000000000000').getValue(),
-        deleted: false,
-        updatedWithSession: null,
-        dates: Dates.create(new Date(123), new Date(123)).getValue(),
-        timestamps: Timestamps.create(123, 123).getValue(),
-      },
-      new UniqueEntityId('00000000-0000-0000-0000-000000000000'),
-    ).getValue()
-
-    secondaryItem2 = Item.create(
-      {
-        duplicateOf: null,
-        itemsKeyId: 'items-key-id=2',
-        content: 'content-2',
-        contentType: ContentType.create(ContentType.TYPES.Note).getValue(),
-        encItemKey: 'enc-item-key-2',
-        authHash: 'auth-hash-2',
-        userUuid: Uuid.create('00000000-0000-0000-0000-000000000000').getValue(),
-        deleted: true,
-        updatedWithSession: null,
-        dates: Dates.create(new Date(123), new Date(123)).getValue(),
-        timestamps: Timestamps.create(123, 123).getValue(),
-      },
-      new UniqueEntityId('00000000-0000-0000-0000-000000000001'),
-    ).getValue()
-
-    primaryItemRepository = {} as jest.Mocked<ItemRepositoryInterface>
-    primaryItemRepository.countAll = jest.fn().mockResolvedValue(2)
-    primaryItemRepository.findAll = jest
-      .fn()
-      .mockResolvedValueOnce([primaryItem1])
-      .mockResolvedValueOnce([primaryItem2])
-      .mockResolvedValueOnce([primaryItem1])
-      .mockResolvedValueOnce([primaryItem2])
-    primaryItemRepository.deleteByUserUuid = jest.fn().mockResolvedValue(undefined)
-
-    secondaryItemRepository = {} as jest.Mocked<ItemRepositoryInterface>
-    secondaryItemRepository.save = jest.fn().mockResolvedValue(undefined)
-    secondaryItemRepository.deleteByUserUuid = jest.fn().mockResolvedValue(undefined)
-    secondaryItemRepository.countAll = jest.fn().mockReturnValueOnce(0).mockReturnValueOnce(2)
-    secondaryItemRepository.findByUuid = jest
-      .fn()
-      .mockResolvedValueOnce(secondaryItem1)
-      .mockResolvedValueOnce(secondaryItem2)
-
-    logger = {} as jest.Mocked<Logger>
-    logger.error = jest.fn()
-    logger.info = jest.fn()
-
-    timer = {} as jest.Mocked<TimerInterface>
-    timer.sleep = jest.fn()
-    timer.getTimestampInMicroseconds = jest.fn().mockReturnValue(123)
-    timer.convertMicrosecondsToTimeStructure = jest.fn().mockReturnValue({
-      days: 0,
-      hours: 0,
-      minutes: 0,
-      seconds: 0,
-      milliseconds: 0,
-    })
-  })
-
-  describe('successfull transition', () => {
-    it('should transition items from primary to secondary database', async () => {
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeFalsy()
-
-      expect(primaryItemRepository.countAll).toHaveBeenCalledTimes(3)
-      expect(primaryItemRepository.countAll).toHaveBeenCalledWith({ userUuid: '00000000-0000-0000-0000-000000000000' })
-      expect(primaryItemRepository.findAll).toHaveBeenCalledTimes(4)
-      expect(primaryItemRepository.findAll).toHaveBeenNthCalledWith(1, {
-        userUuid: '00000000-0000-0000-0000-000000000000',
-        limit: 1,
-        offset: 0,
-      })
-      expect(primaryItemRepository.findAll).toHaveBeenNthCalledWith(2, {
-        userUuid: '00000000-0000-0000-0000-000000000000',
-        limit: 1,
-        offset: 1,
-      })
-      expect(primaryItemRepository.findAll).toHaveBeenNthCalledWith(3, {
-        userUuid: '00000000-0000-0000-0000-000000000000',
-        limit: 1,
-        offset: 0,
-      })
-      expect(primaryItemRepository.findAll).toHaveBeenNthCalledWith(4, {
-        userUuid: '00000000-0000-0000-0000-000000000000',
-        limit: 1,
-        offset: 1,
-      })
-      expect((secondaryItemRepository as ItemRepositoryInterface).save).toHaveBeenCalledTimes(2)
-      expect((secondaryItemRepository as ItemRepositoryInterface).save).toHaveBeenCalledWith(primaryItem1)
-      expect((secondaryItemRepository as ItemRepositoryInterface).save).toHaveBeenCalledWith(primaryItem2)
-      expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).not.toHaveBeenCalled()
-      expect(primaryItemRepository.deleteByUserUuid).toHaveBeenCalledTimes(1)
-    })
-
-    it('should log an error if deleting items from primary database fails', async () => {
-      primaryItemRepository.deleteByUserUuid = jest.fn().mockRejectedValue(new Error('error'))
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeFalsy()
-
-      expect(logger.error).toHaveBeenCalledTimes(1)
-      expect(logger.error).toHaveBeenCalledWith(
-        'Failed to clean up primary database items for user 00000000-0000-0000-0000-000000000000: error',
-      )
-    })
-  })
-
-  describe('failed transition', () => {
-    it('should remove items from secondary database if integrity check fails', async () => {
-      const secondaryItem2WithDifferentContent = Item.create({
-        ...secondaryItem2.props,
-        content: 'different-content',
-      }).getValue()
-
-      ;(secondaryItemRepository as ItemRepositoryInterface).findByUuid = jest
-        .fn()
-        .mockResolvedValueOnce(secondaryItem1)
-        .mockResolvedValueOnce(secondaryItem2WithDifferentContent)
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-
-      expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).toHaveBeenCalledTimes(1)
-      expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-    })
-
-    it('should remove items from secondary database if migrating items fails', async () => {
-      primaryItemRepository.findAll = jest
-        .fn()
-        .mockResolvedValueOnce([primaryItem1])
-        .mockRejectedValueOnce(new Error('error'))
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-      expect(result.getError()).toEqual('error')
-
-      expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).toHaveBeenCalledTimes(1)
-      expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-    })
-
-    it('should log an error if deleting items from secondary database fails upon migration failure', async () => {
-      primaryItemRepository.findAll = jest
-        .fn()
-        .mockResolvedValueOnce([primaryItem1])
-        .mockRejectedValueOnce(new Error('error'))
-      ;(secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid = jest
-        .fn()
-        .mockRejectedValue(new Error('error'))
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-
-      expect(logger.error).toHaveBeenCalledTimes(1)
-      expect(logger.error).toHaveBeenCalledWith(
-        'Failed to clean up secondary database items for user 00000000-0000-0000-0000-000000000000: error',
-      )
-    })
-
-    it('should log an error if deleting items from secondary database fails upon integrity check failure', async () => {
-      const secondaryItem2WithDifferentContent = Item.create({
-        ...secondaryItem2.props,
-        content: 'different-content',
-      }).getValue()
-
-      ;(secondaryItemRepository as ItemRepositoryInterface).findByUuid = jest
-        .fn()
-        .mockResolvedValueOnce(secondaryItem1)
-        .mockResolvedValueOnce(secondaryItem2WithDifferentContent)
-      ;(secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid = jest
-        .fn()
-        .mockRejectedValue(new Error('error'))
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-
-      expect(logger.error).toHaveBeenCalledTimes(1)
-      expect(logger.error).toHaveBeenCalledWith(
-        'Failed to clean up secondary database items for user 00000000-0000-0000-0000-000000000000: error',
-      )
-    })
-
-    it('should not perform the transition if secondary item repository is not set', async () => {
-      secondaryItemRepository = null
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-      expect(result.getError()).toEqual('Secondary item repository is not set')
-
-      expect(primaryItemRepository.countAll).not.toHaveBeenCalled()
-      expect(primaryItemRepository.findAll).not.toHaveBeenCalled()
-      expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-    })
-
-    it('should not perform the transition if the user uuid is invalid', async () => {
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: 'invalid-uuid',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-      expect(result.getError()).toEqual('Given value is not a valid uuid: invalid-uuid')
-
-      expect(primaryItemRepository.countAll).not.toHaveBeenCalled()
-      expect(primaryItemRepository.findAll).not.toHaveBeenCalled()
-      expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-    })
-
-    it('should fail integrity check if the item count is not the same in both databases', async () => {
-      ;(secondaryItemRepository as ItemRepositoryInterface).countAll = jest
-        .fn()
-        .mockResolvedValueOnce(0)
-        .mockResolvedValueOnce(1)
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-      expect(result.getError()).toEqual(
-        'Total items count for user 00000000-0000-0000-0000-000000000000 in primary database (2) does not match total items count in secondary database (1)',
-      )
-
-      expect(primaryItemRepository.countAll).toHaveBeenCalledTimes(3)
-      expect(primaryItemRepository.countAll).toHaveBeenCalledWith({ userUuid: '00000000-0000-0000-0000-000000000000' })
-      expect((secondaryItemRepository as ItemRepositoryInterface).countAll).toHaveBeenCalledTimes(2)
-      expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-      expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).toHaveBeenCalledTimes(1)
-    })
-
-    it('should fail if one item is not found in the secondary database', async () => {
-      ;(secondaryItemRepository as ItemRepositoryInterface).findByUuid = jest
-        .fn()
-        .mockResolvedValueOnce(secondaryItem1)
-        .mockResolvedValueOnce(null)
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-      expect(result.getError()).toEqual('Item 00000000-0000-0000-0000-000000000001 not found in secondary database')
-
-      expect(primaryItemRepository.countAll).toHaveBeenCalledTimes(3)
-      expect(primaryItemRepository.countAll).toHaveBeenCalledWith({ userUuid: '00000000-0000-0000-0000-000000000000' })
-      expect((secondaryItemRepository as ItemRepositoryInterface).countAll).toHaveBeenCalledTimes(2)
-      expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-      expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).toHaveBeenCalledTimes(1)
-    })
-
-    it('should fail if an error is thrown during integrity check between primary and secondary database', async () => {
-      ;(secondaryItemRepository as ItemRepositoryInterface).countAll = jest
-        .fn()
-        .mockReturnValueOnce(0)
-        .mockRejectedValue(new Error('error'))
-
-      const useCase = createUseCase()
-
-      const result = await useCase.execute({
-        userUuid: '00000000-0000-0000-0000-000000000000',
-      })
-
-      expect(result.isFailed()).toBeTruthy()
-      expect(result.getError()).toEqual('error')
-
-      expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-      expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  it('should not migrate items if there are no items in the primary database', async () => {
-    primaryItemRepository.countAll = jest.fn().mockResolvedValue(0)
-
-    const useCase = createUseCase()
-
-    const result = await useCase.execute({
-      userUuid: '00000000-0000-0000-0000-000000000000',
-    })
-
-    expect(result.isFailed()).toBeFalsy()
-
-    expect(primaryItemRepository.countAll).toHaveBeenCalledTimes(1)
-    expect(primaryItemRepository.countAll).toHaveBeenCalledWith({ userUuid: '00000000-0000-0000-0000-000000000000' })
-    expect(primaryItemRepository.findAll).not.toHaveBeenCalled()
-    expect((secondaryItemRepository as ItemRepositoryInterface).save).not.toHaveBeenCalled()
-    expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-    expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).not.toHaveBeenCalled()
-  })
-
-  it('should not migrate items if there are items in the secondary database', async () => {
-    ;(secondaryItemRepository as ItemRepositoryInterface).countAll = jest.fn().mockResolvedValue(1)
-
-    const useCase = createUseCase()
-
-    const result = await useCase.execute({
-      userUuid: '00000000-0000-0000-0000-000000000000',
-    })
-
-    expect(result.isFailed()).toBeTruthy()
-
-    expect(primaryItemRepository.findAll).not.toHaveBeenCalled()
-    expect((secondaryItemRepository as ItemRepositoryInterface).save).not.toHaveBeenCalled()
-    expect(primaryItemRepository.deleteByUserUuid).not.toHaveBeenCalled()
-    expect((secondaryItemRepository as ItemRepositoryInterface).deleteByUserUuid).not.toHaveBeenCalled()
-  })
-})

packages/syncing-server/src/Domain/UseCase/Transition/TransitionItemsFromPrimaryToSecondaryDatabaseForUser/TransitionItemsFromPrimaryToSecondaryDatabaseForUser.ts

@@ -1,3 +1,4 @@
+/* istanbul ignore file */
 import { Result, UseCaseInterface, Uuid } from '@standardnotes/domain-core'
 import { Logger } from 'winston'
 
@@ -5,6 +6,7 @@ import { TransitionItemsFromPrimaryToSecondaryDatabaseForUserDTO } from './Trans
 import { ItemRepositoryInterface } from '../../../Item/ItemRepositoryInterface'
 import { ItemQuery } from '../../../Item/ItemQuery'
 import { TimerInterface } from '@standardnotes/time'
+import { Item } from '../../../Item/Item'
 
 export class TransitionItemsFromPrimaryToSecondaryDatabaseForUser implements UseCaseInterface<void> {
   constructor(
@@ -28,25 +30,36 @@ export class TransitionItemsFromPrimaryToSecondaryDatabaseForUser implements Use
     }
     const userUuid = userUuidOrError.getValue()
 
-    if (await this.isAlreadyMigrated(userUuid)) {
-      this.logger.info(`Items for user ${userUuid.value} are already migrated`)
-
-      return Result.ok()
-    }
-
+    let newItemsInSecondaryCount = 0
     if (await this.hasAlreadyDataInSecondaryDatabase(userUuid)) {
-      return Result.fail(`Items for user ${userUuid.value} already exist in secondary database`)
+      const newItems = await this.getNewItemsCreatedInSecondaryDatabase(userUuid)
+      for (const existingItem of newItems.alreadyExistingInPrimary) {
+        this.logger.info(`Removing item ${existingItem.uuid.value} from secondary database`)
+        await (this.secondaryItemRepository as ItemRepositoryInterface).remove(existingItem)
+      }
+
+      if (newItems.newItemsInSecondary.length > 0) {
+        this.logger.info(
+          `Found ${newItems.newItemsInSecondary.length} new items in secondary database for user ${userUuid.value}`,
+        )
+      }
+
+      newItemsInSecondaryCount = newItems.newItemsInSecondary.length
     }
 
+    await this.allowForSecondaryDatabaseToCatchUp()
+
     const migrationTimeStart = this.timer.getTimestampInMicroseconds()
 
     const migrationResult = await this.migrateItemsForUser(userUuid)
     if (migrationResult.isFailed()) {
-      const cleanupResult = await this.deleteItemsForUser(userUuid, this.secondaryItemRepository)
-      if (cleanupResult.isFailed()) {
-        this.logger.error(
-          `Failed to clean up secondary database items for user ${userUuid.value}: ${cleanupResult.getError()}`,
-        )
+      if (newItemsInSecondaryCount === 0) {
+        const cleanupResult = await this.deleteItemsForUser(userUuid, this.secondaryItemRepository)
+        if (cleanupResult.isFailed()) {
+          this.logger.error(
+            `Failed to clean up secondary database items for user ${userUuid.value}: ${cleanupResult.getError()}`,
+          )
+        }
       }
 
       return Result.fail(migrationResult.getError())
@@ -54,13 +67,18 @@ export class TransitionItemsFromPrimaryToSecondaryDatabaseForUser implements Use
 
     await this.allowForSecondaryDatabaseToCatchUp()
 
-    const integrityCheckResult = await this.checkIntegrityBetweenPrimaryAndSecondaryDatabase(userUuid)
+    const integrityCheckResult = await this.checkIntegrityBetweenPrimaryAndSecondaryDatabase(
+      userUuid,
+      newItemsInSecondaryCount,
+    )
     if (integrityCheckResult.isFailed()) {
-      const cleanupResult = await this.deleteItemsForUser(userUuid, this.secondaryItemRepository)
-      if (cleanupResult.isFailed()) {
-        this.logger.error(
-          `Failed to clean up secondary database items for user ${userUuid.value}: ${cleanupResult.getError()}`,
-        )
+      if (newItemsInSecondaryCount === 0) {
+        const cleanupResult = await this.deleteItemsForUser(userUuid, this.secondaryItemRepository)
+        if (cleanupResult.isFailed()) {
+          this.logger.error(
+            `Failed to clean up secondary database items for user ${userUuid.value}: ${cleanupResult.getError()}`,
+          )
+        }
       }
 
       return Result.fail(integrityCheckResult.getError())
@@ -90,13 +108,12 @@ export class TransitionItemsFromPrimaryToSecondaryDatabaseForUser implements Use
       userUuid: userUuid.value,
     })
 
-    return totalItemsCountForUser > 0
-  }
+    const hasAlreadyDataInSecondaryDatabase = totalItemsCountForUser > 0
+    if (hasAlreadyDataInSecondaryDatabase) {
+      this.logger.info(`User ${userUuid.value} has already ${totalItemsCountForUser} items in secondary database`)
+    }
 
-  private async isAlreadyMigrated(userUuid: Uuid): Promise<boolean> {
-    const totalItemsCountForUser = await this.primaryItemRepository.countAll({ userUuid: userUuid.value })
-
-    return totalItemsCountForUser === 0
+    return hasAlreadyDataInSecondaryDatabase
   }
 
   private async allowForSecondaryDatabaseToCatchUp(): Promise<void> {
@@ -104,6 +121,52 @@ export class TransitionItemsFromPrimaryToSecondaryDatabaseForUser implements Use
     await this.timer.sleep(twoSecondsInMilliseconds)
   }
 
+  private async getNewItemsCreatedInSecondaryDatabase(userUuid: Uuid): Promise<{
+    alreadyExistingInPrimary: Item[]
+    newItemsInSecondary: Item[]
+  }> {
+    const items = await (this.secondaryItemRepository as ItemRepositoryInterface).findAll({
+      userUuid: userUuid.value,
+    })
+
+    const alreadyExistingInPrimary: Item[] = []
+    const newItemsInSecondary: Item[] = []
+
+    for (const item of items) {
+      const itemExistsInPrimary = await this.checkIfItemExistsInPrimaryDatabase(item)
+      if (itemExistsInPrimary) {
+        alreadyExistingInPrimary.push(item)
+      } else {
+        newItemsInSecondary.push(item)
+      }
+    }
+
+    return {
+      alreadyExistingInPrimary: alreadyExistingInPrimary,
+      newItemsInSecondary: newItemsInSecondary,
+    }
+  }
+
+  private async checkIfItemExistsInPrimaryDatabase(item: Item): Promise<boolean> {
+    const itemInPrimary = await this.primaryItemRepository.findByUuid(item.uuid)
+
+    if (itemInPrimary === null) {
+      return false
+    }
+
+    if (!item.isIdenticalTo(itemInPrimary)) {
+      this.logger.error(
+        `Revision ${item.id.toString()} is not identical in primary and secondary database. Revision in secondary database: ${JSON.stringify(
+          item,
+        )}, revision in primary database: ${JSON.stringify(itemInPrimary)}`,
+      )
+
+      return false
+    }
+
+    return true
+  }
+
   private async migrateItemsForUser(userUuid: Uuid): Promise<Result<void>> {
     try {
       const totalItemsCountForUser = await this.primaryItemRepository.countAll({ userUuid: userUuid.value })
@@ -138,7 +201,10 @@ export class TransitionItemsFromPrimaryToSecondaryDatabaseForUser implements Use
     }
   }
 
-  private async checkIntegrityBetweenPrimaryAndSecondaryDatabase(userUuid: Uuid): Promise<Result<boolean>> {
+  private async checkIntegrityBetweenPrimaryAndSecondaryDatabase(
+    userUuid: Uuid,
+    newItemsInSecondaryCount: number,
+  ): Promise<Result<boolean>> {
     try {
       const totalItemsCountForUserInPrimary = await this.primaryItemRepository.countAll({ userUuid: userUuid.value })
       const totalItemsCountForUserInSecondary = await (
@@ -147,9 +213,9 @@ export class TransitionItemsFromPrimaryToSecondaryDatabaseForUser implements Use
         userUuid: userUuid.value,
       })
 
-      if (totalItemsCountForUserInPrimary !== totalItemsCountForUserInSecondary) {
+      if (totalItemsCountForUserInPrimary + newItemsInSecondaryCount !== totalItemsCountForUserInSecondary) {
         return Result.fail(
-          `Total items count for user ${userUuid.value} in primary database (${totalItemsCountForUserInPrimary}) does not match total items count in secondary database (${totalItemsCountForUserInSecondary})`,
+          `Total items count for user ${userUuid.value} in primary database (${totalItemsCountForUserInPrimary} + ${newItemsInSecondaryCount}) does not match total items count in secondary database (${totalItemsCountForUserInSecondary})`,
         )
       }