feat: add sending user requests to process (#1908)

* feat: add sending user requests to process

* fix(snjs): yarn lock

* fix(snjs): imports

* fix: specs

packages/api/src/Domain/Client/User/UserApiOperations.ts

@@ -0,0 +1,5 @@
+export enum UserApiOperations {
+  Registering,
+  SubmittingRequest,
+  DeletingAccount,
+}

packages/api/src/Domain/Client/User/UserApiService.spec.ts

@@ -1,20 +1,35 @@
-import { ProtocolVersion } from '@standardnotes/common'
+import { ProtocolVersion, UserRequestType } from '@standardnotes/common'
 import { RootKeyParamsInterface } from '@standardnotes/models'
+import { UserDeletionResponse } from '../../Response/User/UserDeletionResponse'
+
 import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
+import { UserRequestResponse } from '../../Response/UserRequest/UserRequestResponse'
 import { UserServerInterface } from '../../Server'
+import { UserRequestServerInterface } from '../../Server/UserRequest/UserRequestServerInterface'
+
+import { UserApiOperations } from './UserApiOperations'
 import { UserApiService } from './UserApiService'
 
 describe('UserApiService', () => {
   let userServer: UserServerInterface
+  let userRequestServer: UserRequestServerInterface
   let keyParams: RootKeyParamsInterface
 
-  const createService = () => new UserApiService(userServer)
+  const createService = () => new UserApiService(userServer, userRequestServer)
 
   beforeEach(() => {
     userServer = {} as jest.Mocked<UserServerInterface>
     userServer.register = jest.fn().mockReturnValue({
       data: { user: { email: 'test@test.te', uuid: '1-2-3' } },
     } as jest.Mocked<UserRegistrationResponse>)
+    userServer.deleteAccount = jest.fn().mockReturnValue({
+      data: { message: 'Success' },
+    } as jest.Mocked<UserDeletionResponse>)
+
+    userRequestServer = {} as jest.Mocked<UserRequestServerInterface>
+    userRequestServer.submitUserRequest = jest.fn().mockReturnValue({
+      data: { success: true },
+    } as jest.Mocked<UserRequestResponse>)
 
     keyParams = {} as jest.Mocked<RootKeyParamsInterface>
     keyParams.getPortableValue = jest.fn().mockReturnValue({
@@ -51,8 +66,8 @@ describe('UserApiService', () => {
 
   it('should not register a user if it is already registering', async () => {
     const service = createService()
-    Object.defineProperty(service, 'registering', {
-      get: () => true,
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[UserApiOperations.Registering, true]]),
     })
 
     let error = null
@@ -84,4 +99,99 @@ describe('UserApiService', () => {
 
     expect(error).not.toBeNull()
   })
+
+  it('should submit a user request', async () => {
+    const response = await createService().submitUserRequest({
+      userUuid: '1-2-3',
+      requestType: UserRequestType.ExitDiscount,
+    })
+
+    expect(response).toEqual({
+      data: {
+        success: true,
+      },
+    })
+    expect(userRequestServer.submitUserRequest).toHaveBeenCalledWith({
+      userUuid: '1-2-3',
+      requestType: UserRequestType.ExitDiscount,
+    })
+  })
+
+  it('should not submit a user request if it is already submitting', async () => {
+    const service = createService()
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[UserApiOperations.SubmittingRequest, true]]),
+    })
+
+    let error = null
+    try {
+      await service.submitUserRequest({ userUuid: '1-2-3', requestType: UserRequestType.ExitDiscount })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should not submit a user request if the server fails', async () => {
+    userRequestServer.submitUserRequest = jest.fn().mockImplementation(() => {
+      throw new Error('Oops')
+    })
+
+    let error = null
+    try {
+      await createService().submitUserRequest({
+        userUuid: '1-2-3',
+        requestType: UserRequestType.ExitDiscount,
+      })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should delete a user', async () => {
+    const response = await createService().deleteAccount('1-2-3')
+
+    expect(response).toEqual({
+      data: {
+        message: 'Success',
+      },
+    })
+    expect(userServer.deleteAccount).toHaveBeenCalledWith({
+      userUuid: '1-2-3',
+    })
+  })
+
+  it('should not delete a user if it is already deleting', async () => {
+    const service = createService()
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[UserApiOperations.DeletingAccount, true]]),
+    })
+
+    let error = null
+    try {
+      await service.deleteAccount('1-2-3')
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should not delete a user if the server fails', async () => {
+    userServer.deleteAccount = jest.fn().mockImplementation(() => {
+      throw new Error('Oops')
+    })
+
+    let error = null
+    try {
+      await createService().deleteAccount('1-2-3')
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
 })

packages/api/src/Domain/Client/User/UserApiService.ts

@@ -1,17 +1,57 @@
 import { RootKeyParamsInterface } from '@standardnotes/models'
+import { UserRequestType } from '@standardnotes/common'
+
 import { ErrorMessage } from '../../Error/ErrorMessage'
 import { ApiCallError } from '../../Error/ApiCallError'
 import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
 import { UserServerInterface } from '../../Server/User/UserServerInterface'
 import { ApiVersion } from '../../Api/ApiVersion'
 import { ApiEndpointParam } from '../../Request/ApiEndpointParam'
+import { UserRequestResponse } from '../../Response/UserRequest/UserRequestResponse'
+import { UserDeletionResponse } from '../../Response/User/UserDeletionResponse'
+import { UserRequestServerInterface } from '../../Server/UserRequest/UserRequestServerInterface'
+
+import { UserApiOperations } from './UserApiOperations'
 import { UserApiServiceInterface } from './UserApiServiceInterface'
 
 export class UserApiService implements UserApiServiceInterface {
-  private registering: boolean
+  private operationsInProgress: Map<UserApiOperations, boolean>
 
-  constructor(private userServer: UserServerInterface) {
-    this.registering = false
+  constructor(private userServer: UserServerInterface, private userRequestServer: UserRequestServerInterface) {
+    this.operationsInProgress = new Map()
+  }
+
+  async deleteAccount(userUuid: string): Promise<UserDeletionResponse> {
+    this.lockOperation(UserApiOperations.DeletingAccount)
+
+    try {
+      const response = await this.userServer.deleteAccount({
+        userUuid: userUuid,
+      })
+
+      this.unlockOperation(UserApiOperations.DeletingAccount)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericRegistrationFail)
+    }
+  }
+
+  async submitUserRequest(dto: { userUuid: string; requestType: UserRequestType }): Promise<UserRequestResponse> {
+    this.lockOperation(UserApiOperations.SubmittingRequest)
+
+    try {
+      const response = await this.userRequestServer.submitUserRequest({
+        userUuid: dto.userUuid,
+        requestType: dto.requestType,
+      })
+
+      this.unlockOperation(UserApiOperations.SubmittingRequest)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericRegistrationFail)
+    }
   }
 
   async register(registerDTO: {
@@ -20,10 +60,7 @@ export class UserApiService implements UserApiServiceInterface {
     keyParams: RootKeyParamsInterface
     ephemeral: boolean
   }): Promise<UserRegistrationResponse> {
-    if (this.registering) {
-      throw new ApiCallError(ErrorMessage.RegistrationInProgress)
-    }
-    this.registering = true
+    this.lockOperation(UserApiOperations.Registering)
 
     try {
       const response = await this.userServer.register({
@@ -34,11 +71,23 @@ export class UserApiService implements UserApiServiceInterface {
         ...registerDTO.keyParams.getPortableValue(),
       })
 
-      this.registering = false
+      this.unlockOperation(UserApiOperations.Registering)
 
       return response
     } catch (error) {
       throw new ApiCallError(ErrorMessage.GenericRegistrationFail)
     }
   }
+
+  private lockOperation(operation: UserApiOperations): void {
+    if (this.operationsInProgress.get(operation)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(operation, true)
+  }
+
+  private unlockOperation(operation: UserApiOperations): void {
+    this.operationsInProgress.set(operation, false)
+  }
 }

packages/api/src/Domain/Client/User/UserApiServiceInterface.ts

@@ -1,5 +1,9 @@
+import { UserRequestType, Uuid } from '@standardnotes/common'
 import { RootKeyParamsInterface } from '@standardnotes/models'
+
+import { UserDeletionResponse } from '../../Response/User/UserDeletionResponse'
 import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
+import { UserRequestResponse } from '../../Response/UserRequest/UserRequestResponse'
 
 export interface UserApiServiceInterface {
   register(registerDTO: {
@@ -8,4 +12,6 @@ export interface UserApiServiceInterface {
     keyParams: RootKeyParamsInterface
     ephemeral: boolean
   }): Promise<UserRegistrationResponse>
+  submitUserRequest(dto: { userUuid: Uuid; requestType: UserRequestType }): Promise<UserRequestResponse>
+  deleteAccount(userUuid: string): Promise<UserDeletionResponse>
 }

packages/api/src/Domain/Client/index.ts

@@ -1,6 +1,7 @@
 export * from './Subscription/SubscriptionApiOperations'
 export * from './Subscription/SubscriptionApiService'
 export * from './Subscription/SubscriptionApiServiceInterface'
+export * from './User/UserApiOperations'
 export * from './User/UserApiService'
 export * from './User/UserApiServiceInterface'
 export * from './WebSocket/WebSocketApiService'