feat: home-server package initial setup with Api Gateway and Auth services (#605)

* fix(api-gateway): reduce exports

* wip controllers

* fix: imports of controllers

* fix(api-gateway): rename http service interface to proxy interface

* wip: self-registering services and controllers

* wip: add registering controller method bindings and services in container

* feat: merge two services together

* wip: resolving endpoints to direct code calls

* wip: bind controller container to a singleton

* fix: controller binding to instantiate and self-register on controller container

* fix: move signout endpoint to auth controller

* wip: define inversify controllers in the controller container

* fix(auth): bind inversify controllers to controller container

* fix(auth): linter issues

* fix(auth): specs

* fix(auth): inversify controllers bindings

* wip: endpoint resolving

* wip: add endpoint for more auth controllers

* wip: add sessions controller endpoint resolvings

* wip: add subscription invites endpoint resolvings

* wip: add subscription tokens endpoint resolvings

* wip: add all binding for auth server controllers

* wip: fix migrations path

* fix: configure default env vars and ci setup

.env.sample

@@ -15,6 +15,7 @@ DB_TYPE=mysql
 
 REDIS_PORT=6379
 REDIS_HOST=cache
+CACHE_TYPE=redis
 
 ########
 # KEYS #

.pnp.cjs

@@ -4623,8 +4623,11 @@ const RAW_RUNTIME_STATE =
         "packageDependencies": [\
           ["@standardnotes/home-server", "workspace:packages/home-server"],\
           ["@standardnotes/api-gateway", "workspace:packages/api-gateway"],\
+          ["@standardnotes/auth-server", "workspace:packages/auth"],\
+          ["@standardnotes/domain-core", "workspace:packages/domain-core"],\
           ["@types/cors", "npm:2.8.13"],\
           ["@types/express", "npm:4.17.17"],\
+          ["@types/prettyjson", "npm:0.0.30"],\
           ["@typescript-eslint/eslint-plugin", "virtual:fd909b174d079e30b336c4ce72c38a88c1e447767b1a8dd7655e07719a1e31b97807f0931368724fc78897ff15e6a6d00b83316c0f76d11f85111f342e08bb79#npm:5.59.2"],\
           ["@typescript-eslint/parser", "virtual:fd909b174d079e30b336c4ce72c38a88c1e447767b1a8dd7655e07719a1e31b97807f0931368724fc78897ff15e6a6d00b83316c0f76d11f85111f342e08bb79#npm:5.59.2"],\
           ["cors", "npm:2.8.5"],\
@@ -4637,6 +4640,7 @@ const RAW_RUNTIME_STATE =
           ["inversify", "npm:6.0.1"],\
           ["inversify-express-utils", "npm:6.4.3"],\
           ["prettier", "npm:2.8.8"],\
+          ["prettyjson", "npm:1.2.5"],\
           ["reflect-metadata", "npm:0.1.13"],\
           ["typescript", "patch:typescript@npm%3A5.0.4#optional!builtin<compat/typescript>::version=5.0.4&hash=b5f058"],\
           ["winston", "npm:3.8.2"]\

packages/api-gateway/src/Bootstrap/Container.ts

@@ -9,19 +9,23 @@ import { Timer, TimerInterface } from '@standardnotes/time'
 import { Env } from './Env'
 import { TYPES } from './Types'
 import { AuthMiddleware } from '../Controller/AuthMiddleware'
-import { HttpServiceInterface } from '../Service/Http/HttpServiceInterface'
-import { HttpService } from '../Service/Http/HttpService'
+import { ServiceProxyInterface } from '../Service/Http/ServiceProxyInterface'
+import { HttpServiceProxy } from '../Service/Http/HttpServiceProxy'
 import { SubscriptionTokenAuthMiddleware } from '../Controller/SubscriptionTokenAuthMiddleware'
 import { CrossServiceTokenCacheInterface } from '../Service/Cache/CrossServiceTokenCacheInterface'
 import { RedisCrossServiceTokenCache } from '../Infra/Redis/RedisCrossServiceTokenCache'
 import { WebSocketAuthMiddleware } from '../Controller/WebSocketAuthMiddleware'
 import { InMemoryCrossServiceTokenCache } from '../Infra/InMemory/InMemoryCrossServiceTokenCache'
+import { DirectCallServiceProxy } from '../Service/Proxy/DirectCallServiceProxy'
+import { ServiceContainerInterface } from '@standardnotes/domain-core'
+import { EndpointResolverInterface } from '../Service/Resolver/EndpointResolverInterface'
+import { EndpointResolver } from '../Service/Resolver/EndpointResolver'
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const newrelicFormatter = require('@newrelic/winston-enricher')
 
 export class ContainerConfigLoader {
-  async load(): Promise<Container> {
+  async load(serviceContainer?: ServiceContainerInterface): Promise<Container> {
     const env: Env = new Env()
     env.load()
 
@@ -57,14 +61,14 @@ export class ContainerConfigLoader {
     container.bind<AxiosInstance>(TYPES.HTTPClient).toConstantValue(axios.create())
 
     // env vars
-    container.bind(TYPES.SYNCING_SERVER_JS_URL).toConstantValue(env.get('SYNCING_SERVER_JS_URL'))
-    container.bind(TYPES.AUTH_SERVER_URL).toConstantValue(env.get('AUTH_SERVER_URL'))
+    container.bind(TYPES.SYNCING_SERVER_JS_URL).toConstantValue(env.get('SYNCING_SERVER_JS_URL', true))
+    container.bind(TYPES.AUTH_SERVER_URL).toConstantValue(env.get('AUTH_SERVER_URL', true))
     container.bind(TYPES.REVISIONS_SERVER_URL).toConstantValue(env.get('REVISIONS_SERVER_URL', true))
     container.bind(TYPES.EMAIL_SERVER_URL).toConstantValue(env.get('EMAIL_SERVER_URL', true))
     container.bind(TYPES.PAYMENTS_SERVER_URL).toConstantValue(env.get('PAYMENTS_SERVER_URL', true))
     container.bind(TYPES.FILES_SERVER_URL).toConstantValue(env.get('FILES_SERVER_URL', true))
-    container.bind(TYPES.AUTH_JWT_SECRET).toConstantValue(env.get('AUTH_JWT_SECRET'))
     container.bind(TYPES.WEB_SOCKET_SERVER_URL).toConstantValue(env.get('WEB_SOCKET_SERVER_URL', true))
+    container.bind(TYPES.AUTH_JWT_SECRET).toConstantValue(env.get('AUTH_JWT_SECRET'))
     container
       .bind(TYPES.HTTP_CALL_TIMEOUT)
       .toConstantValue(env.get('HTTP_CALL_TIMEOUT', true) ? +env.get('HTTP_CALL_TIMEOUT', true) : 60_000)
@@ -79,7 +83,16 @@ export class ContainerConfigLoader {
       .to(SubscriptionTokenAuthMiddleware)
 
     // Services
-    container.bind<HttpServiceInterface>(TYPES.HTTPService).to(HttpService)
+    if (isConfiguredForHomeServer) {
+      if (!serviceContainer) {
+        throw new Error('Service container is required when configured for home server')
+      }
+      container
+        .bind<ServiceProxyInterface>(TYPES.ServiceProxy)
+        .toConstantValue(new DirectCallServiceProxy(serviceContainer))
+    } else {
+      container.bind<ServiceProxyInterface>(TYPES.ServiceProxy).to(HttpServiceProxy)
+    }
     container.bind<TimerInterface>(TYPES.Timer).toConstantValue(new Timer())
 
     if (isConfiguredForHomeServer) {
@@ -89,6 +102,9 @@ export class ContainerConfigLoader {
     } else {
       container.bind<CrossServiceTokenCacheInterface>(TYPES.CrossServiceTokenCache).to(RedisCrossServiceTokenCache)
     }
+    container
+      .bind<EndpointResolverInterface>(TYPES.EndpointResolver)
+      .toConstantValue(new EndpointResolver(isConfiguredForHomeServer))
 
     return container
   }

packages/api-gateway/src/Bootstrap/Service.ts

@@ -0,0 +1,37 @@
+import {
+  ControllerContainerInterface,
+  ServiceContainerInterface,
+  ServiceIdentifier,
+  ServiceInterface,
+} from '@standardnotes/domain-core'
+
+import { ContainerConfigLoader } from './Container'
+
+export class Service implements ServiceInterface {
+  constructor(
+    private serviceContainer: ServiceContainerInterface,
+    private controllerContainer: ControllerContainerInterface,
+  ) {
+    this.serviceContainer.register(ServiceIdentifier.create(ServiceIdentifier.NAMES.ApiGateway).getValue(), this)
+  }
+
+  async handleRequest(request: never, response: never, endpointOrMethodIdentifier: string): Promise<unknown> {
+    const method = this.controllerContainer.get(endpointOrMethodIdentifier)
+
+    if (!method) {
+      throw new Error(`Method ${endpointOrMethodIdentifier} not found`)
+    }
+
+    return method(request, response)
+  }
+
+  async getContainer(): Promise<unknown> {
+    const config = new ContainerConfigLoader()
+
+    return config.load(this.serviceContainer)
+  }
+
+  getId(): ServiceIdentifier {
+    return ServiceIdentifier.create(ServiceIdentifier.NAMES.Auth).getValue()
+  }
+}

packages/api-gateway/src/Bootstrap/Types.ts

@@ -19,9 +19,10 @@ export const TYPES = {
   WebSocketAuthMiddleware: Symbol.for('WebSocketAuthMiddleware'),
   SubscriptionTokenAuthMiddleware: Symbol.for('SubscriptionTokenAuthMiddleware'),
   // Services
-  HTTPService: Symbol.for('HTTPService'),
+  ServiceProxy: Symbol.for('ServiceProxy'),
   CrossServiceTokenCache: Symbol.for('CrossServiceTokenCache'),
   Timer: Symbol.for('Timer'),
+  EndpointResolver: Symbol.for('EndpointResolver'),
 }
 
 // export default TYPES

packages/api-gateway/src/Bootstrap/index.ts

@@ -1,3 +1,3 @@
 export * from './Container'
-export * from './Env'
+export * from './Service'
 export * from './Types'

packages/api-gateway/src/Controller/LegacyController.ts

@@ -2,14 +2,14 @@ import { Request, Response } from 'express'
 import { inject } from 'inversify'
 import { controller, all, BaseHttpController, httpPost, httpGet, results, httpDelete } from 'inversify-express-utils'
 import { TYPES } from '../Bootstrap/Types'
-import { HttpServiceInterface } from '../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../Service/Http/ServiceProxyInterface'
 
 @controller('')
 export class LegacyController extends BaseHttpController {
   private AUTH_ROUTES: Map<string, string>
   private PARAMETRIZED_AUTH_ROUTES: Map<string, string>
 
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(@inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface) {
     super()
 
     this.AUTH_ROUTES = new Map([

packages/api-gateway/src/Controller/v1/ActionsController.ts

@@ -2,37 +2,51 @@ import { Request, Response } from 'express'
 import { inject } from 'inversify'
 import { BaseHttpController, controller, httpGet, httpPost } from 'inversify-express-utils'
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1')
 export class ActionsController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private serviceProxy: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpPost('/login')
   async login(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/sign_in', request.body)
+    await this.serviceProxy.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth/sign_in'),
+      request.body,
+    )
   }
 
   @httpGet('/login-params')
   async loginParams(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/params', request.body)
+    await this.serviceProxy.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'auth/params'),
+      request.body,
+    )
   }
 
   @httpPost('/logout')
   async logout(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/sign_out', request.body)
-  }
-
-  @httpGet('/auth/methods')
-  async methods(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/methods', request.body)
+    await this.serviceProxy.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth/sign_out'),
+      request.body,
+    )
   }
 
   @httpGet('/unsubscribe/:token')
   async emailUnsubscribe(request: Request, response: Response): Promise<void> {
-    await this.httpService.callEmailServer(
+    await this.serviceProxy.callEmailServer(
       request,
       response,
       `subscriptions/actions/unsubscribe/${request.params.token}`,
@@ -42,16 +56,31 @@ export class ActionsController extends BaseHttpController {
 
   @httpPost('/recovery/codes', TYPES.AuthMiddleware)
   async recoveryCodes(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/recovery/codes', request.body)
+    await this.serviceProxy.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth/recovery/codes'),
+      request.body,
+    )
   }
 
   @httpPost('/recovery/login')
   async recoveryLogin(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/recovery/login', request.body)
+    await this.serviceProxy.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth/recovery/login'),
+      request.body,
+    )
   }
 
   @httpPost('/recovery/login-params')
   async recoveryParams(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/recovery/params', request.body)
+    await this.serviceProxy.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth/recovery/params'),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v1/AuthenticatorsController.ts

@@ -3,11 +3,15 @@ import { Request, Response } from 'express'
 import { controller, BaseHttpController, httpPost, httpGet, httpDelete } from 'inversify-express-utils'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/authenticators')
 export class AuthenticatorsController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
@@ -16,14 +20,23 @@ export class AuthenticatorsController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      `authenticators/${request.params.authenticatorId}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'DELETE',
+        'authenticators/:authenticatorId',
+        request.params.authenticatorId,
+      ),
       request.body,
     )
   }
 
   @httpGet('/', TYPES.AuthMiddleware)
   async list(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'authenticators/', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'authenticators/'),
+      request.body,
+    )
   }
 
   @httpGet('/generate-registration-options', TYPES.AuthMiddleware)
@@ -31,7 +44,7 @@ export class AuthenticatorsController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      'authenticators/generate-registration-options',
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'authenticators/generate-registration-options'),
       request.body,
     )
   }
@@ -41,13 +54,18 @@ export class AuthenticatorsController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      'authenticators/generate-authentication-options',
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'authenticators/generate-authentication-options'),
       request.body,
     )
   }
 
   @httpPost('/verify-registration', TYPES.AuthMiddleware)
   async verifyRegistration(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'authenticators/verify-registration', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'authenticators/verify-registration'),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v1/FilesController.ts

@@ -3,16 +3,25 @@ import { inject } from 'inversify'
 import { BaseHttpController, controller, httpPost } from 'inversify-express-utils'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/files')
 export class FilesController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpPost('/valet-tokens', TYPES.AuthMiddleware)
   async createToken(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'valet-tokens', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'valet-tokens'),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v1/InvoicesController.ts

@@ -2,11 +2,11 @@ import { Request, Response } from 'express'
 import { BaseHttpController, controller, httpPost } from 'inversify-express-utils'
 import { inject } from 'inversify'
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
 
 @controller('/v1')
 export class InvoicesController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(@inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface) {
     super()
   }
 

packages/api-gateway/src/Controller/v1/ItemsController.ts

@@ -2,26 +2,45 @@ import { Request, Response } from 'express'
 import { inject } from 'inversify'
 import { BaseHttpController, controller, httpGet, httpPost } from 'inversify-express-utils'
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/items', TYPES.AuthMiddleware)
 export class ItemsController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpPost('/')
   async sync(request: Request, response: Response): Promise<void> {
-    await this.httpService.callSyncingServer(request, response, 'items/sync', request.body)
+    await this.httpService.callSyncingServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'items/sync'),
+      request.body,
+    )
   }
 
   @httpPost('/check-integrity')
   async checkIntegrity(request: Request, response: Response): Promise<void> {
-    await this.httpService.callSyncingServer(request, response, 'items/check-integrity', request.body)
+    await this.httpService.callSyncingServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'items/check-integrity'),
+      request.body,
+    )
   }
 
   @httpGet('/:uuid')
   async getItem(request: Request, response: Response): Promise<void> {
-    await this.httpService.callSyncingServer(request, response, `items/${request.params.uuid}`, request.body)
+    await this.httpService.callSyncingServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'items/:uuid', request.params.uuid),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v1/OfflineController.ts

@@ -3,22 +3,36 @@ import { inject } from 'inversify'
 import { BaseHttpController, controller, httpGet, httpPost } from 'inversify-express-utils'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/offline')
 export class OfflineController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpGet('/features')
   async getOfflineFeatures(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'offline/features', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'offline/features'),
+      request.body,
+    )
   }
 
   @httpPost('/subscription-tokens')
   async createOfflineSubscriptionToken(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'offline/subscription-tokens', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'offline/subscription-tokens'),
+      request.body,
+    )
   }
 
   @httpPost('/payments/stripe-setup-intent')

packages/api-gateway/src/Controller/v1/PaymentsController.ts

@@ -2,11 +2,11 @@ import { Request, Response } from 'express'
 import { inject } from 'inversify'
 import { all, BaseHttpController, controller, httpDelete, httpGet, httpPost } from 'inversify-express-utils'
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
 
 @controller('/v1')
 export class PaymentsController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(@inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface) {
     super()
   }
 

packages/api-gateway/src/Controller/v1/SessionsController.ts

@@ -2,33 +2,55 @@ import { Request, Response } from 'express'
 import { inject } from 'inversify'
 import { BaseHttpController, controller, httpDelete, httpGet, httpPost } from 'inversify-express-utils'
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/sessions')
 export class SessionsController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpGet('/', TYPES.AuthMiddleware)
   async getSessions(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'sessions')
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'sessions'),
+    )
   }
 
   @httpDelete('/:uuid', TYPES.AuthMiddleware)
   async deleteSession(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'session', {
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('DELETE', 'session'),
+      {
         uuid: request.params.uuid,
-    })
+      },
+    )
   }
 
   @httpDelete('/', TYPES.AuthMiddleware)
   async deleteSessions(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'session/all')
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('DELETE', 'session/all'),
+    )
   }
 
   @httpPost('/refresh')
   async refreshSession(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'session/refresh', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'session/refresh'),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v1/SubscriptionInvitesController.ts

@@ -3,31 +3,61 @@ import { inject } from 'inversify'
 import { BaseHttpController, controller, httpDelete, httpGet, httpPost } from 'inversify-express-utils'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/subscription-invites')
 export class SubscriptionInvitesController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpPost('/', TYPES.AuthMiddleware)
   async inviteToSubscriptionSharing(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'subscription-invites', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'subscription-invites'),
+      request.body,
+    )
   }
 
   @httpGet('/', TYPES.AuthMiddleware)
   async listInvites(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'subscription-invites', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'subscription-invites'),
+      request.body,
+    )
   }
 
   @httpDelete('/:inviteUuid', TYPES.AuthMiddleware)
   async cancelSubscriptionSharing(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `subscription-invites/${request.params.inviteUuid}`)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'DELETE',
+        'subscription-invites/:inviteUuid',
+        request.params.inviteUuid,
+      ),
+    )
   }
 
   @httpPost('/:inviteUuid/accept', TYPES.AuthMiddleware)
   async acceptInvite(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `subscription-invites/${request.params.inviteUuid}/accept`)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'POST',
+        'subscription-invites/:inviteUuid/accept',
+        request.params.inviteUuid,
+      ),
+    )
   }
 }

packages/api-gateway/src/Controller/v1/TokensController.ts

@@ -3,16 +3,25 @@ import { inject } from 'inversify'
 import { BaseHttpController, controller, httpPost } from 'inversify-express-utils'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/subscription-tokens')
 export class TokensController extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpPost('/', TYPES.AuthMiddleware)
   async createToken(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'subscription-tokens', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'subscription-tokens'),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v1/UsersController.ts

@@ -13,13 +13,15 @@ import {
 } from 'inversify-express-utils'
 import { Logger } from 'winston'
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
 import { TokenAuthenticationMethod } from '../TokenAuthenticationMethod'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/users')
 export class UsersController extends BaseHttpController {
   constructor(
-    @inject(TYPES.HTTPService) private httpService: HttpServiceInterface,
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
     @inject(TYPES.Logger) private logger: Logger,
   ) {
     super()
@@ -37,7 +39,12 @@ export class UsersController extends BaseHttpController {
 
   @httpPatch('/:userId', TYPES.AuthMiddleware)
   async updateUser(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `users/${request.params.userId}`, request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('PATCH', 'users/:userId', request.params.userId),
+      request.body,
+    )
   }
 
   @httpPut('/:userUuid/password', TYPES.AuthMiddleware)
@@ -49,7 +56,11 @@ export class UsersController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      `users/${request.params.userUuid}/attributes/credentials`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'PUT',
+        'users/:userUuid/attributes/credentials',
+        request.params.userUuid,
+      ),
       request.body,
     )
   }
@@ -59,14 +70,22 @@ export class UsersController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      `users/${request.params.userUuid}/attributes/credentials`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'PUT',
+        'users/:userUuid/attributes/credentials',
+        request.params.userUuid,
+      ),
       request.body,
     )
   }
 
   @httpGet('/:userId/params', TYPES.AuthMiddleware)
   async getKeyParams(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/params')
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'auth/params'),
+    )
   }
 
   @all('/:userId/mfa', TYPES.AuthMiddleware)
@@ -76,22 +95,49 @@ export class UsersController extends BaseHttpController {
 
   @httpPost('/:userUuid/integrations/listed', TYPES.AuthMiddleware)
   async createListedAccount(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'listed', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'listed'),
+      request.body,
+    )
   }
 
   @httpPost('/')
   async register(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth'),
+      request.body,
+    )
   }
 
   @httpGet('/:userUuid/settings', TYPES.AuthMiddleware)
   async listSettings(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `users/${request.params.userUuid}/settings`)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'users/:userUuid/settings',
+        request.params.userUuid,
+      ),
+    )
   }
 
   @httpPut('/:userUuid/settings', TYPES.AuthMiddleware)
   async putSetting(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `users/${request.params.userUuid}/settings`, request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'PUT',
+        'users/:userUuid/settings',
+        request.params.userUuid,
+      ),
+      request.body,
+    )
   }
 
   @httpGet('/:userUuid/settings/:settingName', TYPES.AuthMiddleware)
@@ -99,7 +145,12 @@ export class UsersController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      `users/${request.params.userUuid}/settings/${request.params.settingName}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'users/:userUuid/settings/:settingName',
+        request.params.userUuid,
+        request.params.settingName,
+      ),
     )
   }
 
@@ -108,7 +159,12 @@ export class UsersController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      `users/${request.params.userUuid}/settings/${request.params.settingName}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'DELETE',
+        'users/:userUuid/settings/:settingName',
+        request.params.userUuid,
+        request.params.settingName,
+      ),
       request.body,
     )
   }
@@ -118,29 +174,62 @@ export class UsersController extends BaseHttpController {
     await this.httpService.callAuthServer(
       request,
       response,
-      `users/${request.params.userUuid}/subscription-settings/${request.params.subscriptionSettingName}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'users/:userUuid/subscription-settings/:subscriptionSettingName',
+        request.params.userUuid,
+        request.params.subscriptionSettingName,
+      ),
     )
   }
 
   @httpGet('/:userUuid/features', TYPES.AuthMiddleware)
   async getFeatures(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `users/${request.params.userUuid}/features`)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'users/:userUuid/features',
+        request.params.userUuid,
+      ),
+    )
   }
 
   @httpGet('/:userUuid/subscription', TYPES.AuthMiddleware)
   async getSubscription(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `users/${request.params.userUuid}/subscription`)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'users/:userUuid/subscription',
+        request.params.userUuid,
+      ),
+    )
   }
 
   @httpGet('/subscription', TYPES.SubscriptionTokenAuthMiddleware)
   async getSubscriptionBySubscriptionToken(request: Request, response: Response): Promise<void> {
     if (response.locals.tokenAuthenticationMethod === TokenAuthenticationMethod.OfflineSubscriptionToken) {
-      await this.httpService.callAuthServer(request, response, 'offline/users/subscription')
+      await this.httpService.callAuthServer(
+        request,
+        response,
+        this.endpointResolver.resolveEndpointOrMethodIdentifier('GET', 'offline/users/subscription'),
+      )
 
       return
     }
 
-    await this.httpService.callAuthServer(request, response, `users/${response.locals.userUuid}/subscription`)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'users/:userUuid/subscription',
+        response.locals.userUuid,
+      ),
+    )
   }
 
   @httpDelete('/:userUuid', TYPES.AuthMiddleware)
@@ -150,6 +239,15 @@ export class UsersController extends BaseHttpController {
 
   @httpPost('/:userUuid/requests', TYPES.AuthMiddleware)
   async submitRequest(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, `users/${request.params.userUuid}/requests`, request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'POST',
+        'users/:userUuid/requests',
+        request.params.userUuid,
+      ),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v1/WebSocketsController.ts

@@ -4,12 +4,14 @@ import { BaseHttpController, controller, httpDelete, httpPost } from 'inversify-
 import { Logger } from 'winston'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v1/sockets')
 export class WebSocketsController extends BaseHttpController {
   constructor(
-    @inject(TYPES.HTTPService) private httpService: HttpServiceInterface,
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
     @inject(TYPES.Logger) private logger: Logger,
   ) {
     super()
@@ -17,7 +19,12 @@ export class WebSocketsController extends BaseHttpController {
 
   @httpPost('/tokens', TYPES.AuthMiddleware)
   async createWebSocketConnectionToken(request: Request, response: Response): Promise<void> {
-    await this.httpService.callWebSocketServer(request, response, 'sockets/tokens', request.body)
+    await this.httpService.callWebSocketServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'sockets/tokens'),
+      request.body,
+    )
   }
 
   @httpPost('/connections', TYPES.WebSocketAuthMiddleware)
@@ -33,7 +40,11 @@ export class WebSocketsController extends BaseHttpController {
     await this.httpService.callWebSocketServer(
       request,
       response,
-      `sockets/connections/${request.headers.connectionid}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'POST',
+        'sockets/connections/:connectionId',
+        request.headers.connectionid as string,
+      ),
       request.body,
     )
   }
@@ -51,7 +62,11 @@ export class WebSocketsController extends BaseHttpController {
     await this.httpService.callWebSocketServer(
       request,
       response,
-      `sockets/connections/${request.headers.connectionid}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'DELETE',
+        'sockets/connections/:connectionId',
+        request.headers.connectionid as string,
+      ),
       request.body,
     )
   }

packages/api-gateway/src/Controller/v2/ActionsControllerV2.ts

@@ -3,21 +3,35 @@ import { inject } from 'inversify'
 import { BaseHttpController, controller, httpPost } from 'inversify-express-utils'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v2')
 export class ActionsControllerV2 extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpPost('/login')
   async login(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/pkce_sign_in', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth/pkce_sign_in'),
+      request.body,
+    )
   }
 
   @httpPost('/login-params')
   async loginParams(request: Request, response: Response): Promise<void> {
-    await this.httpService.callAuthServer(request, response, 'auth/pkce_params', request.body)
+    await this.httpService.callAuthServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier('POST', 'auth/pkce_params'),
+      request.body,
+    )
   }
 }

packages/api-gateway/src/Controller/v2/PaymentsControllerV2.ts

@@ -2,11 +2,11 @@ import { Request, Response } from 'express'
 import { BaseHttpController, controller, httpDelete, httpGet, httpPatch, httpPost } from 'inversify-express-utils'
 import { inject } from 'inversify'
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
 
 @controller('/v2')
 export class PaymentsControllerV2 extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(@inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface) {
     super()
   }
 

packages/api-gateway/src/Controller/v2/RevisionsControllerV2.ts

@@ -3,17 +3,29 @@ import { inject } from 'inversify'
 import { BaseHttpController, controller, httpDelete, httpGet } from 'inversify-express-utils'
 
 import { TYPES } from '../../Bootstrap/Types'
-import { HttpServiceInterface } from '../../Service/Http/HttpServiceInterface'
+import { ServiceProxyInterface } from '../../Service/Http/ServiceProxyInterface'
+import { EndpointResolverInterface } from '../../Service/Resolver/EndpointResolverInterface'
 
 @controller('/v2/items/:itemUuid/revisions', TYPES.AuthMiddleware)
 export class RevisionsControllerV2 extends BaseHttpController {
-  constructor(@inject(TYPES.HTTPService) private httpService: HttpServiceInterface) {
+  constructor(
+    @inject(TYPES.ServiceProxy) private httpService: ServiceProxyInterface,
+    @inject(TYPES.EndpointResolver) private endpointResolver: EndpointResolverInterface,
+  ) {
     super()
   }
 
   @httpGet('/')
   async getRevisions(request: Request, response: Response): Promise<void> {
-    await this.httpService.callRevisionsServer(request, response, `items/${request.params.itemUuid}/revisions`)
+    await this.httpService.callRevisionsServer(
+      request,
+      response,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'items/:itemUuid/revisions',
+        request.params.itemUuid,
+      ),
+    )
   }
 
   @httpGet('/:id')
@@ -21,7 +33,12 @@ export class RevisionsControllerV2 extends BaseHttpController {
     await this.httpService.callRevisionsServer(
       request,
       response,
-      `items/${request.params.itemUuid}/revisions/${request.params.id}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'GET',
+        'items/:itemUuid/revisions/:id',
+        request.params.itemUuid,
+        request.params.id,
+      ),
     )
   }
 
@@ -30,7 +47,12 @@ export class RevisionsControllerV2 extends BaseHttpController {
     await this.httpService.callRevisionsServer(
       request,
       response,
-      `items/${request.params.itemUuid}/revisions/${request.params.id}`,
+      this.endpointResolver.resolveEndpointOrMethodIdentifier(
+        'DELETE',
+        'items/:itemUuid/revisions/:id',
+        request.params.itemUuid,
+        request.params.id,
+      ),
     )
   }
 }

packages/api-gateway/src/Infra/index.ts

@@ -1,2 +0,0 @@
-export * from './InMemory/InMemoryCrossServiceTokenCache'
-export * from './Redis/RedisCrossServiceTokenCache'

packages/api-gateway/src/Service/Http/HttpServiceProxy.ts

@@ -6,10 +6,10 @@ import { Logger } from 'winston'
 
 import { TYPES } from '../../Bootstrap/Types'
 import { CrossServiceTokenCacheInterface } from '../Cache/CrossServiceTokenCacheInterface'
-import { HttpServiceInterface } from './HttpServiceInterface'
+import { ServiceProxyInterface } from './ServiceProxyInterface'
 
 @injectable()
-export class HttpService implements HttpServiceInterface {
+export class HttpServiceProxy implements ServiceProxyInterface {
   constructor(
     @inject(TYPES.HTTPClient) private httpClient: AxiosInstance,
     @inject(TYPES.AUTH_SERVER_URL) private authServerUrl: string,
@@ -27,16 +27,16 @@ export class HttpService implements HttpServiceInterface {
   async callSyncingServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
-    await this.callServer(this.syncingServerJsUrl, request, response, endpoint, payload)
+    await this.callServer(this.syncingServerJsUrl, request, response, endpointOrMethodIdentifier, payload)
   }
 
   async callRevisionsServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
     if (!this.revisionsServerUrl) {
@@ -44,31 +44,37 @@ export class HttpService implements HttpServiceInterface {
 
       return
     }
-    await this.callServer(this.revisionsServerUrl, request, response, endpoint, payload)
+    await this.callServer(this.revisionsServerUrl, request, response, endpointOrMethodIdentifier, payload)
   }
 
   async callLegacySyncingServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
-    await this.callServerWithLegacyFormat(this.syncingServerJsUrl, request, response, endpoint, payload)
+    await this.callServerWithLegacyFormat(
+      this.syncingServerJsUrl,
+      request,
+      response,
+      endpointOrMethodIdentifier,
+      payload,
+    )
   }
 
   async callAuthServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
-    await this.callServer(this.authServerUrl, request, response, endpoint, payload)
+    await this.callServer(this.authServerUrl, request, response, endpointOrMethodIdentifier, payload)
   }
 
   async callEmailServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
     if (!this.emailServerUrl) {
@@ -77,13 +83,13 @@ export class HttpService implements HttpServiceInterface {
       return
     }
 
-    await this.callServer(this.emailServerUrl, request, response, endpoint, payload)
+    await this.callServer(this.emailServerUrl, request, response, endpointOrMethodIdentifier, payload)
   }
 
   async callWebSocketServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
     if (!this.webSocketServerUrl) {
@@ -92,13 +98,13 @@ export class HttpService implements HttpServiceInterface {
       return
     }
 
-    await this.callServer(this.webSocketServerUrl, request, response, endpoint, payload)
+    await this.callServer(this.webSocketServerUrl, request, response, endpointOrMethodIdentifier, payload)
   }
 
   async callPaymentsServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
     if (!this.paymentsServerUrl) {
@@ -106,23 +112,29 @@ export class HttpService implements HttpServiceInterface {
 
       return
     }
-    await this.callServerWithLegacyFormat(this.paymentsServerUrl, request, response, endpoint, payload)
+    await this.callServerWithLegacyFormat(
+      this.paymentsServerUrl,
+      request,
+      response,
+      endpointOrMethodIdentifier,
+      payload,
+    )
   }
 
   async callAuthServerWithLegacyFormat(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
-    await this.callServerWithLegacyFormat(this.authServerUrl, request, response, endpoint, payload)
+    await this.callServerWithLegacyFormat(this.authServerUrl, request, response, endpointOrMethodIdentifier, payload)
   }
 
   private async getServerResponse(
     serverUrl: string,
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<AxiosResponse | undefined> {
     try {
@@ -142,7 +154,7 @@ export class HttpService implements HttpServiceInterface {
         headers['X-Auth-Offline-Token'] = response.locals.offlineAuthToken
       }
 
-      this.logger.debug(`Calling [${request.method}] ${serverUrl}/${endpoint},
+      this.logger.debug(`Calling [${request.method}] ${serverUrl}/${endpointOrMethodIdentifier},
         headers: ${JSON.stringify(headers)},
         query: ${JSON.stringify(request.query)},
         payload: ${JSON.stringify(payload)}`)
@@ -150,7 +162,7 @@ export class HttpService implements HttpServiceInterface {
       const serviceResponse = await this.httpClient.request({
         method: request.method as Method,
         headers,
-        url: `${serverUrl}/${endpoint}`,
+        url: `${serverUrl}/${endpointOrMethodIdentifier}`,
         data: this.getRequestData(payload),
         maxContentLength: Infinity,
         maxBodyLength: Infinity,
@@ -172,7 +184,9 @@ export class HttpService implements HttpServiceInterface {
         ? JSON.stringify((error as AxiosError).response?.data)
         : (error as Error).message
 
-      this.logger.error(`Could not pass the request to ${serverUrl}/${endpoint} on underlying service: ${errorMessage}`)
+      this.logger.error(
+        `Could not pass the request to ${serverUrl}/${endpointOrMethodIdentifier} on underlying service: ${errorMessage}`,
+      )
 
       this.logger.debug('Response error: %O', (error as AxiosError).response ?? error)
 
@@ -195,10 +209,16 @@ export class HttpService implements HttpServiceInterface {
     serverUrl: string,
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
-    const serviceResponse = await this.getServerResponse(serverUrl, request, response, endpoint, payload)
+    const serviceResponse = await this.getServerResponse(
+      serverUrl,
+      request,
+      response,
+      endpointOrMethodIdentifier,
+      payload,
+    )
 
     this.logger.debug(`Response from underlying server: ${JSON.stringify(serviceResponse?.data)},
       headers: ${JSON.stringify(serviceResponse?.headers)}`)
@@ -233,10 +253,16 @@ export class HttpService implements HttpServiceInterface {
     serverUrl: string,
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void> {
-    const serviceResponse = await this.getServerResponse(serverUrl, request, response, endpoint, payload)
+    const serviceResponse = await this.getServerResponse(
+      serverUrl,
+      request,
+      response,
+      endpointOrMethodIdentifier,
+      payload,
+    )
 
     if (!serviceResponse) {
       return

packages/api-gateway/src/Service/Http/ServiceProxyInterface.ts

@@ -1,52 +1,52 @@
 import { Request, Response } from 'express'
 
-export interface HttpServiceInterface {
+export interface ServiceProxyInterface {
   callEmailServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
   callAuthServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
   callAuthServerWithLegacyFormat(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
   callRevisionsServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
   callSyncingServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
   callLegacySyncingServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
   callPaymentsServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
   callWebSocketServer(
     request: Request,
     response: Response,
-    endpoint: string,
+    endpointOrMethodIdentifier: string,
     payload?: Record<string, unknown> | string,
   ): Promise<void>
 }

packages/api-gateway/src/Service/Proxy/DirectCallServiceProxy.ts

@@ -0,0 +1,74 @@
+import { Request, Response } from 'express'
+
+import { ServiceProxyInterface } from '../Http/ServiceProxyInterface'
+import { ServiceContainerInterface, ServiceIdentifier } from '@standardnotes/domain-core'
+
+export class DirectCallServiceProxy implements ServiceProxyInterface {
+  constructor(private serviceContainer: ServiceContainerInterface) {}
+
+  async callEmailServer(_request: Request, _response: Response, _endpointOrMethodIdentifier: string): Promise<void> {
+    throw new Error('Email server is not available.')
+  }
+
+  async callAuthServer(request: never, response: never, endpointOrMethodIdentifier: string): Promise<void> {
+    const authService = this.serviceContainer.get(ServiceIdentifier.create(ServiceIdentifier.NAMES.Auth).getValue())
+    if (!authService) {
+      throw new Error('Auth service not found')
+    }
+
+    const serviceResponse = (await authService.handleRequest(request, response, endpointOrMethodIdentifier)) as {
+      statusCode: number
+      json: Record<string, unknown>
+    }
+
+    void (response as Response).status(serviceResponse.statusCode).send(serviceResponse.json)
+  }
+
+  async callAuthServerWithLegacyFormat(
+    _request: Request,
+    _response: Response,
+    _endpointOrMethodIdentifier: string,
+  ): Promise<void> {
+    throw new Error('Legacy auth endpoints are no longer available.')
+  }
+
+  async callRevisionsServer(request: never, response: never, endpointOrMethodIdentifier: string): Promise<void> {
+    const service = this.serviceContainer.get(ServiceIdentifier.create(ServiceIdentifier.NAMES.Revisions).getValue())
+    if (!service) {
+      throw new Error('Revisions service not found')
+    }
+
+    await service.handleRequest(request, response, endpointOrMethodIdentifier)
+  }
+
+  async callSyncingServer(request: never, response: never, endpointOrMethodIdentifier: string): Promise<void> {
+    const service = this.serviceContainer.get(
+      ServiceIdentifier.create(ServiceIdentifier.NAMES.SyncingServer).getValue(),
+    )
+    if (!service) {
+      throw new Error('Syncing service not found')
+    }
+
+    await service.handleRequest(request, response, endpointOrMethodIdentifier)
+  }
+
+  async callLegacySyncingServer(
+    _request: Request,
+    _response: Response,
+    _endpointOrMethodIdentifier: string,
+  ): Promise<void> {
+    throw new Error('Legacy syncing server endpoints are no longer available.')
+  }
+
+  async callPaymentsServer(_request: Request, _response: Response, _endpointOrMethodIdentifier: string): Promise<void> {
+    throw new Error('Payments server is not available.')
+  }
+
+  async callWebSocketServer(
+    _request: Request,
+    _response: Response,
+    _endpointOrMethodIdentifier: string,
+  ): Promise<void> {
+    throw new Error('Websockets server is not available.')
+  }
+}

packages/api-gateway/src/Service/Resolver/EndpointResolver.ts

@@ -0,0 +1,70 @@
+import { EndpointResolverInterface } from './EndpointResolverInterface'
+
+export class EndpointResolver implements EndpointResolverInterface {
+  constructor(private isConfiguredForHomeServer: boolean) {}
+
+  private readonly endpointToIdentifierMap: Map<string, string> = new Map([
+    // Actions Controller
+    ['[POST]:auth/sign_in', 'auth.signIn'],
+    ['[GET]:auth/params', 'auth.params'],
+    ['[POST]:auth/sign_out', 'auth.signOut'],
+    ['[POST]:auth/recovery/codes', 'auth.generateRecoveryCodes'],
+    ['[POST]:auth/recovery/login', 'auth.signInWithRecoveryCodes'],
+    ['[POST]:auth/recovery/params', 'auth.recoveryKeyParams'],
+    // Authenticators Controller
+    ['[DELETE]:authenticators/:authenticatorId', 'auth.authenticators.delete'],
+    ['[GET]:authenticators/', 'auth.authenticators.list'],
+    ['[GET]:authenticators/generate-registration-options', 'auth.authenticators.generateRegistrationOptions'],
+    ['[POST]:authenticators/generate-authentication-options', 'auth.authenticators.generateAuthenticationOptions'],
+    ['[POST]:authenticators/verify-registration', 'auth.authenticators.verifyRegistrationResponse'],
+    // Files Controller
+    ['[POST]:valet-tokens', 'auth.valet-tokens.create'],
+    // Offline Controller
+    ['[GET]:offline/features', 'auth.offline.features'],
+    ['[POST]:offline/subscription-tokens', 'auth.offline.subscriptionTokens.create'],
+    // Sessions Controller
+    ['[GET]:sessions', 'auth.sessions.list'],
+    ['[DELETE]:session', 'auth.sessions.delete'],
+    ['[DELETE]:session/all', 'auth.sessions.deleteAll'],
+    ['[POST]:session/refresh', 'auth.sessions.refresh'],
+    // Subscription Invites Controller
+    ['[POST]:subscription-invites', 'auth.subscriptionInvites.create'],
+    ['[GET]:subscription-invites', 'auth.subscriptionInvites.list'],
+    ['[DELETE]:subscription-invites/:inviteUuid', 'auth.subscriptionInvites.delete'],
+    ['[POST]:subscription-invites/:inviteUuid/accept', 'auth.subscriptionInvites.accept'],
+    // Tokens Controller
+    ['[POST]:subscription-tokens', 'auth.subscription-tokens.create'],
+    // Users Controller
+    ['[PATCH]:users/:userId', 'auth.users.update'],
+    ['[PUT]:users/:userUuid/attributes/credentials', 'auth.users.updateCredentials'],
+    ['[PUT]:auth/params', 'auth.users.getKeyParams'],
+    ['[POST]:listed', 'auth.users.createListedAccount'],
+    ['[POST]:auth', 'auth.users.register'],
+    ['[GET]:users/:userUuid/settings', 'auth.users.getSettings'],
+    ['[PUT]:users/:userUuid/settings', 'auth.users.updateSetting'],
+    ['[GET]:users/:userUuid/settings/:settingName', 'auth.users.getSetting'],
+    ['[DELETE]:users/:userUuid/settings/:settingName', 'auth.users.deleteSetting'],
+    ['[GET]:users/:userUuid/subscription-settings/:subscriptionSettingName', 'auth.users.getSubscriptionSetting'],
+    ['[GET]:users/:userUuid/features', 'auth.users.getFeatures'],
+    ['[GET]:users/:userUuid/subscription', 'auth.users.getSubscription'],
+    ['[GET]:offline/users/subscription', 'auth.users.getOfflineSubscriptionByToken'],
+    ['[POST]:users/:userUuid/requests', 'auth.users.createRequest'],
+  ])
+
+  resolveEndpointOrMethodIdentifier(method: string, endpoint: string, ...params: string[]): string {
+    if (!this.isConfiguredForHomeServer) {
+      if (params.length > 0) {
+        return params.reduce((acc, param) => acc.replace(/:[a-zA-Z0-9]+/, param), endpoint)
+      }
+
+      return endpoint
+    }
+    const identifier = this.endpointToIdentifierMap.get(`[${method}]:${endpoint}`)
+
+    if (!identifier) {
+      throw new Error(`Endpoint ${endpoint} not found`)
+    }
+
+    return identifier
+  }
+}

packages/api-gateway/src/Service/Resolver/EndpointResolverInterface.ts

@@ -0,0 +1,3 @@
+export interface EndpointResolverInterface {
+  resolveEndpointOrMethodIdentifier(method: string, endpoint: string, ...params: string[]): string
+}

packages/api-gateway/src/Service/index.ts

@@ -1,3 +0,0 @@
-export * from './Cache/CrossServiceTokenCacheInterface'
-export * from './Http/HttpService'
-export * from './Http/HttpServiceInterface'

packages/api-gateway/src/index.ts

@@ -1,4 +1,2 @@
 export * from './Bootstrap'
 export * from './Controller'
-export * from './Infra'
-export * from './Service'

packages/auth/bin/backup.ts

@@ -84,14 +84,14 @@ void container.load().then((container) => {
   const env: Env = new Env()
   env.load()
 
-  const logger: Logger = container.get(TYPES.Logger)
+  const logger: Logger = container.get(TYPES.Auth_Logger)
 
   logger.info(`Starting ${backupFrequency} ${backupProvider} backup requesting...`)
 
-  const settingRepository: SettingRepositoryInterface = container.get(TYPES.SettingRepository)
-  const roleService: RoleServiceInterface = container.get(TYPES.RoleService)
-  const domainEventFactory: DomainEventFactoryInterface = container.get(TYPES.DomainEventFactory)
-  const domainEventPublisher: DomainEventPublisherInterface = container.get(TYPES.DomainEventPublisher)
+  const settingRepository: SettingRepositoryInterface = container.get(TYPES.Auth_SettingRepository)
+  const roleService: RoleServiceInterface = container.get(TYPES.Auth_RoleService)
+  const domainEventFactory: DomainEventFactoryInterface = container.get(TYPES.Auth_DomainEventFactory)
+  const domainEventPublisher: DomainEventPublisherInterface = container.get(TYPES.Auth_DomainEventPublisher)
 
   Promise.resolve(requestBackups(settingRepository, roleService, domainEventFactory, domainEventPublisher))
     .then(() => {

packages/auth/bin/cleanup.ts

@@ -25,12 +25,12 @@ void container.load().then((container) => {
   const env: Env = new Env()
   env.load()
 
-  const logger: Logger = container.get(TYPES.Logger)
+  const logger: Logger = container.get(TYPES.Auth_Logger)
 
   logger.info('Starting sessions and session traces cleanup')
 
-  const cleanupSessionTraces: CleanupSessionTraces = container.get(TYPES.CleanupSessionTraces)
-  const cleanupExpiredSessions: CleanupExpiredSessions = container.get(TYPES.CleanupExpiredSessions)
+  const cleanupSessionTraces: CleanupSessionTraces = container.get(TYPES.Auth_CleanupSessionTraces)
+  const cleanupExpiredSessions: CleanupExpiredSessions = container.get(TYPES.Auth_CleanupExpiredSessions)
 
   Promise.resolve(cleanup(cleanupSessionTraces, cleanupExpiredSessions))
     .then(() => {

packages/auth/bin/server.ts

@@ -44,7 +44,7 @@ void container.load().then((container) => {
 
   server.setConfig((app) => {
     app.use((_request: Request, response: Response, next: NextFunction) => {
-      response.setHeader('X-Auth-Version', container.get(TYPES.VERSION))
+      response.setHeader('X-Auth-Version', container.get(TYPES.Auth_VERSION))
       next()
     })
     app.use(json())
@@ -52,7 +52,7 @@ void container.load().then((container) => {
     app.use(cors())
   })
 
-  const logger: winston.Logger = container.get(TYPES.Logger)
+  const logger: winston.Logger = container.get(TYPES.Auth_Logger)
 
   server.setErrorConfig((app) => {
     app.use((error: Record<string, unknown>, _request: Request, response: Response, _next: NextFunction) => {

packages/auth/bin/stats.ts

@@ -15,12 +15,12 @@ void container.load().then((container) => {
   const env: Env = new Env()
   env.load()
 
-  const logger: Logger = container.get(TYPES.Logger)
+  const logger: Logger = container.get(TYPES.Auth_Logger)
 
   logger.info('Starting session traces cleanup')
 
-  const persistStats: PersistStatistics = container.get(TYPES.PersistStatistics)
-  const timer: TimerInterface = container.get(TYPES.Timer)
+  const persistStats: PersistStatistics = container.get(TYPES.Auth_PersistStatistics)
+  const timer: TimerInterface = container.get(TYPES.Auth_Timer)
 
   Promise.resolve(
     persistStats.execute({

packages/auth/bin/user_email_backup.ts

@@ -72,15 +72,15 @@ void container.load().then((container) => {
   const env: Env = new Env()
   env.load()
 
-  const logger: Logger = container.get(TYPES.Logger)
+  const logger: Logger = container.get(TYPES.Auth_Logger)
 
   logger.info(`Starting email backup requesting for ${backupEmail} ...`)
 
-  const settingRepository: SettingRepositoryInterface = container.get(TYPES.SettingRepository)
-  const userRepository: UserRepositoryInterface = container.get(TYPES.UserRepository)
-  const roleService: RoleServiceInterface = container.get(TYPES.RoleService)
-  const domainEventFactory: DomainEventFactoryInterface = container.get(TYPES.DomainEventFactory)
-  const domainEventPublisher: DomainEventPublisherInterface = container.get(TYPES.DomainEventPublisher)
+  const settingRepository: SettingRepositoryInterface = container.get(TYPES.Auth_SettingRepository)
+  const userRepository: UserRepositoryInterface = container.get(TYPES.Auth_UserRepository)
+  const roleService: RoleServiceInterface = container.get(TYPES.Auth_RoleService)
+  const domainEventFactory: DomainEventFactoryInterface = container.get(TYPES.Auth_DomainEventFactory)
+  const domainEventPublisher: DomainEventPublisherInterface = container.get(TYPES.Auth_DomainEventPublisher)
 
   Promise.resolve(
     requestBackups(userRepository, settingRepository, roleService, domainEventFactory, domainEventPublisher),

packages/auth/bin/worker.ts

@@ -18,11 +18,13 @@ void container.load().then((container) => {
   const env: Env = new Env()
   env.load()
 
-  const logger: Logger = container.get(TYPES.Logger)
+  const logger: Logger = container.get(TYPES.Auth_Logger)
 
   logger.info('Starting worker...')
 
-  const subscriberFactory: DomainEventSubscriberFactoryInterface = container.get(TYPES.DomainEventSubscriberFactory)
+  const subscriberFactory: DomainEventSubscriberFactoryInterface = container.get(
+    TYPES.Auth_DomainEventSubscriberFactory,
+  )
   subscriberFactory.create().start()
 
   setInterval(() => logger.info('Alive and kicking!'), 20 * 60 * 1000)

packages/auth/package.json

@@ -15,6 +15,7 @@
     "setup:env": "cp .env.sample .env",
     "build": "tsc --build",
     "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --fix --ext .ts",
     "pretest": "yarn lint && yarn build",
     "test": "jest --coverage --config=./jest.config.js --maxWorkers=50%",
     "start": "yarn node dist/bin/server.js",

packages/auth/src/Bootstrap/DataSource.ts

@@ -28,29 +28,6 @@ const maxQueryExecutionTime = env.get('DB_MAX_QUERY_EXECUTION_TIME', true)
   ? +env.get('DB_MAX_QUERY_EXECUTION_TIME', true)
   : 45_000
 
-const inReplicaMode = env.get('DB_REPLICA_HOST', true) ? true : false
-
-const replicationConfig = {
-  master: {
-    host: env.get('DB_HOST'),
-    port: parseInt(env.get('DB_PORT')),
-    username: env.get('DB_USERNAME'),
-    password: env.get('DB_PASSWORD'),
-    database: env.get('DB_DATABASE'),
-  },
-  slaves: [
-    {
-      host: env.get('DB_REPLICA_HOST', true),
-      port: parseInt(env.get('DB_PORT')),
-      username: env.get('DB_USERNAME'),
-      password: env.get('DB_PASSWORD'),
-      database: env.get('DB_DATABASE'),
-    },
-  ],
-  removeNodeErrorCount: 10,
-  restoreNodeTimeout: 5,
-}
-
 const commonDataSourceOptions = {
   maxQueryExecutionTime,
   entities: [
@@ -71,12 +48,37 @@ const commonDataSourceOptions = {
     TypeORMEmergencyAccessInvitation,
     TypeORMCacheEntry,
   ],
-  migrations: [`dist/migrations/${isConfiguredForMySQL ? 'mysql' : 'sqlite'}/*.js`],
+  migrations: [`${__dirname}/../../migrations/${isConfiguredForMySQL ? 'mysql' : 'sqlite'}/*.js`],
   migrationsRun: true,
-  logging: <LoggerOptions>env.get('DB_DEBUG_LEVEL'),
+  logging: <LoggerOptions>env.get('DB_DEBUG_LEVEL', true) ?? 'info',
 }
 
-const mySQLDataSourceOptions: MysqlConnectionOptions = {
+let dataSource: DataSource
+if (isConfiguredForMySQL) {
+  const inReplicaMode = env.get('DB_REPLICA_HOST', true) ? true : false
+
+  const replicationConfig = {
+    master: {
+      host: env.get('DB_HOST'),
+      port: parseInt(env.get('DB_PORT')),
+      username: env.get('DB_USERNAME'),
+      password: env.get('DB_PASSWORD'),
+      database: env.get('DB_DATABASE'),
+    },
+    slaves: [
+      {
+        host: env.get('DB_REPLICA_HOST', true),
+        port: parseInt(env.get('DB_PORT')),
+        username: env.get('DB_USERNAME'),
+        password: env.get('DB_PASSWORD'),
+        database: env.get('DB_DATABASE'),
+      },
+    ],
+    removeNodeErrorCount: 10,
+    restoreNodeTimeout: 5,
+  }
+
+  const mySQLDataSourceOptions: MysqlConnectionOptions = {
     ...commonDataSourceOptions,
     type: 'mysql',
     charset: 'utf8mb4',
@@ -88,12 +90,17 @@ const mySQLDataSourceOptions: MysqlConnectionOptions = {
     username: inReplicaMode ? undefined : env.get('DB_USERNAME'),
     password: inReplicaMode ? undefined : env.get('DB_PASSWORD'),
     database: inReplicaMode ? undefined : env.get('DB_DATABASE'),
-}
+  }
 
-const sqliteDataSourceOptions: SqliteConnectionOptions = {
+  dataSource = new DataSource(mySQLDataSourceOptions)
+} else {
+  const sqliteDataSourceOptions: SqliteConnectionOptions = {
     ...commonDataSourceOptions,
     type: 'sqlite',
     database: `data/${env.get('DB_DATABASE')}.sqlite`,
+  }
+
+  dataSource = new DataSource(sqliteDataSourceOptions)
 }
 
-export const AppDataSource = new DataSource(isConfiguredForMySQL ? mySQLDataSourceOptions : sqliteDataSourceOptions)
+export const AppDataSource = dataSource

packages/auth/src/Bootstrap/Service.ts

@@ -0,0 +1,37 @@
+import {
+  ControllerContainerInterface,
+  ServiceContainerInterface,
+  ServiceIdentifier,
+  ServiceInterface,
+} from '@standardnotes/domain-core'
+
+import { ContainerConfigLoader } from './Container'
+
+export class Service implements ServiceInterface {
+  constructor(
+    private serviceContainer: ServiceContainerInterface,
+    private controllerContainer: ControllerContainerInterface,
+  ) {
+    this.serviceContainer.register(ServiceIdentifier.create(ServiceIdentifier.NAMES.Auth).getValue(), this)
+  }
+
+  async handleRequest(request: never, response: never, endpointOrMethodIdentifier: string): Promise<unknown> {
+    const method = this.controllerContainer.get(endpointOrMethodIdentifier)
+
+    if (!method) {
+      throw new Error(`Method ${endpointOrMethodIdentifier} not found`)
+    }
+
+    return method(request, response)
+  }
+
+  async getContainer(): Promise<unknown> {
+    const config = new ContainerConfigLoader()
+
+    return config.load(this.controllerContainer)
+  }
+
+  getId(): ServiceIdentifier {
+    return ServiceIdentifier.create(ServiceIdentifier.NAMES.Auth).getValue()
+  }
+}

packages/auth/src/Bootstrap/Types.ts

@@ -1,217 +1,227 @@
 const TYPES = {
-  Logger: Symbol.for('Logger'),
-  Redis: Symbol.for('Redis'),
-  SNS: Symbol.for('SNS'),
-  SQS: Symbol.for('SQS'),
+  Auth_Logger: Symbol.for('Auth_Logger'),
+  Auth_Redis: Symbol.for('Auth_Redis'),
+  Auth_SNS: Symbol.for('Auth_SNS'),
+  Auth_SQS: Symbol.for('Auth_SQS'),
   // Mapping
-  SessionTracePersistenceMapper: Symbol.for('SessionTracePersistenceMapper'),
-  AuthenticatorChallengePersistenceMapper: Symbol.for('AuthenticatorChallengePersistenceMapper'),
-  AuthenticatorPersistenceMapper: Symbol.for('AuthenticatorPersistenceMapper'),
-  AuthenticatorHttpMapper: Symbol.for('AuthenticatorHttpMapper'),
-  CacheEntryPersistenceMapper: Symbol.for('CacheEntryPersistenceMapper'),
+  Auth_SessionTracePersistenceMapper: Symbol.for('Auth_SessionTracePersistenceMapper'),
+  Auth_AuthenticatorChallengePersistenceMapper: Symbol.for('Auth_AuthenticatorChallengePersistenceMapper'),
+  Auth_AuthenticatorPersistenceMapper: Symbol.for('Auth_AuthenticatorPersistenceMapper'),
+  Auth_AuthenticatorHttpMapper: Symbol.for('Auth_AuthenticatorHttpMapper'),
+  Auth_CacheEntryPersistenceMapper: Symbol.for('Auth_CacheEntryPersistenceMapper'),
   // Controller
-  AuthController: Symbol.for('AuthController'),
-  AuthenticatorsController: Symbol.for('AuthenticatorsController'),
-  SubscriptionInvitesController: Symbol.for('SubscriptionInvitesController'),
-  UserRequestsController: Symbol.for('UserRequestsController'),
+  Auth_ControllerContainer: Symbol.for('Auth_ControllerContainer'),
+  Auth_AuthController: Symbol.for('Auth_AuthController'),
+  Auth_AuthenticatorsController: Symbol.for('Auth_AuthenticatorsController'),
+  Auth_SubscriptionInvitesController: Symbol.for('Auth_SubscriptionInvitesController'),
+  Auth_UserRequestsController: Symbol.for('Auth_UserRequestsController'),
   // Repositories
-  UserRepository: Symbol.for('UserRepository'),
-  SessionRepository: Symbol.for('SessionRepository'),
-  EphemeralSessionRepository: Symbol.for('EphemeralSessionRepository'),
-  RevokedSessionRepository: Symbol.for('RevokedSessionRepository'),
-  SettingRepository: Symbol.for('SettingRepository'),
-  SubscriptionSettingRepository: Symbol.for('SubscriptionSettingRepository'),
-  OfflineSettingRepository: Symbol.for('OfflineSettingRepository'),
-  LockRepository: Symbol.for('LockRepository'),
-  RoleRepository: Symbol.for('RoleRepository'),
-  UserSubscriptionRepository: Symbol.for('UserSubscriptionRepository'),
-  OfflineUserSubscriptionRepository: Symbol.for('OfflineUserSubscriptionRepository'),
-  SubscriptionTokenRepository: Symbol.for('SubscriptionTokenRepository'),
-  OfflineSubscriptionTokenRepository: Symbol.for('OfflineSubscriptionTokenRepository'),
-  SharedSubscriptionInvitationRepository: Symbol.for('SharedSubscriptionInvitationRepository'),
-  PKCERepository: Symbol.for('PKCERepository'),
-  SessionTraceRepository: Symbol.for('SessionTraceRepository'),
-  AuthenticatorRepository: Symbol.for('AuthenticatorRepository'),
-  AuthenticatorChallengeRepository: Symbol.for('AuthenticatorChallengeRepository'),
-  CacheEntryRepository: Symbol.for('CacheEntryRepository'),
+  Auth_UserRepository: Symbol.for('Auth_UserRepository'),
+  Auth_SessionRepository: Symbol.for('Auth_SessionRepository'),
+  Auth_EphemeralSessionRepository: Symbol.for('Auth_EphemeralSessionRepository'),
+  Auth_RevokedSessionRepository: Symbol.for('Auth_RevokedSessionRepository'),
+  Auth_SettingRepository: Symbol.for('Auth_SettingRepository'),
+  Auth_SubscriptionSettingRepository: Symbol.for('Auth_SubscriptionSettingRepository'),
+  Auth_OfflineSettingRepository: Symbol.for('Auth_OfflineSettingRepository'),
+  Auth_LockRepository: Symbol.for('Auth_LockRepository'),
+  Auth_RoleRepository: Symbol.for('Auth_RoleRepository'),
+  Auth_UserSubscriptionRepository: Symbol.for('Auth_UserSubscriptionRepository'),
+  Auth_OfflineUserSubscriptionRepository: Symbol.for('Auth_OfflineUserSubscriptionRepository'),
+  Auth_SubscriptionTokenRepository: Symbol.for('Auth_SubscriptionTokenRepository'),
+  Auth_OfflineSubscriptionTokenRepository: Symbol.for('Auth_OfflineSubscriptionTokenRepository'),
+  Auth_SharedSubscriptionInvitationRepository: Symbol.for('Auth_SharedSubscriptionInvitationRepository'),
+  Auth_PKCERepository: Symbol.for('Auth_PKCERepository'),
+  Auth_SessionTraceRepository: Symbol.for('Auth_SessionTraceRepository'),
+  Auth_AuthenticatorRepository: Symbol.for('Auth_AuthenticatorRepository'),
+  Auth_AuthenticatorChallengeRepository: Symbol.for('Auth_AuthenticatorChallengeRepository'),
+  Auth_CacheEntryRepository: Symbol.for('Auth_CacheEntryRepository'),
   // ORM
-  ORMOfflineSettingRepository: Symbol.for('ORMOfflineSettingRepository'),
-  ORMOfflineUserSubscriptionRepository: Symbol.for('ORMOfflineUserSubscriptionRepository'),
-  ORMRevokedSessionRepository: Symbol.for('ORMRevokedSessionRepository'),
-  ORMRoleRepository: Symbol.for('ORMRoleRepository'),
-  ORMSessionRepository: Symbol.for('ORMSessionRepository'),
-  ORMSettingRepository: Symbol.for('ORMSettingRepository'),
-  ORMSharedSubscriptionInvitationRepository: Symbol.for('ORMSharedSubscriptionInvitationRepository'),
-  ORMSubscriptionSettingRepository: Symbol.for('ORMSubscriptionSettingRepository'),
-  ORMUserRepository: Symbol.for('ORMUserRepository'),
-  ORMUserSubscriptionRepository: Symbol.for('ORMUserSubscriptionRepository'),
-  ORMSessionTraceRepository: Symbol.for('ORMSessionTraceRepository'),
-  ORMAuthenticatorRepository: Symbol.for('ORMAuthenticatorRepository'),
-  ORMAuthenticatorChallengeRepository: Symbol.for('ORMAuthenticatorChallengeRepository'),
-  ORMCacheEntryRepository: Symbol.for('ORMCacheEntryRepository'),
+  Auth_ORMOfflineSettingRepository: Symbol.for('Auth_ORMOfflineSettingRepository'),
+  Auth_ORMOfflineUserSubscriptionRepository: Symbol.for('Auth_ORMOfflineUserSubscriptionRepository'),
+  Auth_ORMRevokedSessionRepository: Symbol.for('Auth_ORMRevokedSessionRepository'),
+  Auth_ORMRoleRepository: Symbol.for('Auth_ORMRoleRepository'),
+  Auth_ORMSessionRepository: Symbol.for('Auth_ORMSessionRepository'),
+  Auth_ORMSettingRepository: Symbol.for('Auth_ORMSettingRepository'),
+  Auth_ORMSharedSubscriptionInvitationRepository: Symbol.for('Auth_ORMSharedSubscriptionInvitationRepository'),
+  Auth_ORMSubscriptionSettingRepository: Symbol.for('Auth_ORMSubscriptionSettingRepository'),
+  Auth_ORMUserRepository: Symbol.for('Auth_ORMUserRepository'),
+  Auth_ORMUserSubscriptionRepository: Symbol.for('Auth_ORMUserSubscriptionRepository'),
+  Auth_ORMSessionTraceRepository: Symbol.for('Auth_ORMSessionTraceRepository'),
+  Auth_ORMAuthenticatorRepository: Symbol.for('Auth_ORMAuthenticatorRepository'),
+  Auth_ORMAuthenticatorChallengeRepository: Symbol.for('Auth_ORMAuthenticatorChallengeRepository'),
+  Auth_ORMCacheEntryRepository: Symbol.for('Auth_ORMCacheEntryRepository'),
   // Middleware
-  AuthMiddleware: Symbol.for('AuthMiddleware'),
-  ApiGatewayAuthMiddleware: Symbol.for('ApiGatewayAuthMiddleware'),
-  ApiGatewayOfflineAuthMiddleware: Symbol.for('ApiGatewayOfflineAuthMiddleware'),
-  OfflineUserAuthMiddleware: Symbol.for('OfflineUserAuthMiddleware'),
-  AuthMiddlewareWithoutResponse: Symbol.for('AuthMiddlewareWithoutResponse'),
-  LockMiddleware: Symbol.for('LockMiddleware'),
-  SessionMiddleware: Symbol.for('SessionMiddleware'),
+  Auth_AuthMiddleware: Symbol.for('Auth_AuthMiddleware'),
+  Auth_ApiGatewayAuthMiddleware: Symbol.for('Auth_ApiGatewayAuthMiddleware'),
+  Auth_ApiGatewayOfflineAuthMiddleware: Symbol.for('Auth_ApiGatewayOfflineAuthMiddleware'),
+  Auth_OfflineUserAuthMiddleware: Symbol.for('Auth_OfflineUserAuthMiddleware'),
+  Auth_AuthMiddlewareWithoutResponse: Symbol.for('Auth_AuthMiddlewareWithoutResponse'),
+  Auth_LockMiddleware: Symbol.for('Auth_LockMiddleware'),
+  Auth_SessionMiddleware: Symbol.for('Auth_SessionMiddleware'),
   // Projectors
-  SessionProjector: Symbol.for('SessionProjector'),
-  UserProjector: Symbol.for('UserProjector'),
-  RoleProjector: Symbol.for('RoleProjector'),
-  PermissionProjector: Symbol.for('PermissionProjector'),
-  SettingProjector: Symbol.for('SettingProjector'),
-  SubscriptionSettingProjector: Symbol.for('SubscriptionSettingProjector'),
+  Auth_SessionProjector: Symbol.for('Auth_SessionProjector'),
+  Auth_UserProjector: Symbol.for('Auth_UserProjector'),
+  Auth_RoleProjector: Symbol.for('Auth_RoleProjector'),
+  Auth_PermissionProjector: Symbol.for('Auth_PermissionProjector'),
+  Auth_SettingProjector: Symbol.for('Auth_SettingProjector'),
+  Auth_SubscriptionSettingProjector: Symbol.for('Auth_SubscriptionSettingProjector'),
   // Factories
-  SettingFactory: Symbol.for('SettingFactory'),
+  Auth_SettingFactory: Symbol.for('Auth_SettingFactory'),
   // env vars
-  JWT_SECRET: Symbol.for('JWT_SECRET'),
-  LEGACY_JWT_SECRET: Symbol.for('LEGACY_JWT_SECRET'),
-  AUTH_JWT_SECRET: Symbol.for('AUTH_JWT_SECRET'),
-  AUTH_JWT_TTL: Symbol.for('AUTH_JWT_TTL'),
-  VALET_TOKEN_SECRET: Symbol.for('VALET_TOKEN_SECRET'),
-  VALET_TOKEN_TTL: Symbol.for('VALET_TOKEN_TTL'),
-  WEB_SOCKET_CONNECTION_TOKEN_SECRET: Symbol.for('WEB_SOCKET_CONNECTION_TOKEN_SECRET'),
-  WEB_SOCKET_CONNECTION_TOKEN_TTL: Symbol.for('WEB_SOCKET_CONNECTION_TOKEN_TTL'),
-  ENCRYPTION_SERVER_KEY: Symbol.for('ENCRYPTION_SERVER_KEY'),
-  ACCESS_TOKEN_AGE: Symbol.for('ACCESS_TOKEN_AGE'),
-  REFRESH_TOKEN_AGE: Symbol.for('REFRESH_TOKEN_AGE'),
-  EPHEMERAL_SESSION_AGE: Symbol.for('EPHEMERAL_SESSION_AGE'),
-  MAX_LOGIN_ATTEMPTS: Symbol.for('MAX_LOGIN_ATTEMPTS'),
-  FAILED_LOGIN_LOCKOUT: Symbol.for('FAILED_LOGIN_LOCKOUT'),
-  PSEUDO_KEY_PARAMS_KEY: Symbol.for('PSEUDO_KEY_PARAMS_KEY'),
-  REDIS_URL: Symbol.for('REDIS_URL'),
-  DISABLE_USER_REGISTRATION: Symbol.for('DISABLE_USER_REGISTRATION'),
-  SNS_TOPIC_ARN: Symbol.for('SNS_TOPIC_ARN'),
-  SNS_AWS_REGION: Symbol.for('SNS_AWS_REGION'),
-  SQS_QUEUE_URL: Symbol.for('SQS_QUEUE_URL'),
-  SQS_AWS_REGION: Symbol.for('SQS_AWS_REGION'),
-  USER_SERVER_REGISTRATION_URL: Symbol.for('USER_SERVER_REGISTRATION_URL'),
-  USER_SERVER_AUTH_KEY: Symbol.for('USER_SERVER_AUTH_KEY'),
-  USER_SERVER_CHANGE_EMAIL_URL: Symbol.for('USER_SERVER_CHANGE_EMAIL_URL'),
-  NEW_RELIC_ENABLED: Symbol.for('NEW_RELIC_ENABLED'),
-  SYNCING_SERVER_URL: Symbol.for('SYNCING_SERVER_URL'),
-  VERSION: Symbol.for('VERSION'),
-  PAYMENTS_SERVER_URL: Symbol.for('PAYMENTS_SERVER_URL'),
-  SESSION_TRACE_DAYS_TTL: Symbol.for('SESSION_TRACE_DAYS_TTL'),
-  U2F_RELYING_PARTY_ID: Symbol.for('U2F_RELYING_PARTY_ID'),
-  U2F_RELYING_PARTY_NAME: Symbol.for('U2F_RELYING_PARTY_NAME'),
-  U2F_EXPECTED_ORIGIN: Symbol.for('U2F_EXPECTED_ORIGIN'),
-  U2F_REQUIRE_USER_VERIFICATION: Symbol.for('U2F_REQUIRE_USER_VERIFICATION'),
-  READONLY_USERS: Symbol.for('READONLY_USERS'),
+  Auth_JWT_SECRET: Symbol.for('Auth_JWT_SECRET'),
+  Auth_LEGACY_JWT_SECRET: Symbol.for('Auth_LEGACY_JWT_SECRET'),
+  Auth_AUTH_JWT_SECRET: Symbol.for('Auth_AUTH_JWT_SECRET'),
+  Auth_AUTH_JWT_TTL: Symbol.for('Auth_AUTH_JWT_TTL'),
+  Auth_VALET_TOKEN_SECRET: Symbol.for('Auth_VALET_TOKEN_SECRET'),
+  Auth_VALET_TOKEN_TTL: Symbol.for('Auth_VALET_TOKEN_TTL'),
+  Auth_WEB_SOCKET_CONNECTION_TOKEN_SECRET: Symbol.for('Auth_WEB_SOCKET_CONNECTION_TOKEN_SECRET'),
+  Auth_WEB_SOCKET_CONNECTION_TOKEN_TTL: Symbol.for('Auth_WEB_SOCKET_CONNECTION_TOKEN_TTL'),
+  Auth_ENCRYPTION_SERVER_KEY: Symbol.for('Auth_ENCRYPTION_SERVER_KEY'),
+  Auth_ACCESS_TOKEN_AGE: Symbol.for('Auth_ACCESS_TOKEN_AGE'),
+  Auth_REFRESH_TOKEN_AGE: Symbol.for('Auth_REFRESH_TOKEN_AGE'),
+  Auth_EPHEMERAL_SESSION_AGE: Symbol.for('Auth_EPHEMERAL_SESSION_AGE'),
+  Auth_MAX_LOGIN_ATTEMPTS: Symbol.for('Auth_MAX_LOGIN_ATTEMPTS'),
+  Auth_FAILED_LOGIN_LOCKOUT: Symbol.for('Auth_FAILED_LOGIN_LOCKOUT'),
+  Auth_PSEUDO_KEY_PARAMS_KEY: Symbol.for('Auth_PSEUDO_KEY_PARAMS_KEY'),
+  Auth_REDIS_URL: Symbol.for('Auth_REDIS_URL'),
+  Auth_DISABLE_USER_REGISTRATION: Symbol.for('Auth_DISABLE_USER_REGISTRATION'),
+  Auth_SNS_TOPIC_ARN: Symbol.for('Auth_SNS_TOPIC_ARN'),
+  Auth_SNS_AWS_REGION: Symbol.for('Auth_SNS_AWS_REGION'),
+  Auth_SQS_QUEUE_URL: Symbol.for('Auth_SQS_QUEUE_URL'),
+  Auth_SQS_AWS_REGION: Symbol.for('Auth_SQS_AWS_REGION'),
+  Auth_USER_SERVER_REGISTRATION_URL: Symbol.for('Auth_USER_SERVER_REGISTRATION_URL'),
+  Auth_USER_SERVER_AUTH_KEY: Symbol.for('Auth_USER_SERVER_AUTH_KEY'),
+  Auth_USER_SERVER_CHANGE_EMAIL_URL: Symbol.for('Auth_USER_SERVER_CHANGE_EMAIL_URL'),
+  Auth_NEW_RELIC_ENABLED: Symbol.for('Auth_NEW_RELIC_ENABLED'),
+  Auth_SYNCING_SERVER_URL: Symbol.for('Auth_SYNCING_SERVER_URL'),
+  Auth_VERSION: Symbol.for('Auth_VERSION'),
+  Auth_PAYMENTS_SERVER_URL: Symbol.for('Auth_PAYMENTS_SERVER_URL'),
+  Auth_SESSION_TRACE_DAYS_TTL: Symbol.for('Auth_SESSION_TRACE_DAYS_TTL'),
+  Auth_U2F_RELYING_PARTY_ID: Symbol.for('Auth_U2F_RELYING_PARTY_ID'),
+  Auth_U2F_RELYING_PARTY_NAME: Symbol.for('Auth_U2F_RELYING_PARTY_NAME'),
+  Auth_U2F_EXPECTED_ORIGIN: Symbol.for('Auth_U2F_EXPECTED_ORIGIN'),
+  Auth_U2F_REQUIRE_USER_VERIFICATION: Symbol.for('Auth_U2F_REQUIRE_USER_VERIFICATION'),
+  Auth_READONLY_USERS: Symbol.for('Auth_READONLY_USERS'),
   // use cases
-  AuthenticateUser: Symbol.for('AuthenticateUser'),
-  AuthenticateRequest: Symbol.for('AuthenticateRequest'),
-  RefreshSessionToken: Symbol.for('RefreshSessionToken'),
-  VerifyMFA: Symbol.for('VerifyMFA'),
-  SignIn: Symbol.for('SignIn'),
-  ClearLoginAttempts: Symbol.for('ClearLoginAttempts'),
-  IncreaseLoginAttempts: Symbol.for('IncreaseLoginAttempts'),
-  GetUserKeyParams: Symbol.for('GetUserKeyParams'),
-  UpdateUser: Symbol.for('UpdateUser'),
-  Register: Symbol.for('Register'),
-  GetActiveSessionsForUser: Symbol.for('GetActiveSessionsForUser'),
-  DeletePreviousSessionsForUser: Symbol.for('DeletePreviousSessionsForUser'),
-  DeleteSessionForUser: Symbol.for('DeleteSessionForUser'),
-  ChangeCredentials: Symbol.for('ChangePassword'),
-  GetSettings: Symbol.for('GetSettings'),
-  GetSetting: Symbol.for('GetSetting'),
-  GetUserFeatures: Symbol.for('GetUserFeatures'),
-  UpdateSetting: Symbol.for('UpdateSetting'),
-  DeleteSetting: Symbol.for('DeleteSetting'),
-  DeleteAccount: Symbol.for('DeleteAccount'),
-  GetUserSubscription: Symbol.for('GetUserSubscription'),
-  GetUserOfflineSubscription: Symbol.for('GetUserOfflineSubscription'),
-  CreateSubscriptionToken: Symbol.for('CreateSubscriptionToken'),
-  AuthenticateSubscriptionToken: Symbol.for('AuthenticateSubscriptionToken'),
-  CreateOfflineSubscriptionToken: Symbol.for('CreateOfflineSubscriptionToken'),
-  AuthenticateOfflineSubscriptionToken: Symbol.for('AuthenticateOfflineSubscriptionToken'),
-  CreateValetToken: Symbol.for('CreateValetToken'),
-  CreateListedAccount: Symbol.for('CreateListedAccount'),
-  InviteToSharedSubscription: Symbol.for('InviteToSharedSubscription'),
-  AcceptSharedSubscriptionInvitation: Symbol.for('AcceptSharedSubscriptionInvitation'),
-  DeclineSharedSubscriptionInvitation: Symbol.for('DeclineSharedSubscriptionInvitation'),
-  CancelSharedSubscriptionInvitation: Symbol.for('CancelSharedSubscriptionInvitation'),
-  ListSharedSubscriptionInvitations: Symbol.for('ListSharedSubscriptionInvitations'),
-  VerifyPredicate: Symbol.for('VerifyPredicate'),
-  CreateCrossServiceToken: Symbol.for('CreateCrossServiceToken'),
-  ProcessUserRequest: Symbol.for('ProcessUserRequest'),
-  TraceSession: Symbol.for('TraceSession'),
-  CleanupSessionTraces: Symbol.for('CleanupSessionTraces'),
-  CleanupExpiredSessions: Symbol.for('CleanupExpiredSessions'),
-  PersistStatistics: Symbol.for('PersistStatistics'),
-  GenerateAuthenticatorRegistrationOptions: Symbol.for('GenerateAuthenticatorRegistrationOptions'),
-  VerifyAuthenticatorRegistrationResponse: Symbol.for('VerifyAuthenticatorRegistrationResponse'),
-  GenerateAuthenticatorAuthenticationOptions: Symbol.for('GenerateAuthenticatorAuthenticationOptions'),
-  VerifyAuthenticatorAuthenticationResponse: Symbol.for('VerifyAuthenticatorAuthenticationResponse'),
-  ListAuthenticators: Symbol.for('ListAuthenticators'),
-  DeleteAuthenticator: Symbol.for('DeleteAuthenticator'),
-  GenerateRecoveryCodes: Symbol.for('GenerateRecoveryCodes'),
-  SignInWithRecoveryCodes: Symbol.for('SignInWithRecoveryCodes'),
-  GetUserKeyParamsRecovery: Symbol.for('GetUserKeyParamsRecovery'),
+  Auth_AuthenticateUser: Symbol.for('Auth_AuthenticateUser'),
+  Auth_AuthenticateRequest: Symbol.for('Auth_AuthenticateRequest'),
+  Auth_RefreshSessionToken: Symbol.for('Auth_RefreshSessionToken'),
+  Auth_VerifyMFA: Symbol.for('Auth_VerifyMFA'),
+  Auth_SignIn: Symbol.for('Auth_SignIn'),
+  Auth_ClearLoginAttempts: Symbol.for('Auth_ClearLoginAttempts'),
+  Auth_IncreaseLoginAttempts: Symbol.for('Auth_IncreaseLoginAttempts'),
+  Auth_GetUserKeyParams: Symbol.for('Auth_GetUserKeyParams'),
+  Auth_UpdateUser: Symbol.for('Auth_UpdateUser'),
+  Auth_Register: Symbol.for('Auth_Register'),
+  Auth_GetActiveSessionsForUser: Symbol.for('Auth_GetActiveSessionsForUser'),
+  Auth_DeletePreviousSessionsForUser: Symbol.for('Auth_DeletePreviousSessionsForUser'),
+  Auth_DeleteSessionForUser: Symbol.for('Auth_DeleteSessionForUser'),
+  Auth_ChangeCredentials: Symbol.for('Auth_ChangePassword'),
+  Auth_GetSettings: Symbol.for('Auth_GetSettings'),
+  Auth_GetSetting: Symbol.for('Auth_GetSetting'),
+  Auth_GetUserFeatures: Symbol.for('Auth_GetUserFeatures'),
+  Auth_UpdateSetting: Symbol.for('Auth_UpdateSetting'),
+  Auth_DeleteSetting: Symbol.for('Auth_DeleteSetting'),
+  Auth_DeleteAccount: Symbol.for('Auth_DeleteAccount'),
+  Auth_GetUserSubscription: Symbol.for('Auth_GetUserSubscription'),
+  Auth_GetUserOfflineSubscription: Symbol.for('Auth_GetUserOfflineSubscription'),
+  Auth_CreateSubscriptionToken: Symbol.for('Auth_CreateSubscriptionToken'),
+  Auth_AuthenticateSubscriptionToken: Symbol.for('Auth_AuthenticateSubscriptionToken'),
+  Auth_CreateOfflineSubscriptionToken: Symbol.for('Auth_CreateOfflineSubscriptionToken'),
+  Auth_AuthenticateOfflineSubscriptionToken: Symbol.for('Auth_AuthenticateOfflineSubscriptionToken'),
+  Auth_CreateValetToken: Symbol.for('Auth_CreateValetToken'),
+  Auth_CreateListedAccount: Symbol.for('Auth_CreateListedAccount'),
+  Auth_InviteToSharedSubscription: Symbol.for('Auth_InviteToSharedSubscription'),
+  Auth_AcceptSharedSubscriptionInvitation: Symbol.for('Auth_AcceptSharedSubscriptionInvitation'),
+  Auth_DeclineSharedSubscriptionInvitation: Symbol.for('Auth_DeclineSharedSubscriptionInvitation'),
+  Auth_CancelSharedSubscriptionInvitation: Symbol.for('Auth_CancelSharedSubscriptionInvitation'),
+  Auth_ListSharedSubscriptionInvitations: Symbol.for('Auth_ListSharedSubscriptionInvitations'),
+  Auth_VerifyPredicate: Symbol.for('Auth_VerifyPredicate'),
+  Auth_CreateCrossServiceToken: Symbol.for('Auth_CreateCrossServiceToken'),
+  Auth_ProcessUserRequest: Symbol.for('Auth_ProcessUserRequest'),
+  Auth_TraceSession: Symbol.for('Auth_TraceSession'),
+  Auth_CleanupSessionTraces: Symbol.for('Auth_CleanupSessionTraces'),
+  Auth_CleanupExpiredSessions: Symbol.for('Auth_CleanupExpiredSessions'),
+  Auth_PersistStatistics: Symbol.for('Auth_PersistStatistics'),
+  Auth_GenerateAuthenticatorRegistrationOptions: Symbol.for('Auth_GenerateAuthenticatorRegistrationOptions'),
+  Auth_VerifyAuthenticatorRegistrationResponse: Symbol.for('Auth_VerifyAuthenticatorRegistrationResponse'),
+  Auth_GenerateAuthenticatorAuthenticationOptions: Symbol.for('Auth_GenerateAuthenticatorAuthenticationOptions'),
+  Auth_VerifyAuthenticatorAuthenticationResponse: Symbol.for('Auth_VerifyAuthenticatorAuthenticationResponse'),
+  Auth_ListAuthenticators: Symbol.for('Auth_ListAuthenticators'),
+  Auth_DeleteAuthenticator: Symbol.for('Auth_DeleteAuthenticator'),
+  Auth_GenerateRecoveryCodes: Symbol.for('Auth_GenerateRecoveryCodes'),
+  Auth_SignInWithRecoveryCodes: Symbol.for('Auth_SignInWithRecoveryCodes'),
+  Auth_GetUserKeyParamsRecovery: Symbol.for('Auth_GetUserKeyParamsRecovery'),
   // Handlers
-  UserRegisteredEventHandler: Symbol.for('UserRegisteredEventHandler'),
-  AccountDeletionRequestedEventHandler: Symbol.for('AccountDeletionRequestedEventHandler'),
-  SubscriptionPurchasedEventHandler: Symbol.for('SubscriptionPurchasedEventHandler'),
-  SubscriptionCancelledEventHandler: Symbol.for('SubscriptionCancelledEventHandler'),
-  SubscriptionReassignedEventHandler: Symbol.for('SubscriptionReassignedEventHandler'),
-  SubscriptionRenewedEventHandler: Symbol.for('SubscriptionRenewedEventHandler'),
-  SubscriptionRefundedEventHandler: Symbol.for('SubscriptionRefundedEventHandler'),
-  SubscriptionExpiredEventHandler: Symbol.for('SubscriptionExpiredEventHandler'),
-  SubscriptionSyncRequestedEventHandler: Symbol.for('SubscriptionSyncRequestedEventHandler'),
-  ExtensionKeyGrantedEventHandler: Symbol.for('ExtensionKeyGrantedEventHandler'),
-  UserEmailChangedEventHandler: Symbol.for('UserEmailChangedEventHandler'),
-  FileUploadedEventHandler: Symbol.for('FileUploadedEventHandler'),
-  FileRemovedEventHandler: Symbol.for('FileRemovedEventHandler'),
-  ListedAccountCreatedEventHandler: Symbol.for('ListedAccountCreatedEventHandler'),
-  ListedAccountDeletedEventHandler: Symbol.for('ListedAccountDeletedEventHandler'),
-  UserDisabledSessionUserAgentLoggingEventHandler: Symbol.for('UserDisabledSessionUserAgentLoggingEventHandler'),
-  SharedSubscriptionInvitationCreatedEventHandler: Symbol.for('SharedSubscriptionInvitationCreatedEventHandler'),
-  PredicateVerificationRequestedEventHandler: Symbol.for('PredicateVerificationRequestedEventHandler'),
-  EmailSubscriptionUnsubscribedEventHandler: Symbol.for('EmailSubscriptionUnsubscribedEventHandler'),
+  Auth_UserRegisteredEventHandler: Symbol.for('Auth_UserRegisteredEventHandler'),
+  Auth_AccountDeletionRequestedEventHandler: Symbol.for('Auth_AccountDeletionRequestedEventHandler'),
+  Auth_SubscriptionPurchasedEventHandler: Symbol.for('Auth_SubscriptionPurchasedEventHandler'),
+  Auth_SubscriptionCancelledEventHandler: Symbol.for('Auth_SubscriptionCancelledEventHandler'),
+  Auth_SubscriptionReassignedEventHandler: Symbol.for('Auth_SubscriptionReassignedEventHandler'),
+  Auth_SubscriptionRenewedEventHandler: Symbol.for('Auth_SubscriptionRenewedEventHandler'),
+  Auth_SubscriptionRefundedEventHandler: Symbol.for('Auth_SubscriptionRefundedEventHandler'),
+  Auth_SubscriptionExpiredEventHandler: Symbol.for('Auth_SubscriptionExpiredEventHandler'),
+  Auth_SubscriptionSyncRequestedEventHandler: Symbol.for('Auth_SubscriptionSyncRequestedEventHandler'),
+  Auth_ExtensionKeyGrantedEventHandler: Symbol.for('Auth_ExtensionKeyGrantedEventHandler'),
+  Auth_UserEmailChangedEventHandler: Symbol.for('Auth_UserEmailChangedEventHandler'),
+  Auth_FileUploadedEventHandler: Symbol.for('Auth_FileUploadedEventHandler'),
+  Auth_FileRemovedEventHandler: Symbol.for('Auth_FileRemovedEventHandler'),
+  Auth_ListedAccountCreatedEventHandler: Symbol.for('Auth_ListedAccountCreatedEventHandler'),
+  Auth_ListedAccountDeletedEventHandler: Symbol.for('Auth_ListedAccountDeletedEventHandler'),
+  Auth_UserDisabledSessionUserAgentLoggingEventHandler: Symbol.for(
+    'Auth_UserDisabledSessionUserAgentLoggingEventHandler',
+  ),
+  Auth_SharedSubscriptionInvitationCreatedEventHandler: Symbol.for(
+    'Auth_SharedSubscriptionInvitationCreatedEventHandler',
+  ),
+  Auth_PredicateVerificationRequestedEventHandler: Symbol.for('Auth_PredicateVerificationRequestedEventHandler'),
+  Auth_EmailSubscriptionUnsubscribedEventHandler: Symbol.for('Auth_EmailSubscriptionUnsubscribedEventHandler'),
   // Services
-  DeviceDetector: Symbol.for('DeviceDetector'),
-  SessionService: Symbol.for('SessionService'),
-  SettingService: Symbol.for('SettingService'),
-  SubscriptionSettingService: Symbol.for('SubscriptionSettingService'),
-  OfflineSettingService: Symbol.for('OfflineSettingService'),
-  AuthResponseFactory20161215: Symbol.for('AuthResponseFactory20161215'),
-  AuthResponseFactory20190520: Symbol.for('AuthResponseFactory20190520'),
-  AuthResponseFactory20200115: Symbol.for('AuthResponseFactory20200115'),
-  AuthResponseFactoryResolver: Symbol.for('AuthResponseFactoryResolver'),
-  KeyParamsFactory: Symbol.for('KeyParamsFactory'),
-  SessionTokenDecoder: Symbol.for('SessionTokenDecoder'),
-  FallbackSessionTokenDecoder: Symbol.for('FallbackSessionTokenDecoder'),
-  CrossServiceTokenDecoder: Symbol.for('CrossServiceTokenDecoder'),
-  OfflineUserTokenDecoder: Symbol.for('OfflineUserTokenDecoder'),
-  OfflineUserTokenEncoder: Symbol.for('OfflineUserTokenEncoder'),
-  CrossServiceTokenEncoder: Symbol.for('CrossServiceTokenEncoder'),
-  SessionTokenEncoder: Symbol.for('SessionTokenEncoder'),
-  ValetTokenEncoder: Symbol.for('ValetTokenEncoder'),
-  WebSocketConnectionTokenDecoder: Symbol.for('WebSocketConnectionTokenDecoder'),
-  AuthenticationMethodResolver: Symbol.for('AuthenticationMethodResolver'),
-  DomainEventPublisher: Symbol.for('DomainEventPublisher'),
-  DomainEventSubscriberFactory: Symbol.for('DomainEventSubscriberFactory'),
-  DomainEventFactory: Symbol.for('DomainEventFactory'),
-  DomainEventMessageHandler: Symbol.for('DomainEventMessageHandler'),
-  HTTPClient: Symbol.for('HTTPClient'),
-  Crypter: Symbol.for('Crypter'),
-  CryptoNode: Symbol.for('CryptoNode'),
-  Timer: Symbol.for('Timer'),
-  ContenDecoder: Symbol.for('ContenDecoder'),
-  WebSocketsClientService: Symbol.for('WebSocketClientService'),
-  RoleService: Symbol.for('RoleService'),
-  RoleToSubscriptionMap: Symbol.for('RoleToSubscriptionMap'),
-  SettingsAssociationService: Symbol.for('SettingsAssociationService'),
-  SubscriptionSettingsAssociationService: Symbol.for('SubscriptionSettingsAssociationService'),
-  FeatureService: Symbol.for('FeatureService'),
-  SettingDecrypter: Symbol.for('SettingDecrypter'),
-  SettingInterpreter: Symbol.for('SettingInterpreter'),
-  ProtocolVersionSelector: Symbol.for('ProtocolVersionSelector'),
-  BooleanSelector: Symbol.for('BooleanSelector'),
-  UserSubscriptionService: Symbol.for('UserSubscriptionService'),
+  Auth_DeviceDetector: Symbol.for('Auth_DeviceDetector'),
+  Auth_SessionService: Symbol.for('Auth_SessionService'),
+  Auth_SettingService: Symbol.for('Auth_SettingService'),
+  Auth_SubscriptionSettingService: Symbol.for('Auth_SubscriptionSettingService'),
+  Auth_OfflineSettingService: Symbol.for('Auth_OfflineSettingService'),
+  Auth_AuthResponseFactory20161215: Symbol.for('Auth_AuthResponseFactory20161215'),
+  Auth_AuthResponseFactory20190520: Symbol.for('Auth_AuthResponseFactory20190520'),
+  Auth_AuthResponseFactory20200115: Symbol.for('Auth_AuthResponseFactory20200115'),
+  Auth_AuthResponseFactoryResolver: Symbol.for('Auth_AuthResponseFactoryResolver'),
+  Auth_KeyParamsFactory: Symbol.for('Auth_KeyParamsFactory'),
+  Auth_SessionTokenDecoder: Symbol.for('Auth_SessionTokenDecoder'),
+  Auth_FallbackSessionTokenDecoder: Symbol.for('Auth_FallbackSessionTokenDecoder'),
+  Auth_CrossServiceTokenDecoder: Symbol.for('Auth_CrossServiceTokenDecoder'),
+  Auth_OfflineUserTokenDecoder: Symbol.for('Auth_OfflineUserTokenDecoder'),
+  Auth_OfflineUserTokenEncoder: Symbol.for('Auth_OfflineUserTokenEncoder'),
+  Auth_CrossServiceTokenEncoder: Symbol.for('Auth_CrossServiceTokenEncoder'),
+  Auth_SessionTokenEncoder: Symbol.for('Auth_SessionTokenEncoder'),
+  Auth_ValetTokenEncoder: Symbol.for('Auth_ValetTokenEncoder'),
+  Auth_WebSocketConnectionTokenDecoder: Symbol.for('Auth_WebSocketConnectionTokenDecoder'),
+  Auth_AuthenticationMethodResolver: Symbol.for('Auth_AuthenticationMethodResolver'),
+  Auth_DomainEventPublisher: Symbol.for('Auth_DomainEventPublisher'),
+  Auth_DomainEventSubscriberFactory: Symbol.for('Auth_DomainEventSubscriberFactory'),
+  Auth_DomainEventFactory: Symbol.for('Auth_DomainEventFactory'),
+  Auth_DomainEventMessageHandler: Symbol.for('Auth_DomainEventMessageHandler'),
+  Auth_HTTPClient: Symbol.for('Auth_HTTPClient'),
+  Auth_Crypter: Symbol.for('Auth_Crypter'),
+  Auth_CryptoNode: Symbol.for('Auth_CryptoNode'),
+  Auth_Timer: Symbol.for('Auth_Timer'),
+  Auth_ContenDecoder: Symbol.for('Auth_ContenDecoder'),
+  Auth_WebSocketsClientService: Symbol.for('Auth_WebSocketClientService'),
+  Auth_RoleService: Symbol.for('Auth_RoleService'),
+  Auth_RoleToSubscriptionMap: Symbol.for('Auth_RoleToSubscriptionMap'),
+  Auth_SettingsAssociationService: Symbol.for('Auth_SettingsAssociationService'),
+  Auth_SubscriptionSettingsAssociationService: Symbol.for('Auth_SubscriptionSettingsAssociationService'),
+  Auth_FeatureService: Symbol.for('Auth_FeatureService'),
+  Auth_SettingDecrypter: Symbol.for('Auth_SettingDecrypter'),
+  Auth_SettingInterpreter: Symbol.for('Auth_SettingInterpreter'),
+  Auth_ProtocolVersionSelector: Symbol.for('Auth_ProtocolVersionSelector'),
+  Auth_BooleanSelector: Symbol.for('Auth_BooleanSelector'),
+  Auth_UserSubscriptionService: Symbol.for('Auth_UserSubscriptionService'),
+  Auth_InversifyExpressAuthController: Symbol.for('Auth_InversifyExpressAuthController'),
+  Auth_InversifyExpressAuthenticatorsController: Symbol.for('Auth_InversifyExpressAuthenticatorsController'),
+  Auth_InversifyExpressSubscriptionInvitesController: Symbol.for('Auth_InversifyExpressSubscriptionInvitesController'),
+  Auth_InversifyExpressUserRequestsController: Symbol.for('Auth_InversifyExpressUserRequestsController'),
+  Auth_InversifyExpressWebSocketsController: Symbol.for('Auth_InversifyExpressWebSocketsController'),
 }
 
 export default TYPES

packages/auth/src/Bootstrap/index.ts

@@ -0,0 +1 @@
+export * from './Service'

packages/auth/src/Controller/AdminController.spec.ts

@@ -8,6 +8,7 @@ import * as express from 'express'
 import { DeleteSetting } from '../Domain/UseCase/DeleteSetting/DeleteSetting'
 import { CreateSubscriptionToken } from '../Domain/UseCase/CreateSubscriptionToken/CreateSubscriptionToken'
 import { CreateOfflineSubscriptionToken } from '../Domain/UseCase/CreateOfflineSubscriptionToken/CreateOfflineSubscriptionToken'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('AdminController', () => {
   let deleteSetting: DeleteSetting
@@ -16,9 +17,16 @@ describe('AdminController', () => {
   let createOfflineSubscriptionToken: CreateOfflineSubscriptionToken
   let request: express.Request
   let user: User
+  let controllerContainer: ControllerContainerInterface
 
   const createController = () =>
-    new AdminController(deleteSetting, userRepository, createSubscriptionToken, createOfflineSubscriptionToken)
+    new AdminController(
+      deleteSetting,
+      userRepository,
+      createSubscriptionToken,
+      createOfflineSubscriptionToken,
+      controllerContainer,
+    )
 
   beforeEach(() => {
     user = {} as jest.Mocked<User>
@@ -50,6 +58,9 @@ describe('AdminController', () => {
       body: {},
       params: {},
     } as jest.Mocked<express.Request>
+
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
   })
 
   it('should return error if missing email parameter', async () => {

packages/auth/src/Controller/AdminController.ts

@@ -1,4 +1,4 @@
-import { Username } from '@standardnotes/domain-core'
+import { ControllerContainerInterface, Username } from '@standardnotes/domain-core'
 import { SettingName } from '@standardnotes/settings'
 import { Request } from 'express'
 import { inject } from 'inversify'
@@ -20,13 +20,20 @@ import { UserRepositoryInterface } from '../Domain/User/UserRepositoryInterface'
 @controller('/admin')
 export class AdminController extends BaseHttpController {
   constructor(
-    @inject(TYPES.DeleteSetting) private doDeleteSetting: DeleteSetting,
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.CreateSubscriptionToken) private createSubscriptionToken: CreateSubscriptionToken,
-    @inject(TYPES.CreateOfflineSubscriptionToken)
+    @inject(TYPES.Auth_DeleteSetting) private doDeleteSetting: DeleteSetting,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_CreateSubscriptionToken) private createSubscriptionToken: CreateSubscriptionToken,
+    @inject(TYPES.Auth_CreateOfflineSubscriptionToken)
     private createOfflineSubscriptionToken: CreateOfflineSubscriptionToken,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
   ) {
     super()
+
+    this.controllerContainer.register('admin.getUser', this.getUser.bind(this))
+    this.controllerContainer.register('admin.deleteMFASetting', this.deleteMFASetting.bind(this))
+    this.controllerContainer.register('admin.createToken', this.createToken.bind(this))
+    this.controllerContainer.register('admin.createOfflineToken', this.createOfflineToken.bind(this))
+    this.controllerContainer.register('admin.disableEmailBackups', this.disableEmailBackups.bind(this))
   }
 
   @httpGet('/user/:email')

packages/auth/src/Controller/ApiGatewayAuthMiddleware.ts

@@ -8,8 +8,8 @@ import TYPES from '../Bootstrap/Types'
 @injectable()
 export class ApiGatewayAuthMiddleware extends BaseMiddleware {
   constructor(
-    @inject(TYPES.CrossServiceTokenDecoder) private tokenDecoder: TokenDecoderInterface<CrossServiceTokenData>,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_CrossServiceTokenDecoder) private tokenDecoder: TokenDecoderInterface<CrossServiceTokenData>,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {
     super()
   }

packages/auth/src/Controller/ApiGatewayOfflineAuthMiddleware.ts

@@ -8,8 +8,8 @@ import TYPES from '../Bootstrap/Types'
 @injectable()
 export class ApiGatewayOfflineAuthMiddleware extends BaseMiddleware {
   constructor(
-    @inject(TYPES.OfflineUserTokenDecoder) private tokenDecoder: TokenDecoderInterface<OfflineUserTokenData>,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_OfflineUserTokenDecoder) private tokenDecoder: TokenDecoderInterface<OfflineUserTokenData>,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {
     super()
   }

packages/auth/src/Controller/AuthController.spec.ts

@@ -13,6 +13,7 @@ import { SignInWithRecoveryCodes } from '../Domain/UseCase/SignInWithRecoveryCod
 import { GetUserKeyParamsRecovery } from '../Domain/UseCase/GetUserKeyParamsRecovery/GetUserKeyParamsRecovery'
 import { GenerateRecoveryCodes } from '../Domain/UseCase/GenerateRecoveryCodes/GenerateRecoveryCodes'
 import { Logger } from 'winston'
+import { SessionServiceInterface } from '../Domain/Session/SessionServiceInterface'
 
 describe('AuthController', () => {
   let clearLoginAttempts: ClearLoginAttempts
@@ -25,6 +26,7 @@ describe('AuthController', () => {
   let getUserKeyParamsRecovery: GetUserKeyParamsRecovery
   let doGenerateRecoveryCodes: GenerateRecoveryCodes
   let logger: Logger
+  let sessionService: SessionServiceInterface
 
   const createController = () =>
     new AuthController(
@@ -36,6 +38,7 @@ describe('AuthController', () => {
       getUserKeyParamsRecovery,
       doGenerateRecoveryCodes,
       logger,
+      sessionService,
     )
 
   beforeEach(() => {
@@ -58,6 +61,9 @@ describe('AuthController', () => {
 
     logger = {} as jest.Mocked<Logger>
     logger.debug = jest.fn()
+
+    sessionService = {} as jest.Mocked<SessionServiceInterface>
+    sessionService.deleteSessionByToken = jest.fn().mockReturnValue('1-2-3')
   })
 
   it('should register a user', async () => {

packages/auth/src/Controller/AuthController.ts

@@ -1,4 +1,3 @@
-import { inject, injectable } from 'inversify'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
 import {
   ApiVersion,
@@ -7,10 +6,9 @@ import {
   UserDeletionResponseBody,
   UserRegistrationResponseBody,
 } from '@standardnotes/api'
-import { HttpResponse, HttpStatusCode } from '@standardnotes/responses'
+import { ErrorTag, HttpResponse, HttpStatusCode } from '@standardnotes/responses'
 import { ProtocolVersion } from '@standardnotes/common'
 
-import TYPES from '../Bootstrap/Types'
 import { ClearLoginAttempts } from '../Domain/UseCase/ClearLoginAttempts'
 import { Register } from '../Domain/UseCase/Register'
 import { DomainEventFactoryInterface } from '../Domain/Event/DomainEventFactoryInterface'
@@ -24,18 +22,19 @@ import { GenerateRecoveryCodesResponseBody } from '../Infra/Http/Response/Genera
 import { GenerateRecoveryCodes } from '../Domain/UseCase/GenerateRecoveryCodes/GenerateRecoveryCodes'
 import { GenerateRecoveryCodesRequestParams } from '../Infra/Http/Request/GenerateRecoveryCodesRequestParams'
 import { Logger } from 'winston'
+import { SessionServiceInterface } from '../Domain/Session/SessionServiceInterface'
 
-@injectable()
 export class AuthController implements UserServerInterface {
   constructor(
-    @inject(TYPES.ClearLoginAttempts) private clearLoginAttempts: ClearLoginAttempts,
-    @inject(TYPES.Register) private registerUser: Register,
-    @inject(TYPES.DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
-    @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
-    @inject(TYPES.SignInWithRecoveryCodes) private doSignInWithRecoveryCodes: SignInWithRecoveryCodes,
-    @inject(TYPES.GetUserKeyParamsRecovery) private getUserKeyParamsRecovery: GetUserKeyParamsRecovery,
-    @inject(TYPES.GenerateRecoveryCodes) private doGenerateRecoveryCodes: GenerateRecoveryCodes,
-    @inject(TYPES.Logger) private logger: Logger,
+    private clearLoginAttempts: ClearLoginAttempts,
+    private registerUser: Register,
+    private domainEventPublisher: DomainEventPublisherInterface,
+    private domainEventFactory: DomainEventFactoryInterface,
+    private doSignInWithRecoveryCodes: SignInWithRecoveryCodes,
+    private getUserKeyParamsRecovery: GetUserKeyParamsRecovery,
+    private doGenerateRecoveryCodes: GenerateRecoveryCodes,
+    private logger: Logger,
+    private sessionService: SessionServiceInterface,
   ) {}
 
   async deleteAccount(_params: never): Promise<HttpResponse<UserDeletionResponseBody>> {
@@ -200,4 +199,33 @@ export class AuthController implements UserServerInterface {
       },
     }
   }
+
+  async signOut(params: Record<string, unknown>): Promise<HttpResponse> {
+    if (params.readOnlyAccess) {
+      return {
+        status: HttpStatusCode.Unauthorized,
+        data: {
+          error: {
+            tag: ErrorTag.ReadOnlyAccess,
+            message: 'Session has read-only access.',
+          },
+        },
+      }
+    }
+
+    const userUuid = await this.sessionService.deleteSessionByToken(
+      (params.authorizationHeader as string).replace('Bearer ', ''),
+    )
+
+    let headers = undefined
+    if (userUuid !== null) {
+      headers = new Map([['x-invalidate-cache', userUuid]])
+    }
+
+    return {
+      status: HttpStatusCode.NoContent,
+      data: {},
+      headers,
+    }
+  }
 }

packages/auth/src/Controller/AuthMiddleware.ts

@@ -8,8 +8,8 @@ import { AuthenticateRequest } from '../Domain/UseCase/AuthenticateRequest'
 @injectable()
 export class AuthMiddleware extends BaseMiddleware {
   constructor(
-    @inject(TYPES.AuthenticateRequest) private authenticateRequest: AuthenticateRequest,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_AuthenticateRequest) private authenticateRequest: AuthenticateRequest,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {
     super()
   }

packages/auth/src/Controller/AuthMiddlewareWithoutResponse.ts

@@ -6,7 +6,7 @@ import { AuthenticateRequest } from '../Domain/UseCase/AuthenticateRequest'
 
 @injectable()
 export class AuthMiddlewareWithoutResponse extends BaseMiddleware {
-  constructor(@inject(TYPES.AuthenticateRequest) private authenticateRequest: AuthenticateRequest) {
+  constructor(@inject(TYPES.Auth_AuthenticateRequest) private authenticateRequest: AuthenticateRequest) {
     super()
   }
 

packages/auth/src/Controller/FeaturesController.spec.ts

@@ -6,6 +6,7 @@ import { FeaturesController } from './FeaturesController'
 import { results } from 'inversify-express-utils'
 import { User } from '../Domain/User/User'
 import { GetUserFeatures } from '../Domain/UseCase/GetUserFeatures/GetUserFeatures'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('FeaturesController', () => {
   let getUserFeatures: GetUserFeatures
@@ -13,10 +14,14 @@ describe('FeaturesController', () => {
   let request: express.Request
   let response: express.Response
   let user: User
+  let controllerContainer: ControllerContainerInterface
 
-  const createController = () => new FeaturesController(getUserFeatures)
+  const createController = () => new FeaturesController(getUserFeatures, controllerContainer)
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     user = {} as jest.Mocked<User>
     user.uuid = '123'
 

packages/auth/src/Controller/FeaturesController.ts

@@ -9,14 +9,20 @@ import {
 } from 'inversify-express-utils'
 import TYPES from '../Bootstrap/Types'
 import { GetUserFeatures } from '../Domain/UseCase/GetUserFeatures/GetUserFeatures'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/users/:userUuid/features')
 export class FeaturesController extends BaseHttpController {
-  constructor(@inject(TYPES.GetUserFeatures) private doGetUserFeatures: GetUserFeatures) {
+  constructor(
+    @inject(TYPES.Auth_GetUserFeatures) private doGetUserFeatures: GetUserFeatures,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
+  ) {
     super()
+
+    this.controllerContainer.register('auth.users.getFeatures', this.getFeatures.bind(this))
   }
 
-  @httpGet('/', TYPES.ApiGatewayAuthMiddleware)
+  @httpGet('/', TYPES.Auth_ApiGatewayAuthMiddleware)
   async getFeatures(request: Request, response: Response): Promise<results.JsonResult> {
     if (request.params.userUuid !== response.locals.user.uuid) {
       return this.json(

packages/auth/src/Controller/InternalController.ts

@@ -14,8 +14,8 @@ import { GetUserFeatures } from '../Domain/UseCase/GetUserFeatures/GetUserFeatur
 @controller('/internal')
 export class InternalController extends BaseHttpController {
   constructor(
-    @inject(TYPES.GetUserFeatures) private doGetUserFeatures: GetUserFeatures,
-    @inject(TYPES.GetSetting) private doGetSetting: GetSetting,
+    @inject(TYPES.Auth_GetUserFeatures) private doGetUserFeatures: GetUserFeatures,
+    @inject(TYPES.Auth_GetSetting) private doGetSetting: GetSetting,
   ) {
     super()
   }

packages/auth/src/Controller/ListedController.spec.ts

@@ -6,6 +6,7 @@ import { results } from 'inversify-express-utils'
 import { ListedController } from './ListedController'
 import { User } from '../Domain/User/User'
 import { CreateListedAccount } from '../Domain/UseCase/CreateListedAccount/CreateListedAccount'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('ListedController', () => {
   let createListedAccount: CreateListedAccount
@@ -13,10 +14,14 @@ describe('ListedController', () => {
   let request: express.Request
   let response: express.Response
   let user: User
+  let controllerContainer: ControllerContainerInterface
 
-  const createController = () => new ListedController(createListedAccount)
+  const createController = () => new ListedController(createListedAccount, controllerContainer)
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     user = {} as jest.Mocked<User>
     user.uuid = '123'
 

packages/auth/src/Controller/ListedController.ts

@@ -5,14 +5,20 @@ import { Request, Response } from 'express'
 import TYPES from '../Bootstrap/Types'
 import { CreateListedAccount } from '../Domain/UseCase/CreateListedAccount/CreateListedAccount'
 import { ErrorTag } from '@standardnotes/responses'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/listed')
 export class ListedController extends BaseHttpController {
-  constructor(@inject(TYPES.CreateListedAccount) private doCreateListedAccount: CreateListedAccount) {
+  constructor(
+    @inject(TYPES.Auth_CreateListedAccount) private doCreateListedAccount: CreateListedAccount,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
+  ) {
     super()
+
+    this.controllerContainer.register('auth.users.createListedAccount', this.createListedAccount.bind(this))
   }
 
-  @httpPost('/', TYPES.ApiGatewayAuthMiddleware)
+  @httpPost('/', TYPES.Auth_ApiGatewayAuthMiddleware)
   async createListedAccount(_request: Request, response: Response): Promise<results.JsonResult> {
     if (response.locals.readOnlyAccess) {
       return this.json(

packages/auth/src/Controller/LockMiddleware.ts

@@ -10,8 +10,8 @@ import { UserRepositoryInterface } from '../Domain/User/UserRepositoryInterface'
 @injectable()
 export class LockMiddleware extends BaseMiddleware {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.LockRepository) private lockRepository: LockRepositoryInterface,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_LockRepository) private lockRepository: LockRepositoryInterface,
   ) {
     super()
   }

packages/auth/src/Controller/OfflineController.spec.ts

@@ -14,6 +14,7 @@ import { GetUserOfflineSubscription } from '../Domain/UseCase/GetUserOfflineSubs
 import { OfflineUserTokenData, TokenEncoderInterface } from '@standardnotes/security'
 import { SubscriptionName } from '@standardnotes/common'
 import { Logger } from 'winston'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('OfflineController', () => {
   let getUserFeatures: GetUserFeatures
@@ -28,6 +29,8 @@ describe('OfflineController', () => {
   let response: express.Response
   let user: User
 
+  let controllerContainer: ControllerContainerInterface
+
   const createController = () =>
     new OfflineController(
       getUserFeatures,
@@ -37,9 +40,13 @@ describe('OfflineController', () => {
       tokenEncoder,
       jwtTTL,
       logger,
+      controllerContainer,
     )
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     user = {} as jest.Mocked<User>
     user.uuid = '123'
 

packages/auth/src/Controller/OfflineController.ts

@@ -15,23 +15,30 @@ import { CreateOfflineSubscriptionToken } from '../Domain/UseCase/CreateOfflineS
 import { GetUserOfflineSubscription } from '../Domain/UseCase/GetUserOfflineSubscription/GetUserOfflineSubscription'
 import { Logger } from 'winston'
 import { OfflineUserTokenData, TokenEncoderInterface } from '@standardnotes/security'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/offline')
 export class OfflineController extends BaseHttpController {
   constructor(
-    @inject(TYPES.GetUserFeatures) private doGetUserFeatures: GetUserFeatures,
-    @inject(TYPES.GetUserOfflineSubscription) private getUserOfflineSubscription: GetUserOfflineSubscription,
-    @inject(TYPES.CreateOfflineSubscriptionToken)
+    @inject(TYPES.Auth_GetUserFeatures) private doGetUserFeatures: GetUserFeatures,
+    @inject(TYPES.Auth_GetUserOfflineSubscription) private getUserOfflineSubscription: GetUserOfflineSubscription,
+    @inject(TYPES.Auth_CreateOfflineSubscriptionToken)
     private createOfflineSubscriptionToken: CreateOfflineSubscriptionToken,
-    @inject(TYPES.AuthenticateOfflineSubscriptionToken) private authenticateToken: AuthenticateOfflineSubscriptionToken,
-    @inject(TYPES.OfflineUserTokenEncoder) private tokenEncoder: TokenEncoderInterface<OfflineUserTokenData>,
-    @inject(TYPES.AUTH_JWT_TTL) private jwtTTL: number,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_AuthenticateOfflineSubscriptionToken)
+    private authenticateToken: AuthenticateOfflineSubscriptionToken,
+    @inject(TYPES.Auth_OfflineUserTokenEncoder) private tokenEncoder: TokenEncoderInterface<OfflineUserTokenData>,
+    @inject(TYPES.Auth_AUTH_JWT_TTL) private jwtTTL: number,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
   ) {
     super()
+
+    this.controllerContainer.register('auth.offline.features', this.getOfflineFeatures.bind(this))
+    this.controllerContainer.register('auth.offline.subscriptionTokens.create', this.createToken.bind(this))
+    this.controllerContainer.register('auth.users.getOfflineSubscriptionByToken', this.getSubscription.bind(this))
   }
 
-  @httpGet('/features', TYPES.OfflineUserAuthMiddleware)
+  @httpGet('/features', TYPES.Auth_OfflineUserAuthMiddleware)
   async getOfflineFeatures(_request: Request, response: Response): Promise<results.JsonResult> {
     const result = await this.doGetUserFeatures.execute({
       email: response.locals.offlineUserEmail,
@@ -119,7 +126,7 @@ export class OfflineController extends BaseHttpController {
     return this.json({ authToken })
   }
 
-  @httpGet('/users/subscription', TYPES.ApiGatewayOfflineAuthMiddleware)
+  @httpGet('/users/subscription', TYPES.Auth_ApiGatewayOfflineAuthMiddleware)
   async getSubscription(_request: Request, response: Response): Promise<results.JsonResult> {
     const result = await this.getUserOfflineSubscription.execute({
       userEmail: response.locals.userEmail,

packages/auth/src/Controller/OfflineUserAuthMiddleware.ts

@@ -9,8 +9,8 @@ import { OfflineSettingRepositoryInterface } from '../Domain/Setting/OfflineSett
 @injectable()
 export class OfflineUserAuthMiddleware extends BaseMiddleware {
   constructor(
-    @inject(TYPES.OfflineSettingRepository) private offlineSettingRepository: OfflineSettingRepositoryInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_OfflineSettingRepository) private offlineSettingRepository: OfflineSettingRepositoryInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {
     super()
   }

packages/auth/src/Controller/SessionController.spec.ts

@@ -7,6 +7,7 @@ import { results } from 'inversify-express-utils'
 import { RefreshSessionToken } from '../Domain/UseCase/RefreshSessionToken'
 import { DeletePreviousSessionsForUser } from '../Domain/UseCase/DeletePreviousSessionsForUser'
 import { DeleteSessionForUser } from '../Domain/UseCase/DeleteSessionForUser'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('SessionController', () => {
   let deleteSessionForUser: DeleteSessionForUser
@@ -14,11 +15,15 @@ describe('SessionController', () => {
   let refreshSessionToken: RefreshSessionToken
   let request: express.Request
   let response: express.Response
+  let controllerContainer: ControllerContainerInterface
 
   const createController = () =>
-    new SessionController(deleteSessionForUser, deletePreviousSessionsForUser, refreshSessionToken)
+    new SessionController(deleteSessionForUser, deletePreviousSessionsForUser, refreshSessionToken, controllerContainer)
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     deleteSessionForUser = {} as jest.Mocked<DeleteSessionForUser>
     deleteSessionForUser.execute = jest.fn().mockReturnValue({ success: true })
 

packages/auth/src/Controller/SessionController.ts

@@ -13,18 +13,25 @@ import TYPES from '../Bootstrap/Types'
 import { DeletePreviousSessionsForUser } from '../Domain/UseCase/DeletePreviousSessionsForUser'
 import { DeleteSessionForUser } from '../Domain/UseCase/DeleteSessionForUser'
 import { RefreshSessionToken } from '../Domain/UseCase/RefreshSessionToken'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/session')
 export class SessionController extends BaseHttpController {
   constructor(
-    @inject(TYPES.DeleteSessionForUser) private deleteSessionForUser: DeleteSessionForUser,
-    @inject(TYPES.DeletePreviousSessionsForUser) private deletePreviousSessionsForUser: DeletePreviousSessionsForUser,
-    @inject(TYPES.RefreshSessionToken) private refreshSessionToken: RefreshSessionToken,
+    @inject(TYPES.Auth_DeleteSessionForUser) private deleteSessionForUser: DeleteSessionForUser,
+    @inject(TYPES.Auth_DeletePreviousSessionsForUser)
+    private deletePreviousSessionsForUser: DeletePreviousSessionsForUser,
+    @inject(TYPES.Auth_RefreshSessionToken) private refreshSessionToken: RefreshSessionToken,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
   ) {
     super()
+
+    this.controllerContainer.register('auth.session.delete', this.deleteSession.bind(this))
+    this.controllerContainer.register('auth.session.deleteAll', this.deleteAllSessions.bind(this))
+    this.controllerContainer.register('auth.session.refresh', this.refresh.bind(this))
   }
 
-  @httpDelete('/', TYPES.AuthMiddleware, TYPES.SessionMiddleware)
+  @httpDelete('/', TYPES.Auth_AuthMiddleware, TYPES.Auth_SessionMiddleware)
   async deleteSession(request: Request, response: Response): Promise<results.JsonResult | void> {
     if (response.locals.readOnlyAccess) {
       return this.json(
@@ -80,7 +87,7 @@ export class SessionController extends BaseHttpController {
     response.status(204).send()
   }
 
-  @httpDelete('/all', TYPES.AuthMiddleware, TYPES.SessionMiddleware)
+  @httpDelete('/all', TYPES.Auth_AuthMiddleware, TYPES.Auth_SessionMiddleware)
   async deleteAllSessions(_request: Request, response: Response): Promise<results.JsonResult | void> {
     if (response.locals.readOnlyAccess) {
       return this.json(

packages/auth/src/Controller/SessionsController.spec.ts

@@ -10,6 +10,7 @@ import { GetActiveSessionsForUser } from '../Domain/UseCase/GetActiveSessionsFor
 import { AuthenticateRequest } from '../Domain/UseCase/AuthenticateRequest'
 import { User } from '../Domain/User/User'
 import { CreateCrossServiceToken } from '../Domain/UseCase/CreateCrossServiceToken/CreateCrossServiceToken'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('SessionsController', () => {
   let getActiveSessionsForUser: GetActiveSessionsForUser
@@ -20,11 +21,21 @@ describe('SessionsController', () => {
   let response: express.Response
   let user: User
   let createCrossServiceToken: CreateCrossServiceToken
+  let controllerContainer: ControllerContainerInterface
 
   const createController = () =>
-    new SessionsController(getActiveSessionsForUser, authenticateRequest, sessionProjector, createCrossServiceToken)
+    new SessionsController(
+      getActiveSessionsForUser,
+      authenticateRequest,
+      sessionProjector,
+      createCrossServiceToken,
+      controllerContainer,
+    )
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     session = {} as jest.Mocked<Session>
 
     user = {} as jest.Mocked<User>

packages/auth/src/Controller/SessionsController.ts

@@ -16,16 +16,20 @@ import { User } from '../Domain/User/User'
 import { ProjectorInterface } from '../Projection/ProjectorInterface'
 import { SessionProjector } from '../Projection/SessionProjector'
 import { CreateCrossServiceToken } from '../Domain/UseCase/CreateCrossServiceToken/CreateCrossServiceToken'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/sessions')
 export class SessionsController extends BaseHttpController {
   constructor(
-    @inject(TYPES.GetActiveSessionsForUser) private getActiveSessionsForUser: GetActiveSessionsForUser,
-    @inject(TYPES.AuthenticateRequest) private authenticateRequest: AuthenticateRequest,
-    @inject(TYPES.SessionProjector) private sessionProjector: ProjectorInterface<Session>,
-    @inject(TYPES.CreateCrossServiceToken) private createCrossServiceToken: CreateCrossServiceToken,
+    @inject(TYPES.Auth_GetActiveSessionsForUser) private getActiveSessionsForUser: GetActiveSessionsForUser,
+    @inject(TYPES.Auth_AuthenticateRequest) private authenticateRequest: AuthenticateRequest,
+    @inject(TYPES.Auth_SessionProjector) private sessionProjector: ProjectorInterface<Session>,
+    @inject(TYPES.Auth_CreateCrossServiceToken) private createCrossServiceToken: CreateCrossServiceToken,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
   ) {
     super()
+
+    this.controllerContainer.register('auth.sessions.list', this.getSessions.bind(this))
   }
 
   @httpPost('/validate')
@@ -56,7 +60,7 @@ export class SessionsController extends BaseHttpController {
     return this.json({ authToken: result.token })
   }
 
-  @httpGet('/', TYPES.AuthMiddleware, TYPES.SessionMiddleware)
+  @httpGet('/', TYPES.Auth_AuthMiddleware, TYPES.Auth_SessionMiddleware)
   async getSessions(_request: Request, response: Response): Promise<results.JsonResult> {
     if (response.locals.readOnlyAccess) {
       return this.json([])

packages/auth/src/Controller/SettingsController.spec.ts

@@ -10,6 +10,7 @@ import { GetSetting } from '../Domain/UseCase/GetSetting/GetSetting'
 import { UpdateSetting } from '../Domain/UseCase/UpdateSetting/UpdateSetting'
 import { DeleteSetting } from '../Domain/UseCase/DeleteSetting/DeleteSetting'
 import { EncryptionVersion } from '../Domain/Encryption/EncryptionVersion'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('SettingsController', () => {
   let deleteSetting: DeleteSetting
@@ -20,10 +21,15 @@ describe('SettingsController', () => {
   let request: express.Request
   let response: express.Response
   let user: User
+  let controllerContainer: ControllerContainerInterface
 
-  const createController = () => new SettingsController(getSettings, getSetting, updateSetting, deleteSetting)
+  const createController = () =>
+    new SettingsController(getSettings, getSetting, updateSetting, deleteSetting, controllerContainer)
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     deleteSetting = {} as jest.Mocked<DeleteSetting>
     deleteSetting.execute = jest.fn().mockReturnValue({ success: true })
 

packages/auth/src/Controller/SettingsController.ts

@@ -16,19 +16,26 @@ import { DeleteSetting } from '../Domain/UseCase/DeleteSetting/DeleteSetting'
 import { GetSetting } from '../Domain/UseCase/GetSetting/GetSetting'
 import { GetSettings } from '../Domain/UseCase/GetSettings/GetSettings'
 import { UpdateSetting } from '../Domain/UseCase/UpdateSetting/UpdateSetting'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/users/:userUuid')
 export class SettingsController extends BaseHttpController {
   constructor(
-    @inject(TYPES.GetSettings) private doGetSettings: GetSettings,
-    @inject(TYPES.GetSetting) private doGetSetting: GetSetting,
-    @inject(TYPES.UpdateSetting) private doUpdateSetting: UpdateSetting,
-    @inject(TYPES.DeleteSetting) private doDeleteSetting: DeleteSetting,
+    @inject(TYPES.Auth_GetSettings) private doGetSettings: GetSettings,
+    @inject(TYPES.Auth_GetSetting) private doGetSetting: GetSetting,
+    @inject(TYPES.Auth_UpdateSetting) private doUpdateSetting: UpdateSetting,
+    @inject(TYPES.Auth_DeleteSetting) private doDeleteSetting: DeleteSetting,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
   ) {
     super()
+
+    this.controllerContainer.register('auth.users.getSettings', this.getSettings.bind(this))
+    this.controllerContainer.register('auth.users.getSetting', this.getSetting.bind(this))
+    this.controllerContainer.register('auth.users.updateSetting', this.updateSetting.bind(this))
+    this.controllerContainer.register('auth.users.deleteSetting', this.deleteSetting.bind(this))
   }
 
-  @httpGet('/settings', TYPES.ApiGatewayAuthMiddleware)
+  @httpGet('/settings', TYPES.Auth_ApiGatewayAuthMiddleware)
   async getSettings(request: Request, response: Response): Promise<results.JsonResult> {
     if (request.params.userUuid !== response.locals.user.uuid) {
       return this.json(
@@ -47,7 +54,7 @@ export class SettingsController extends BaseHttpController {
     return this.json(result)
   }
 
-  @httpGet('/settings/:settingName', TYPES.ApiGatewayAuthMiddleware)
+  @httpGet('/settings/:settingName', TYPES.Auth_ApiGatewayAuthMiddleware)
   async getSetting(request: Request, response: Response): Promise<results.JsonResult> {
     if (request.params.userUuid !== response.locals.user.uuid) {
       return this.json(
@@ -70,7 +77,7 @@ export class SettingsController extends BaseHttpController {
     return this.json(result, 400)
   }
 
-  @httpPut('/settings', TYPES.ApiGatewayAuthMiddleware)
+  @httpPut('/settings', TYPES.Auth_ApiGatewayAuthMiddleware)
   async updateSetting(request: Request, response: Response): Promise<results.JsonResult | results.StatusCodeResult> {
     if (response.locals.readOnlyAccess) {
       return this.json(
@@ -117,7 +124,7 @@ export class SettingsController extends BaseHttpController {
     return this.json(result, result.statusCode)
   }
 
-  @httpDelete('/settings/:settingName', TYPES.ApiGatewayAuthMiddleware)
+  @httpDelete('/settings/:settingName', TYPES.Auth_ApiGatewayAuthMiddleware)
   async deleteSetting(request: Request, response: Response): Promise<results.JsonResult> {
     if (response.locals.readOnlyAccess) {
       return this.json(

packages/auth/src/Controller/SubscriptionInvitesController.ts

@@ -26,14 +26,14 @@ import { ListSharedSubscriptionInvitations } from '../Domain/UseCase/ListSharedS
 @injectable()
 export class SubscriptionInvitesController implements SubscriptionServerInterface {
   constructor(
-    @inject(TYPES.InviteToSharedSubscription) private inviteToSharedSubscription: InviteToSharedSubscription,
-    @inject(TYPES.AcceptSharedSubscriptionInvitation)
+    @inject(TYPES.Auth_InviteToSharedSubscription) private inviteToSharedSubscription: InviteToSharedSubscription,
+    @inject(TYPES.Auth_AcceptSharedSubscriptionInvitation)
     private acceptSharedSubscriptionInvitation: AcceptSharedSubscriptionInvitation,
-    @inject(TYPES.DeclineSharedSubscriptionInvitation)
+    @inject(TYPES.Auth_DeclineSharedSubscriptionInvitation)
     private declineSharedSubscriptionInvitation: DeclineSharedSubscriptionInvitation,
-    @inject(TYPES.CancelSharedSubscriptionInvitation)
+    @inject(TYPES.Auth_CancelSharedSubscriptionInvitation)
     private cancelSharedSubscriptionInvitation: CancelSharedSubscriptionInvitation,
-    @inject(TYPES.ListSharedSubscriptionInvitations)
+    @inject(TYPES.Auth_ListSharedSubscriptionInvitations)
     private listSharedSubscriptionInvitations: ListSharedSubscriptionInvitations,
   ) {}
 

packages/auth/src/Controller/SubscriptionSettingsController.spec.ts

@@ -6,6 +6,7 @@ import { results } from 'inversify-express-utils'
 import { User } from '../Domain/User/User'
 import { SubscriptionSettingsController } from './SubscriptionSettingsController'
 import { GetSetting } from '../Domain/UseCase/GetSetting/GetSetting'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('SubscriptionSettingsController', () => {
   let getSetting: GetSetting
@@ -13,10 +14,14 @@ describe('SubscriptionSettingsController', () => {
   let request: express.Request
   let response: express.Response
   let user: User
+  let controllerContainer: ControllerContainerInterface
 
-  const createController = () => new SubscriptionSettingsController(getSetting)
+  const createController = () => new SubscriptionSettingsController(getSetting, controllerContainer)
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     user = {} as jest.Mocked<User>
     user.uuid = '123'
 

packages/auth/src/Controller/SubscriptionSettingsController.ts

@@ -9,14 +9,20 @@ import {
 } from 'inversify-express-utils'
 import TYPES from '../Bootstrap/Types'
 import { GetSetting } from '../Domain/UseCase/GetSetting/GetSetting'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/users/:userUuid')
 export class SubscriptionSettingsController extends BaseHttpController {
-  constructor(@inject(TYPES.GetSetting) private doGetSetting: GetSetting) {
+  constructor(
+    @inject(TYPES.Auth_GetSetting) private doGetSetting: GetSetting,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
+  ) {
     super()
+
+    this.controllerContainer.register('auth.users.getSubscriptionSetting', this.getSubscriptionSetting.bind(this))
   }
 
-  @httpGet('/subscription-settings/:subscriptionSettingName', TYPES.ApiGatewayAuthMiddleware)
+  @httpGet('/subscription-settings/:subscriptionSettingName', TYPES.Auth_ApiGatewayAuthMiddleware)
   async getSubscriptionSetting(request: Request, response: Response): Promise<results.JsonResult> {
     const result = await this.doGetSetting.execute({
       userUuid: response.locals.user.uuid,

packages/auth/src/Controller/SubscriptionTokensController.spec.ts

@@ -13,6 +13,7 @@ import { Role } from '../Domain/Role/Role'
 import { SettingServiceInterface } from '../Domain/Setting/SettingServiceInterface'
 import { Setting } from '../Domain/Setting/Setting'
 import { CrossServiceTokenData, TokenEncoderInterface } from '@standardnotes/security'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('SubscriptionTokensController', () => {
   let createSubscriptionToken: CreateSubscriptionToken
@@ -29,6 +30,8 @@ describe('SubscriptionTokensController', () => {
   let user: User
   let role: Role
 
+  let controllerContainer: ControllerContainerInterface
+
   const createController = () =>
     new SubscriptionTokensController(
       createSubscriptionToken,
@@ -38,9 +41,13 @@ describe('SubscriptionTokensController', () => {
       roleProjector,
       tokenEncoder,
       jwtTTL,
+      controllerContainer,
     )
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     user = {} as jest.Mocked<User>
     user.uuid = '123'
     user.roles = Promise.resolve([role])

packages/auth/src/Controller/SubscriptionTokensController.ts

@@ -18,22 +18,26 @@ import { AuthenticateSubscriptionToken } from '../Domain/UseCase/AuthenticateSub
 import { CreateSubscriptionToken } from '../Domain/UseCase/CreateSubscriptionToken/CreateSubscriptionToken'
 import { User } from '../Domain/User/User'
 import { ProjectorInterface } from '../Projection/ProjectorInterface'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/subscription-tokens')
 export class SubscriptionTokensController extends BaseHttpController {
   constructor(
-    @inject(TYPES.CreateSubscriptionToken) private createSubscriptionToken: CreateSubscriptionToken,
-    @inject(TYPES.AuthenticateSubscriptionToken) private authenticateToken: AuthenticateSubscriptionToken,
-    @inject(TYPES.SettingService) private settingService: SettingServiceInterface,
-    @inject(TYPES.UserProjector) private userProjector: ProjectorInterface<User>,
-    @inject(TYPES.RoleProjector) private roleProjector: ProjectorInterface<Role>,
-    @inject(TYPES.CrossServiceTokenEncoder) private tokenEncoder: TokenEncoderInterface<CrossServiceTokenData>,
-    @inject(TYPES.AUTH_JWT_TTL) private jwtTTL: number,
+    @inject(TYPES.Auth_CreateSubscriptionToken) private createSubscriptionToken: CreateSubscriptionToken,
+    @inject(TYPES.Auth_AuthenticateSubscriptionToken) private authenticateToken: AuthenticateSubscriptionToken,
+    @inject(TYPES.Auth_SettingService) private settingService: SettingServiceInterface,
+    @inject(TYPES.Auth_UserProjector) private userProjector: ProjectorInterface<User>,
+    @inject(TYPES.Auth_RoleProjector) private roleProjector: ProjectorInterface<Role>,
+    @inject(TYPES.Auth_CrossServiceTokenEncoder) private tokenEncoder: TokenEncoderInterface<CrossServiceTokenData>,
+    @inject(TYPES.Auth_AUTH_JWT_TTL) private jwtTTL: number,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
   ) {
     super()
+
+    this.controllerContainer.register('auth.subscription-tokens.create', this.createToken.bind(this))
   }
 
-  @httpPost('/', TYPES.ApiGatewayAuthMiddleware)
+  @httpPost('/', TYPES.Auth_ApiGatewayAuthMiddleware)
   async createToken(_request: Request, response: Response): Promise<results.JsonResult> {
     if (response.locals.readOnlyAccess) {
       return this.json(

packages/auth/src/Controller/UserRequestsController.ts

@@ -6,7 +6,7 @@ import { ProcessUserRequest } from '../Domain/UseCase/ProcessUserRequest/Process
 
 @injectable()
 export class UserRequestsController implements UserRequestServerInterface {
-  constructor(@inject(TYPES.ProcessUserRequest) private processUserRequest: ProcessUserRequest) {}
+  constructor(@inject(TYPES.Auth_ProcessUserRequest) private processUserRequest: ProcessUserRequest) {}
 
   async submitUserRequest(params: UserRequestRequestParams): Promise<HttpResponse<UserRequestResponseBody>> {
     const result = await this.processUserRequest.execute({

packages/auth/src/Controller/UsersController.spec.ts

@@ -13,6 +13,7 @@ import { ClearLoginAttempts } from '../Domain/UseCase/ClearLoginAttempts'
 import { IncreaseLoginAttempts } from '../Domain/UseCase/IncreaseLoginAttempts'
 import { ChangeCredentials } from '../Domain/UseCase/ChangeCredentials/ChangeCredentials'
 import { InviteToSharedSubscription } from '../Domain/UseCase/InviteToSharedSubscription/InviteToSharedSubscription'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('UsersController', () => {
   let updateUser: UpdateUser
@@ -27,6 +28,7 @@ describe('UsersController', () => {
   let request: express.Request
   let response: express.Response
   let user: User
+  let controllerContainer: ControllerContainerInterface
 
   const createController = () =>
     new UsersController(
@@ -37,9 +39,13 @@ describe('UsersController', () => {
       clearLoginAttempts,
       increaseLoginAttempts,
       changeCredentials,
+      controllerContainer,
     )
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     updateUser = {} as jest.Mocked<UpdateUser>
     updateUser.execute = jest.fn()
 

packages/auth/src/Controller/UsersController.ts

@@ -19,22 +19,29 @@ import { GetUserSubscription } from '../Domain/UseCase/GetUserSubscription/GetUs
 import { ClearLoginAttempts } from '../Domain/UseCase/ClearLoginAttempts'
 import { IncreaseLoginAttempts } from '../Domain/UseCase/IncreaseLoginAttempts'
 import { ChangeCredentials } from '../Domain/UseCase/ChangeCredentials/ChangeCredentials'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 @controller('/users')
 export class UsersController extends BaseHttpController {
   constructor(
-    @inject(TYPES.UpdateUser) private updateUser: UpdateUser,
-    @inject(TYPES.GetUserKeyParams) private getUserKeyParams: GetUserKeyParams,
-    @inject(TYPES.DeleteAccount) private doDeleteAccount: DeleteAccount,
-    @inject(TYPES.GetUserSubscription) private doGetUserSubscription: GetUserSubscription,
-    @inject(TYPES.ClearLoginAttempts) private clearLoginAttempts: ClearLoginAttempts,
-    @inject(TYPES.IncreaseLoginAttempts) private increaseLoginAttempts: IncreaseLoginAttempts,
-    @inject(TYPES.ChangeCredentials) private changeCredentialsUseCase: ChangeCredentials,
+    @inject(TYPES.Auth_UpdateUser) private updateUser: UpdateUser,
+    @inject(TYPES.Auth_GetUserKeyParams) private getUserKeyParams: GetUserKeyParams,
+    @inject(TYPES.Auth_DeleteAccount) private doDeleteAccount: DeleteAccount,
+    @inject(TYPES.Auth_GetUserSubscription) private doGetUserSubscription: GetUserSubscription,
+    @inject(TYPES.Auth_ClearLoginAttempts) private clearLoginAttempts: ClearLoginAttempts,
+    @inject(TYPES.Auth_IncreaseLoginAttempts) private increaseLoginAttempts: IncreaseLoginAttempts,
+    @inject(TYPES.Auth_ChangeCredentials) private changeCredentialsUseCase: ChangeCredentials,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
   ) {
     super()
+
+    this.controllerContainer.register('auth.users.update', this.update.bind(this))
+    this.controllerContainer.register('auth.users.getKeyParams', this.keyParams.bind(this))
+    this.controllerContainer.register('auth.users.getSubscription', this.getSubscription.bind(this))
+    this.controllerContainer.register('auth.users.updateCredentials', this.changeCredentials.bind(this))
   }
 
-  @httpPatch('/:userId', TYPES.ApiGatewayAuthMiddleware)
+  @httpPatch('/:userId', TYPES.Auth_ApiGatewayAuthMiddleware)
   async update(request: Request, response: Response): Promise<results.JsonResult | void> {
     if (response.locals.readOnlyAccess) {
       return this.json(
@@ -125,7 +132,7 @@ export class UsersController extends BaseHttpController {
     return this.json({ message: result.message }, result.responseCode)
   }
 
-  @httpGet('/:userUuid/subscription', TYPES.ApiGatewayAuthMiddleware)
+  @httpGet('/:userUuid/subscription', TYPES.Auth_ApiGatewayAuthMiddleware)
   async getSubscription(request: Request, response: Response): Promise<results.JsonResult> {
     if (request.params.userUuid !== response.locals.user.uuid) {
       return this.json(
@@ -149,7 +156,7 @@ export class UsersController extends BaseHttpController {
     return this.json(result, 400)
   }
 
-  @httpPut('/:userId/attributes/credentials', TYPES.AuthMiddleware)
+  @httpPut('/:userId/attributes/credentials', TYPES.Auth_AuthMiddleware)
   async changeCredentials(request: Request, response: Response): Promise<results.JsonResult | void> {
     if (response.locals.readOnlyAccess) {
       return this.json(

packages/auth/src/Controller/ValetTokenController.spec.ts

@@ -4,15 +4,20 @@ import { Request, Response } from 'express'
 import { results } from 'inversify-express-utils'
 import { ValetTokenController } from './ValetTokenController'
 import { CreateValetToken } from '../Domain/UseCase/CreateValetToken/CreateValetToken'
+import { ControllerContainerInterface } from '@standardnotes/domain-core'
 
 describe('ValetTokenController', () => {
   let createValetToken: CreateValetToken
   let request: Request
   let response: Response
+  let controllerContainer: ControllerContainerInterface
 
-  const createController = () => new ValetTokenController(createValetToken)
+  const createController = () => new ValetTokenController(createValetToken, controllerContainer)
 
   beforeEach(() => {
+    controllerContainer = {} as jest.Mocked<ControllerContainerInterface>
+    controllerContainer.register = jest.fn()
+
     createValetToken = {} as jest.Mocked<CreateValetToken>
     createValetToken.execute = jest.fn().mockReturnValue({ success: true, valetToken: 'foobar' })
 

packages/auth/src/Controller/ValetTokenController.ts

@@ -9,15 +9,20 @@ import {
 } from 'inversify-express-utils'
 import { CreateValetTokenPayload, ErrorTag } from '@standardnotes/responses'
 import { ValetTokenOperation } from '@standardnotes/security'
-import { Uuid } from '@standardnotes/domain-core'
+import { ControllerContainerInterface, Uuid } from '@standardnotes/domain-core'
 
 import TYPES from '../Bootstrap/Types'
 import { CreateValetToken } from '../Domain/UseCase/CreateValetToken/CreateValetToken'
 
-@controller('/valet-tokens', TYPES.ApiGatewayAuthMiddleware)
+@controller('/valet-tokens', TYPES.Auth_ApiGatewayAuthMiddleware)
 export class ValetTokenController extends BaseHttpController {
-  constructor(@inject(TYPES.CreateValetToken) private createValetKey: CreateValetToken) {
+  constructor(
+    @inject(TYPES.Auth_CreateValetToken) private createValetKey: CreateValetToken,
+    @inject(TYPES.Auth_ControllerContainer) private controllerContainer: ControllerContainerInterface,
+  ) {
     super()
+
+    this.controllerContainer.register('auth.valet-tokens.create', this.create.bind(this))
   }
 
   @httpPost('/')

packages/auth/src/Domain/Auth/AuthResponseFactory20161215.ts

@@ -15,9 +15,9 @@ import { AuthResponseFactoryInterface } from './AuthResponseFactoryInterface'
 @injectable()
 export class AuthResponseFactory20161215 implements AuthResponseFactoryInterface {
   constructor(
-    @inject(TYPES.UserProjector) protected userProjector: ProjectorInterface<User>,
-    @inject(TYPES.SessionTokenEncoder) protected tokenEncoder: TokenEncoderInterface<SessionTokenData>,
-    @inject(TYPES.Logger) protected logger: Logger,
+    @inject(TYPES.Auth_UserProjector) protected userProjector: ProjectorInterface<User>,
+    @inject(TYPES.Auth_SessionTokenEncoder) protected tokenEncoder: TokenEncoderInterface<SessionTokenData>,
+    @inject(TYPES.Auth_Logger) protected logger: Logger,
   ) {}
 
   async createResponse(dto: {

packages/auth/src/Domain/Auth/AuthResponseFactory20200115.ts

@@ -23,13 +23,13 @@ import { AuthResponse20200115 } from './AuthResponse20200115'
 @injectable()
 export class AuthResponseFactory20200115 extends AuthResponseFactory20190520 {
   constructor(
-    @inject(TYPES.SessionService) private sessionService: SessionServiceInterface,
-    @inject(TYPES.KeyParamsFactory) private keyParamsFactory: KeyParamsFactoryInterface,
-    @inject(TYPES.UserProjector) userProjector: ProjectorInterface<User>,
-    @inject(TYPES.SessionTokenEncoder) protected override tokenEncoder: TokenEncoderInterface<SessionTokenData>,
-    @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
-    @inject(TYPES.DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
-    @inject(TYPES.Logger) logger: Logger,
+    @inject(TYPES.Auth_SessionService) private sessionService: SessionServiceInterface,
+    @inject(TYPES.Auth_KeyParamsFactory) private keyParamsFactory: KeyParamsFactoryInterface,
+    @inject(TYPES.Auth_UserProjector) userProjector: ProjectorInterface<User>,
+    @inject(TYPES.Auth_SessionTokenEncoder) protected override tokenEncoder: TokenEncoderInterface<SessionTokenData>,
+    @inject(TYPES.Auth_DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
+    @inject(TYPES.Auth_DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
+    @inject(TYPES.Auth_Logger) logger: Logger,
   ) {
     super(userProjector, tokenEncoder, logger)
   }

packages/auth/src/Domain/Auth/AuthResponseFactoryResolver.ts

@@ -11,10 +11,10 @@ import { AuthResponseFactoryResolverInterface } from './AuthResponseFactoryResol
 @injectable()
 export class AuthResponseFactoryResolver implements AuthResponseFactoryResolverInterface {
   constructor(
-    @inject(TYPES.AuthResponseFactory20161215) private authResponseFactory20161215: AuthResponseFactory20161215,
-    @inject(TYPES.AuthResponseFactory20190520) private authResponseFactory20190520: AuthResponseFactory20190520,
-    @inject(TYPES.AuthResponseFactory20200115) private authResponseFactory20200115: AuthResponseFactory20200115,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_AuthResponseFactory20161215) private authResponseFactory20161215: AuthResponseFactory20161215,
+    @inject(TYPES.Auth_AuthResponseFactory20190520) private authResponseFactory20190520: AuthResponseFactory20190520,
+    @inject(TYPES.Auth_AuthResponseFactory20200115) private authResponseFactory20200115: AuthResponseFactory20200115,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   resolveAuthResponseFactoryVersion(apiVersion: string): AuthResponseFactoryInterface {

packages/auth/src/Domain/Auth/AuthenticationMethodResolver.ts

@@ -9,10 +9,10 @@ import { AuthenticationMethodResolverInterface } from './AuthenticationMethodRes
 @injectable()
 export class AuthenticationMethodResolver implements AuthenticationMethodResolverInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.SessionService) private sessionService: SessionServiceInterface,
-    @inject(TYPES.SessionTokenDecoder) private sessionTokenDecoder: TokenDecoderInterface<SessionTokenData>,
-    @inject(TYPES.FallbackSessionTokenDecoder)
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_SessionService) private sessionService: SessionServiceInterface,
+    @inject(TYPES.Auth_SessionTokenDecoder) private sessionTokenDecoder: TokenDecoderInterface<SessionTokenData>,
+    @inject(TYPES.Auth_FallbackSessionTokenDecoder)
     private fallbackSessionTokenDecoder: TokenDecoderInterface<SessionTokenData>,
   ) {}
 

packages/auth/src/Domain/Encryption/CrypterNode.ts

@@ -9,9 +9,9 @@ import { CrypterInterface } from './CrypterInterface'
 @injectable()
 export class CrypterNode implements CrypterInterface {
   constructor(
-    @inject(TYPES.ENCRYPTION_SERVER_KEY) private encryptionServerKey: string,
-    @inject(TYPES.CryptoNode) private cryptoNode: CryptoNode,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_ENCRYPTION_SERVER_KEY) private encryptionServerKey: string,
+    @inject(TYPES.Auth_CryptoNode) private cryptoNode: CryptoNode,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {
     const keyBuffer = Buffer.from(encryptionServerKey, 'hex')
     const { byteLength } = keyBuffer

packages/auth/src/Domain/Event/DomainEventFactory.ts

@@ -30,7 +30,7 @@ import { DomainEventFactoryInterface } from './DomainEventFactoryInterface'
 
 @injectable()
 export class DomainEventFactory implements DomainEventFactoryInterface {
-  constructor(@inject(TYPES.Timer) private timer: TimerInterface) {}
+  constructor(@inject(TYPES.Auth_Timer) private timer: TimerInterface) {}
 
   createSessionCreatedEvent(dto: { userUuid: string }): SessionCreatedEvent {
     return {

packages/auth/src/Domain/Feature/FeatureService.ts

@@ -15,10 +15,10 @@ import { TimerInterface } from '@standardnotes/time'
 @injectable()
 export class FeatureService implements FeatureServiceInterface {
   constructor(
-    @inject(TYPES.RoleToSubscriptionMap) private roleToSubscriptionMap: RoleToSubscriptionMapInterface,
-    @inject(TYPES.OfflineUserSubscriptionRepository)
+    @inject(TYPES.Auth_RoleToSubscriptionMap) private roleToSubscriptionMap: RoleToSubscriptionMapInterface,
+    @inject(TYPES.Auth_OfflineUserSubscriptionRepository)
     private offlineUserSubscriptionRepository: OfflineUserSubscriptionRepositoryInterface,
-    @inject(TYPES.Timer) private timer: TimerInterface,
+    @inject(TYPES.Auth_Timer) private timer: TimerInterface,
   ) {}
 
   async userIsEntitledToFeature(user: User, featureIdentifier: string): Promise<boolean> {

packages/auth/src/Domain/Handler/AccountDeletionRequestedEventHandler.ts

@@ -10,11 +10,12 @@ import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 @injectable()
 export class AccountDeletionRequestedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.SessionRepository) private sessionRepository: SessionRepositoryInterface,
-    @inject(TYPES.EphemeralSessionRepository) private ephemeralSessionRepository: EphemeralSessionRepositoryInterface,
-    @inject(TYPES.RevokedSessionRepository) private revokedSessionRepository: RevokedSessionRepositoryInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_SessionRepository) private sessionRepository: SessionRepositoryInterface,
+    @inject(TYPES.Auth_EphemeralSessionRepository)
+    private ephemeralSessionRepository: EphemeralSessionRepositoryInterface,
+    @inject(TYPES.Auth_RevokedSessionRepository) private revokedSessionRepository: RevokedSessionRepositoryInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: AccountDeletionRequestedEvent): Promise<void> {

packages/auth/src/Domain/Handler/ExtensionKeyGrantedEventHandler.ts

@@ -16,11 +16,11 @@ import { Username } from '@standardnotes/domain-core'
 @injectable()
 export class ExtensionKeyGrantedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.SettingService) private settingService: SettingServiceInterface,
-    @inject(TYPES.OfflineSettingService) private offlineSettingService: OfflineSettingServiceInterface,
-    @inject(TYPES.ContenDecoder) private contentDecoder: ContentDecoderInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_SettingService) private settingService: SettingServiceInterface,
+    @inject(TYPES.Auth_OfflineSettingService) private offlineSettingService: OfflineSettingServiceInterface,
+    @inject(TYPES.Auth_ContenDecoder) private contentDecoder: ContentDecoderInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: ExtensionKeyGrantedEvent): Promise<void> {

packages/auth/src/Domain/Handler/FileRemovedEventHandler.ts

@@ -12,9 +12,10 @@ import { UserSubscriptionServiceInterface } from '../Subscription/UserSubscripti
 @injectable()
 export class FileRemovedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserSubscriptionService) private userSubscriptionService: UserSubscriptionServiceInterface,
-    @inject(TYPES.SubscriptionSettingService) private subscriptionSettingService: SubscriptionSettingServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_UserSubscriptionService) private userSubscriptionService: UserSubscriptionServiceInterface,
+    @inject(TYPES.Auth_SubscriptionSettingService)
+    private subscriptionSettingService: SubscriptionSettingServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: FileRemovedEvent): Promise<void> {

packages/auth/src/Domain/Handler/FileUploadedEventHandler.ts

@@ -13,10 +13,11 @@ import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 @injectable()
 export class FileUploadedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.UserSubscriptionService) private userSubscriptionService: UserSubscriptionServiceInterface,
-    @inject(TYPES.SubscriptionSettingService) private subscriptionSettingService: SubscriptionSettingServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_UserSubscriptionService) private userSubscriptionService: UserSubscriptionServiceInterface,
+    @inject(TYPES.Auth_SubscriptionSettingService)
+    private subscriptionSettingService: SubscriptionSettingServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: FileUploadedEvent): Promise<void> {

packages/auth/src/Domain/Handler/ListedAccountCreatedEventHandler.ts

@@ -11,9 +11,9 @@ import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 @injectable()
 export class ListedAccountCreatedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.SettingService) private settingService: SettingServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_SettingService) private settingService: SettingServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: ListedAccountCreatedEvent): Promise<void> {

packages/auth/src/Domain/Handler/ListedAccountDeletedEventHandler.ts

@@ -11,9 +11,9 @@ import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 @injectable()
 export class ListedAccountDeletedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.SettingService) private settingService: SettingServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_SettingService) private settingService: SettingServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: ListedAccountDeletedEvent): Promise<void> {

packages/auth/src/Domain/Handler/PredicateVerificationRequestedEventHandler.ts

@@ -16,11 +16,11 @@ import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 @injectable()
 export class PredicateVerificationRequestedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.VerifyPredicate) private verifyPredicate: VerifyPredicate,
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
-    @inject(TYPES.DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_VerifyPredicate) private verifyPredicate: VerifyPredicate,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
+    @inject(TYPES.Auth_DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: PredicateVerificationRequestedEvent): Promise<void> {

packages/auth/src/Domain/Handler/SharedSubscriptionInvitationCreatedEventHandler.ts

@@ -8,7 +8,7 @@ import { AcceptSharedSubscriptionInvitation } from '../UseCase/AcceptSharedSubsc
 @injectable()
 export class SharedSubscriptionInvitationCreatedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.AcceptSharedSubscriptionInvitation)
+    @inject(TYPES.Auth_AcceptSharedSubscriptionInvitation)
     private acceptSharedSubscriptionInvitation: AcceptSharedSubscriptionInvitation,
   ) {}
 

packages/auth/src/Domain/Handler/SubscriptionCancelledEventHandler.ts

@@ -8,8 +8,9 @@ import { OfflineUserSubscriptionRepositoryInterface } from '../Subscription/Offl
 @injectable()
 export class SubscriptionCancelledEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-    @inject(TYPES.OfflineUserSubscriptionRepository)
+    @inject(TYPES.Auth_UserSubscriptionRepository)
+    private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.Auth_OfflineUserSubscriptionRepository)
     private offlineUserSubscriptionRepository: OfflineUserSubscriptionRepositoryInterface,
   ) {}
 

packages/auth/src/Domain/Handler/SubscriptionExpiredEventHandler.ts

@@ -12,12 +12,13 @@ import { Username } from '@standardnotes/domain-core'
 @injectable()
 export class SubscriptionExpiredEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-    @inject(TYPES.OfflineUserSubscriptionRepository)
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_UserSubscriptionRepository)
+    private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.Auth_OfflineUserSubscriptionRepository)
     private offlineUserSubscriptionRepository: OfflineUserSubscriptionRepositoryInterface,
-    @inject(TYPES.RoleService) private roleService: RoleServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_RoleService) private roleService: RoleServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: SubscriptionExpiredEvent): Promise<void> {

packages/auth/src/Domain/Handler/SubscriptionPurchasedEventHandler.ts

@@ -17,13 +17,15 @@ import { Username } from '@standardnotes/domain-core'
 @injectable()
 export class SubscriptionPurchasedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-    @inject(TYPES.OfflineUserSubscriptionRepository)
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_UserSubscriptionRepository)
+    private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.Auth_OfflineUserSubscriptionRepository)
     private offlineUserSubscriptionRepository: OfflineUserSubscriptionRepositoryInterface,
-    @inject(TYPES.RoleService) private roleService: RoleServiceInterface,
-    @inject(TYPES.SubscriptionSettingService) private subscriptionSettingService: SubscriptionSettingServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_RoleService) private roleService: RoleServiceInterface,
+    @inject(TYPES.Auth_SubscriptionSettingService)
+    private subscriptionSettingService: SubscriptionSettingServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: SubscriptionPurchasedEvent): Promise<void> {

packages/auth/src/Domain/Handler/SubscriptionReassignedEventHandler.ts

@@ -18,12 +18,14 @@ import { Username } from '@standardnotes/domain-core'
 @injectable()
 export class SubscriptionReassignedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-    @inject(TYPES.RoleService) private roleService: RoleServiceInterface,
-    @inject(TYPES.SettingService) private settingService: SettingServiceInterface,
-    @inject(TYPES.SubscriptionSettingService) private subscriptionSettingService: SubscriptionSettingServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_UserSubscriptionRepository)
+    private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.Auth_RoleService) private roleService: RoleServiceInterface,
+    @inject(TYPES.Auth_SettingService) private settingService: SettingServiceInterface,
+    @inject(TYPES.Auth_SubscriptionSettingService)
+    private subscriptionSettingService: SubscriptionSettingServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: SubscriptionReassignedEvent): Promise<void> {

packages/auth/src/Domain/Handler/SubscriptionRefundedEventHandler.ts

@@ -12,12 +12,13 @@ import { Username } from '@standardnotes/domain-core'
 @injectable()
 export class SubscriptionRefundedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-    @inject(TYPES.OfflineUserSubscriptionRepository)
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_UserSubscriptionRepository)
+    private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.Auth_OfflineUserSubscriptionRepository)
     private offlineUserSubscriptionRepository: OfflineUserSubscriptionRepositoryInterface,
-    @inject(TYPES.RoleService) private roleService: RoleServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_RoleService) private roleService: RoleServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: SubscriptionRefundedEvent): Promise<void> {

packages/auth/src/Domain/Handler/SubscriptionRenewedEventHandler.ts

@@ -13,12 +13,13 @@ import { Username } from '@standardnotes/domain-core'
 @injectable()
 export class SubscriptionRenewedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-    @inject(TYPES.OfflineUserSubscriptionRepository)
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_UserSubscriptionRepository)
+    private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.Auth_OfflineUserSubscriptionRepository)
     private offlineUserSubscriptionRepository: OfflineUserSubscriptionRepositoryInterface,
-    @inject(TYPES.RoleService) private roleService: RoleServiceInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_RoleService) private roleService: RoleServiceInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: SubscriptionRenewedEvent): Promise<void> {

packages/auth/src/Domain/Handler/SubscriptionSyncRequestedEventHandler.ts

@@ -24,16 +24,18 @@ import { Username } from '@standardnotes/domain-core'
 @injectable()
 export class SubscriptionSyncRequestedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
-    @inject(TYPES.UserSubscriptionRepository) private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-    @inject(TYPES.OfflineUserSubscriptionRepository)
+    @inject(TYPES.Auth_UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.Auth_UserSubscriptionRepository)
+    private userSubscriptionRepository: UserSubscriptionRepositoryInterface,
+    @inject(TYPES.Auth_OfflineUserSubscriptionRepository)
     private offlineUserSubscriptionRepository: OfflineUserSubscriptionRepositoryInterface,
-    @inject(TYPES.RoleService) private roleService: RoleServiceInterface,
-    @inject(TYPES.SettingService) private settingService: SettingServiceInterface,
-    @inject(TYPES.SubscriptionSettingService) private subscriptionSettingService: SubscriptionSettingServiceInterface,
-    @inject(TYPES.OfflineSettingService) private offlineSettingService: OfflineSettingServiceInterface,
-    @inject(TYPES.ContenDecoder) private contentDecoder: ContentDecoderInterface,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_RoleService) private roleService: RoleServiceInterface,
+    @inject(TYPES.Auth_SettingService) private settingService: SettingServiceInterface,
+    @inject(TYPES.Auth_SubscriptionSettingService)
+    private subscriptionSettingService: SubscriptionSettingServiceInterface,
+    @inject(TYPES.Auth_OfflineSettingService) private offlineSettingService: OfflineSettingServiceInterface,
+    @inject(TYPES.Auth_ContenDecoder) private contentDecoder: ContentDecoderInterface,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: SubscriptionSyncRequestedEvent): Promise<void> {

packages/auth/src/Domain/Handler/UserDisabledSessionUserAgentLoggingEventHandler.ts

@@ -8,8 +8,8 @@ import { SessionRepositoryInterface } from '../Session/SessionRepositoryInterfac
 @injectable()
 export class UserDisabledSessionUserAgentLoggingEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.SessionRepository) private sessionRepository: SessionRepositoryInterface,
-    @inject(TYPES.SessionRepository) private revokedSessionRepository: RevokedSessionRepositoryInterface,
+    @inject(TYPES.Auth_SessionRepository) private sessionRepository: SessionRepositoryInterface,
+    @inject(TYPES.Auth_SessionRepository) private revokedSessionRepository: RevokedSessionRepositoryInterface,
   ) {}
 
   async handle(event: UserDisabledSessionUserAgentLoggingEvent): Promise<void> {

packages/auth/src/Domain/Handler/UserEmailChangedEventHandler.ts

@@ -8,10 +8,10 @@ import TYPES from '../../Bootstrap/Types'
 @injectable()
 export class UserEmailChangedEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.HTTPClient) private httpClient: AxiosInstance,
-    @inject(TYPES.USER_SERVER_CHANGE_EMAIL_URL) private userServerChangeEmailUrl: string,
-    @inject(TYPES.USER_SERVER_AUTH_KEY) private userServerAuthKey: string,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_HTTPClient) private httpClient: AxiosInstance,
+    @inject(TYPES.Auth_USER_SERVER_CHANGE_EMAIL_URL) private userServerChangeEmailUrl: string,
+    @inject(TYPES.Auth_USER_SERVER_AUTH_KEY) private userServerAuthKey: string,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: UserEmailChangedEvent): Promise<void> {

packages/auth/src/Domain/Handler/UserRegisteredEventHandler.ts

@@ -8,10 +8,10 @@ import TYPES from '../../Bootstrap/Types'
 @injectable()
 export class UserRegisteredEventHandler implements DomainEventHandlerInterface {
   constructor(
-    @inject(TYPES.HTTPClient) private httpClient: AxiosInstance,
-    @inject(TYPES.USER_SERVER_REGISTRATION_URL) private userServerRegistrationUrl: string,
-    @inject(TYPES.USER_SERVER_AUTH_KEY) private userServerAuthKey: string,
-    @inject(TYPES.Logger) private logger: Logger,
+    @inject(TYPES.Auth_HTTPClient) private httpClient: AxiosInstance,
+    @inject(TYPES.Auth_USER_SERVER_REGISTRATION_URL) private userServerRegistrationUrl: string,
+    @inject(TYPES.Auth_USER_SERVER_AUTH_KEY) private userServerAuthKey: string,
+    @inject(TYPES.Auth_Logger) private logger: Logger,
   ) {}
 
   async handle(event: UserRegisteredEvent): Promise<void> {