feat(auth): add processing user requests

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

@@ -0,0 +1,94 @@
+import 'reflect-metadata'
+
+import { DomainEventPublisherInterface, ExitDiscountApplyRequestedEvent } from '@standardnotes/domain-events'
+import { UserRequestType } from '@standardnotes/common'
+
+import { DomainEventFactoryInterface } from '../../Event/DomainEventFactoryInterface'
+import { UserSubscription } from '../../Subscription/UserSubscription'
+import { UserSubscriptionRepositoryInterface } from '../../Subscription/UserSubscriptionRepositoryInterface'
+
+import { ProcessUserRequest } from './ProcessUserRequest'
+
+describe('ProcessUserRequest', () => {
+  let userSubscriptionRepository: UserSubscriptionRepositoryInterface
+  let domainEventFactory: DomainEventFactoryInterface
+  let domainEventPublisher: DomainEventPublisherInterface
+
+  const createUseCase = () =>
+    new ProcessUserRequest(userSubscriptionRepository, domainEventFactory, domainEventPublisher)
+
+  beforeEach(() => {
+    userSubscriptionRepository = {} as jest.Mocked<UserSubscriptionRepositoryInterface>
+    userSubscriptionRepository.findOneByUserUuid = jest.fn().mockReturnValue({
+      cancelled: true,
+    } as jest.Mocked<UserSubscription>)
+
+    domainEventFactory = {} as jest.Mocked<DomainEventFactoryInterface>
+    domainEventFactory.createExitDiscountApplyRequestedEvent = jest
+      .fn()
+      .mockReturnValue({} as jest.Mocked<ExitDiscountApplyRequestedEvent>)
+
+    domainEventPublisher = {} as jest.Mocked<DomainEventPublisherInterface>
+    domainEventPublisher.publish = jest.fn()
+  })
+
+  it('should not process unsupported requests', async () => {
+    expect(
+      await createUseCase().execute({
+        userEmail: '[email protected]',
+        userUuid: '1-2-3',
+        requestType: 'foobar' as UserRequestType,
+      }),
+    ).toEqual({
+      success: false,
+    })
+
+    expect(domainEventPublisher.publish).not.toHaveBeenCalled()
+  })
+
+  it('should not process uncancelled subscriptions', async () => {
+    userSubscriptionRepository.findOneByUserUuid = jest.fn().mockReturnValue({} as jest.Mocked<UserSubscription>)
+
+    expect(
+      await createUseCase().execute({
+        userEmail: '[email protected]',
+        userUuid: '1-2-3',
+        requestType: UserRequestType.ExitDiscount,
+      }),
+    ).toEqual({
+      success: false,
+    })
+
+    expect(domainEventPublisher.publish).not.toHaveBeenCalled()
+  })
+
+  it('should not process non existing subscriptions', async () => {
+    userSubscriptionRepository.findOneByUserUuid = jest.fn().mockReturnValue(null)
+
+    expect(
+      await createUseCase().execute({
+        userEmail: '[email protected]',
+        userUuid: '1-2-3',
+        requestType: UserRequestType.ExitDiscount,
+      }),
+    ).toEqual({
+      success: false,
+    })
+
+    expect(domainEventPublisher.publish).not.toHaveBeenCalled()
+  })
+
+  it('should publish an exit discount apply requested event', async () => {
+    expect(
+      await createUseCase().execute({
+        userEmail: '[email protected]',
+        userUuid: '1-2-3',
+        requestType: UserRequestType.ExitDiscount,
+      }),
+    ).toEqual({
+      success: true,
+    })
+
+    expect(domainEventPublisher.publish).toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,46 @@
+import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
+import { inject, injectable } from 'inversify'
+import { UserRequestType } from '@standardnotes/common'
+
+import TYPES from '../../../Bootstrap/Types'
+import { DomainEventFactoryInterface } from '../../Event/DomainEventFactoryInterface'
+import { UserSubscriptionRepositoryInterface } from '../../Subscription/UserSubscriptionRepositoryInterface'
+
+import { UseCaseInterface } from '../UseCaseInterface'
+import { ProcessUserRequestDTO } from './ProcessUserRequestDTO'
+import { ProcessUserRequestResponse } from './ProcessUserRequestResponse'
+
+@injectable()
+export class ProcessUserRequest implements UseCaseInterface {
+  constructor(
+    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
+    @inject(TYPES.DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
+  ) {}
+
+  async execute(dto: ProcessUserRequestDTO): Promise<ProcessUserRequestResponse> {
+    if (dto.requestType !== UserRequestType.ExitDiscount) {
+      return {
+        success: false,
+      }
+    }
+
+    const subscription = await this.userSubscriptionRepository.findOneByUserUuid(dto.userUuid)
+    if (subscription === null || !subscription.cancelled) {
+      return {
+        success: false,
+      }
+    }
+
+    await this.domainEventPublisher.publish(
+      this.domainEventFactory.createExitDiscountApplyRequestedEvent({
+        userEmail: dto.userEmail,
+        discountCode: 'exit-20',
+      }),
+    )
+
+    return {
+      success: true,
+    }
+  }
+}

packages/auth/src/Domain/UseCase/ProcessUserRequest/ProcessUserRequestDTO.ts

@@ -0,0 +1,7 @@
+import { UserRequestType, Uuid } from '@standardnotes/common'
+
+export type ProcessUserRequestDTO = {
+  userUuid: Uuid
+  userEmail: string
+  requestType: UserRequestType
+}

packages/auth/src/Domain/UseCase/ProcessUserRequest/ProcessUserRequestResponse.ts

@@ -0,0 +1,3 @@
+export type ProcessUserRequestResponse = {
+  success: boolean
+}