fix(auth): remove redundant specs and fix stream query

packages/auth/docker/entrypoint.sh

@@ -5,69 +5,69 @@ COMMAND=$1 && shift 1
 
 case "$COMMAND" in
   'start-local' )
-    echo "Starting Web..."
+    echo "[Docker] Starting Web..."
     yarn workspace @standardnotes/auth-server start:local
     ;;
 
   'start-web' )
-    echo "Starting Web..."
+    echo "[Docker] Starting Web..."
     yarn workspace @standardnotes/auth-server start
     ;;
 
   'start-worker' )
-    echo "Starting Worker..."
+    echo "[Docker] Starting Worker..."
     yarn workspace @standardnotes/auth-server worker
     ;;
 
   'email-daily-backup' )
-    echo "Starting Email Daily Backup..."
+    echo "[Docker] Starting Email Daily Backup..."
     yarn workspace @standardnotes/auth-server daily-backup:email
     ;;
 
   'email-weekly-backup' )
-    echo "Starting Email Weekly Backup..."
+    echo "[Docker] Starting Email Weekly Backup..."
     yarn workspace @standardnotes/auth-server weekly-backup:email
     ;;
 
   'email-backup' )
-    echo "Starting Email Backup For Single User..."
+    echo "[Docker] Starting Email Backup For Single User..."
     EMAIL=$1 && shift 1
     yarn workspace @standardnotes/auth-server user-email-backup $EMAIL
     ;;
 
   'dropbox-daily-backup' )
-    echo "Starting Dropbox Daily Backup..."
+    echo "[Docker] Starting Dropbox Daily Backup..."
     yarn workspace @standardnotes/auth-server daily-backup:dropbox
     ;;
 
   'google-drive-daily-backup' )
-    echo "Starting Google Drive Daily Backup..."
+    echo "[Docker] Starting Google Drive Daily Backup..."
     yarn workspace @standardnotes/auth-server daily-backup:google_drive
     ;;
 
   'one-drive-daily-backup' )
-    echo "Starting One Drive Daily Backup..."
+    echo "[Docker] Starting One Drive Daily Backup..."
     yarn workspace @standardnotes/auth-server daily-backup:one_drive
     ;;
 
   'email-campaign' )
-    echo "Starting Email Campaign Sending..."
+    echo "[Docker] Starting Email Campaign Sending..."
     MESSAGE_IDENTIFIER=$1 && shift 1
     yarn workspace @standardnotes/auth-server email-campaign $MESSAGE_IDENTIFIER
     ;;
 
   'email-subscriptions-sync' )
-    echo "Starting Email Subscriptions sync..."
+    echo "[Docker] Starting Email Subscriptions sync..."
     yarn workspace @standardnotes/auth-server email-subscriptions-sync
     ;;
 
   'content-recalculation' )
-    echo "Starting Content Size Recalculation..."
+    echo "[Docker] Starting Content Size Recalculation..."
     yarn workspace @standardnotes/auth-server content-recalculation
     ;;
 
    * )
-    echo "Unknown command"
+    echo "[Docker] Unknown command"
     ;;
 esac
 

packages/auth/jest.config.js

@@ -7,6 +7,6 @@ module.exports = {
   transform: {
     ...tsjPreset.transform,
   },
-  coveragePathIgnorePatterns: ['/Bootstrap/', '/InversifyExpressUtils/', 'HealthCheckController', '/Infra/'],
+  coveragePathIgnorePatterns: ['/Bootstrap/', '/InversifyExpressUtils/', '/Infra/', '/Projection/'],
   setupFilesAfterEnv: ['./test-setup.ts'],
 }

packages/auth/src/Infra/MySQL/MySQLOfflineSettingRepository.spec.ts

@@ -1,57 +0,0 @@
-import 'reflect-metadata'
-
-import { Repository, SelectQueryBuilder } from 'typeorm'
-import { OfflineSetting } from '../../Domain/Setting/OfflineSetting'
-import { OfflineSettingName } from '../../Domain/Setting/OfflineSettingName'
-
-import { MySQLOfflineSettingRepository } from './MySQLOfflineSettingRepository'
-
-describe('MySQLOfflineSettingRepository', () => {
-  let queryBuilder: SelectQueryBuilder<OfflineSetting>
-  let offlineSetting: OfflineSetting
-  let ormRepository: Repository<OfflineSetting>
-
-  const createRepository = () => new MySQLOfflineSettingRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<OfflineSetting>>
-
-    offlineSetting = {} as jest.Mocked<OfflineSetting>
-
-    ormRepository = {} as jest.Mocked<Repository<OfflineSetting>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-    ormRepository.save = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(offlineSetting)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(offlineSetting)
-  })
-
-  it('should find one setting by name and user email', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(offlineSetting)
-
-    const result = await createRepository().findOneByNameAndEmail(OfflineSettingName.FeaturesToken, 'test@test.com')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('offline_setting.name = :name AND offline_setting.email = :email', {
-      name: 'FEATURES_TOKEN',
-      email: 'test@test.com',
-    })
-    expect(result).toEqual(offlineSetting)
-  })
-
-  it('should find one setting by name and value', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(offlineSetting)
-
-    const result = await createRepository().findOneByNameAndValue(OfflineSettingName.FeaturesToken, 'features-token')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('offline_setting.name = :name AND offline_setting.value = :value', {
-      name: 'FEATURES_TOKEN',
-      value: 'features-token',
-    })
-    expect(result).toEqual(offlineSetting)
-  })
-})

packages/auth/src/Infra/MySQL/MySQLOfflineUserSubscriptionRepository.spec.ts

@@ -1,189 +0,0 @@
-import 'reflect-metadata'
-
-import { SubscriptionName } from '@standardnotes/common'
-
-import { Repository, SelectQueryBuilder, UpdateQueryBuilder } from 'typeorm'
-
-import { MySQLOfflineUserSubscriptionRepository } from './MySQLOfflineUserSubscriptionRepository'
-import { OfflineUserSubscription } from '../../Domain/Subscription/OfflineUserSubscription'
-
-describe('MySQLOfflineUserSubscriptionRepository', () => {
-  let selectQueryBuilder: SelectQueryBuilder<OfflineUserSubscription>
-  let updateQueryBuilder: UpdateQueryBuilder<OfflineUserSubscription>
-  let offlineSubscription: OfflineUserSubscription
-  let ormRepository: Repository<OfflineUserSubscription>
-
-  const createRepository = () => new MySQLOfflineUserSubscriptionRepository(ormRepository)
-
-  beforeEach(() => {
-    selectQueryBuilder = {} as jest.Mocked<SelectQueryBuilder<OfflineUserSubscription>>
-    updateQueryBuilder = {} as jest.Mocked<UpdateQueryBuilder<OfflineUserSubscription>>
-
-    offlineSubscription = {
-      planName: SubscriptionName.ProPlan,
-      cancelled: false,
-      email: 'test@test.com',
-    } as jest.Mocked<OfflineUserSubscription>
-
-    ormRepository = {} as jest.Mocked<Repository<OfflineUserSubscription>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-    ormRepository.save = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(offlineSubscription)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(offlineSubscription)
-  })
-
-  it('should find one longest lasting uncanceled subscription by user email if there are canceled ones', async () => {
-    const canceledSubscription = {
-      planName: SubscriptionName.ProPlan,
-      cancelled: true,
-      email: 'test@test.com',
-    } as jest.Mocked<OfflineUserSubscription>
-
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([canceledSubscription, offlineSubscription])
-
-    const result = await createRepository().findOneByEmail('test@test.com')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('email = :email', {
-      email: 'test@test.com',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual(offlineSubscription)
-  })
-
-  it('should find one, longest lasting subscription by user email if there are no canceled ones', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([offlineSubscription])
-
-    const result = await createRepository().findOneByEmail('test@test.com')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('email = :email', {
-      email: 'test@test.com',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual(offlineSubscription)
-  })
-
-  it('should find one, longest lasting subscription by user email if there are no ucanceled ones', async () => {
-    offlineSubscription.cancelled = true
-
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([offlineSubscription])
-
-    const result = await createRepository().findOneByEmail('test@test.com')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('email = :email', {
-      email: 'test@test.com',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual(offlineSubscription)
-  })
-
-  it('should find none if there are no subscriptions for the user', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([])
-
-    const result = await createRepository().findOneByEmail('test@test.com')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('email = :email', {
-      email: 'test@test.com',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toBeNull()
-  })
-
-  it('should find multiple by user email active after', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([offlineSubscription])
-
-    const result = await createRepository().findByEmail('test@test.com', 123)
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('email = :email AND ends_at > :endsAt', {
-      email: 'test@test.com',
-      endsAt: 123,
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual([offlineSubscription])
-  })
-
-  it('should update cancelled by subscription id', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().updateCancelled(1, true, 1000)
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      updatedAt: expect.any(Number),
-      cancelled: true,
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('subscription_id = :subscriptionId', {
-      subscriptionId: 1,
-    })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should update ends at by subscription id', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().updateEndsAt(1, 1000, 1000)
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      updatedAt: expect.any(Number),
-      endsAt: 1000,
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('subscription_id = :subscriptionId', {
-      subscriptionId: 1,
-    })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should find one offline user subscription by user subscription id', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.getOne = jest.fn().mockReturnValue(offlineSubscription)
-
-    const result = await createRepository().findOneBySubscriptionId(123)
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('subscription_id = :subscriptionId', {
-      subscriptionId: 123,
-    })
-    expect(selectQueryBuilder.getOne).toHaveBeenCalled()
-    expect(result).toEqual(offlineSubscription)
-  })
-})

packages/auth/src/Infra/MySQL/MySQLRevokedSessionRepository.spec.ts

@@ -1,78 +0,0 @@
-import 'reflect-metadata'
-
-import { Repository, SelectQueryBuilder, UpdateQueryBuilder } from 'typeorm'
-
-import { RevokedSession } from '../../Domain/Session/RevokedSession'
-
-import { MySQLRevokedSessionRepository } from './MySQLRevokedSessionRepository'
-
-describe('MySQLRevokedSessionRepository', () => {
-  let ormRepository: Repository<RevokedSession>
-  let queryBuilder: SelectQueryBuilder<RevokedSession>
-  let updateQueryBuilder: UpdateQueryBuilder<RevokedSession>
-  let session: RevokedSession
-
-  const createRepository = () => new MySQLRevokedSessionRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<RevokedSession>>
-    updateQueryBuilder = {} as jest.Mocked<UpdateQueryBuilder<RevokedSession>>
-
-    session = {} as jest.Mocked<RevokedSession>
-
-    ormRepository = {} as jest.Mocked<Repository<RevokedSession>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-    ormRepository.save = jest.fn()
-    ormRepository.remove = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(session)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(session)
-  })
-
-  it('should remove', async () => {
-    await createRepository().remove(session)
-
-    expect(ormRepository.remove).toHaveBeenCalledWith(session)
-  })
-
-  it('should clear user agent data on all user sessions', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().clearUserAgentByUserUuid('1-2-3')
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      userAgent: null,
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :userUuid', { userUuid: '1-2-3' })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should find one session by id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(session)
-
-    const result = await createRepository().findOneByUuid('123')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('revoked_session.uuid = :uuid', { uuid: '123' })
-    expect(result).toEqual(session)
-  })
-
-  it('should find all revoked sessions by user id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([session])
-
-    const result = await createRepository().findAllByUserUuid('123')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('revoked_session.user_uuid = :user_uuid', { user_uuid: '123' })
-    expect(result).toEqual([session])
-  })
-})

packages/auth/src/Infra/MySQL/MySQLRoleRepository.spec.ts

@@ -1,49 +0,0 @@
-import 'reflect-metadata'
-
-import { Repository, SelectQueryBuilder } from 'typeorm'
-import { Role } from '../../Domain/Role/Role'
-
-import { MySQLRoleRepository } from './MySQLRoleRepository'
-
-describe('MySQLRoleRepository', () => {
-  let ormRepository: Repository<Role>
-  let queryBuilder: SelectQueryBuilder<Role>
-  let role: Role
-
-  const createRepository = () => new MySQLRoleRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<Role>>
-    queryBuilder.cache = jest.fn().mockReturnThis()
-
-    role = {} as jest.Mocked<Role>
-
-    ormRepository = {} as jest.Mocked<Repository<Role>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-  })
-
-  it('should find latest version of a role by name', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.take = jest.fn().mockReturnThis()
-    queryBuilder.orderBy = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([role])
-
-    const result = await createRepository().findOneByName('test')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('role.name = :name', { name: 'test' })
-    expect(queryBuilder.take).toHaveBeenCalledWith(1)
-    expect(queryBuilder.orderBy).toHaveBeenCalledWith('version', 'DESC')
-    expect(result).toEqual(role)
-  })
-
-  it('should return null if not found the latest version of a role by name', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.take = jest.fn().mockReturnThis()
-    queryBuilder.orderBy = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([])
-
-    const result = await createRepository().findOneByName('test')
-
-    expect(result).toBeNull()
-  })
-})

packages/auth/src/Infra/MySQL/MySQLSessionRepository.spec.ts

@@ -1,174 +0,0 @@
-import 'reflect-metadata'
-
-import * as dayjs from 'dayjs'
-
-import { Repository, SelectQueryBuilder, UpdateQueryBuilder } from 'typeorm'
-import { Session } from '../../Domain/Session/Session'
-
-import { MySQLSessionRepository } from './MySQLSessionRepository'
-
-describe('MySQLSessionRepository', () => {
-  let ormRepository: Repository<Session>
-  let queryBuilder: SelectQueryBuilder<Session>
-  let updateQueryBuilder: UpdateQueryBuilder<Session>
-  let session: Session
-
-  const createRepository = () => new MySQLSessionRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<Session>>
-    updateQueryBuilder = {} as jest.Mocked<UpdateQueryBuilder<Session>>
-
-    session = {} as jest.Mocked<Session>
-
-    ormRepository = {} as jest.Mocked<Repository<Session>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-    ormRepository.save = jest.fn()
-    ormRepository.remove = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(session)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(session)
-  })
-
-  it('should remove', async () => {
-    await createRepository().remove(session)
-
-    expect(ormRepository.remove).toHaveBeenCalledWith(session)
-  })
-
-  it('should clear user agent data on all user sessions', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().clearUserAgentByUserUuid('1-2-3')
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      userAgent: null,
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :userUuid', { userUuid: '1-2-3' })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should update hashed tokens on a session', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().updateHashedTokens('123', '234', '345')
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      hashedAccessToken: '234',
-      hashedRefreshToken: '345',
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('uuid = :uuid', { uuid: '123' })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should update token expiration dates on a session', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().updatedTokenExpirationDates(
-      '123',
-      dayjs.utc('2020-11-26 13:34').toDate(),
-      dayjs.utc('2020-11-26 14:34').toDate(),
-    )
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      accessExpiration: dayjs.utc('2020-11-26T13:34:00.000Z').toDate(),
-      refreshExpiration: dayjs.utc('2020-11-26T14:34:00.000Z').toDate(),
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('uuid = :uuid', { uuid: '123' })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should find active sessions by user id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([session])
-
-    const result = await createRepository().findAllByRefreshExpirationAndUserUuid('123')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith(
-      'session.refresh_expiration > :refresh_expiration AND session.user_uuid = :user_uuid',
-      { refresh_expiration: expect.any(Date), user_uuid: '123' },
-    )
-    expect(result).toEqual([session])
-  })
-
-  it('should find all sessions by user id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([session])
-
-    const result = await createRepository().findAllByUserUuid('123')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('session.user_uuid = :user_uuid', { user_uuid: '123' })
-    expect(result).toEqual([session])
-  })
-
-  it('should find one session by id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(session)
-
-    const result = await createRepository().findOneByUuid('123')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('session.uuid = :uuid', { uuid: '123' })
-    expect(result).toEqual(session)
-  })
-
-  it('should find one session by id and user id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(session)
-
-    const result = await createRepository().findOneByUuidAndUserUuid('123', '234')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('session.uuid = :uuid AND session.user_uuid = :user_uuid', {
-      uuid: '123',
-      user_uuid: '234',
-    })
-    expect(result).toEqual(session)
-  })
-
-  it('should delete all session for a user except the current one', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.delete = jest.fn().mockReturnThis()
-    queryBuilder.execute = jest.fn()
-
-    await createRepository().deleteAllByUserUuid('123', '234')
-
-    expect(queryBuilder.delete).toHaveBeenCalled()
-    expect(queryBuilder.where).toHaveBeenCalledWith('user_uuid = :user_uuid AND uuid != :current_session_uuid', {
-      user_uuid: '123',
-      current_session_uuid: '234',
-    })
-    expect(queryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should delete one session by id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.delete = jest.fn().mockReturnThis()
-    queryBuilder.execute = jest.fn()
-
-    await createRepository().deleteOneByUuid('123')
-
-    expect(queryBuilder.delete).toHaveBeenCalled()
-    expect(queryBuilder.where).toHaveBeenCalledWith('uuid = :uuid', { uuid: '123' })
-    expect(queryBuilder.execute).toHaveBeenCalled()
-  })
-})

packages/auth/src/Infra/MySQL/MySQLSettingRepository.spec.ts

@@ -1,140 +0,0 @@
-import 'reflect-metadata'
-
-import { ReadStream } from 'fs'
-import { Repository, SelectQueryBuilder } from 'typeorm'
-import { Setting } from '../../Domain/Setting/Setting'
-
-import { MySQLSettingRepository } from './MySQLSettingRepository'
-import { EmailBackupFrequency, SettingName } from '@standardnotes/settings'
-
-describe('MySQLSettingRepository', () => {
-  let ormRepository: Repository<Setting>
-  let queryBuilder: SelectQueryBuilder<Setting>
-  let setting: Setting
-
-  const createRepository = () => new MySQLSettingRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<Setting>>
-
-    setting = {} as jest.Mocked<Setting>
-
-    ormRepository = {} as jest.Mocked<Repository<Setting>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-    ormRepository.save = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(setting)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(setting)
-  })
-
-  it('should stream all settings by name and value', async () => {
-    const stream = {} as jest.Mocked<ReadStream>
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.orderBy = jest.fn().mockReturnThis()
-    queryBuilder.stream = jest.fn().mockReturnValue(stream)
-
-    const result = await createRepository().streamAllByNameAndValue(
-      SettingName.EmailBackupFrequency,
-      EmailBackupFrequency.Daily,
-    )
-
-    expect(result).toEqual(stream)
-  })
-
-  it('should find one setting by uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(setting)
-
-    const result = await createRepository().findOneByUuid('1-2-3')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('setting.uuid = :uuid', { uuid: '1-2-3' })
-    expect(result).toEqual(setting)
-  })
-
-  it('should find one setting by name and user uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(setting)
-
-    const result = await createRepository().findOneByNameAndUserUuid('test', '1-2-3')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('setting.name = :name AND setting.user_uuid = :user_uuid', {
-      name: 'test',
-      user_uuid: '1-2-3',
-    })
-    expect(result).toEqual(setting)
-  })
-
-  it('should find one setting by name and uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(setting)
-
-    const result = await createRepository().findOneByUuidAndNames('1-2-3', ['test' as SettingName])
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('setting.uuid = :uuid AND setting.name IN (:...names)', {
-      names: ['test'],
-      uuid: '1-2-3',
-    })
-    expect(result).toEqual(setting)
-  })
-
-  it('should find last setting by name and user uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.orderBy = jest.fn().mockReturnThis()
-    queryBuilder.limit = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([setting])
-
-    const result = await createRepository().findLastByNameAndUserUuid('test', '1-2-3')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('setting.name = :name AND setting.user_uuid = :user_uuid', {
-      name: 'test',
-      user_uuid: '1-2-3',
-    })
-    expect(queryBuilder.orderBy).toHaveBeenCalledWith('updated_at', 'DESC')
-    expect(queryBuilder.limit).toHaveBeenCalledWith(1)
-    expect(result).toEqual(setting)
-  })
-
-  it('should return null if not found last setting by name and user uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.orderBy = jest.fn().mockReturnThis()
-    queryBuilder.limit = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([])
-
-    const result = await createRepository().findLastByNameAndUserUuid('test', '1-2-3')
-
-    expect(result).toBeNull()
-  })
-
-  it('should find all by user uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-
-    const settings = [setting]
-    queryBuilder.getMany = jest.fn().mockReturnValue(settings)
-
-    const userUuid = '123'
-    const result = await createRepository().findAllByUserUuid(userUuid)
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('setting.user_uuid = :user_uuid', { user_uuid: userUuid })
-    expect(result).toEqual(settings)
-  })
-
-  it('should delete setting if it does exist', async () => {
-    const queryBuilder = {
-      delete: () => queryBuilder,
-      where: () => queryBuilder,
-      execute: () => undefined,
-    }
-
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-
-    const result = await createRepository().deleteByUserUuid({
-      userUuid: 'userUuid',
-      settingName: 'settingName',
-    })
-
-    expect(result).toEqual(undefined)
-  })
-})

packages/auth/src/Infra/MySQL/MySQLSharedSubscriptionInvitationRepository.spec.ts

@@ -1,100 +0,0 @@
-import 'reflect-metadata'
-
-import { Repository, SelectQueryBuilder } from 'typeorm'
-
-import { MySQLSharedSubscriptionInvitationRepository } from './MySQLSharedSubscriptionInvitationRepository'
-import { SharedSubscriptionInvitation } from '../../Domain/SharedSubscription/SharedSubscriptionInvitation'
-import { InvitationStatus } from '../../Domain/SharedSubscription/InvitationStatus'
-
-describe('MySQLSharedSubscriptionInvitationRepository', () => {
-  let ormRepository: Repository<SharedSubscriptionInvitation>
-  let queryBuilder: SelectQueryBuilder<SharedSubscriptionInvitation>
-  let invitation: SharedSubscriptionInvitation
-
-  const createRepository = () => new MySQLSharedSubscriptionInvitationRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<SharedSubscriptionInvitation>>
-
-    invitation = {} as jest.Mocked<SharedSubscriptionInvitation>
-
-    ormRepository = {} as jest.Mocked<Repository<SharedSubscriptionInvitation>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-    ormRepository.save = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(invitation)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(invitation)
-  })
-
-  it('should get invitations by inviter email', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([])
-
-    const result = await createRepository().findByInviterEmail('test@test.te')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('invitation.inviter_identifier = :inviterEmail', {
-      inviterEmail: 'test@test.te',
-    })
-
-    expect(result).toEqual([])
-  })
-
-  it('should count invitations by inviter email and statuses', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getCount = jest.fn().mockReturnValue(3)
-
-    const result = await createRepository().countByInviterEmailAndStatus('test@test.te', [InvitationStatus.Sent])
-
-    expect(queryBuilder.where).toHaveBeenCalledWith(
-      'invitation.inviter_identifier = :inviterEmail AND invitation.status IN (:...statuses)',
-      { inviterEmail: 'test@test.te', statuses: ['sent'] },
-    )
-
-    expect(result).toEqual(3)
-  })
-
-  it('should find one invitation by name and uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(invitation)
-
-    const result = await createRepository().findOneByUuidAndStatus('1-2-3', InvitationStatus.Sent)
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('invitation.uuid = :uuid AND invitation.status = :status', {
-      uuid: '1-2-3',
-      status: 'sent',
-    })
-
-    expect(result).toEqual(invitation)
-  })
-
-  it('should find one invitation by invitee and inviter email', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(invitation)
-
-    const result = await createRepository().findOneByInviteeAndInviterEmail('invitee@test.te', 'inviter@test.te')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith(
-      'invitation.inviter_identifier = :inviterEmail AND invitation.invitee_identifier = :inviteeEmail',
-      {
-        inviterEmail: 'inviter@test.te',
-        inviteeEmail: 'invitee@test.te',
-      },
-    )
-
-    expect(result).toEqual(invitation)
-  })
-
-  it('should find one invitation by uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(invitation)
-
-    const result = await createRepository().findOneByUuid('1-2-3')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('invitation.uuid = :uuid', { uuid: '1-2-3' })
-
-    expect(result).toEqual(invitation)
-  })
-})

packages/auth/src/Infra/MySQL/MySQLSubscriptionSettingRepository.spec.ts

@@ -1,68 +0,0 @@
-import 'reflect-metadata'
-
-import { Repository, SelectQueryBuilder } from 'typeorm'
-import { SubscriptionSetting } from '../../Domain/Setting/SubscriptionSetting'
-
-import { MySQLSubscriptionSettingRepository } from './MySQLSubscriptionSettingRepository'
-
-describe('MySQLSubscriptionSettingRepository', () => {
-  let ormRepository: Repository<SubscriptionSetting>
-  let queryBuilder: SelectQueryBuilder<SubscriptionSetting>
-  let setting: SubscriptionSetting
-
-  const createRepository = () => new MySQLSubscriptionSettingRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<SubscriptionSetting>>
-
-    setting = {} as jest.Mocked<SubscriptionSetting>
-
-    ormRepository = {} as jest.Mocked<Repository<SubscriptionSetting>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-    ormRepository.save = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(setting)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(setting)
-  })
-
-  it('should find one setting by uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(setting)
-
-    const result = await createRepository().findOneByUuid('1-2-3')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('setting.uuid = :uuid', { uuid: '1-2-3' })
-    expect(result).toEqual(setting)
-  })
-
-  it('should find last setting by name and user uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.orderBy = jest.fn().mockReturnThis()
-    queryBuilder.limit = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([setting])
-
-    const result = await createRepository().findLastByNameAndUserSubscriptionUuid('test', '1-2-3')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith(
-      'setting.name = :name AND setting.user_subscription_uuid = :userSubscriptionUuid',
-      { name: 'test', userSubscriptionUuid: '1-2-3' },
-    )
-    expect(queryBuilder.orderBy).toHaveBeenCalledWith('updated_at', 'DESC')
-    expect(queryBuilder.limit).toHaveBeenCalledWith(1)
-    expect(result).toEqual(setting)
-  })
-
-  it('should return null if not found last setting by name and user uuid', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.orderBy = jest.fn().mockReturnThis()
-    queryBuilder.limit = jest.fn().mockReturnThis()
-    queryBuilder.getMany = jest.fn().mockReturnValue([])
-
-    const result = await createRepository().findLastByNameAndUserSubscriptionUuid('test', '1-2-3')
-
-    expect(result).toBeNull()
-  })
-})

packages/auth/src/Infra/MySQL/MySQLUserRepository.spec.ts

@@ -1,69 +0,0 @@
-import 'reflect-metadata'
-
-import { ReadStream } from 'fs'
-
-import { Repository, SelectQueryBuilder } from 'typeorm'
-import { User } from '../../Domain/User/User'
-
-import { MySQLUserRepository } from './MySQLUserRepository'
-
-describe('MySQLUserRepository', () => {
-  let ormRepository: Repository<User>
-  let queryBuilder: SelectQueryBuilder<User>
-  let user: User
-
-  const createRepository = () => new MySQLUserRepository(ormRepository)
-
-  beforeEach(() => {
-    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<User>>
-    queryBuilder.cache = jest.fn().mockReturnThis()
-
-    user = {} as jest.Mocked<User>
-
-    ormRepository = {} as jest.Mocked<Repository<User>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
-    ormRepository.save = jest.fn()
-    ormRepository.remove = jest.fn()
-  })
-
-  it('should save', async () => {
-    await createRepository().save(user)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(user)
-  })
-
-  it('should remove', async () => {
-    await createRepository().remove(user)
-
-    expect(ormRepository.remove).toHaveBeenCalledWith(user)
-  })
-
-  it('should find one user by id', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(user)
-
-    const result = await createRepository().findOneByUuid('123')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('user.uuid = :uuid', { uuid: '123' })
-    expect(result).toEqual(user)
-  })
-
-  it('should stream all users', async () => {
-    const stream = {} as jest.Mocked<ReadStream>
-    queryBuilder.stream = jest.fn().mockReturnValue(stream)
-
-    const result = await createRepository().streamAll()
-
-    expect(result).toEqual(stream)
-  })
-
-  it('should find one user by email', async () => {
-    queryBuilder.where = jest.fn().mockReturnThis()
-    queryBuilder.getOne = jest.fn().mockReturnValue(user)
-
-    const result = await createRepository().findOneByEmail('test@test.te')
-
-    expect(queryBuilder.where).toHaveBeenCalledWith('user.email = :email', { email: 'test@test.te' })
-    expect(result).toEqual(user)
-  })
-})

packages/auth/src/Infra/MySQL/MySQLUserRepository.ts

@@ -22,7 +22,10 @@ export class MySQLUserRepository implements UserRepositoryInterface {
   }
 
   async streamAll(): Promise<ReadStream> {
-    return this.ormRepository.createQueryBuilder('user').stream()
+    return this.ormRepository
+      .createQueryBuilder('user')
+      .where('created_at < :createdAt', { createdAt: new Date().toISOString() })
+      .stream()
   }
 
   async streamTeam(memberEmail?: string): Promise<ReadStream> {

packages/auth/src/Infra/MySQL/MySQLUserSubscriptionRepository.spec.ts

@@ -1,287 +0,0 @@
-import 'reflect-metadata'
-
-import { SubscriptionName } from '@standardnotes/common'
-
-import { Repository, SelectQueryBuilder, UpdateQueryBuilder } from 'typeorm'
-import { UserSubscription } from '../../Domain/Subscription/UserSubscription'
-
-import { MySQLUserSubscriptionRepository } from './MySQLUserSubscriptionRepository'
-import { UserSubscriptionType } from '../../Domain/Subscription/UserSubscriptionType'
-import { TimerInterface } from '@standardnotes/time'
-
-describe('MySQLUserSubscriptionRepository', () => {
-  let ormRepository: Repository<UserSubscription>
-  let selectQueryBuilder: SelectQueryBuilder<UserSubscription>
-  let updateQueryBuilder: UpdateQueryBuilder<UserSubscription>
-  let subscription: UserSubscription
-  let timer: TimerInterface
-
-  const createRepository = () => new MySQLUserSubscriptionRepository(ormRepository, timer)
-
-  beforeEach(() => {
-    selectQueryBuilder = {} as jest.Mocked<SelectQueryBuilder<UserSubscription>>
-    updateQueryBuilder = {} as jest.Mocked<UpdateQueryBuilder<UserSubscription>>
-
-    subscription = {
-      planName: SubscriptionName.ProPlan,
-      cancelled: false,
-    } as jest.Mocked<UserSubscription>
-
-    ormRepository = {} as jest.Mocked<Repository<UserSubscription>>
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-    ormRepository.save = jest.fn()
-
-    timer = {} as jest.Mocked<TimerInterface>
-    timer.getTimestampInMicroseconds = jest.fn().mockReturnValue(123)
-  })
-
-  it('should save', async () => {
-    await createRepository().save(subscription)
-
-    expect(ormRepository.save).toHaveBeenCalledWith(subscription)
-  })
-
-  it('should find all subscriptions by user uuid', async () => {
-    const canceledSubscription = {
-      planName: SubscriptionName.ProPlan,
-      cancelled: true,
-    } as jest.Mocked<UserSubscription>
-
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([canceledSubscription, subscription])
-
-    const result = await createRepository().findByUserUuid('123')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :user_uuid', {
-      user_uuid: '123',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual([canceledSubscription, subscription])
-  })
-
-  it('should count all active subscriptions', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.groupBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.getCount = jest.fn().mockReturnValue(2)
-
-    const result = await createRepository().countActiveSubscriptions()
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('ends_at > :timestamp', {
-      timestamp: 123,
-    })
-    expect(selectQueryBuilder.groupBy).toHaveBeenCalledWith('user_uuid')
-    expect(selectQueryBuilder.getCount).toHaveBeenCalled()
-    expect(result).toEqual(2)
-  })
-
-  it('should find one longest lasting uncanceled subscription by user uuid if there are canceled ones', async () => {
-    const canceledSubscription = {
-      planName: SubscriptionName.ProPlan,
-      cancelled: true,
-    } as jest.Mocked<UserSubscription>
-
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([canceledSubscription, subscription])
-
-    const result = await createRepository().findOneByUserUuid('123')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :user_uuid', {
-      user_uuid: '123',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual(subscription)
-  })
-
-  it('should find one, longest lasting subscription by user uuid if there are no canceled ones', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([subscription])
-
-    const result = await createRepository().findOneByUserUuid('123')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :user_uuid', {
-      user_uuid: '123',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual(subscription)
-  })
-
-  it('should count by user uuid', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.getCount = jest.fn().mockReturnValue(2)
-
-    const result = await createRepository().countByUserUuid('123')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :user_uuid', {
-      user_uuid: '123',
-    })
-    expect(selectQueryBuilder.getCount).toHaveBeenCalled()
-    expect(result).toEqual(2)
-  })
-
-  it('should find one, longest lasting subscription by user uuid if there are no ucanceled ones', async () => {
-    subscription.cancelled = true
-
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([subscription])
-
-    const result = await createRepository().findOneByUserUuid('123')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :user_uuid', {
-      user_uuid: '123',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual(subscription)
-  })
-
-  it('should find none if there are no subscriptions for the user', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([])
-
-    const result = await createRepository().findOneByUserUuid('123')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('user_uuid = :user_uuid', {
-      user_uuid: '123',
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('ends_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toBeNull()
-  })
-
-  it('should update ends at by subscription id', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().updateEndsAt(1, 1000, 1000)
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      updatedAt: 1000,
-      renewedAt: 1000,
-      endsAt: 1000,
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('subscription_id = :subscriptionId', {
-      subscriptionId: 1,
-    })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should update cancelled by subscription id', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => updateQueryBuilder)
-
-    updateQueryBuilder.update = jest.fn().mockReturnThis()
-    updateQueryBuilder.set = jest.fn().mockReturnThis()
-    updateQueryBuilder.where = jest.fn().mockReturnThis()
-    updateQueryBuilder.execute = jest.fn()
-
-    await createRepository().updateCancelled(1, true, 1000)
-
-    expect(updateQueryBuilder.update).toHaveBeenCalled()
-    expect(updateQueryBuilder.set).toHaveBeenCalledWith({
-      updatedAt: expect.any(Number),
-      cancelled: true,
-    })
-    expect(updateQueryBuilder.where).toHaveBeenCalledWith('subscription_id = :subscriptionId', {
-      subscriptionId: 1,
-    })
-    expect(updateQueryBuilder.execute).toHaveBeenCalled()
-  })
-
-  it('should find subscriptions by id', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([subscription])
-
-    const result = await createRepository().findBySubscriptionId(123)
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('subscription_id = :subscriptionId', {
-      subscriptionId: 123,
-    })
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('created_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual([subscription])
-  })
-
-  it('should find subscriptions by id and type', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.orderBy = jest.fn().mockReturnThis()
-    selectQueryBuilder.getMany = jest.fn().mockReturnValue([subscription])
-
-    const result = await createRepository().findBySubscriptionIdAndType(123, UserSubscriptionType.Regular)
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith(
-      'subscription_id = :subscriptionId AND subscription_type = :type',
-      {
-        subscriptionId: 123,
-        type: 'regular',
-      },
-    )
-    expect(selectQueryBuilder.orderBy).toHaveBeenCalledWith('created_at', 'DESC')
-    expect(selectQueryBuilder.getMany).toHaveBeenCalled()
-    expect(result).toEqual([subscription])
-  })
-
-  it('should find one subscription by id and user uuid', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.getOne = jest.fn().mockReturnValue(subscription)
-
-    const result = await createRepository().findOneByUserUuidAndSubscriptionId('1-2-3', 5)
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith(
-      'user_uuid = :userUuid AND subscription_id = :subscriptionId',
-      {
-        subscriptionId: 5,
-        userUuid: '1-2-3',
-      },
-    )
-    expect(selectQueryBuilder.getOne).toHaveBeenCalled()
-    expect(result).toEqual(subscription)
-  })
-
-  it('should find one subscription by uuid', async () => {
-    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => selectQueryBuilder)
-
-    selectQueryBuilder.where = jest.fn().mockReturnThis()
-    selectQueryBuilder.getOne = jest.fn().mockReturnValue(subscription)
-
-    const result = await createRepository().findOneByUuid('1-2-3')
-
-    expect(selectQueryBuilder.where).toHaveBeenCalledWith('uuid = :uuid', {
-      uuid: '1-2-3',
-    })
-    expect(selectQueryBuilder.getOne).toHaveBeenCalled()
-    expect(result).toEqual(subscription)
-  })
-})

packages/auth/src/Infra/Redis/LockRepository.spec.ts

@@ -1,92 +0,0 @@
-import 'reflect-metadata'
-
-import * as IORedis from 'ioredis'
-import { LockRepository } from './LockRepository'
-
-describe('LockRepository', () => {
-  let redisClient: IORedis.Redis
-  const maxLoginAttempts = 3
-  const failedLoginLockout = 120
-
-  const createRepository = () => new LockRepository(redisClient, maxLoginAttempts, failedLoginLockout)
-
-  beforeEach(() => {
-    redisClient = {} as jest.Mocked<IORedis.Redis>
-    redisClient.expire = jest.fn()
-    redisClient.del = jest.fn()
-    redisClient.get = jest.fn()
-    redisClient.setex = jest.fn()
-  })
-
-  it('should lock a successfully used OTP for the lockout period', async () => {
-    await createRepository().lockSuccessfullOTP('test@test.te', '123456')
-
-    expect(redisClient.setex).toHaveBeenCalledWith('otp-lock:test@test.te', 60, '123456')
-  })
-
-  it('should indicate if an OTP was already used in the lockout period', async () => {
-    redisClient.get = jest.fn().mockReturnValue('123456')
-
-    expect(await createRepository().isOTPLocked('test@test.te', '123456')).toEqual(true)
-  })
-
-  it('should indicate if an OTP was not already used in the lockout period', async () => {
-    redisClient.get = jest.fn().mockReturnValue('654321')
-
-    expect(await createRepository().isOTPLocked('test@test.te', '123456')).toEqual(false)
-  })
-
-  it('should lock a user for the lockout period', async () => {
-    await createRepository().lockUser('123')
-
-    expect(redisClient.expire).toHaveBeenCalledWith('lock:123', 120)
-  })
-
-  it('should tell a user is locked if his counter is above threshold', async () => {
-    redisClient.get = jest.fn().mockReturnValue('4')
-
-    expect(await createRepository().isUserLocked('123')).toBeTruthy()
-  })
-
-  it('should tell a user is locked if his counter is at the threshold', async () => {
-    redisClient.get = jest.fn().mockReturnValue('3')
-
-    expect(await createRepository().isUserLocked('123')).toBeTruthy()
-  })
-
-  it('should tell a user is not locked if his counter is below threshold', async () => {
-    redisClient.get = jest.fn().mockReturnValue('2')
-
-    expect(await createRepository().isUserLocked('123')).toBeFalsy()
-  })
-
-  it('should tell a user is not locked if he has no counter', async () => {
-    redisClient.get = jest.fn().mockReturnValue(null)
-
-    expect(await createRepository().isUserLocked('123')).toBeFalsy()
-  })
-
-  it('should tell what the user lock counter is', async () => {
-    redisClient.get = jest.fn().mockReturnValue('3')
-
-    expect(await createRepository().getLockCounter('123')).toStrictEqual(3)
-  })
-
-  it('should tell that the user lock counter is 0 when there is no counter', async () => {
-    redisClient.get = jest.fn().mockReturnValue(null)
-
-    expect(await createRepository().getLockCounter('123')).toStrictEqual(0)
-  })
-
-  it('should reset a lock counter', async () => {
-    await createRepository().resetLockCounter('123')
-
-    expect(redisClient.del).toHaveBeenCalledWith('lock:123')
-  })
-
-  it('should update a lock counter', async () => {
-    await createRepository().updateLockCounter('123', 3)
-
-    expect(redisClient.setex).toHaveBeenCalledWith('lock:123', 120, 3)
-  })
-})

packages/auth/src/Infra/Redis/RedisEphemeralSessionRepository.spec.ts

@@ -1,152 +0,0 @@
-import 'reflect-metadata'
-
-import * as IORedis from 'ioredis'
-
-import { RedisEphemeralSessionRepository } from './RedisEphemeralSessionRepository'
-import { EphemeralSession } from '../../Domain/Session/EphemeralSession'
-
-describe('RedisEphemeralSessionRepository', () => {
-  let redisClient: IORedis.Redis
-  let pipeline: IORedis.Pipeline
-
-  const createRepository = () => new RedisEphemeralSessionRepository(redisClient, 3600)
-
-  beforeEach(() => {
-    redisClient = {} as jest.Mocked<IORedis.Redis>
-
-    redisClient.get = jest.fn()
-    redisClient.smembers = jest.fn()
-
-    pipeline = {} as jest.Mocked<IORedis.Pipeline>
-    pipeline.setex = jest.fn()
-    pipeline.expire = jest.fn()
-    pipeline.sadd = jest.fn()
-    pipeline.del = jest.fn()
-    pipeline.srem = jest.fn()
-    pipeline.exec = jest.fn()
-
-    redisClient.pipeline = jest.fn().mockReturnValue(pipeline)
-  })
-
-  it('should delete an ephemeral', async () => {
-    await createRepository().deleteOne('1-2-3', '2-3-4')
-
-    expect(pipeline.del).toHaveBeenCalledWith('session:1-2-3:2-3-4')
-    expect(pipeline.del).toHaveBeenCalledWith('session:1-2-3')
-    expect(pipeline.srem).toHaveBeenCalledWith('user-sessions:2-3-4', '1-2-3')
-  })
-
-  it('should save an ephemeral session', async () => {
-    const ephemeralSession = new EphemeralSession()
-    ephemeralSession.uuid = '1-2-3'
-    ephemeralSession.userUuid = '2-3-4'
-    ephemeralSession.userAgent = 'Mozilla Firefox'
-    ephemeralSession.createdAt = new Date(1)
-    ephemeralSession.updatedAt = new Date(2)
-
-    await createRepository().save(ephemeralSession)
-
-    expect(pipeline.setex).toHaveBeenCalledWith(
-      'session:1-2-3:2-3-4',
-      3600,
-      '{"uuid":"1-2-3","userUuid":"2-3-4","userAgent":"Mozilla Firefox","createdAt":"1970-01-01T00:00:00.001Z","updatedAt":"1970-01-01T00:00:00.002Z"}',
-    )
-    expect(pipeline.sadd).toHaveBeenCalledWith('user-sessions:2-3-4', '1-2-3')
-    expect(pipeline.expire).toHaveBeenCalledWith('user-sessions:2-3-4', 3600)
-  })
-
-  it('should find all ephemeral sessions by user uuid', async () => {
-    redisClient.smembers = jest.fn().mockReturnValue(['1-2-3', '2-3-4', '3-4-5'])
-
-    redisClient.get = jest
-      .fn()
-      .mockReturnValueOnce(
-        '{"uuid":"1-2-3","userUuid":"2-3-4","userAgent":"Mozilla Firefox","createdAt":"1970-01-01T00:00:00.001Z","updatedAt":"1970-01-01T00:00:00.002Z"}',
-      )
-      .mockReturnValueOnce(
-        '{"uuid":"2-3-4","userUuid":"2-3-4","userAgent":"Google Chrome","createdAt":"1970-01-01T00:00:00.001Z","updatedAt":"1970-01-01T00:00:00.002Z"}',
-      )
-      .mockReturnValueOnce(null)
-
-    const ephemeralSessions = await createRepository().findAllByUserUuid('2-3-4')
-
-    expect(ephemeralSessions.length).toEqual(2)
-    expect(ephemeralSessions[1].userAgent).toEqual('Google Chrome')
-  })
-
-  it('should find an ephemeral session by uuid', async () => {
-    redisClient.get = jest
-      .fn()
-      .mockReturnValue(
-        '{"uuid":"1-2-3","userUuid":"2-3-4","userAgent":"Mozilla Firefox","createdAt":"1970-01-01T00:00:00.001Z","updatedAt":"1970-01-01T00:00:00.002Z"}',
-      )
-
-    const ephemeralSession = <EphemeralSession>await createRepository().findOneByUuid('1-2-3')
-
-    expect(ephemeralSession).not.toBeUndefined()
-    expect(ephemeralSession.userAgent).toEqual('Mozilla Firefox')
-  })
-
-  it('should find an ephemeral session by uuid and user uuid', async () => {
-    redisClient.get = jest
-      .fn()
-      .mockReturnValue(
-        '{"uuid":"1-2-3","userUuid":"2-3-4","userAgent":"Mozilla Firefox","createdAt":"1970-01-01T00:00:00.001Z","updatedAt":"1970-01-01T00:00:00.002Z"}',
-      )
-
-    const ephemeralSession = <EphemeralSession>await createRepository().findOneByUuidAndUserUuid('1-2-3', '2-3-4')
-
-    expect(ephemeralSession).not.toBeUndefined()
-    expect(ephemeralSession.userAgent).toEqual('Mozilla Firefox')
-  })
-
-  it('should return undefined if session is not found', async () => {
-    redisClient.get = jest.fn().mockReturnValue(null)
-
-    const ephemeralSession = <EphemeralSession>await createRepository().findOneByUuid('1-2-3')
-
-    expect(ephemeralSession).toBeNull()
-  })
-
-  it('should return undefined if ephemeral session is not found', async () => {
-    redisClient.get = jest.fn().mockReturnValue(null)
-
-    const ephemeralSession = <EphemeralSession>await createRepository().findOneByUuidAndUserUuid('1-2-3', '2-3-4')
-
-    expect(ephemeralSession).toBeNull()
-  })
-
-  it('should update tokens and expirations dates', async () => {
-    redisClient.get = jest
-      .fn()
-      .mockReturnValue(
-        '{"uuid":"1-2-3","userUuid":"2-3-4","userAgent":"Mozilla Firefox","createdAt":"1970-01-01T00:00:00.001Z","updatedAt":"1970-01-01T00:00:00.002Z"}',
-      )
-
-    await createRepository().updateTokensAndExpirationDates(
-      '1-2-3',
-      'dummy_access_token',
-      'dummy_refresh_token',
-      new Date(3),
-      new Date(4),
-    )
-
-    expect(pipeline.setex).toHaveBeenCalledWith(
-      'session:1-2-3:2-3-4',
-      3600,
-      '{"uuid":"1-2-3","userUuid":"2-3-4","userAgent":"Mozilla Firefox","createdAt":"1970-01-01T00:00:00.001Z","updatedAt":"1970-01-01T00:00:00.002Z","hashedAccessToken":"dummy_access_token","hashedRefreshToken":"dummy_refresh_token","accessExpiration":"1970-01-01T00:00:00.003Z","refreshExpiration":"1970-01-01T00:00:00.004Z"}',
-    )
-  })
-
-  it('should not update tokens and expirations dates if the ephemeral session does not exist', async () => {
-    await createRepository().updateTokensAndExpirationDates(
-      '1-2-3',
-      'dummy_access_token',
-      'dummy_refresh_token',
-      new Date(3),
-      new Date(4),
-    )
-
-    expect(pipeline.setex).not.toHaveBeenCalled()
-  })
-})

packages/auth/src/Infra/Redis/RedisOfflineSubscriptionTokenRepository.spec.ts

@@ -1,59 +0,0 @@
-import 'reflect-metadata'
-
-import * as IORedis from 'ioredis'
-import { TimerInterface } from '@standardnotes/time'
-
-import { RedisOfflineSubscriptionTokenRepository } from './RedisOfflineSubscriptionTokenRepository'
-import { OfflineSubscriptionToken } from '../../Domain/Auth/OfflineSubscriptionToken'
-import { Logger } from 'winston'
-
-describe('RedisOfflineSubscriptionTokenRepository', () => {
-  let redisClient: IORedis.Redis
-  let timer: TimerInterface
-  let logger: Logger
-
-  const createRepository = () => new RedisOfflineSubscriptionTokenRepository(redisClient, timer, logger)
-
-  beforeEach(() => {
-    redisClient = {} as jest.Mocked<IORedis.Redis>
-    redisClient.set = jest.fn()
-    redisClient.get = jest.fn()
-    redisClient.expireat = jest.fn()
-
-    timer = {} as jest.Mocked<TimerInterface>
-    timer.convertMicrosecondsToSeconds = jest.fn().mockReturnValue(1)
-
-    logger = {} as jest.Mocked<Logger>
-    logger.debug = jest.fn()
-  })
-
-  it('should get a user uuid in exchange for an dashboard token', async () => {
-    redisClient.get = jest.fn().mockReturnValue('test@test.com')
-
-    expect(await createRepository().getUserEmailByToken('random-string')).toEqual('test@test.com')
-
-    expect(redisClient.get).toHaveBeenCalledWith('offline-subscription-token:random-string')
-  })
-
-  it('should return undefined if a user uuid is not exchanged for an dashboard token', async () => {
-    redisClient.get = jest.fn().mockReturnValue(null)
-
-    expect(await createRepository().getUserEmailByToken('random-string')).toBeUndefined()
-
-    expect(redisClient.get).toHaveBeenCalledWith('offline-subscription-token:random-string')
-  })
-
-  it('should save an dashboard token', async () => {
-    const offlineSubscriptionToken: OfflineSubscriptionToken = {
-      userEmail: 'test@test.com',
-      token: 'random-string',
-      expiresAt: 123,
-    }
-
-    await createRepository().save(offlineSubscriptionToken)
-
-    expect(redisClient.set).toHaveBeenCalledWith('offline-subscription-token:random-string', 'test@test.com')
-
-    expect(redisClient.expireat).toHaveBeenCalledWith('offline-subscription-token:random-string', 1)
-  })
-})

packages/auth/src/Infra/Redis/RedisPKCERepository.spec.ts

@@ -1,34 +0,0 @@
-import 'reflect-metadata'
-
-import * as IORedis from 'ioredis'
-import { Logger } from 'winston'
-
-import { RedisPKCERepository } from './RedisPKCERepository'
-
-describe('RedisPKCERepository', () => {
-  let redisClient: IORedis.Redis
-  let logger: Logger
-
-  const createRepository = () => new RedisPKCERepository(redisClient, logger)
-
-  beforeEach(() => {
-    redisClient = {} as jest.Mocked<IORedis.Redis>
-    redisClient.setex = jest.fn()
-    redisClient.del = jest.fn().mockReturnValue(1)
-
-    logger = {} as jest.Mocked<Logger>
-    logger.debug = jest.fn()
-  })
-
-  it('should store a code challenge', async () => {
-    await createRepository().storeCodeChallenge('test')
-
-    expect(redisClient.setex).toHaveBeenCalledWith('pkce:test', 3600, 'test')
-  })
-
-  it('should remove a code challenge and notify of success', async () => {
-    expect(await createRepository().removeCodeChallenge('test')).toBeTruthy()
-
-    expect(redisClient.del).toHaveBeenCalledWith('pkce:test')
-  })
-})

packages/auth/src/Infra/Redis/RedisSubscriptionTokenRepository.spec.ts

@@ -1,70 +0,0 @@
-import 'reflect-metadata'
-
-import * as IORedis from 'ioredis'
-import { TimerInterface } from '@standardnotes/time'
-
-import { RedisSubscriptionTokenRepository } from './RedisSubscriptionTokenRepository'
-import { SubscriptionToken } from '../../Domain/Subscription/SubscriptionToken'
-
-describe('RedisSubscriptionTokenRepository', () => {
-  let redisClient: IORedis.Redis
-  let timer: TimerInterface
-
-  const createRepository = () => new RedisSubscriptionTokenRepository(redisClient, timer)
-
-  beforeEach(() => {
-    redisClient = {} as jest.Mocked<IORedis.Redis>
-    redisClient.set = jest.fn().mockReturnValue('OK')
-    redisClient.get = jest.fn()
-    redisClient.expireat = jest.fn().mockReturnValue(1)
-
-    timer = {} as jest.Mocked<TimerInterface>
-    timer.convertMicrosecondsToSeconds = jest.fn().mockReturnValue(1)
-  })
-
-  it('should get a user uuid in exchange for an subscription token', async () => {
-    redisClient.get = jest.fn().mockReturnValue('1-2-3')
-
-    expect(await createRepository().getUserUuidByToken('random-string')).toEqual('1-2-3')
-
-    expect(redisClient.get).toHaveBeenCalledWith('subscription-token:random-string')
-  })
-
-  it('should return undefined if a user uuid is not exchanged for an subscription token', async () => {
-    redisClient.get = jest.fn().mockReturnValue(null)
-
-    expect(await createRepository().getUserUuidByToken('random-string')).toBeUndefined()
-
-    expect(redisClient.get).toHaveBeenCalledWith('subscription-token:random-string')
-  })
-
-  it('should save an subscription token', async () => {
-    const subscriptionToken: SubscriptionToken = {
-      userUuid: '1-2-3',
-      token: 'random-string',
-      expiresAt: 123,
-    }
-
-    expect(await createRepository().save(subscriptionToken)).toBeTruthy()
-
-    expect(redisClient.set).toHaveBeenCalledWith('subscription-token:random-string', '1-2-3')
-
-    expect(redisClient.expireat).toHaveBeenCalledWith('subscription-token:random-string', 1)
-  })
-
-  it('should indicate subscription token was not saved', async () => {
-    redisClient.set = jest.fn().mockReturnValue(null)
-
-    const subscriptionToken: SubscriptionToken = {
-      userUuid: '1-2-3',
-      token: 'random-string',
-      expiresAt: 123,
-    }
-
-    expect(await createRepository().save(subscriptionToken)).toBeFalsy()
-
-    expect(redisClient.set).toHaveBeenCalledWith('subscription-token:random-string', '1-2-3')
-
-    expect(redisClient.expireat).toHaveBeenCalledWith('subscription-token:random-string', 1)
-  })
-})

packages/auth/src/Infra/WebSockets/WebSocketsClientService.spec.ts

@@ -1,53 +0,0 @@
-import 'reflect-metadata'
-
-import {
-  DomainEventPublisherInterface,
-  UserRolesChangedEvent,
-  WebSocketMessageRequestedEvent,
-} from '@standardnotes/domain-events'
-import { RoleName } from '@standardnotes/common'
-
-import { User } from '../../Domain/User/User'
-import { WebSocketsClientService } from './WebSocketsClientService'
-import { DomainEventFactoryInterface } from '../../Domain/Event/DomainEventFactoryInterface'
-
-describe('WebSocketsClientService', () => {
-  let user: User
-  let event: UserRolesChangedEvent
-  let domainEventFactory: DomainEventFactoryInterface
-  let domainEventPublisher: DomainEventPublisherInterface
-
-  const createService = () => new WebSocketsClientService(domainEventFactory, domainEventPublisher)
-
-  beforeEach(() => {
-    user = {
-      uuid: '123',
-      email: 'test@test.com',
-      roles: Promise.resolve([
-        {
-          name: RoleName.ProUser,
-        },
-      ]),
-    } as jest.Mocked<User>
-
-    event = {} as jest.Mocked<UserRolesChangedEvent>
-
-    domainEventFactory = {} as jest.Mocked<DomainEventFactoryInterface>
-    domainEventFactory.createUserRolesChangedEvent = jest.fn().mockReturnValue(event)
-    domainEventFactory.createWebSocketMessageRequestedEvent = jest
-      .fn()
-      .mockReturnValue({} as jest.Mocked<WebSocketMessageRequestedEvent>)
-
-    domainEventPublisher = {} as jest.Mocked<DomainEventPublisherInterface>
-    domainEventPublisher.publish = jest.fn()
-  })
-
-  it('should request a message about a user role changed', async () => {
-    await createService().sendUserRolesChangedEvent(user)
-
-    expect(domainEventFactory.createUserRolesChangedEvent).toHaveBeenCalledWith('123', 'test@test.com', [
-      RoleName.ProUser,
-    ])
-    expect(domainEventPublisher.publish).toHaveBeenCalled()
-  })
-})

packages/auth/src/Projection/PermissionProjector.spec.ts

@@ -1,47 +0,0 @@
-import 'reflect-metadata'
-
-import { Permission } from '../Domain/Permission/Permission'
-
-import { PermissionProjector } from './PermissionProjector'
-
-describe('PermissionProjector', () => {
-  let permission: Permission
-
-  const createProjector = () => new PermissionProjector()
-
-  beforeEach(() => {
-    permission = new Permission()
-    permission.uuid = '123'
-    permission.name = 'permission1'
-    permission.createdAt = new Date(1)
-    permission.updatedAt = new Date(2)
-  })
-
-  it('should create a simple projection', () => {
-    const projection = createProjector().projectSimple(permission)
-    expect(projection).toMatchObject({
-      uuid: '123',
-      name: 'permission1',
-    })
-  })
-
-  it('should throw error on custom projection', () => {
-    let error = null
-    try {
-      createProjector().projectCustom('test', permission)
-    } catch (e) {
-      error = e
-    }
-    expect(error).not.toBeNull()
-  })
-
-  it('should throw error on not implemetned full projection', () => {
-    let error = null
-    try {
-      createProjector().projectFull(permission)
-    } catch (e) {
-      error = e
-    }
-    expect(error).not.toBeNull()
-  })
-})

packages/auth/src/Projection/RoleProjector.spec.ts

@@ -1,47 +0,0 @@
-import 'reflect-metadata'
-
-import { Role } from '../Domain/Role/Role'
-
-import { RoleProjector } from './RoleProjector'
-
-describe('RoleProjector', () => {
-  let role: Role
-
-  const createProjector = () => new RoleProjector()
-
-  beforeEach(() => {
-    role = new Role()
-    role.uuid = '123'
-    role.name = 'role1'
-    role.createdAt = new Date(1)
-    role.updatedAt = new Date(2)
-  })
-
-  it('should create a simple projection', () => {
-    const projection = createProjector().projectSimple(role)
-    expect(projection).toMatchObject({
-      uuid: '123',
-      name: 'role1',
-    })
-  })
-
-  it('should throw error on custom projection', () => {
-    let error = null
-    try {
-      createProjector().projectCustom('test', role)
-    } catch (e) {
-      error = e
-    }
-    expect(error).not.toBeNull()
-  })
-
-  it('should throw error on not implemetned full projection', () => {
-    let error = null
-    try {
-      createProjector().projectFull(role)
-    } catch (e) {
-      error = e
-    }
-    expect(error).not.toBeNull()
-  })
-})

packages/auth/src/Projection/SessionProjector.spec.ts

@@ -1,109 +0,0 @@
-import 'reflect-metadata'
-
-import { SessionServiceInterface } from '../Domain/Session/SessionServiceInterface'
-import { SessionProjector } from './SessionProjector'
-import { Session } from '../Domain/Session/Session'
-import { TimerInterface } from '@standardnotes/time'
-
-describe('SessionProjector', () => {
-  let session: Session
-  let currentSession: Session
-  let sessionService: SessionServiceInterface
-  let timer: TimerInterface
-
-  const createProjector = () => new SessionProjector(sessionService, timer)
-
-  beforeEach(() => {
-    session = new Session()
-    session.uuid = '123'
-    session.hashedAccessToken = 'hashed access token'
-    session.userUuid = '234'
-    session.apiVersion = '004'
-    session.createdAt = new Date(1)
-    session.updatedAt = new Date(1)
-    session.accessExpiration = new Date(1)
-    session.refreshExpiration = new Date(1)
-    session.readonlyAccess = false
-
-    currentSession = new Session()
-    currentSession.uuid = '234'
-
-    sessionService = {} as jest.Mocked<SessionServiceInterface>
-    sessionService.getDeviceInfo = jest.fn().mockReturnValue('Some Device Info')
-
-    timer = {} as jest.Mocked<TimerInterface>
-    timer.convertDateToISOString = jest.fn().mockReturnValue('2020-11-26T13:34:00.000Z')
-  })
-
-  it('should create a simple projection of a session', () => {
-    const projection = createProjector().projectSimple(session)
-    expect(projection).toMatchObject({
-      uuid: '123',
-      api_version: '004',
-      created_at: '2020-11-26T13:34:00.000Z',
-      updated_at: '2020-11-26T13:34:00.000Z',
-      device_info: 'Some Device Info',
-      readonly_access: false,
-      access_expiration: '2020-11-26T13:34:00.000Z',
-      refresh_expiration: '2020-11-26T13:34:00.000Z',
-    })
-  })
-
-  it('should create a custom projection of a session', () => {
-    const projection = createProjector().projectCustom(
-      SessionProjector.CURRENT_SESSION_PROJECTION.toString(),
-      session,
-      currentSession,
-    )
-
-    expect(projection).toMatchObject({
-      uuid: '123',
-      api_version: '004',
-      created_at: '2020-11-26T13:34:00.000Z',
-      updated_at: '2020-11-26T13:34:00.000Z',
-      device_info: 'Some Device Info',
-      current: false,
-      readonly_access: false,
-    })
-  })
-
-  it('should create a custom projection of a current session', () => {
-    currentSession.uuid = '123'
-
-    const projection = createProjector().projectCustom(
-      SessionProjector.CURRENT_SESSION_PROJECTION.toString(),
-      session,
-      currentSession,
-    )
-
-    expect(projection).toMatchObject({
-      uuid: '123',
-      api_version: '004',
-      created_at: '2020-11-26T13:34:00.000Z',
-      updated_at: '2020-11-26T13:34:00.000Z',
-      device_info: 'Some Device Info',
-      current: true,
-      readonly_access: false,
-    })
-  })
-
-  it('should throw error on unknown custom projection', () => {
-    let error = null
-    try {
-      createProjector().projectCustom('test', session, currentSession)
-    } catch (e) {
-      error = e
-    }
-    expect((error as Error).message).toEqual('Not supported projection type: test')
-  })
-
-  it('should throw error on not implemetned full projection', () => {
-    let error = null
-    try {
-      createProjector().projectFull(session)
-    } catch (e) {
-      error = e
-    }
-    expect((error as Error).message).toEqual('not implemented')
-  })
-})

packages/auth/src/Projection/SettingProjector.spec.ts

@@ -1,48 +0,0 @@
-import 'reflect-metadata'
-
-import { Setting } from '../Domain/Setting/Setting'
-
-import { SettingProjector } from './SettingProjector'
-
-describe('SettingProjector', () => {
-  let setting: Setting
-
-  const createProjector = () => new SettingProjector()
-
-  beforeEach(() => {
-    setting = {
-      uuid: 'setting-uuid',
-      name: 'setting-name',
-      value: 'setting-value',
-      serverEncryptionVersion: 1,
-      createdAt: 1,
-      updatedAt: 2,
-      sensitive: false,
-    } as jest.Mocked<Setting>
-  })
-
-  it('should create a simple projection of a setting', async () => {
-    const projection = await createProjector().projectSimple(setting)
-    expect(projection).toStrictEqual({
-      uuid: 'setting-uuid',
-      name: 'setting-name',
-      value: 'setting-value',
-      createdAt: 1,
-      updatedAt: 2,
-      sensitive: false,
-    })
-  })
-  it('should create a simple projection of list of settings', async () => {
-    const projection = await createProjector().projectManySimple([setting])
-    expect(projection).toStrictEqual([
-      {
-        uuid: 'setting-uuid',
-        name: 'setting-name',
-        value: 'setting-value',
-        createdAt: 1,
-        updatedAt: 2,
-        sensitive: false,
-      },
-    ])
-  })
-})

packages/auth/src/Projection/SubscriptionSettingProjector.spec.ts

@@ -1,48 +0,0 @@
-import 'reflect-metadata'
-
-import { SubscriptionSetting } from '../Domain/Setting/SubscriptionSetting'
-
-import { SubscriptionSettingProjector } from './SubscriptionSettingProjector'
-
-describe('SubscriptionSettingProjector', () => {
-  let setting: SubscriptionSetting
-
-  const createProjector = () => new SubscriptionSettingProjector()
-
-  beforeEach(() => {
-    setting = {
-      uuid: 'setting-uuid',
-      name: 'setting-name',
-      value: 'setting-value',
-      serverEncryptionVersion: 1,
-      createdAt: 1,
-      updatedAt: 2,
-      sensitive: false,
-    } as jest.Mocked<SubscriptionSetting>
-  })
-
-  it('should create a simple projection of a setting', async () => {
-    const projection = await createProjector().projectSimple(setting)
-    expect(projection).toStrictEqual({
-      uuid: 'setting-uuid',
-      name: 'setting-name',
-      value: 'setting-value',
-      createdAt: 1,
-      updatedAt: 2,
-      sensitive: false,
-    })
-  })
-  it('should create a simple projection of list of settings', async () => {
-    const projection = await createProjector().projectManySimple([setting])
-    expect(projection).toStrictEqual([
-      {
-        uuid: 'setting-uuid',
-        name: 'setting-name',
-        value: 'setting-value',
-        createdAt: 1,
-        updatedAt: 2,
-        sensitive: false,
-      },
-    ])
-  })
-})

packages/auth/src/Projection/UserProjector.spec.ts

@@ -1,45 +0,0 @@
-import 'reflect-metadata'
-
-import { UserProjector } from './UserProjector'
-import { User } from '../Domain/User/User'
-
-describe('UserProjector', () => {
-  let user: User
-
-  const createProjector = () => new UserProjector()
-
-  beforeEach(() => {
-    user = new User()
-    user.uuid = '123'
-    user.email = 'test@test.te'
-    user.encryptedPassword = '123qwe345'
-  })
-
-  it('should create a simple projection of a user', () => {
-    const projection = createProjector().projectSimple(user)
-    expect(projection).toMatchObject({
-      uuid: '123',
-      email: 'test@test.te',
-    })
-  })
-
-  it('should throw error on custom projection', () => {
-    let error = null
-    try {
-      createProjector().projectCustom('test', user)
-    } catch (e) {
-      error = e
-    }
-    expect(error).not.toBeNull()
-  })
-
-  it('should throw error on not implemetned full projection', () => {
-    let error = null
-    try {
-      createProjector().projectFull(user)
-    } catch (e) {
-      error = e
-    }
-    expect(error).not.toBeNull()
-  })
-})