chore(release): publish new version

- @standardnotes/analytics@1.43.0
 - @standardnotes/api-gateway@1.36.5
 - @standardnotes/auth-server@1.49.8
 - @standardnotes/domain-events-infra@1.9.8
 - @standardnotes/domain-events@2.74.1
 - @standardnotes/event-store@1.6.3
 - @standardnotes/files-server@1.8.3
 - @standardnotes/scheduler-server@1.13.4
 - @standardnotes/syncing-server@1.10.16
 - @standardnotes/websockets-server@1.4.3
 - @standardnotes/workspace-server@1.17.3

.github/workflows/analytics.yml

@@ -0,0 +1,39 @@
+name: Analytics Server
+
+concurrency:
+  group: analytics
+  cancel-in-progress: true
+
+on:
+  push:
+    tags:
+      - '*standardnotes/analytics*'
+  workflow_dispatch:
+
+jobs:
+  call_server_application_workflow:
+    name: Server Application
+    uses: standardnotes/server/.github/workflows/common-server-application.yml@main
+    with:
+      service_name: analytics
+      workspace_name: "@standardnotes/analytics"
+      e2e_tag_parameter_name: analytics_image_tag
+      deploy_web: false
+      package_path: packages/analytics
+    secrets: inherit
+
+  newrelic:
+    needs: call_server_application_workflow
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Create New Relic deployment marker for Worker
+        uses: newrelic/deployment-marker-action@v1
+        with:
+          accountId: ${{ secrets.NEW_RELIC_ACCOUNT_ID }}
+          apiKey: ${{ secrets.NEW_RELIC_API_KEY }}
+          applicationId: ${{ secrets.NEW_RELIC_APPLICATION_ID_ANALYTICS_WORKER_PROD }}
+          revision: "${{ github.sha }}"
+          description: "Automated Deployment via Github Actions"
+          user: "${{ github.actor }}"

package.json

@@ -20,6 +20,7 @@
     "lint:event-store": "yarn workspace @standardnotes/event-store lint",
     "lint:websockets": "yarn workspace @standardnotes/websockets-server lint",
     "lint:workspace": "yarn workspace @standardnotes/workspace-server lint",
+    "lint:analytics": "yarn workspace @standardnotes/analytics lint",
     "clean": "yarn workspaces foreach -p --verbose run clean",
     "setup:env": "cp .env.sample .env && yarn workspaces foreach -p --verbose run setup:env",
     "start:auth": "yarn workspace @standardnotes/auth-server start",
@@ -32,6 +33,7 @@
     "start:api-gateway": "yarn workspace @standardnotes/api-gateway start",
     "start:websockets": "yarn workspace @standardnotes/websockets-server start",
     "start:workspace": "yarn workspace @standardnotes/workspace-server start",
+    "start:analytics": "yarn workspace @standardnotes/analytics worker",
     "release": "lerna version --conventional-graduate --conventional-commits --yes -m \"chore(release): publish new version\"",
     "publish": "lerna publish from-git --yes --no-verify-access --loglevel verbose",
     "postversion": "./scripts/push-tags-one-by-one.sh",

packages/analytics/.env.sample

@@ -0,0 +1,28 @@
+LOG_LEVEL=debug
+NODE_ENV=development
+
+DB_HOST=127.0.0.1
+DB_REPLICA_HOST=127.0.0.1
+DB_PORT=3306
+DB_USERNAME=analytics
+DB_PASSWORD=changeme123
+DB_DATABASE=analytics
+DB_DEBUG_LEVEL=all # "all" | "query" | "schema" | "error" | "warn" | "info" | "log" | "migration"
+DB_MIGRATIONS_PATH=dist/migrations/*.js
+
+REDIS_URL=redis://cache
+REDIS_EVENTS_CHANNEL=events
+
+SNS_TOPIC_ARN=
+SNS_AWS_REGION=
+SQS_QUEUE_URL=
+SQS_AWS_REGION=
+
+# (Optional) New Relic Setup
+NEW_RELIC_ENABLED=false
+NEW_RELIC_APP_NAME=Analytics
+NEW_RELIC_LICENSE_KEY=
+NEW_RELIC_NO_CONFIG_FILE=true
+NEW_RELIC_DISTRIBUTED_TRACING_ENABLED=false
+NEW_RELIC_LOG_ENABLED=false
+NEW_RELIC_LOG_LEVEL=info

packages/analytics/CHANGELOG.md

@@ -3,6 +3,62 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.43.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.42.0...@standardnotes/analytics@1.43.0) (2022-11-04)
+
+### Features
+
+* **analytics:** add account deletion event handler ([5383e0c](https://github.com/standardnotes/server/commit/5383e0cf525ddd203beee451f1cfd5fd8600b522))
+
+# [1.42.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.41.0...@standardnotes/analytics@1.42.0) (2022-11-04)
+
+### Bug Fixes
+
+* **analytics:** imports ([35611fb](https://github.com/standardnotes/server/commit/35611fbc07e50efbba954d7c96db9917e0dddd7d))
+
+### Features
+
+* **analytics:** add user registered handler ([034aa38](https://github.com/standardnotes/server/commit/034aa381539cf4b46769cfd1646dec2051d836c3))
+
+# [1.41.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.40.0...@standardnotes/analytics@1.41.0) (2022-11-04)
+
+### Bug Fixes
+
+* **analytics:** linter setup with migrations ([262d295](https://github.com/standardnotes/server/commit/262d2951218753f6f14613c5d8ae20ade0e4ef06))
+
+### Features
+
+* **analytics:** add retrieving user analytics id ([4e5ac0a](https://github.com/standardnotes/server/commit/4e5ac0a47b469e5fa681f0131d04c9823cebedf3))
+
+# [1.40.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.39.1...@standardnotes/analytics@1.40.0) (2022-11-04)
+
+### Features
+
+* **analytics:** add analytics entities ([f315b1a](https://github.com/standardnotes/server/commit/f315b1ac5c9369d36fa616c6b4bb5492148564f8))
+
+## [1.39.1](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.39.0...@standardnotes/analytics@1.39.1) (2022-11-04)
+
+### Bug Fixes
+
+* **analytics:** linter setup ([5329f2a](https://github.com/standardnotes/server/commit/5329f2a2fb815f8691e37279fcadcf01beb716ad))
+
+# [1.39.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.38.0...@standardnotes/analytics@1.39.0) (2022-11-04)
+
+### Features
+
+* **analytics:** move the analytics report from api-gateway to analytics ([34e11fd](https://github.com/standardnotes/server/commit/34e11fd5b0ef09a056c90127065c9dfae3e0172a))
+
+# [1.38.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.37.0...@standardnotes/analytics@1.38.0) (2022-11-04)
+
+### Features
+
+* add analytics worker service ([d568432](https://github.com/standardnotes/server/commit/d5684326b1301855d0e07415195d4b246292f9a9))
+
+# [1.37.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.36.0...@standardnotes/analytics@1.37.0) (2022-11-03)
+
+### Features
+
+* **auth:** add analytics for subscription reactivating ([460d6a8](https://github.com/standardnotes/server/commit/460d6a8d0f17eee624feb5d2588086ae6f0996e4))
+
 # [1.36.0](https://github.com/standardnotes/server/compare/@standardnotes/analytics@1.35.1...@standardnotes/analytics@1.36.0) (2022-10-19)
 
 ### Features

packages/analytics/Dockerfile

@@ -0,0 +1,17 @@
+FROM node:16.15.1-alpine
+
+RUN apk add --update \
+  curl \
+  && rm -rf /var/cache/apk/*
+
+ENV NODE_ENV production
+
+RUN corepack enable
+
+WORKDIR /workspace
+
+COPY ./ /workspace
+
+ENTRYPOINT [ "/workspace/packages/analytics/docker/entrypoint.sh" ]
+
+CMD [ "start-worker" ]

packages/analytics/bin/report.ts

@@ -4,30 +4,34 @@ import 'newrelic'
 
 import { Logger } from 'winston'
 
+import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
+import { AnalyticsActivity } from '../src/Domain/Analytics/AnalyticsActivity'
+import { Period } from '../src/Domain/Time/Period'
+import { StatisticsMeasure } from '../src/Domain/Statistics/StatisticsMeasure'
+import { AnalyticsStoreInterface } from '../src/Domain/Analytics/AnalyticsStoreInterface'
+import { StatisticsStoreInterface } from '../src/Domain/Statistics/StatisticsStoreInterface'
+import { PeriodKeyGeneratorInterface } from '../src/Domain/Time/PeriodKeyGeneratorInterface'
 import { ContainerConfigLoader } from '../src/Bootstrap/Container'
 import TYPES from '../src/Bootstrap/Types'
 import { Env } from '../src/Bootstrap/Env'
-import {
-  DomainEventPublisherInterface,
-  DailyAnalyticsReportGeneratedEvent,
-  DomainEventService,
-} from '@standardnotes/domain-events'
-import {
-  AnalyticsActivity,
-  AnalyticsStoreInterface,
-  Period,
-  PeriodKeyGeneratorInterface,
-  StatisticsMeasure,
-  StatisticsStoreInterface,
-} from '@standardnotes/analytics'
+import { DomainEventFactoryInterface } from '../src/Domain/Event/DomainEventFactoryInterface'
 
 const requestReport = async (
   analyticsStore: AnalyticsStoreInterface,
   statisticsStore: StatisticsStoreInterface,
+  domainEventFactory: DomainEventFactoryInterface,
   domainEventPublisher: DomainEventPublisherInterface,
   periodKeyGenerator: PeriodKeyGeneratorInterface,
 ): Promise<void> => {
-  const analyticsOverTime = []
+  const analyticsOverTime: Array<{
+    name: string
+    period: number
+    counts: Array<{
+      periodKey: string
+      totalCount: number
+    }>
+    totalCount: number
+  }> = []
 
   const thirtyDaysAnalyticsNames = [
     AnalyticsActivity.GeneralActivity,
@@ -40,6 +44,7 @@ const requestReport = async (
     AnalyticsActivity.SubscriptionRefunded,
     AnalyticsActivity.ExistingCustomersChurn,
     AnalyticsActivity.NewCustomersChurn,
+    AnalyticsActivity.SubscriptionReactivated,
   ]
 
   for (const analyticsName of thirtyDaysAnalyticsNames) {
@@ -68,7 +73,11 @@ const requestReport = async (
     }
   }
 
-  const yesterdayActivityStatistics = []
+  const yesterdayActivityStatistics: Array<{
+    name: string
+    retention: number
+    totalCount: number
+  }> = []
   const yesterdayActivityNames = [
     AnalyticsActivity.LimitedDiscountOfferPurchased,
     AnalyticsActivity.GeneralActivity,
@@ -113,7 +122,13 @@ const requestReport = async (
     StatisticsMeasure.NewCustomers,
     StatisticsMeasure.TotalCustomers,
   ]
-  const statisticMeasures = []
+  const statisticMeasures: Array<{
+    name: string
+    totalValue: number
+    average: number
+    increments: number
+    period: number
+  }> = []
   for (const statisticMeasureName of statisticMeasureNames) {
     for (const period of [Period.Yesterday, Period.ThisMonth]) {
       statisticMeasures.push({
@@ -127,7 +142,11 @@ const requestReport = async (
   }
 
   const periodKeys = periodKeyGenerator.getDiscretePeriodKeys(Period.Last7Days)
-  const retentionOverDays = []
+  const retentionOverDays: Array<{
+    firstPeriodKey: string
+    secondPeriodKey: string
+    value: number
+  }> = []
   for (let i = 0; i < periodKeys.length; i++) {
     for (let j = 0; j < periodKeys.length - i; j++) {
       const dailyRetention = await analyticsStore.calculateActivitiesRetention({
@@ -146,7 +165,10 @@ const requestReport = async (
   }
 
   const monthlyPeriodKeys = periodKeyGenerator.getDiscretePeriodKeys(Period.ThisYear)
-  const churnRates = []
+  const churnRates: Array<{
+    rate: number
+    periodKey: string
+  }> = []
   for (const monthPeriodKey of monthlyPeriodKeys) {
     const monthPeriod = periodKeyGenerator.convertPeriodKeyToPeriod(monthPeriodKey)
     const dailyPeriodKeys = periodKeyGenerator.getDiscretePeriodKeys(monthPeriod)
@@ -178,39 +200,28 @@ const requestReport = async (
     })
   }
 
-  const event: DailyAnalyticsReportGeneratedEvent = {
-    type: 'DAILY_ANALYTICS_REPORT_GENERATED',
-    createdAt: new Date(),
-    meta: {
-      correlation: {
-        userIdentifier: '',
-        userIdentifierType: 'uuid',
-      },
-      origin: DomainEventService.ApiGateway,
-    },
-    payload: {
-      applicationStatistics: await statisticsStore.getYesterdayApplicationUsage(),
-      snjsStatistics: await statisticsStore.getYesterdaySNJSUsage(),
-      outOfSyncIncidents: await statisticsStore.getYesterdayOutOfSyncIncidents(),
-      activityStatistics: yesterdayActivityStatistics,
-      activityStatisticsOverTime: analyticsOverTime,
-      statisticMeasures,
-      retentionStatistics: [
-        {
-          firstActivity: AnalyticsActivity.Register,
-          secondActivity: AnalyticsActivity.GeneralActivity,
-          retention: {
-            periodKeys,
-            values: retentionOverDays,
-          },
+  const event = domainEventFactory.createDailyAnalyticsReportGeneratedEvent({
+    applicationStatistics: await statisticsStore.getYesterdayApplicationUsage(),
+    snjsStatistics: await statisticsStore.getYesterdaySNJSUsage(),
+    outOfSyncIncidents: await statisticsStore.getYesterdayOutOfSyncIncidents(),
+    activityStatistics: yesterdayActivityStatistics,
+    activityStatisticsOverTime: analyticsOverTime,
+    statisticMeasures,
+    retentionStatistics: [
+      {
+        firstActivity: AnalyticsActivity.Register,
+        secondActivity: AnalyticsActivity.GeneralActivity,
+        retention: {
+          periodKeys,
+          values: retentionOverDays,
         },
-      ],
-      churn: {
-        periodKeys: monthlyPeriodKeys,
-        values: churnRates,
       },
+    ],
+    churn: {
+      periodKeys: monthlyPeriodKeys,
+      values: churnRates,
     },
-  }
+  })
 
   await domainEventPublisher.publish(event)
 }
@@ -226,10 +237,13 @@ void container.load().then((container) => {
 
   const analyticsStore: AnalyticsStoreInterface = container.get(TYPES.AnalyticsStore)
   const statisticsStore: StatisticsStoreInterface = container.get(TYPES.StatisticsStore)
+  const domainEventFactory: DomainEventFactoryInterface = container.get(TYPES.DomainEventFactory)
   const domainEventPublisher: DomainEventPublisherInterface = container.get(TYPES.DomainEventPublisher)
   const periodKeyGenerator: PeriodKeyGeneratorInterface = container.get(TYPES.PeriodKeyGenerator)
 
-  Promise.resolve(requestReport(analyticsStore, statisticsStore, domainEventPublisher, periodKeyGenerator))
+  Promise.resolve(
+    requestReport(analyticsStore, statisticsStore, domainEventFactory, domainEventPublisher, periodKeyGenerator),
+  )
     .then(() => {
       logger.info('Usage report generation complete')
 

packages/analytics/bin/worker.ts

@@ -0,0 +1,29 @@
+import 'reflect-metadata'
+
+import 'newrelic'
+
+import { Logger } from 'winston'
+import { DomainEventSubscriberFactoryInterface } from '@standardnotes/domain-events'
+import * as dayjs from 'dayjs'
+import * as utc from 'dayjs/plugin/utc'
+
+import { ContainerConfigLoader } from '../src/Bootstrap/Container'
+import TYPES from '../src/Bootstrap/Types'
+import { Env } from '../src/Bootstrap/Env'
+
+const container = new ContainerConfigLoader()
+void container.load().then((container) => {
+  dayjs.extend(utc)
+
+  const env: Env = new Env()
+  env.load()
+
+  const logger: Logger = container.get(TYPES.Logger)
+
+  logger.info('Starting worker...')
+
+  const subscriberFactory: DomainEventSubscriberFactoryInterface = container.get(TYPES.DomainEventSubscriberFactory)
+  subscriberFactory.create().start()
+
+  setInterval(() => logger.info('Alive and kicking!'), 20 * 60 * 1000)
+})

packages/analytics/docker/entrypoint.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+set -e
+
+COMMAND=$1 && shift 1
+
+case "$COMMAND" in
+  'start-worker' )
+    echo "Starting Worker..."
+    yarn workspace @standardnotes/analytics worker
+    ;;
+
+  'report' )
+    echo "Starting Usage Report Generation..."
+    yarn workspace @standardnotes/analytics report
+    ;;
+
+   * )
+    echo "Unknown command"
+    ;;
+esac
+
+exec "$@"

packages/analytics/migrations/1667555285111-init_database.ts

@@ -0,0 +1,16 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class initDatabase1667555285111 implements MigrationInterface {
+  name = 'initDatabase1667555285111'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      'CREATE TABLE `analytics_entities` (`id` int NOT NULL AUTO_INCREMENT, `user_uuid` varchar(36) NOT NULL, INDEX `user_uuid` (`user_uuid`), PRIMARY KEY (`id`)) ENGINE=InnoDB',
+    )
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query('DROP INDEX `user_uuid` ON `analytics_entities`')
+    await queryRunner.query('DROP TABLE `analytics_entities`')
+  }
+}

packages/analytics/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/analytics",
-  "version": "1.36.0",
+  "version": "1.43.0",
   "engines": {
     "node": ">=14.0.0 <17.0.0"
   },
@@ -20,19 +20,41 @@
     "clean": "rm -fr dist",
     "build": "tsc --build",
     "lint": "eslint . --ext .ts",
-    "test": "jest spec --coverage"
+    "lint:fix": "eslint . --ext .ts --fix",
+    "test": "jest --coverage --config=./jest.config.js --maxWorkers=50%",
+    "worker": "yarn node dist/bin/worker.js",
+    "report": "yarn node dist/bin/report.js",
+    "setup:env": "cp .env.sample .env",
+    "typeorm": "typeorm-ts-node-commonjs"
   },
   "devDependencies": {
     "@types/ioredis": "^4.28.10",
     "@types/jest": "^29.1.1",
+    "@types/newrelic": "^7.0.3",
+    "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.30.0",
+    "eslint": "^8.14.0",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.1.2",
     "ts-jest": "^29.0.3",
     "typescript": "^4.8.4"
   },
   "dependencies": {
+    "@newrelic/winston-enricher": "^4.0.0",
+    "@sentry/node": "^7.3.0",
+    "@standardnotes/common": "workspace:*",
+    "@standardnotes/domain-events": "workspace:*",
+    "@standardnotes/domain-events-infra": "workspace:*",
+    "@standardnotes/time": "workspace:*",
+    "aws-sdk": "^2.1158.0",
+    "dayjs": "^1.11.6",
+    "dotenv": "^16.0.1",
+    "inversify": "^6.0.1",
     "ioredis": "^5.2.3",
-    "reflect-metadata": "^0.1.13"
+    "mysql2": "^2.3.3",
+    "newrelic": "^9.0.0",
+    "reflect-metadata": "^0.1.13",
+    "typeorm": "^0.3.6",
+    "winston": "^3.8.1"
   }
 }

packages/analytics/src/Bootstrap/Container.ts

@@ -0,0 +1,186 @@
+import * as winston from 'winston'
+import Redis from 'ioredis'
+import * as AWS from 'aws-sdk'
+import { Container } from 'inversify'
+import {
+  DomainEventHandlerInterface,
+  DomainEventMessageHandlerInterface,
+  DomainEventSubscriberFactoryInterface,
+} from '@standardnotes/domain-events'
+
+import { Env } from './Env'
+import TYPES from './Types'
+import { AppDataSource } from './DataSource'
+import { DomainEventFactory } from '../Domain/Event/DomainEventFactory'
+import {
+  RedisDomainEventPublisher,
+  RedisDomainEventSubscriberFactory,
+  RedisEventMessageHandler,
+  SNSDomainEventPublisher,
+  SQSDomainEventSubscriberFactory,
+  SQSEventMessageHandler,
+  SQSNewRelicEventMessageHandler,
+} from '@standardnotes/domain-events-infra'
+import { Timer, TimerInterface } from '@standardnotes/time'
+import { PeriodKeyGeneratorInterface } from '../Domain/Time/PeriodKeyGeneratorInterface'
+import { PeriodKeyGenerator } from '../Domain/Time/PeriodKeyGenerator'
+import { AnalyticsStoreInterface } from '../Domain/Analytics/AnalyticsStoreInterface'
+import { RedisAnalyticsStore } from '../Infra/Redis/RedisAnalyticsStore'
+import { StatisticsStoreInterface } from '../Domain/Statistics/StatisticsStoreInterface'
+import { RedisStatisticsStore } from '../Infra/Redis/RedisStatisticsStore'
+import { AnalyticsEntityRepositoryInterface } from '../Domain/Entity/AnalyticsEntityRepositoryInterface'
+import { MySQLAnalyticsEntityRepository } from '../Infra/MySQL/MySQLAnalyticsEntityRepository'
+import { Repository } from 'typeorm'
+import { AnalyticsEntity } from '../Domain/Entity/AnalyticsEntity'
+import { GetUserAnalyticsId } from '../Domain/UseCase/GetUserAnalyticsId/GetUserAnalyticsId'
+import { UserRegisteredEventHandler } from '../Domain/Handler/UserRegisteredEventHandler'
+import { AccountDeletionRequestedEventHandler } from '../Domain/Handler/AccountDeletionRequestedEventHandler'
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const newrelicFormatter = require('@newrelic/winston-enricher')
+
+export class ContainerConfigLoader {
+  async load(): Promise<Container> {
+    const env: Env = new Env()
+    env.load()
+
+    const container = new Container()
+
+    await AppDataSource.initialize()
+
+    const redisUrl = env.get('REDIS_URL')
+    const isRedisInClusterMode = redisUrl.indexOf(',') > 0
+    let redis
+    if (isRedisInClusterMode) {
+      redis = new Redis.Cluster(redisUrl.split(','))
+    } else {
+      redis = new Redis(redisUrl)
+    }
+
+    container.bind(TYPES.Redis).toConstantValue(redis)
+
+    const newrelicWinstonFormatter = newrelicFormatter(winston)
+    const winstonFormatters = [winston.format.splat(), winston.format.json()]
+    if (env.get('NEW_RELIC_ENABLED', true) === 'true') {
+      winstonFormatters.push(newrelicWinstonFormatter())
+    }
+
+    const logger = winston.createLogger({
+      level: env.get('LOG_LEVEL') || 'info',
+      format: winston.format.combine(...winstonFormatters),
+      transports: [new winston.transports.Console({ level: env.get('LOG_LEVEL') || 'info' })],
+    })
+    container.bind<winston.Logger>(TYPES.Logger).toConstantValue(logger)
+
+    if (env.get('SNS_AWS_REGION', true)) {
+      container.bind<AWS.SNS>(TYPES.SNS).toConstantValue(
+        new AWS.SNS({
+          apiVersion: 'latest',
+          region: env.get('SNS_AWS_REGION', true),
+        }),
+      )
+    }
+
+    if (env.get('SQS_QUEUE_URL', true)) {
+      const sqsConfig: AWS.SQS.Types.ClientConfiguration = {
+        apiVersion: 'latest',
+        region: env.get('SQS_AWS_REGION', true),
+      }
+      if (env.get('SQS_ACCESS_KEY_ID', true) && env.get('SQS_SECRET_ACCESS_KEY', true)) {
+        sqsConfig.credentials = {
+          accessKeyId: env.get('SQS_ACCESS_KEY_ID', true),
+          secretAccessKey: env.get('SQS_SECRET_ACCESS_KEY', true),
+        }
+      }
+      container.bind<AWS.SQS>(TYPES.SQS).toConstantValue(new AWS.SQS(sqsConfig))
+    }
+
+    // env vars
+    container.bind(TYPES.REDIS_URL).toConstantValue(env.get('REDIS_URL'))
+    container.bind(TYPES.SNS_TOPIC_ARN).toConstantValue(env.get('SNS_TOPIC_ARN', true))
+    container.bind(TYPES.SNS_AWS_REGION).toConstantValue(env.get('SNS_AWS_REGION', true))
+    container.bind(TYPES.SQS_QUEUE_URL).toConstantValue(env.get('SQS_QUEUE_URL', true))
+    container.bind(TYPES.REDIS_EVENTS_CHANNEL).toConstantValue(env.get('REDIS_EVENTS_CHANNEL'))
+    container.bind(TYPES.NEW_RELIC_ENABLED).toConstantValue(env.get('NEW_RELIC_ENABLED', true))
+
+    // Repositories
+    container
+      .bind<AnalyticsEntityRepositoryInterface>(TYPES.AnalyticsEntityRepository)
+      .to(MySQLAnalyticsEntityRepository)
+
+    // ORM
+    container
+      .bind<Repository<AnalyticsEntity>>(TYPES.ORMAnalyticsEntityRepository)
+      .toConstantValue(AppDataSource.getRepository(AnalyticsEntity))
+
+    // Use Case
+    container.bind<GetUserAnalyticsId>(TYPES.GetUserAnalyticsId).to(GetUserAnalyticsId)
+
+    // Hanlders
+    container.bind<UserRegisteredEventHandler>(TYPES.UserRegisteredEventHandler).to(UserRegisteredEventHandler)
+    container
+      .bind<AccountDeletionRequestedEventHandler>(TYPES.AccountDeletionRequestedEventHandler)
+      .to(AccountDeletionRequestedEventHandler)
+
+    // Services
+    container.bind<DomainEventFactory>(TYPES.DomainEventFactory).to(DomainEventFactory)
+    container.bind<PeriodKeyGeneratorInterface>(TYPES.PeriodKeyGenerator).toConstantValue(new PeriodKeyGenerator())
+    container
+      .bind<AnalyticsStoreInterface>(TYPES.AnalyticsStore)
+      .toConstantValue(new RedisAnalyticsStore(container.get(TYPES.PeriodKeyGenerator), container.get(TYPES.Redis)))
+    container
+      .bind<StatisticsStoreInterface>(TYPES.StatisticsStore)
+      .toConstantValue(new RedisStatisticsStore(container.get(TYPES.PeriodKeyGenerator), container.get(TYPES.Redis)))
+    container.bind<TimerInterface>(TYPES.Timer).toConstantValue(new Timer())
+
+    if (env.get('SNS_TOPIC_ARN', true)) {
+      container
+        .bind<SNSDomainEventPublisher>(TYPES.DomainEventPublisher)
+        .toConstantValue(new SNSDomainEventPublisher(container.get(TYPES.SNS), container.get(TYPES.SNS_TOPIC_ARN)))
+    } else {
+      container
+        .bind<RedisDomainEventPublisher>(TYPES.DomainEventPublisher)
+        .toConstantValue(
+          new RedisDomainEventPublisher(container.get(TYPES.Redis), container.get(TYPES.REDIS_EVENTS_CHANNEL)),
+        )
+    }
+
+    const eventHandlers: Map<string, DomainEventHandlerInterface> = new Map([
+      ['USER_REGISTERED', container.get(TYPES.UserRegisteredEventHandler)],
+    ])
+
+    if (env.get('SQS_QUEUE_URL', true)) {
+      container
+        .bind<DomainEventMessageHandlerInterface>(TYPES.DomainEventMessageHandler)
+        .toConstantValue(
+          env.get('NEW_RELIC_ENABLED', true) === 'true'
+            ? new SQSNewRelicEventMessageHandler(eventHandlers, container.get(TYPES.Logger))
+            : new SQSEventMessageHandler(eventHandlers, container.get(TYPES.Logger)),
+        )
+      container
+        .bind<DomainEventSubscriberFactoryInterface>(TYPES.DomainEventSubscriberFactory)
+        .toConstantValue(
+          new SQSDomainEventSubscriberFactory(
+            container.get(TYPES.SQS),
+            container.get(TYPES.SQS_QUEUE_URL),
+            container.get(TYPES.DomainEventMessageHandler),
+          ),
+        )
+    } else {
+      container
+        .bind<DomainEventMessageHandlerInterface>(TYPES.DomainEventMessageHandler)
+        .toConstantValue(new RedisEventMessageHandler(eventHandlers, container.get(TYPES.Logger)))
+      container
+        .bind<DomainEventSubscriberFactoryInterface>(TYPES.DomainEventSubscriberFactory)
+        .toConstantValue(
+          new RedisDomainEventSubscriberFactory(
+            container.get(TYPES.Redis),
+            container.get(TYPES.DomainEventMessageHandler),
+            container.get(TYPES.REDIS_EVENTS_CHANNEL),
+          ),
+        )
+    }
+
+    return container
+  }
+}

packages/analytics/src/Bootstrap/DataSource.ts

@@ -0,0 +1,43 @@
+import { DataSource, LoggerOptions } from 'typeorm'
+
+import { AnalyticsEntity } from '../Domain/Entity/AnalyticsEntity'
+
+import { Env } from './Env'
+
+const env: Env = new Env()
+env.load()
+
+const maxQueryExecutionTime = env.get('DB_MAX_QUERY_EXECUTION_TIME', true)
+  ? +env.get('DB_MAX_QUERY_EXECUTION_TIME', true)
+  : 45_000
+
+export const AppDataSource = new DataSource({
+  type: 'mysql',
+  charset: 'utf8mb4',
+  supportBigNumbers: true,
+  bigNumberStrings: false,
+  maxQueryExecutionTime,
+  replication: {
+    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'),
+        port: parseInt(env.get('DB_PORT')),
+        username: env.get('DB_USERNAME'),
+        password: env.get('DB_PASSWORD'),
+        database: env.get('DB_DATABASE'),
+      },
+    ],
+    removeNodeErrorCount: 10,
+  },
+  entities: [AnalyticsEntity],
+  migrations: [env.get('DB_MIGRATIONS_PATH', true) ?? 'dist/migrations/*.js'],
+  migrationsRun: true,
+  logging: <LoggerOptions>env.get('DB_DEBUG_LEVEL'),
+})

packages/analytics/src/Bootstrap/Env.ts

@@ -0,0 +1,24 @@
+import { config, DotenvParseOutput } from 'dotenv'
+import { injectable } from 'inversify'
+
+@injectable()
+export class Env {
+  private env?: DotenvParseOutput
+
+  public load(): void {
+    const output = config()
+    this.env = <DotenvParseOutput>output.parsed
+  }
+
+  public get(key: string, optional = false): string {
+    if (!this.env) {
+      this.load()
+    }
+
+    if (!process.env[key] && !optional) {
+      throw new Error(`Environment variable ${key} not set`)
+    }
+
+    return <string>process.env[key]
+  }
+}

packages/analytics/src/Bootstrap/Types.ts

@@ -0,0 +1,34 @@
+const TYPES = {
+  Logger: Symbol.for('Logger'),
+  Redis: Symbol.for('Redis'),
+  SNS: Symbol.for('SNS'),
+  SQS: Symbol.for('SQS'),
+  // env vars
+  REDIS_URL: Symbol.for('REDIS_URL'),
+  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'),
+  REDIS_EVENTS_CHANNEL: Symbol.for('REDIS_EVENTS_CHANNEL'),
+  NEW_RELIC_ENABLED: Symbol.for('NEW_RELIC_ENABLED'),
+  // Repositories
+  AnalyticsEntityRepository: Symbol.for('AnalyticsEntityRepository'),
+  // ORM
+  ORMAnalyticsEntityRepository: Symbol.for('ORMAnalyticsEntityRepository'),
+  // Use Case
+  GetUserAnalyticsId: Symbol.for('GetUserAnalyticsId'),
+  // Handlers
+  UserRegisteredEventHandler: Symbol.for('UserRegisteredEventHandler'),
+  AccountDeletionRequestedEventHandler: Symbol.for('AccountDeletionRequestedEventHandler'),
+  // Services
+  DomainEventPublisher: Symbol.for('DomainEventPublisher'),
+  DomainEventSubscriberFactory: Symbol.for('DomainEventSubscriberFactory'),
+  DomainEventFactory: Symbol.for('DomainEventFactory'),
+  DomainEventMessageHandler: Symbol.for('DomainEventMessageHandler'),
+  AnalyticsStore: Symbol.for('AnalyticsStore'),
+  StatisticsStore: Symbol.for('StatisticsStore'),
+  Timer: Symbol.for('Timer'),
+  PeriodKeyGenerator: Symbol.for('PeriodKeyGenerator'),
+}
+
+export default TYPES

packages/analytics/src/Domain/Analytics/AnalyticsActivity.ts

@@ -12,6 +12,7 @@ export enum AnalyticsActivity {
   SubscriptionRefunded = 'subscription-refunded',
   SubscriptionCancelled = 'subscription-cancelled',
   SubscriptionExpired = 'subscription-expired',
+  SubscriptionReactivated = 'subscription-reactivated',
   EmailUnbackedUpData = 'email-unbacked-up-data',
   EmailBackup = 'email-backup',
   LimitedDiscountOfferPurchased = 'limited-discount-offer-purchased',

packages/analytics/src/Domain/Entity/AnalyticsEntity.ts

@@ -0,0 +1,14 @@
+import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm'
+
+@Entity({ name: 'analytics_entities' })
+export class AnalyticsEntity {
+  @PrimaryGeneratedColumn()
+  declare id: number
+
+  @Column({
+    name: 'user_uuid',
+    length: 36,
+  })
+  @Index('user_uuid')
+  declare userUuid: string
+}

packages/analytics/src/Domain/Entity/AnalyticsEntityRepositoryInterface.ts

@@ -0,0 +1,7 @@
+import { Uuid } from '@standardnotes/common'
+import { AnalyticsEntity } from './AnalyticsEntity'
+
+export interface AnalyticsEntityRepositoryInterface {
+  save(analyticsEntity: AnalyticsEntity): Promise<AnalyticsEntity>
+  findOneByUserUuid(userUuid: Uuid): Promise<AnalyticsEntity | null>
+}

packages/analytics/src/Domain/Event/DomainEventFactory.spec.ts

@@ -0,0 +1,174 @@
+import 'reflect-metadata'
+
+import { TimerInterface } from '@standardnotes/time'
+
+import { AnalyticsActivity } from '../Analytics/AnalyticsActivity'
+import { StatisticsMeasure } from '../Statistics/StatisticsMeasure'
+import { Period } from '../Time/Period'
+
+import { DomainEventFactory } from './DomainEventFactory'
+
+describe('DomainEventFactory', () => {
+  let timer: TimerInterface
+
+  const createFactory = () => new DomainEventFactory(timer)
+
+  beforeEach(() => {
+    timer = {} as jest.Mocked<TimerInterface>
+    timer.getTimestampInMicroseconds = jest.fn().mockReturnValue(1)
+    timer.getUTCDate = jest.fn().mockReturnValue(new Date(1))
+  })
+
+  it('should create a DAILY_ANALYTICS_REPORT_GENERATED event', () => {
+    expect(
+      createFactory().createDailyAnalyticsReportGeneratedEvent({
+        snjsStatistics: [
+          {
+            version: '1-2-3',
+            count: 2,
+          },
+        ],
+        applicationStatistics: [
+          {
+            version: '2-3-4',
+            count: 45,
+          },
+        ],
+        activityStatistics: [
+          {
+            name: AnalyticsActivity.Register,
+            retention: 24,
+            totalCount: 45,
+          },
+        ],
+        statisticMeasures: [
+          {
+            name: StatisticsMeasure.Income,
+            totalValue: 43,
+            average: 23,
+            increments: 5,
+            period: Period.Today,
+          },
+        ],
+        activityStatisticsOverTime: [
+          {
+            name: AnalyticsActivity.Register,
+            period: Period.Last30Days,
+            counts: [
+              {
+                periodKey: '2022-10-9',
+                totalCount: 3,
+              },
+            ],
+            totalCount: 123,
+          },
+        ],
+        outOfSyncIncidents: 324,
+        retentionStatistics: [
+          {
+            firstActivity: AnalyticsActivity.Register,
+            secondActivity: AnalyticsActivity.Login,
+            retention: {
+              periodKeys: ['2022-10-9'],
+              values: [
+                {
+                  firstPeriodKey: AnalyticsActivity.Register,
+                  secondPeriodKey: AnalyticsActivity.Login,
+                  value: 12,
+                },
+              ],
+            },
+          },
+        ],
+        churn: {
+          periodKeys: ['2022-10-9'],
+          values: [
+            {
+              rate: 12,
+              periodKey: '2022-10-9',
+            },
+          ],
+        },
+      }),
+    ).toEqual({
+      createdAt: expect.any(Date),
+      meta: {
+        correlation: {
+          userIdentifier: '',
+          userIdentifierType: 'uuid',
+        },
+        origin: 'analytics',
+      },
+      payload: {
+        activityStatistics: [
+          {
+            name: 'register',
+            retention: 24,
+            totalCount: 45,
+          },
+        ],
+        activityStatisticsOverTime: [
+          {
+            counts: [
+              {
+                periodKey: '2022-10-9',
+                totalCount: 3,
+              },
+            ],
+            name: 'register',
+            period: 9,
+            totalCount: 123,
+          },
+        ],
+        applicationStatistics: [
+          {
+            count: 45,
+            version: '2-3-4',
+          },
+        ],
+        churn: {
+          periodKeys: ['2022-10-9'],
+          values: [
+            {
+              periodKey: '2022-10-9',
+              rate: 12,
+            },
+          ],
+        },
+        outOfSyncIncidents: 324,
+        retentionStatistics: [
+          {
+            firstActivity: 'register',
+            retention: {
+              periodKeys: ['2022-10-9'],
+              values: [
+                {
+                  firstPeriodKey: 'register',
+                  secondPeriodKey: 'login',
+                  value: 12,
+                },
+              ],
+            },
+            secondActivity: 'login',
+          },
+        ],
+        snjsStatistics: [
+          {
+            count: 2,
+            version: '1-2-3',
+          },
+        ],
+        statisticMeasures: [
+          {
+            average: 23,
+            increments: 5,
+            name: 'income',
+            period: 0,
+            totalValue: 43,
+          },
+        ],
+      },
+      type: 'DAILY_ANALYTICS_REPORT_GENERATED',
+    })
+  })
+})

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

@@ -0,0 +1,75 @@
+import { DomainEventService, DailyAnalyticsReportGeneratedEvent } from '@standardnotes/domain-events'
+import { TimerInterface } from '@standardnotes/time'
+import { inject, injectable } from 'inversify'
+import TYPES from '../../Bootstrap/Types'
+import { DomainEventFactoryInterface } from './DomainEventFactoryInterface'
+
+@injectable()
+export class DomainEventFactory implements DomainEventFactoryInterface {
+  constructor(@inject(TYPES.Timer) private timer: TimerInterface) {}
+
+  createDailyAnalyticsReportGeneratedEvent(dto: {
+    snjsStatistics: Array<{
+      version: string
+      count: number
+    }>
+    applicationStatistics: Array<{
+      version: string
+      count: number
+    }>
+    activityStatistics: Array<{
+      name: string
+      retention: number
+      totalCount: number
+    }>
+    statisticMeasures: Array<{
+      name: string
+      totalValue: number
+      average: number
+      increments: number
+      period: number
+    }>
+    activityStatisticsOverTime: Array<{
+      name: string
+      period: number
+      counts: Array<{
+        periodKey: string
+        totalCount: number
+      }>
+      totalCount: number
+    }>
+    outOfSyncIncidents: number
+    retentionStatistics: Array<{
+      firstActivity: string
+      secondActivity: string
+      retention: {
+        periodKeys: Array<string>
+        values: Array<{
+          firstPeriodKey: string
+          secondPeriodKey: string
+          value: number
+        }>
+      }
+    }>
+    churn: {
+      periodKeys: Array<string>
+      values: Array<{
+        rate: number
+        periodKey: string
+      }>
+    }
+  }): DailyAnalyticsReportGeneratedEvent {
+    return {
+      type: 'DAILY_ANALYTICS_REPORT_GENERATED',
+      createdAt: this.timer.getUTCDate(),
+      meta: {
+        correlation: {
+          userIdentifier: '',
+          userIdentifierType: 'uuid',
+        },
+        origin: DomainEventService.Analytics,
+      },
+      payload: dto,
+    }
+  }
+}

packages/analytics/src/Domain/Event/DomainEventFactoryInterface.ts

@@ -0,0 +1,55 @@
+import { DailyAnalyticsReportGeneratedEvent } from '@standardnotes/domain-events'
+
+export interface DomainEventFactoryInterface {
+  createDailyAnalyticsReportGeneratedEvent(dto: {
+    snjsStatistics: Array<{
+      version: string
+      count: number
+    }>
+    applicationStatistics: Array<{
+      version: string
+      count: number
+    }>
+    activityStatistics: Array<{
+      name: string
+      retention: number
+      totalCount: number
+    }>
+    statisticMeasures: Array<{
+      name: string
+      totalValue: number
+      average: number
+      increments: number
+      period: number
+    }>
+    activityStatisticsOverTime: Array<{
+      name: string
+      period: number
+      counts: Array<{
+        periodKey: string
+        totalCount: number
+      }>
+      totalCount: number
+    }>
+    outOfSyncIncidents: number
+    retentionStatistics: Array<{
+      firstActivity: string
+      secondActivity: string
+      retention: {
+        periodKeys: Array<string>
+        values: Array<{
+          firstPeriodKey: string
+          secondPeriodKey: string
+          value: number
+        }>
+      }
+    }>
+    churn: {
+      periodKeys: Array<string>
+      values: Array<{
+        rate: number
+        periodKey: string
+      }>
+    }
+  }): DailyAnalyticsReportGeneratedEvent
+}

packages/analytics/src/Domain/Handler/AccountDeletionRequestedEventHandler.spec.ts

@@ -0,0 +1,57 @@
+import 'reflect-metadata'
+
+import { AccountDeletionRequestedEvent } from '@standardnotes/domain-events'
+import { AccountDeletionRequestedEventHandler } from './AccountDeletionRequestedEventHandler'
+import { GetUserAnalyticsId } from '../UseCase/GetUserAnalyticsId/GetUserAnalyticsId'
+import { TimerInterface } from '@standardnotes/time'
+import { AnalyticsStoreInterface } from '../Analytics/AnalyticsStoreInterface'
+import { StatisticsStoreInterface } from '../Statistics/StatisticsStoreInterface'
+import { Period } from '../Time/Period'
+
+describe('AccountDeletionRequestedEventHandler', () => {
+  let event: AccountDeletionRequestedEvent
+  let getUserAnalyticsId: GetUserAnalyticsId
+  let analyticsStore: AnalyticsStoreInterface
+  let statisticsStore: StatisticsStoreInterface
+  let timer: TimerInterface
+
+  const createHandler = () =>
+    new AccountDeletionRequestedEventHandler(getUserAnalyticsId, analyticsStore, statisticsStore, timer)
+
+  beforeEach(() => {
+    event = {} as jest.Mocked<AccountDeletionRequestedEvent>
+    event.createdAt = new Date(1)
+    event.payload = {
+      userUuid: '1-2-3',
+      userCreatedAtTimestamp: 1,
+      regularSubscriptionUuid: '2-3-4',
+    }
+
+    getUserAnalyticsId = {} as jest.Mocked<GetUserAnalyticsId>
+    getUserAnalyticsId.execute = jest.fn().mockReturnValue({ analyticsId: 3 })
+
+    analyticsStore = {} as jest.Mocked<AnalyticsStoreInterface>
+    analyticsStore.markActivity = jest.fn()
+
+    statisticsStore = {} as jest.Mocked<StatisticsStoreInterface>
+    statisticsStore.incrementMeasure = jest.fn()
+
+    timer = {} as jest.Mocked<TimerInterface>
+    timer.getTimestampInMicroseconds = jest.fn().mockReturnValue(123)
+  })
+
+  it('should mark account deletion and registration length', async () => {
+    await createHandler().handle(event)
+
+    expect(analyticsStore.markActivity).toHaveBeenCalledWith(['DeleteAccount'], 3, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+    expect(statisticsStore.incrementMeasure).toHaveBeenCalledWith('registration-length', 122, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+  })
+})

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

@@ -0,0 +1,37 @@
+import { AccountDeletionRequestedEvent, DomainEventHandlerInterface } from '@standardnotes/domain-events'
+import { TimerInterface } from '@standardnotes/time'
+import { inject, injectable } from 'inversify'
+
+import TYPES from '../../Bootstrap/Types'
+import { AnalyticsActivity } from '../Analytics/AnalyticsActivity'
+import { AnalyticsStoreInterface } from '../Analytics/AnalyticsStoreInterface'
+import { StatisticsMeasure } from '../Statistics/StatisticsMeasure'
+import { StatisticsStoreInterface } from '../Statistics/StatisticsStoreInterface'
+import { Period } from '../Time/Period'
+import { GetUserAnalyticsId } from '../UseCase/GetUserAnalyticsId/GetUserAnalyticsId'
+
+@injectable()
+export class AccountDeletionRequestedEventHandler implements DomainEventHandlerInterface {
+  constructor(
+    @inject(TYPES.GetUserAnalyticsId) private getUserAnalyticsId: GetUserAnalyticsId,
+    @inject(TYPES.AnalyticsStore) private analyticsStore: AnalyticsStoreInterface,
+    @inject(TYPES.StatisticsStore) private statisticsStore: StatisticsStoreInterface,
+    @inject(TYPES.Timer) private timer: TimerInterface,
+  ) {}
+
+  async handle(event: AccountDeletionRequestedEvent): Promise<void> {
+    const { analyticsId } = await this.getUserAnalyticsId.execute({ userUuid: event.payload.userUuid })
+    await this.analyticsStore.markActivity([AnalyticsActivity.DeleteAccount], analyticsId, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+
+    const registrationLength = this.timer.getTimestampInMicroseconds() - event.payload.userCreatedAtTimestamp
+    await this.statisticsStore.incrementMeasure(StatisticsMeasure.RegistrationLength, registrationLength, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+  }
+}

packages/analytics/src/Domain/Handler/UserRegisteredEventHandler.spec.ts

@@ -0,0 +1,47 @@
+import 'reflect-metadata'
+
+import { UserRegisteredEvent } from '@standardnotes/domain-events'
+import { ProtocolVersion } from '@standardnotes/common'
+
+import { UserRegisteredEventHandler } from './UserRegisteredEventHandler'
+import { AnalyticsEntityRepositoryInterface } from '../Entity/AnalyticsEntityRepositoryInterface'
+import { AnalyticsStoreInterface } from '../Analytics/AnalyticsStoreInterface'
+import { Period } from '../Time/Period'
+
+describe('UserRegisteredEventHandler', () => {
+  let analyticsEntityRepository: AnalyticsEntityRepositoryInterface
+  let event: UserRegisteredEvent
+  let analyticsStore: AnalyticsStoreInterface
+
+  const createHandler = () => new UserRegisteredEventHandler(analyticsEntityRepository, analyticsStore)
+
+  beforeEach(() => {
+    event = {} as jest.Mocked<UserRegisteredEvent>
+    event.createdAt = new Date(1)
+    event.payload = {
+      userUuid: '1-2-3',
+      email: 'test@test.te',
+      protocolVersion: ProtocolVersion.V004,
+    }
+
+    analyticsStore = {} as jest.Mocked<AnalyticsStoreInterface>
+    analyticsStore.markActivity = jest.fn()
+
+    analyticsEntityRepository = {} as jest.Mocked<AnalyticsEntityRepositoryInterface>
+    analyticsEntityRepository.save = jest.fn().mockImplementation((entity) => ({
+      ...entity,
+      id: 1,
+    }))
+  })
+
+  it('should save analytics entity upon user registration', async () => {
+    await createHandler().handle(event)
+
+    expect(analyticsEntityRepository.save).toHaveBeenCalled()
+    expect(analyticsStore.markActivity).toHaveBeenCalledWith(['register'], 1, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+  })
+})

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

@@ -0,0 +1,29 @@
+import { DomainEventHandlerInterface, UserRegisteredEvent } from '@standardnotes/domain-events'
+import { inject, injectable } from 'inversify'
+
+import TYPES from '../../Bootstrap/Types'
+import { AnalyticsActivity } from '../Analytics/AnalyticsActivity'
+import { AnalyticsStoreInterface } from '../Analytics/AnalyticsStoreInterface'
+import { AnalyticsEntity } from '../Entity/AnalyticsEntity'
+import { AnalyticsEntityRepositoryInterface } from '../Entity/AnalyticsEntityRepositoryInterface'
+import { Period } from '../Time/Period'
+
+@injectable()
+export class UserRegisteredEventHandler implements DomainEventHandlerInterface {
+  constructor(
+    @inject(TYPES.AnalyticsEntityRepository) private analyticsEntityRepository: AnalyticsEntityRepositoryInterface,
+    @inject(TYPES.AnalyticsStore) private analyticsStore: AnalyticsStoreInterface,
+  ) {}
+
+  async handle(event: UserRegisteredEvent): Promise<void> {
+    let analyticsEntity = new AnalyticsEntity()
+    analyticsEntity.userUuid = event.payload.userUuid
+    analyticsEntity = await this.analyticsEntityRepository.save(analyticsEntity)
+
+    await this.analyticsStore.markActivity([AnalyticsActivity.Register], analyticsEntity.id, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+  }
+}

packages/analytics/src/Domain/UseCase/GetUserAnalyticsId/GetUserAnalyticsId.spec.ts

@@ -0,0 +1,37 @@
+import 'reflect-metadata'
+
+import { AnalyticsEntity } from '../../Entity/AnalyticsEntity'
+import { AnalyticsEntityRepositoryInterface } from '../../Entity/AnalyticsEntityRepositoryInterface'
+
+import { GetUserAnalyticsId } from './GetUserAnalyticsId'
+
+describe('GetUserAnalyticsId', () => {
+  let analyticsEntityRepository: AnalyticsEntityRepositoryInterface
+  let analyticsEntity: AnalyticsEntity
+
+  const createUseCase = () => new GetUserAnalyticsId(analyticsEntityRepository)
+
+  beforeEach(() => {
+    analyticsEntity = { id: 123 } as jest.Mocked<AnalyticsEntity>
+
+    analyticsEntityRepository = {} as jest.Mocked<AnalyticsEntityRepositoryInterface>
+    analyticsEntityRepository.findOneByUserUuid = jest.fn().mockReturnValue(analyticsEntity)
+  })
+
+  it('should return analytics id for a user', async () => {
+    expect(await createUseCase().execute({ userUuid: '1-2-3' })).toEqual({ analyticsId: 123 })
+  })
+
+  it('should throw error if user is missing analytics entity', async () => {
+    analyticsEntityRepository.findOneByUserUuid = jest.fn().mockReturnValue(null)
+    let error = null
+
+    try {
+      await createUseCase().execute({ userUuid: '1-2-3' })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+})

packages/analytics/src/Domain/UseCase/GetUserAnalyticsId/GetUserAnalyticsId.ts

@@ -0,0 +1,25 @@
+import { inject, injectable } from 'inversify'
+import TYPES from '../../../Bootstrap/Types'
+import { AnalyticsEntityRepositoryInterface } from '../../Entity/AnalyticsEntityRepositoryInterface'
+import { UseCaseInterface } from '../UseCaseInterface'
+import { GetUserAnalyticsIdDTO } from './GetUserAnalyticsIdDTO'
+import { GetUserAnalyticsIdResponse } from './GetUserAnalyticsIdResponse'
+
+@injectable()
+export class GetUserAnalyticsId implements UseCaseInterface {
+  constructor(
+    @inject(TYPES.AnalyticsEntityRepository) private analyticsEntityRepository: AnalyticsEntityRepositoryInterface,
+  ) {}
+
+  async execute(dto: GetUserAnalyticsIdDTO): Promise<GetUserAnalyticsIdResponse> {
+    const analyticsEntity = await this.analyticsEntityRepository.findOneByUserUuid(dto.userUuid)
+
+    if (analyticsEntity === null) {
+      throw new Error(`Could not find analytics entity for user ${dto.userUuid}`)
+    }
+
+    return {
+      analyticsId: analyticsEntity.id,
+    }
+  }
+}

packages/analytics/src/Domain/UseCase/GetUserAnalyticsId/GetUserAnalyticsIdDTO.ts

@@ -0,0 +1,5 @@
+import { Uuid } from '@standardnotes/common'
+
+export type GetUserAnalyticsIdDTO = {
+  userUuid: Uuid
+}

packages/analytics/src/Domain/UseCase/GetUserAnalyticsId/GetUserAnalyticsIdResponse.ts

@@ -0,0 +1,3 @@
+export type GetUserAnalyticsIdResponse = {
+  analyticsId: number
+}

packages/analytics/src/Domain/UseCase/UseCaseInterface.ts

@@ -0,0 +1,3 @@
+export interface UseCaseInterface {
+  execute(...args: any[]): Promise<Record<string, unknown>>
+}

packages/analytics/src/Infra/MySQL/MySQLAnalyticsEntityRepository.spec.ts

@@ -0,0 +1,42 @@
+import 'reflect-metadata'
+
+import { Repository, SelectQueryBuilder } from 'typeorm'
+
+import { AnalyticsEntity } from '../../Domain/Entity/AnalyticsEntity'
+
+import { MySQLAnalyticsEntityRepository } from './MySQLAnalyticsEntityRepository'
+
+describe('MySQLAnalyticsEntityRepository', () => {
+  let ormRepository: Repository<AnalyticsEntity>
+  let analyticsEntity: AnalyticsEntity
+  let queryBuilder: SelectQueryBuilder<AnalyticsEntity>
+
+  const createRepository = () => new MySQLAnalyticsEntityRepository(ormRepository)
+
+  beforeEach(() => {
+    analyticsEntity = {} as jest.Mocked<AnalyticsEntity>
+
+    queryBuilder = {} as jest.Mocked<SelectQueryBuilder<AnalyticsEntity>>
+
+    ormRepository = {} as jest.Mocked<Repository<AnalyticsEntity>>
+    ormRepository.save = jest.fn()
+    ormRepository.createQueryBuilder = jest.fn().mockImplementation(() => queryBuilder)
+  })
+
+  it('should save', async () => {
+    await createRepository().save(analyticsEntity)
+
+    expect(ormRepository.save).toHaveBeenCalledWith(analyticsEntity)
+  })
+
+  it('should find one by user uuid', async () => {
+    queryBuilder.where = jest.fn().mockReturnThis()
+    queryBuilder.getOne = jest.fn().mockReturnValue(analyticsEntity)
+
+    const result = await createRepository().findOneByUserUuid('123')
+
+    expect(queryBuilder.where).toHaveBeenCalledWith('analytics_entity.user_uuid = :userUuid', { userUuid: '123' })
+
+    expect(result).toEqual(analyticsEntity)
+  })
+})

packages/analytics/src/Infra/MySQL/MySQLAnalyticsEntityRepository.ts

@@ -0,0 +1,26 @@
+import { Uuid } from '@standardnotes/common'
+import { inject, injectable } from 'inversify'
+import { Repository } from 'typeorm'
+
+import TYPES from '../../Bootstrap/Types'
+import { AnalyticsEntity } from '../../Domain/Entity/AnalyticsEntity'
+import { AnalyticsEntityRepositoryInterface } from '../../Domain/Entity/AnalyticsEntityRepositoryInterface'
+
+@injectable()
+export class MySQLAnalyticsEntityRepository implements AnalyticsEntityRepositoryInterface {
+  constructor(
+    @inject(TYPES.ORMAnalyticsEntityRepository)
+    private ormRepository: Repository<AnalyticsEntity>,
+  ) {}
+
+  async findOneByUserUuid(userUuid: Uuid): Promise<AnalyticsEntity | null> {
+    return this.ormRepository
+      .createQueryBuilder('analytics_entity')
+      .where('analytics_entity.user_uuid = :userUuid', { userUuid })
+      .getOne()
+  }
+
+  async save(analyticsEntity: AnalyticsEntity): Promise<AnalyticsEntity> {
+    return this.ormRepository.save(analyticsEntity)
+  }
+}

packages/analytics/tsconfig.json

@@ -5,7 +5,9 @@
     "outDir": "./dist",
   },
   "include": [
-    "src/**/*"
+    "src/**/*",
+    "bin/**/*",
+    "migrations/**/*"
   ],
   "references": []
 }

packages/api-gateway/.env.sample

@@ -27,9 +27,5 @@ NEW_RELIC_LOG_LEVEL=info
 REDIS_URL=redis://cache
 REDIS_EVENTS_CHANNEL=events
 
-# (Optional) SNS Setup
-SNS_TOPIC_ARN=
-SNS_AWS_REGION=
-
 # (Optional) Caching Cross Service Tokens
 CROSS_SERVICE_TOKEN_CACHE_TTL=

packages/api-gateway/CHANGELOG.md

@@ -3,6 +3,54 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.36.5](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.36.4...@standardnotes/api-gateway@1.36.5) (2022-11-04)
+
+### Bug Fixes
+
+* **api-gateway:** removing sns bindings ([b4c5b5a](https://github.com/standardnotes/api-gateway/commit/b4c5b5a84e4c619f175620b141279dfa8e2e6754))
+
+## [1.36.4](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.36.3...@standardnotes/api-gateway@1.36.4) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.36.3](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.36.2...@standardnotes/api-gateway@1.36.3) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.36.2](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.36.1...@standardnotes/api-gateway@1.36.2) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.36.1](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.36.0...@standardnotes/api-gateway@1.36.1) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+# [1.36.0](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.35.1...@standardnotes/api-gateway@1.36.0) (2022-11-04)
+
+### Features
+
+* **analytics:** move the analytics report from api-gateway to analytics ([34e11fd](https://github.com/standardnotes/api-gateway/commit/34e11fd5b0ef09a056c90127065c9dfae3e0172a))
+
+## [1.35.1](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.35.0...@standardnotes/api-gateway@1.35.1) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+# [1.35.0](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.34.1...@standardnotes/api-gateway@1.35.0) (2022-11-03)
+
+### Features
+
+* **auth:** add analytics for subscription reactivating ([460d6a8](https://github.com/standardnotes/api-gateway/commit/460d6a8d0f17eee624feb5d2588086ae6f0996e4))
+
+## [1.34.1](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.34.0...@standardnotes/api-gateway@1.34.1) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+# [1.34.0](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.33.6...@standardnotes/api-gateway@1.34.0) (2022-11-02)
+
+### Features
+
+* **auth:** add processing user requests ([2255f85](https://github.com/standardnotes/api-gateway/commit/2255f856f928e855ac94f8aca4e1fb81047f58f7))
+
 ## [1.33.6](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.33.5...@standardnotes/api-gateway@1.33.6) (2022-11-02)
 
 **Note:** Version bump only for package @standardnotes/api-gateway

packages/api-gateway/docker/entrypoint.sh

@@ -16,11 +16,6 @@ case "$COMMAND" in
     yarn workspace @standardnotes/api-gateway start
     ;;
 
-  'report' )
-    echo "Starting Usage Report Generation..."
-    yarn workspace @standardnotes/api-gateway report
-    ;;
-
    * )
     echo "Unknown command"
     ;;

packages/api-gateway/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/api-gateway",
-  "version": "1.33.6",
+  "version": "1.36.5",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -17,7 +17,6 @@
     "lint": "eslint . --ext .ts",
     "setup:env": "cp .env.sample .env",
     "start": "yarn node dist/bin/server.js",
-    "report": "yarn node dist/bin/report.js",
     "upgrade:snjs": "yarn ncu -u '@standardnotes/*'"
   },
   "dependencies": {

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

@@ -2,7 +2,6 @@ import * as winston from 'winston'
 import axios, { AxiosInstance } from 'axios'
 import Redis from 'ioredis'
 import { Container } from 'inversify'
-import * as AWS from 'aws-sdk'
 import {
   AnalyticsStoreInterface,
   PeriodKeyGenerator,
@@ -11,7 +10,6 @@ import {
   RedisStatisticsStore,
   StatisticsStoreInterface,
 } from '@standardnotes/analytics'
-import { RedisDomainEventPublisher, SNSDomainEventPublisher } from '@standardnotes/domain-events-infra'
 import { Timer, TimerInterface } from '@standardnotes/time'
 
 import { Env } from './Env'
@@ -58,15 +56,6 @@ export class ContainerConfigLoader {
     }
     container.bind(TYPES.Redis).toConstantValue(redis)
 
-    if (env.get('SNS_AWS_REGION', true)) {
-      container.bind<AWS.SNS>(TYPES.SNS).toConstantValue(
-        new AWS.SNS({
-          apiVersion: 'latest',
-          region: env.get('SNS_AWS_REGION', true),
-        }),
-      )
-    }
-
     container.bind<AxiosInstance>(TYPES.HTTPClient).toConstantValue(axios.create())
 
     // env vars
@@ -81,8 +70,6 @@ export class ContainerConfigLoader {
       .bind(TYPES.HTTP_CALL_TIMEOUT)
       .toConstantValue(env.get('HTTP_CALL_TIMEOUT', true) ? +env.get('HTTP_CALL_TIMEOUT', true) : 60_000)
     container.bind(TYPES.VERSION).toConstantValue(env.get('VERSION'))
-    container.bind(TYPES.SNS_TOPIC_ARN).toConstantValue(env.get('SNS_TOPIC_ARN', true))
-    container.bind(TYPES.SNS_AWS_REGION).toConstantValue(env.get('SNS_AWS_REGION', true))
     container.bind(TYPES.REDIS_EVENTS_CHANNEL).toConstantValue(env.get('REDIS_EVENTS_CHANNEL'))
     container.bind(TYPES.CROSS_SERVICE_TOKEN_CACHE_TTL).toConstantValue(+env.get('CROSS_SERVICE_TOKEN_CACHE_TTL', true))
 
@@ -106,18 +93,6 @@ export class ContainerConfigLoader {
     container.bind<CrossServiceTokenCacheInterface>(TYPES.CrossServiceTokenCache).to(RedisCrossServiceTokenCache)
     container.bind<TimerInterface>(TYPES.Timer).toConstantValue(new Timer())
 
-    if (env.get('SNS_TOPIC_ARN', true)) {
-      container
-        .bind<SNSDomainEventPublisher>(TYPES.DomainEventPublisher)
-        .toConstantValue(new SNSDomainEventPublisher(container.get(TYPES.SNS), container.get(TYPES.SNS_TOPIC_ARN)))
-    } else {
-      container
-        .bind<RedisDomainEventPublisher>(TYPES.DomainEventPublisher)
-        .toConstantValue(
-          new RedisDomainEventPublisher(container.get(TYPES.Redis), container.get(TYPES.REDIS_EVENTS_CHANNEL)),
-        )
-    }
-
     return container
   }
 }

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

@@ -2,7 +2,6 @@ const TYPES = {
   Logger: Symbol.for('Logger'),
   Redis: Symbol.for('Redis'),
   HTTPClient: Symbol.for('HTTPClient'),
-  SNS: Symbol.for('SNS'),
   // env vars
   SYNCING_SERVER_JS_URL: Symbol.for('SYNCING_SERVER_JS_URL'),
   AUTH_SERVER_URL: Symbol.for('AUTH_SERVER_URL'),
@@ -13,8 +12,6 @@ const TYPES = {
   AUTH_JWT_SECRET: Symbol.for('AUTH_JWT_SECRET'),
   HTTP_CALL_TIMEOUT: Symbol.for('HTTP_CALL_TIMEOUT'),
   VERSION: Symbol.for('VERSION'),
-  SNS_TOPIC_ARN: Symbol.for('SNS_TOPIC_ARN'),
-  SNS_AWS_REGION: Symbol.for('SNS_AWS_REGION'),
   REDIS_EVENTS_CHANNEL: Symbol.for('REDIS_EVENTS_CHANNEL'),
   CROSS_SERVICE_TOKEN_CACHE_TTL: Symbol.for('CROSS_SERVICE_TOKEN_CACHE_TTL'),
   // Middleware
@@ -27,7 +24,6 @@ const TYPES = {
   CrossServiceTokenCache: Symbol.for('CrossServiceTokenCache'),
   AnalyticsStore: Symbol.for('AnalyticsStore'),
   StatisticsStore: Symbol.for('StatisticsStore'),
-  DomainEventPublisher: Symbol.for('DomainEventPublisher'),
   Timer: Symbol.for('Timer'),
   PeriodKeyGenerator: Symbol.for('PeriodKeyGenerator'),
 }

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

@@ -147,4 +147,9 @@ export class UsersController extends BaseHttpController {
   async deleteUser(request: Request, response: Response): Promise<void> {
     await this.httpService.callPaymentsServer(request, response, 'api/account', request.body)
   }
+
+  @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)
+  }
 }

packages/auth/CHANGELOG.md

@@ -3,6 +3,64 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.49.8](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.7...@standardnotes/auth-server@1.49.8) (2022-11-04)
+
+### Bug Fixes
+
+* **auth:** add user created at timestamp to account deletion event ([7b05bf8](https://github.com/standardnotes/server/commit/7b05bf899152a2f36ce1fa851e8d5821c67840d7))
+
+## [1.49.7](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.6...@standardnotes/auth-server@1.49.7) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.49.6](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.5...@standardnotes/auth-server@1.49.6) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.49.5](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.4...@standardnotes/auth-server@1.49.5) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.49.4](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.3...@standardnotes/auth-server@1.49.4) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.49.3](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.2...@standardnotes/auth-server@1.49.3) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.49.2](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.1...@standardnotes/auth-server@1.49.2) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.49.1](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.49.0...@standardnotes/auth-server@1.49.1) (2022-11-03)
+
+### Bug Fixes
+
+* **auth:** updating offline subscription end date ([2504887](https://github.com/standardnotes/server/commit/2504887e8d2d06608927e17a766cf0794dda2d4d))
+
+# [1.49.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.48.2...@standardnotes/auth-server@1.49.0) (2022-11-03)
+
+### Features
+
+* **auth:** add analytics for subscription reactivating ([460d6a8](https://github.com/standardnotes/server/commit/460d6a8d0f17eee624feb5d2588086ae6f0996e4))
+
+## [1.48.2](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.48.1...@standardnotes/auth-server@1.48.2) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.48.1](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.48.0...@standardnotes/auth-server@1.48.1) (2022-11-02)
+
+### Bug Fixes
+
+* **auth:** controller name ([5b0d9dd](https://github.com/standardnotes/server/commit/5b0d9dd3949d4da9d5ac3ca86a0e54ead2ce730d))
+
+# [1.48.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.47.7...@standardnotes/auth-server@1.48.0) (2022-11-02)
+
+### Features
+
+* **auth:** add processing user requests ([2255f85](https://github.com/standardnotes/server/commit/2255f856f928e855ac94f8aca4e1fb81047f58f7))
+
 ## [1.47.7](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.47.6...@standardnotes/auth-server@1.47.7) (2022-11-02)
 
 **Note:** Version bump only for package @standardnotes/auth-server

packages/auth/bin/server.ts

@@ -20,6 +20,7 @@ import '../src/Controller/SubscriptionSettingsController'
 
 import '../src/Infra/InversifyExpressUtils/InversifyExpressAuthController'
 import '../src/Infra/InversifyExpressUtils/InversifyExpressSubscriptionInvitesController'
+import '../src/Infra/InversifyExpressUtils/InversifyExpressUserRequestsController'
 import '../src/Infra/InversifyExpressUtils/InversifyExpressWebSocketsController'
 
 import * as cors from 'cors'

packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/auth-server",
-  "version": "1.47.7",
+  "version": "1.49.8",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -33,7 +33,7 @@
     "@newrelic/winston-enricher": "^4.0.0",
     "@sentry/node": "^7.3.0",
     "@standardnotes/analytics": "workspace:*",
-    "@standardnotes/api": "^1.17.2",
+    "@standardnotes/api": "^1.19.0",
     "@standardnotes/common": "workspace:*",
     "@standardnotes/domain-events": "workspace:*",
     "@standardnotes/domain-events-infra": "workspace:*",
@@ -49,7 +49,7 @@
     "axios": "^0.27.2",
     "bcryptjs": "2.4.3",
     "cors": "2.8.5",
-    "dayjs": "^1.11.3",
+    "dayjs": "^1.11.6",
     "dotenv": "^16.0.1",
     "express": "^4.18.1",
     "inversify": "^6.0.1",

packages/auth/src/Bootstrap/Container.ts

@@ -203,6 +203,9 @@ import { PaymentSuccessEventHandler } from '../Domain/Handler/PaymentSuccessEven
 import { RefundProcessedEventHandler } from '../Domain/Handler/RefundProcessedEventHandler'
 import { SubscriptionInvitesController } from '../Controller/SubscriptionInvitesController'
 import { CreateCrossServiceToken } from '../Domain/UseCase/CreateCrossServiceToken/CreateCrossServiceToken'
+import { ProcessUserRequest } from '../Domain/UseCase/ProcessUserRequest/ProcessUserRequest'
+import { UserRequestsController } from '../Controller/UserRequestsController'
+import { SubscriptionReactivatedEventHandler } from '../Domain/Handler/SubscriptionReactivatedEventHandler'
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const newrelicFormatter = require('@newrelic/winston-enricher')
@@ -266,6 +269,7 @@ export class ContainerConfigLoader {
     // Controller
     container.bind<AuthController>(TYPES.AuthController).to(AuthController)
     container.bind<SubscriptionInvitesController>(TYPES.SubscriptionInvitesController).to(SubscriptionInvitesController)
+    container.bind<UserRequestsController>(TYPES.UserRequestsController).to(UserRequestsController)
 
     // Repositories
     container.bind<SessionRepositoryInterface>(TYPES.SessionRepository).to(MySQLSessionRepository)
@@ -438,6 +442,7 @@ export class ContainerConfigLoader {
     container.bind<GetUserAnalyticsId>(TYPES.GetUserAnalyticsId).to(GetUserAnalyticsId)
     container.bind<VerifyPredicate>(TYPES.VerifyPredicate).to(VerifyPredicate)
     container.bind<CreateCrossServiceToken>(TYPES.CreateCrossServiceToken).to(CreateCrossServiceToken)
+    container.bind<ProcessUserRequest>(TYPES.ProcessUserRequest).to(ProcessUserRequest)
 
     // Handlers
     container.bind<UserRegisteredEventHandler>(TYPES.UserRegisteredEventHandler).to(UserRegisteredEventHandler)
@@ -489,6 +494,9 @@ export class ContainerConfigLoader {
     container.bind<PaymentFailedEventHandler>(TYPES.PaymentFailedEventHandler).to(PaymentFailedEventHandler)
     container.bind<PaymentSuccessEventHandler>(TYPES.PaymentSuccessEventHandler).to(PaymentSuccessEventHandler)
     container.bind<RefundProcessedEventHandler>(TYPES.RefundProcessedEventHandler).to(RefundProcessedEventHandler)
+    container
+      .bind<SubscriptionReactivatedEventHandler>(TYPES.SubscriptionReactivatedEventHandler)
+      .to(SubscriptionReactivatedEventHandler)
 
     // Services
     container.bind<UAParser>(TYPES.DeviceDetector).toConstantValue(new UAParser())
@@ -600,6 +608,7 @@ export class ContainerConfigLoader {
       ['PAYMENT_FAILED', container.get(TYPES.PaymentFailedEventHandler)],
       ['PAYMENT_SUCCESS', container.get(TYPES.PaymentSuccessEventHandler)],
       ['REFUND_PROCESSED', container.get(TYPES.RefundProcessedEventHandler)],
+      ['SUBSCRIPTION_REACTIVATED', container.get(TYPES.SubscriptionReactivatedEventHandler)],
     ])
 
     if (env.get('SQS_QUEUE_URL', true)) {

packages/auth/src/Bootstrap/Types.ts

@@ -6,6 +6,7 @@ const TYPES = {
   // Controller
   AuthController: Symbol.for('AuthController'),
   SubscriptionInvitesController: Symbol.for('SubscriptionInvitesController'),
+  UserRequestsController: Symbol.for('UserRequestsController'),
   // Repositories
   UserRepository: Symbol.for('UserRepository'),
   SessionRepository: Symbol.for('SessionRepository'),
@@ -121,6 +122,7 @@ const TYPES = {
   GetUserAnalyticsId: Symbol.for('GetUserAnalyticsId'),
   VerifyPredicate: Symbol.for('VerifyPredicate'),
   CreateCrossServiceToken: Symbol.for('CreateCrossServiceToken'),
+  ProcessUserRequest: Symbol.for('ProcessUserRequest'),
   // Handlers
   UserRegisteredEventHandler: Symbol.for('UserRegisteredEventHandler'),
   AccountDeletionRequestedEventHandler: Symbol.for('AccountDeletionRequestedEventHandler'),
@@ -143,6 +145,7 @@ const TYPES = {
   PaymentFailedEventHandler: Symbol.for('PaymentFailedEventHandler'),
   PaymentSuccessEventHandler: Symbol.for('PaymentSuccessEventHandler'),
   RefundProcessedEventHandler: Symbol.for('RefundProcessedEventHandler'),
+  SubscriptionReactivatedEventHandler: Symbol.for('SubscriptionReactivatedEventHandler'),
   // Services
   DeviceDetector: Symbol.for('DeviceDetector'),
   SessionService: Symbol.for('SessionService'),

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

@@ -109,4 +109,15 @@ describe('AuthController', () => {
 
     expect(response.status).toEqual(400)
   })
+
+  it('should throw error on the delete user method as it is still a part of the payments server', async () => {
+    let caughtError = null
+    try {
+      await createController().deleteAccount({ userUuid: '1-2-3' })
+    } catch (error) {
+      caughtError = error
+    }
+
+    expect(caughtError).not.toBeNull()
+  })
 })

packages/auth/src/Controller/AuthController.ts

@@ -2,6 +2,7 @@ import { inject, injectable } from 'inversify'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
 import {
   HttpStatusCode,
+  UserDeletionResponse,
   UserRegistrationRequestParams,
   UserRegistrationResponse,
   UserServerInterface,
@@ -12,6 +13,7 @@ import { ClearLoginAttempts } from '../Domain/UseCase/ClearLoginAttempts'
 import { Register } from '../Domain/UseCase/Register'
 import { DomainEventFactoryInterface } from '../Domain/Event/DomainEventFactoryInterface'
 import { ProtocolVersion } from '@standardnotes/common'
+import { UserDeletionRequestParams } from '@standardnotes/api/dist/Domain/Request/User/UserDeletionRequestParams'
 
 @injectable()
 export class AuthController implements UserServerInterface {
@@ -22,6 +24,10 @@ export class AuthController implements UserServerInterface {
     @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
   ) {}
 
+  async deleteAccount(_params: UserDeletionRequestParams): Promise<UserDeletionResponse> {
+    throw new Error('This method is implemented on the payments server.')
+  }
+
   async register(params: UserRegistrationRequestParams): Promise<UserRegistrationResponse> {
     if (!params.email || !params.password) {
       return {

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

@@ -0,0 +1,43 @@
+import 'reflect-metadata'
+
+import { UserRequestType } from '@standardnotes/common'
+
+import { ProcessUserRequest } from '../Domain/UseCase/ProcessUserRequest/ProcessUserRequest'
+
+import { UserRequestsController } from './UserRequestsController'
+
+describe('UserRequestsController', () => {
+  let processUserRequest: ProcessUserRequest
+
+  const createController = () => new UserRequestsController(processUserRequest)
+
+  beforeEach(() => {
+    processUserRequest = {} as jest.Mocked<ProcessUserRequest>
+    processUserRequest.execute = jest.fn().mockReturnValue({ success: true })
+  })
+
+  it('should process user request', async () => {
+    expect(
+      await createController().submitUserRequest({
+        userUuid: '1-2-3',
+        requestType: UserRequestType.ExitDiscount,
+      }),
+    ).toEqual({
+      status: 200,
+      data: { success: true },
+    })
+  })
+
+  it('should not process user request', async () => {
+    processUserRequest.execute = jest.fn().mockReturnValue({ success: false })
+    expect(
+      await createController().submitUserRequest({
+        userUuid: '1-2-3',
+        requestType: UserRequestType.ExitDiscount,
+      }),
+    ).toEqual({
+      status: 400,
+      data: { success: false },
+    })
+  })
+})

packages/auth/src/Controller/UserRequestsController.ts

@@ -0,0 +1,34 @@
+import {
+  HttpStatusCode,
+  UserRequestRequestParams,
+  UserRequestResponse,
+  UserRequestServerInterface,
+} from '@standardnotes/api'
+import { inject, injectable } from 'inversify'
+import TYPES from '../Bootstrap/Types'
+import { ProcessUserRequest } from '../Domain/UseCase/ProcessUserRequest/ProcessUserRequest'
+
+@injectable()
+export class UserRequestsController implements UserRequestServerInterface {
+  constructor(@inject(TYPES.ProcessUserRequest) private processUserRequest: ProcessUserRequest) {}
+
+  async submitUserRequest(params: UserRequestRequestParams): Promise<UserRequestResponse> {
+    const result = await this.processUserRequest.execute({
+      requestType: params.requestType,
+      userEmail: params.userEmail as string,
+      userUuid: params.userUuid,
+    })
+
+    if (!result.success) {
+      return {
+        status: HttpStatusCode.BadRequest,
+        data: result,
+      }
+    }
+
+    return {
+      status: HttpStatusCode.Success,
+      data: result,
+    }
+  }
+}

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

@@ -18,6 +18,29 @@ describe('DomainEventFactory', () => {
     timer.getUTCDate = jest.fn().mockReturnValue(new Date(1))
   })
 
+  it('should create a EXIT_DISCOUNT_APPLY_REQUESTED event', () => {
+    expect(
+      createFactory().createExitDiscountApplyRequestedEvent({
+        userEmail: 'test@test.te',
+        discountCode: 'exit-20',
+      }),
+    ).toEqual({
+      createdAt: expect.any(Date),
+      meta: {
+        correlation: {
+          userIdentifier: 'test@test.te',
+          userIdentifierType: 'email',
+        },
+        origin: 'auth',
+      },
+      payload: {
+        userEmail: 'test@test.te',
+        discountCode: 'exit-20',
+      },
+      type: 'EXIT_DISCOUNT_APPLY_REQUESTED',
+    })
+  })
+
   it('should create a WEB_SOCKET_MESSAGE_REQUESTED event', () => {
     expect(
       createFactory().createWebSocketMessageRequestedEvent({
@@ -340,6 +363,7 @@ describe('DomainEventFactory', () => {
     expect(
       createFactory().createAccountDeletionRequestedEvent({
         userUuid: '1-2-3',
+        userCreatedAtTimestamp: 123,
         regularSubscriptionUuid: '2-3-4',
       }),
     ).toEqual({
@@ -353,6 +377,7 @@ describe('DomainEventFactory', () => {
       },
       payload: {
         userUuid: '1-2-3',
+        userCreatedAtTimestamp: 123,
         regularSubscriptionUuid: '2-3-4',
       },
       type: 'ACCOUNT_DELETION_REQUESTED',

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

@@ -16,6 +16,7 @@ import {
   DomainEventService,
   EmailMessageRequestedEvent,
   WebSocketMessageRequestedEvent,
+  ExitDiscountApplyRequestedEvent,
 } from '@standardnotes/domain-events'
 import { Predicate, PredicateVerificationResult } from '@standardnotes/predicates'
 import { TimerInterface } from '@standardnotes/time'
@@ -28,6 +29,24 @@ import { DomainEventFactoryInterface } from './DomainEventFactoryInterface'
 export class DomainEventFactory implements DomainEventFactoryInterface {
   constructor(@inject(TYPES.Timer) private timer: TimerInterface) {}
 
+  createExitDiscountApplyRequestedEvent(dto: {
+    userEmail: string
+    discountCode: string
+  }): ExitDiscountApplyRequestedEvent {
+    return {
+      type: 'EXIT_DISCOUNT_APPLY_REQUESTED',
+      createdAt: this.timer.getUTCDate(),
+      meta: {
+        correlation: {
+          userIdentifier: dto.userEmail,
+          userIdentifierType: 'email',
+        },
+        origin: DomainEventService.Auth,
+      },
+      payload: dto,
+    }
+  }
+
   createWebSocketMessageRequestedEvent(dto: { userUuid: Uuid; message: JSONString }): WebSocketMessageRequestedEvent {
     return {
       type: 'WEB_SOCKET_MESSAGE_REQUESTED',
@@ -235,6 +254,7 @@ export class DomainEventFactory implements DomainEventFactoryInterface {
 
   createAccountDeletionRequestedEvent(dto: {
     userUuid: Uuid
+    userCreatedAtTimestamp: number
     regularSubscriptionUuid: Uuid | undefined
   }): AccountDeletionRequestedEvent {
     return {

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

@@ -16,6 +16,7 @@ import {
   PredicateVerifiedEvent,
   EmailMessageRequestedEvent,
   WebSocketMessageRequestedEvent,
+  ExitDiscountApplyRequestedEvent,
 } from '@standardnotes/domain-events'
 import { InviteeIdentifierType } from '../SharedSubscription/InviteeIdentifierType'
 
@@ -54,6 +55,7 @@ export interface DomainEventFactoryInterface {
   ): CloudBackupRequestedEvent
   createAccountDeletionRequestedEvent(dto: {
     userUuid: Uuid
+    userCreatedAtTimestamp: number
     regularSubscriptionUuid: Uuid | undefined
   }): AccountDeletionRequestedEvent
   createUserRolesChangedEvent(userUuid: string, email: string, currentRoles: RoleName[]): UserRolesChangedEvent
@@ -83,4 +85,8 @@ export interface DomainEventFactoryInterface {
     predicate: Predicate
     predicateVerificationResult: PredicateVerificationResult
   }): PredicateVerifiedEvent
+  createExitDiscountApplyRequestedEvent(dto: {
+    userEmail: string
+    discountCode: string
+  }): ExitDiscountApplyRequestedEvent
 }

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

@@ -91,7 +91,9 @@ export class SubscriptionPurchasedEventHandler implements DomainEventHandlerInte
       [Period.Today, Period.ThisWeek, Period.ThisMonth],
     )
 
-    const limitedDiscountPurchased = ['limited-10', 'limited-20'].includes(event.payload.discountCode as string)
+    const limitedDiscountPurchased = ['limited-10', 'limited-20', 'exit-20'].includes(
+      event.payload.discountCode as string,
+    )
     if (limitedDiscountPurchased) {
       await this.analyticsStore.markActivity([AnalyticsActivity.LimitedDiscountOfferPurchased], analyticsId, [
         Period.Today,

packages/auth/src/Domain/Handler/SubscriptionReactivatedEventHandler.spec.ts

@@ -0,0 +1,78 @@
+import 'reflect-metadata'
+
+import { RoleName, SubscriptionName } from '@standardnotes/common'
+import { SubscriptionReactivatedEvent } from '@standardnotes/domain-events'
+import { Logger } from 'winston'
+
+import { User } from '../User/User'
+import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
+import { SubscriptionReactivatedEventHandler } from './SubscriptionReactivatedEventHandler'
+import { AnalyticsStoreInterface, Period } from '@standardnotes/analytics'
+import { GetUserAnalyticsId } from '../UseCase/GetUserAnalyticsId/GetUserAnalyticsId'
+
+describe('SubscriptionReactivatedEventHandler', () => {
+  let userRepository: UserRepositoryInterface
+  let logger: Logger
+  let user: User
+  let event: SubscriptionReactivatedEvent
+  let getUserAnalyticsId: GetUserAnalyticsId
+  let analyticsStore: AnalyticsStoreInterface
+
+  const createHandler = () =>
+    new SubscriptionReactivatedEventHandler(userRepository, analyticsStore, getUserAnalyticsId, logger)
+
+  beforeEach(() => {
+    user = {
+      uuid: '123',
+      email: 'test@test.com',
+      roles: Promise.resolve([
+        {
+          name: RoleName.ProUser,
+        },
+      ]),
+    } as jest.Mocked<User>
+
+    userRepository = {} as jest.Mocked<UserRepositoryInterface>
+    userRepository.findOneByEmail = jest.fn().mockReturnValue(user)
+    userRepository.save = jest.fn().mockReturnValue(user)
+
+    event = {} as jest.Mocked<SubscriptionReactivatedEvent>
+    event.createdAt = new Date(1)
+    event.payload = {
+      previousSubscriptionId: 1,
+      currentSubscriptionId: 2,
+      userEmail: 'test@test.com',
+      subscriptionName: SubscriptionName.PlusPlan,
+      subscriptionExpiresAt: 5,
+      discountCode: 'exit-20',
+    }
+
+    getUserAnalyticsId = {} as jest.Mocked<GetUserAnalyticsId>
+    getUserAnalyticsId.execute = jest.fn().mockReturnValue({ analyticsId: 3 })
+
+    analyticsStore = {} as jest.Mocked<AnalyticsStoreInterface>
+    analyticsStore.markActivity = jest.fn()
+
+    logger = {} as jest.Mocked<Logger>
+    logger.info = jest.fn()
+    logger.warn = jest.fn()
+  })
+
+  it('should mark subscription reactivated activity for analytics', async () => {
+    await createHandler().handle(event)
+
+    expect(analyticsStore.markActivity).toHaveBeenCalledWith(['subscription-reactivated'], 3, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+  })
+
+  it('should not do anything if no user is found for specified email', async () => {
+    userRepository.findOneByEmail = jest.fn().mockReturnValue(null)
+
+    await createHandler().handle(event)
+
+    expect(analyticsStore.markActivity).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,34 @@
+import { AnalyticsActivity, AnalyticsStoreInterface, Period } from '@standardnotes/analytics'
+import { DomainEventHandlerInterface, SubscriptionReactivatedEvent } from '@standardnotes/domain-events'
+import { inject, injectable } from 'inversify'
+import { Logger } from 'winston'
+
+import TYPES from '../../Bootstrap/Types'
+import { GetUserAnalyticsId } from '../UseCase/GetUserAnalyticsId/GetUserAnalyticsId'
+import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
+
+@injectable()
+export class SubscriptionReactivatedEventHandler implements DomainEventHandlerInterface {
+  constructor(
+    @inject(TYPES.UserRepository) private userRepository: UserRepositoryInterface,
+    @inject(TYPES.AnalyticsStore) private analyticsStore: AnalyticsStoreInterface,
+    @inject(TYPES.GetUserAnalyticsId) private getUserAnalyticsId: GetUserAnalyticsId,
+    @inject(TYPES.Logger) private logger: Logger,
+  ) {}
+
+  async handle(event: SubscriptionReactivatedEvent): Promise<void> {
+    const user = await this.userRepository.findOneByEmail(event.payload.userEmail)
+
+    if (user === null) {
+      this.logger.warn(`Could not find user with email: ${event.payload.userEmail}`)
+      return
+    }
+
+    const { analyticsId } = await this.getUserAnalyticsId.execute({ userUuid: user.uuid })
+    await this.analyticsStore.markActivity([AnalyticsActivity.SubscriptionReactivated], analyticsId, [
+      Period.Today,
+      Period.ThisWeek,
+      Period.ThisMonth,
+    ])
+  }
+}

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

@@ -37,7 +37,11 @@ export class SubscriptionRenewedEventHandler implements DomainEventHandlerInterf
         return
       }
 
-      await this.updateOfflineSubscriptionEndsAt(offlineUserSubscription, event.payload.timestamp)
+      await this.updateOfflineSubscriptionEndsAt(
+        offlineUserSubscription,
+        event.payload.subscriptionExpiresAt,
+        event.payload.timestamp,
+      )
 
       await this.roleService.setOfflineUserRole(offlineUserSubscription)
 
@@ -92,9 +96,10 @@ export class SubscriptionRenewedEventHandler implements DomainEventHandlerInterf
 
   private async updateOfflineSubscriptionEndsAt(
     offlineUserSubscription: OfflineUserSubscription,
+    subscriptionExpiresAt: number,
     timestamp: number,
   ): Promise<void> {
-    offlineUserSubscription.endsAt = timestamp
+    offlineUserSubscription.endsAt = subscriptionExpiresAt
     offlineUserSubscription.updatedAt = timestamp
 
     await this.offlineUserSubscriptionRepository.save(offlineUserSubscription)

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

@@ -8,6 +8,7 @@ import { DeleteAccount } from './DeleteAccount'
 import { UserSubscription } from '../../Subscription/UserSubscription'
 import { UserSubscriptionType } from '../../Subscription/UserSubscriptionType'
 import { UserSubscriptionServiceInterface } from '../../Subscription/UserSubscriptionServiceInterface'
+import { TimerInterface } from '@standardnotes/time'
 
 describe('DeleteAccount', () => {
   let userRepository: UserRepositoryInterface
@@ -16,9 +17,10 @@ describe('DeleteAccount', () => {
   let userSubscriptionService: UserSubscriptionServiceInterface
   let user: User
   let regularSubscription: UserSubscription
+  let timer: TimerInterface
 
   const createUseCase = () =>
-    new DeleteAccount(userRepository, userSubscriptionService, domainEventPublisher, domainEventFactory)
+    new DeleteAccount(userRepository, userSubscriptionService, domainEventPublisher, domainEventFactory, timer)
 
   beforeEach(() => {
     user = {
@@ -46,6 +48,9 @@ describe('DeleteAccount', () => {
     domainEventFactory.createAccountDeletionRequestedEvent = jest
       .fn()
       .mockReturnValue({} as jest.Mocked<AccountDeletionRequestedEvent>)
+
+    timer = {} as jest.Mocked<TimerInterface>
+    timer.convertDateToMicroseconds = jest.fn().mockReturnValue(1)
   })
 
   it('should trigger account deletion - no subscription', async () => {
@@ -62,6 +67,7 @@ describe('DeleteAccount', () => {
     expect(domainEventPublisher.publish).toHaveBeenCalledTimes(1)
     expect(domainEventFactory.createAccountDeletionRequestedEvent).toHaveBeenLastCalledWith({
       userUuid: '1-2-3',
+      userCreatedAtTimestamp: 1,
       regularSubscriptionUuid: undefined,
     })
   })
@@ -80,6 +86,7 @@ describe('DeleteAccount', () => {
     expect(domainEventPublisher.publish).toHaveBeenCalledTimes(1)
     expect(domainEventFactory.createAccountDeletionRequestedEvent).toHaveBeenLastCalledWith({
       userUuid: '1-2-3',
+      userCreatedAtTimestamp: 1,
       regularSubscriptionUuid: '1-2-3',
     })
   })

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

@@ -1,10 +1,13 @@
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
+import { TimerInterface } from '@standardnotes/time'
 import { inject, injectable } from 'inversify'
+
 import TYPES from '../../../Bootstrap/Types'
 import { DomainEventFactoryInterface } from '../../Event/DomainEventFactoryInterface'
 import { UserSubscriptionServiceInterface } from '../../Subscription/UserSubscriptionServiceInterface'
 import { UserRepositoryInterface } from '../../User/UserRepositoryInterface'
 import { UseCaseInterface } from '../UseCaseInterface'
+
 import { DeleteAccountDTO } from './DeleteAccountDTO'
 import { DeleteAccountResponse } from './DeleteAccountResponse'
 
@@ -15,6 +18,7 @@ export class DeleteAccount implements UseCaseInterface {
     @inject(TYPES.UserSubscriptionService) private userSubscriptionService: UserSubscriptionServiceInterface,
     @inject(TYPES.DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
     @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
+    @inject(TYPES.Timer) private timer: TimerInterface,
   ) {}
 
   async execute(dto: DeleteAccountDTO): Promise<DeleteAccountResponse> {
@@ -37,6 +41,7 @@ export class DeleteAccount implements UseCaseInterface {
     await this.domainEventPublisher.publish(
       this.domainEventFactory.createAccountDeletionRequestedEvent({
         userUuid: user.uuid,
+        userCreatedAtTimestamp: this.timer.convertDateToMicroseconds(user.createdAt),
         regularSubscriptionUuid,
       }),
     )

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

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

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

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

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

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

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

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

packages/auth/src/Infra/InversifyExpressUtils/InversifyExpressUserRequestsController.ts

@@ -0,0 +1,24 @@
+import { Request, Response } from 'express'
+import { inject } from 'inversify'
+import { controller, BaseHttpController, results, httpPost } from 'inversify-express-utils'
+
+import TYPES from '../../Bootstrap/Types'
+import { UserRequestsController } from '../../Controller/UserRequestsController'
+
+@controller('/users/:userUuid/requests')
+export class InversifyExpressUserRequestsController extends BaseHttpController {
+  constructor(@inject(TYPES.UserRequestsController) private userRequestsController: UserRequestsController) {
+    super()
+  }
+
+  @httpPost('/', TYPES.ApiGatewayAuthMiddleware)
+  async submitRequest(request: Request, response: Response): Promise<results.JsonResult> {
+    const result = await this.userRequestsController.submitUserRequest({
+      requestType: request.body.requestType,
+      userUuid: response.locals.user.uuid,
+      userEmail: response.locals.user.email,
+    })
+
+    return this.json(result.data, result.status)
+  }
+}

packages/common/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.44.0](https://github.com/standardnotes/server/compare/@standardnotes/common@1.43.0...@standardnotes/common@1.44.0) (2022-11-03)
+
+### Features
+
+* **common:** add subscription cancelled email message identifier ([0c5305a](https://github.com/standardnotes/server/commit/0c5305acf62aae047caedca25de25049c37f7653))
+
 # [1.43.0](https://github.com/standardnotes/server/compare/@standardnotes/common@1.42.0...@standardnotes/common@1.43.0) (2022-11-01)
 
 ### Features

packages/common/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/common",
-  "version": "1.43.0",
+  "version": "1.44.0",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },

packages/common/src/Domain/Email/EmailMessageIdentifier.ts

@@ -26,4 +26,5 @@ export enum EmailMessageIdentifier {
   RATE_ADJUSTMENT_NOTICE = 'RATE_ADJUSTMENT_NOTICE',
   WORKSPACE_INVITE_CREATED = 'WORKSPACE_INVITE_CREATED',
   EXIT_DISCOUNT = 'EXIT_DISCOUNT',
+  SUBSCRIPTION_CANCELLED = 'SUBSCRIPTION_CANCELLED',
 }

packages/domain-events-infra/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.9.8](https://github.com/standardnotes/server/compare/@standardnotes/domain-events-infra@1.9.7...@standardnotes/domain-events-infra@1.9.8) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/domain-events-infra
+
+## [1.9.7](https://github.com/standardnotes/server/compare/@standardnotes/domain-events-infra@1.9.6...@standardnotes/domain-events-infra@1.9.7) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/domain-events-infra
+
+## [1.9.6](https://github.com/standardnotes/server/compare/@standardnotes/domain-events-infra@1.9.5...@standardnotes/domain-events-infra@1.9.6) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/domain-events-infra
+
 ## [1.9.5](https://github.com/standardnotes/server/compare/@standardnotes/domain-events-infra@1.9.4...@standardnotes/domain-events-infra@1.9.5) (2022-11-02)
 
 **Note:** Version bump only for package @standardnotes/domain-events-infra

packages/domain-events-infra/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/domain-events-infra",
-  "version": "1.9.5",
+  "version": "1.9.8",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },

packages/domain-events/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.74.1](https://github.com/standardnotes/server/compare/@standardnotes/domain-events@2.74.0...@standardnotes/domain-events@2.74.1) (2022-11-04)
+
+### Bug Fixes
+
+* **auth:** add user created at timestamp to account deletion event ([7b05bf8](https://github.com/standardnotes/server/commit/7b05bf899152a2f36ce1fa851e8d5821c67840d7))
+
+# [2.74.0](https://github.com/standardnotes/server/compare/@standardnotes/domain-events@2.73.1...@standardnotes/domain-events@2.74.0) (2022-11-04)
+
+### Features
+
+* add analytics worker service ([d568432](https://github.com/standardnotes/server/commit/d5684326b1301855d0e07415195d4b246292f9a9))
+
+## [2.73.1](https://github.com/standardnotes/server/compare/@standardnotes/domain-events@2.73.0...@standardnotes/domain-events@2.73.1) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/domain-events
+
 # [2.73.0](https://github.com/standardnotes/server/compare/@standardnotes/domain-events@2.72.1...@standardnotes/domain-events@2.73.0) (2022-11-02)
 
 ### Features

packages/domain-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/domain-events",
-  "version": "2.73.0",
+  "version": "2.74.1",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },

packages/domain-events/src/Domain/Event/AccountDeletionRequestedEventPayload.ts

@@ -2,5 +2,6 @@ import { Uuid } from '@standardnotes/common'
 
 export interface AccountDeletionRequestedEventPayload {
   userUuid: string
+  userCreatedAtTimestamp: number
   regularSubscriptionUuid: Uuid | undefined
 }

packages/domain-events/src/Domain/Event/DomainEventService.ts

@@ -9,4 +9,5 @@ export enum DomainEventService {
   Files = 'files',
   Scheduler = 'scheduler',
   Workspace = 'workspace',
+  Analytics = 'analytics',
 }

packages/event-store/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.6.3](https://github.com/standardnotes/server/compare/@standardnotes/event-store@1.6.2...@standardnotes/event-store@1.6.3) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/event-store
+
+## [1.6.2](https://github.com/standardnotes/server/compare/@standardnotes/event-store@1.6.1...@standardnotes/event-store@1.6.2) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/event-store
+
+## [1.6.1](https://github.com/standardnotes/server/compare/@standardnotes/event-store@1.6.0...@standardnotes/event-store@1.6.1) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/event-store
+
+# [1.6.0](https://github.com/standardnotes/server/compare/@standardnotes/event-store@1.5.8...@standardnotes/event-store@1.6.0) (2022-11-03)
+
+### Features
+
+* **event-store:** add discount events to event store ([eb53c38](https://github.com/standardnotes/server/commit/eb53c3896f8c64747e30901722c0bdc63125128f))
+
+## [1.5.8](https://github.com/standardnotes/server/compare/@standardnotes/event-store@1.5.7...@standardnotes/event-store@1.5.8) (2022-11-02)
+
+**Note:** Version bump only for package @standardnotes/event-store
+
 ## [1.5.7](https://github.com/standardnotes/server/compare/@standardnotes/event-store@1.5.6...@standardnotes/event-store@1.5.7) (2022-11-02)
 
 **Note:** Version bump only for package @standardnotes/event-store

packages/event-store/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/event-store",
-  "version": "1.5.7",
+  "version": "1.6.3",
   "description": "Event Store Service",
   "private": true,
   "main": "dist/src/index.js",

packages/event-store/src/Bootstrap/Container.ts

@@ -82,12 +82,17 @@ export class ContainerConfigLoader {
       ['SUBSCRIPTION_REVERT_REQUESTED', container.get(TYPES.EventHandler)],
       ['REFUND_PROCESSED', container.get(TYPES.EventHandler)],
       ['ACCOUNT_RESET_REQUESTED', container.get(TYPES.EventHandler)],
+      ['DISCOUNT_APPLY_REQUESTED', container.get(TYPES.EventHandler)],
       ['DISCOUNT_APPLIED', container.get(TYPES.EventHandler)],
+      ['DISCOUNT_WITHDRAW_REQUESTED', container.get(TYPES.EventHandler)],
       ['SUBSCRIPTION_RATE_ADJUSTED', container.get(TYPES.EventHandler)],
       ['REFUND_REQUESTED', container.get(TYPES.EventHandler)],
       ['INVOICE_GENERATED', container.get(TYPES.EventHandler)],
       ['WORKSPACE_INVITE_CREATED', container.get(TYPES.EventHandler)],
       ['SUBSCRIPTION_REACTIVATED', container.get(TYPES.EventHandler)],
+      ['EXIT_DISCOUNT_APPLY_REQUESTED', container.get(TYPES.EventHandler)],
+      ['EXIT_DISCOUNT_APPLIED', container.get(TYPES.EventHandler)],
+      ['EXIT_DISCOUNT_WITHDRAW_REQUESTED', container.get(TYPES.EventHandler)],
     ])
 
     container

packages/files/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.8.3](https://github.com/standardnotes/files/compare/@standardnotes/files-server@1.8.2...@standardnotes/files-server@1.8.3) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/files-server
+
+## [1.8.2](https://github.com/standardnotes/files/compare/@standardnotes/files-server@1.8.1...@standardnotes/files-server@1.8.2) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/files-server
+
+## [1.8.1](https://github.com/standardnotes/files/compare/@standardnotes/files-server@1.8.0...@standardnotes/files-server@1.8.1) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/files-server
+
+# [1.8.0](https://github.com/standardnotes/files/compare/@standardnotes/files-server@1.7.5...@standardnotes/files-server@1.8.0) (2022-11-02)
+
+### Features
+
+* **auth:** add processing user requests ([2255f85](https://github.com/standardnotes/files/commit/2255f856f928e855ac94f8aca4e1fb81047f58f7))
+
 ## [1.7.5](https://github.com/standardnotes/files/compare/@standardnotes/files-server@1.7.4...@standardnotes/files-server@1.7.5) (2022-11-02)
 
 **Note:** Version bump only for package @standardnotes/files-server

packages/files/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/files-server",
-  "version": "1.7.5",
+  "version": "1.8.3",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -36,7 +36,7 @@
     "aws-sdk": "^2.1158.0",
     "connect-busboy": "^1.0.0",
     "cors": "^2.8.5",
-    "dayjs": "^1.11.3",
+    "dayjs": "^1.11.6",
     "dotenv": "^16.0.1",
     "express": "^4.18.1",
     "express-winston": "^4.0.5",

packages/predicates/CHANGELOG.md

@@ -3,6 +3,10 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.5.3](https://github.com/standardnotes/server/compare/@standardnotes/predicates@1.5.2...@standardnotes/predicates@1.5.3) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/predicates
+
 ## [1.5.2](https://github.com/standardnotes/server/compare/@standardnotes/predicates@1.5.1...@standardnotes/predicates@1.5.2) (2022-11-01)
 
 **Note:** Version bump only for package @standardnotes/predicates

packages/predicates/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/predicates",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },

packages/scheduler/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.13.4](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.13.3...@standardnotes/scheduler-server@1.13.4) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/scheduler-server
+
+## [1.13.3](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.13.2...@standardnotes/scheduler-server@1.13.3) (2022-11-04)
+
+**Note:** Version bump only for package @standardnotes/scheduler-server
+
+## [1.13.2](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.13.1...@standardnotes/scheduler-server@1.13.2) (2022-11-03)
+
+### Bug Fixes
+
+* **scheduler:** specs ([dcb20e6](https://github.com/standardnotes/server/commit/dcb20e6ea612d8ca2e169e12e33c268855517962))
+
+## [1.13.1](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.13.0...@standardnotes/scheduler-server@1.13.1) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/scheduler-server
+
+# [1.13.0](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.12.0...@standardnotes/scheduler-server@1.13.0) (2022-11-03)
+
+### Features
+
+* **scheduler:** add publishing exit discount withdraw requested event ([d66f784](https://github.com/standardnotes/server/commit/d66f78453820c8a97d090f858d9a4fc2557773fa))
+
+# [1.12.0](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.11.7...@standardnotes/scheduler-server@1.12.0) (2022-11-02)
+
+### Features
+
+* **auth:** add processing user requests ([2255f85](https://github.com/standardnotes/server/commit/2255f856f928e855ac94f8aca4e1fb81047f58f7))
+
 ## [1.11.7](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.11.6...@standardnotes/scheduler-server@1.11.7) (2022-11-02)
 
 **Note:** Version bump only for package @standardnotes/scheduler-server

packages/scheduler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/scheduler-server",
-  "version": "1.11.7",
+  "version": "1.13.4",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -32,7 +32,7 @@
     "@standardnotes/predicates": "workspace:*",
     "@standardnotes/time": "workspace:*",
     "aws-sdk": "^2.1158.0",
-    "dayjs": "^1.11.3",
+    "dayjs": "^1.11.6",
     "dotenv": "^16.0.1",
     "inversify": "^6.0.1",
     "ioredis": "^5.2.0",

packages/scheduler/src/Bootstrap/Container.ts

@@ -36,6 +36,7 @@ import { PredicateVerifiedEventHandler } from '../Domain/Handler/PredicateVerifi
 import { VerifyPredicates } from '../Domain/UseCase/VerifyPredicates/VerifyPredicates'
 import { UserRegisteredEventHandler } from '../Domain/Handler/UserRegisteredEventHandler'
 import { SubscriptionCancelledEventHandler } from '../Domain/Handler/SubscriptionCancelledEventHandler'
+import { ExitDiscountAppliedEventHandler } from '../Domain/Handler/ExitDiscountAppliedEventHandler'
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const newrelicFormatter = require('@newrelic/winston-enricher')
@@ -124,6 +125,9 @@ export class ContainerConfigLoader {
     container
       .bind<SubscriptionCancelledEventHandler>(TYPES.SubscriptionCancelledEventHandler)
       .to(SubscriptionCancelledEventHandler)
+    container
+      .bind<ExitDiscountAppliedEventHandler>(TYPES.ExitDiscountAppliedEventHandler)
+      .to(ExitDiscountAppliedEventHandler)
 
     // Services
     container.bind<DomainEventFactory>(TYPES.DomainEventFactory).to(DomainEventFactory)
@@ -146,6 +150,7 @@ export class ContainerConfigLoader {
       ['PREDICATE_VERIFIED', container.get(TYPES.PredicateVerifiedEventHandler)],
       ['USER_REGISTERED', container.get(TYPES.UserRegisteredEventHandler)],
       ['SUBSCRIPTION_CANCELLED', container.get(TYPES.SubscriptionCancelledEventHandler)],
+      ['EXIT_DISCOUNT_APPLIED', container.get(TYPES.ExitDiscountAppliedEventHandler)],
     ])
 
     if (env.get('SQS_QUEUE_URL', true)) {

packages/scheduler/src/Bootstrap/Types.ts

@@ -24,6 +24,7 @@ const TYPES = {
   PredicateVerifiedEventHandler: Symbol.for('PredicateVerifiedEventHandler'),
   UserRegisteredEventHandler: Symbol.for('UserRegisteredEventHandler'),
   SubscriptionCancelledEventHandler: Symbol.for('SubscriptionCancelledEventHandler'),
+  ExitDiscountAppliedEventHandler: Symbol.for('ExitDiscountAppliedEventHandler'),
   // Services
   DomainEventPublisher: Symbol.for('DomainEventPublisher'),
   DomainEventSubscriberFactory: Symbol.for('DomainEventSubscriberFactory'),

packages/scheduler/src/Domain/Event/DomainEventFactory.spec.ts

@@ -65,6 +65,29 @@ describe('DomainEventFactory', () => {
     })
   })
 
+  it('should create a EXIT_DISCOUNT_WITHDRAW_REQUESTED event', () => {
+    expect(
+      createFactory().createExitDiscountWithdrawRequestedEvent({
+        userEmail: 'test@test.te',
+        discountCode: 'exit-20',
+      }),
+    ).toEqual({
+      createdAt: expect.any(Date),
+      meta: {
+        correlation: {
+          userIdentifier: 'test@test.te',
+          userIdentifierType: 'email',
+        },
+        origin: 'scheduler',
+      },
+      payload: {
+        userEmail: 'test@test.te',
+        discountCode: 'exit-20',
+      },
+      type: 'EXIT_DISCOUNT_WITHDRAW_REQUESTED',
+    })
+  })
+
   it('should create a EMAIL_MESSAGE_REQUESTED event', () => {
     expect(
       createFactory().createEmailMessageRequestedEvent({

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

@@ -4,6 +4,7 @@ import {
   DiscountWithdrawRequestedEvent,
   DomainEventService,
   EmailMessageRequestedEvent,
+  ExitDiscountWithdrawRequestedEvent,
   PredicateVerificationRequestedEvent,
 } from '@standardnotes/domain-events'
 import { PredicateAuthority } from '@standardnotes/predicates'
@@ -51,6 +52,24 @@ export class DomainEventFactory implements DomainEventFactoryInterface {
     }
   }
 
+  createExitDiscountWithdrawRequestedEvent(dto: {
+    userEmail: string
+    discountCode: string
+  }): ExitDiscountWithdrawRequestedEvent {
+    return {
+      type: 'EXIT_DISCOUNT_WITHDRAW_REQUESTED',
+      createdAt: this.timer.getUTCDate(),
+      meta: {
+        correlation: {
+          userIdentifier: dto.userEmail,
+          userIdentifierType: 'email',
+        },
+        origin: DomainEventService.Scheduler,
+      },
+      payload: dto,
+    }
+  }
+
   createEmailMessageRequestedEvent(dto: {
     userEmail: string
     messageIdentifier: EmailMessageIdentifier

packages/scheduler/src/Domain/Event/DomainEventFactoryInterface.ts

@@ -3,6 +3,7 @@ import {
   DiscountApplyRequestedEvent,
   DiscountWithdrawRequestedEvent,
   EmailMessageRequestedEvent,
+  ExitDiscountWithdrawRequestedEvent,
   PredicateVerificationRequestedEvent,
 } from '@standardnotes/domain-events'
 
@@ -18,4 +19,8 @@ export interface DomainEventFactoryInterface {
   }): EmailMessageRequestedEvent
   createDiscountApplyRequestedEvent(dto: { userEmail: string; discountCode: string }): DiscountApplyRequestedEvent
   createDiscountWithdrawRequestedEvent(dto: { userEmail: string; discountCode: string }): DiscountWithdrawRequestedEvent
+  createExitDiscountWithdrawRequestedEvent(dto: {
+    userEmail: string
+    discountCode: string
+  }): ExitDiscountWithdrawRequestedEvent
 }

packages/scheduler/src/Domain/Handler/ExitDiscountAppliedEventHandler.spec.ts

@@ -0,0 +1,40 @@
+import 'reflect-metadata'
+
+import { ExitDiscountAppliedEvent } from '@standardnotes/domain-events'
+import { TimerInterface } from '@standardnotes/time'
+
+import { JobRepositoryInterface } from '../Job/JobRepositoryInterface'
+
+import { ExitDiscountAppliedEventHandler } from './ExitDiscountAppliedEventHandler'
+
+describe('ExitDiscountAppliedEventHandler', () => {
+  let timer: TimerInterface
+  let jobRepository: JobRepositoryInterface
+
+  const createHandler = () => new ExitDiscountAppliedEventHandler(timer, jobRepository)
+
+  beforeEach(() => {
+    timer = {} as jest.Mocked<TimerInterface>
+    timer.getUTCDateNHoursAhead = jest.fn().mockReturnValue(new Date(2))
+    timer.convertDateToMicroseconds = jest.fn().mockReturnValue(123)
+    timer.getTimestampInMicroseconds = jest.fn().mockReturnValue(1)
+
+    jobRepository = {} as jest.Mocked<JobRepositoryInterface>
+    jobRepository.save = jest.fn()
+  })
+
+  it('should schedule a job to do an exit discount withdrawal', async () => {
+    await createHandler().handle({
+      payload: { userEmail: 'test@test.te', discountRate: 20 },
+    } as jest.Mocked<ExitDiscountAppliedEvent>)
+
+    expect(jobRepository.save).toHaveBeenNthCalledWith(1, {
+      createdAt: 1,
+      name: 'withdraw-subscription-exit-discount',
+      scheduledAt: 123,
+      status: 'pending',
+      userIdentifier: 'test@test.te',
+      userIdentifierType: 'email',
+    })
+  })
+})

packages/scheduler/src/Domain/Handler/ExitDiscountAppliedEventHandler.ts

@@ -0,0 +1,33 @@
+import { DomainEventHandlerInterface, ExitDiscountAppliedEvent } from '@standardnotes/domain-events'
+import { inject, injectable } from 'inversify'
+import { TimerInterface } from '@standardnotes/time'
+
+import TYPES from '../../Bootstrap/Types'
+import { Job } from '../Job/Job'
+import { JobName } from '../Job/JobName'
+import { JobRepositoryInterface } from '../Job/JobRepositoryInterface'
+import { JobStatus } from '../Job/JobStatus'
+
+@injectable()
+export class ExitDiscountAppliedEventHandler implements DomainEventHandlerInterface {
+  constructor(
+    @inject(TYPES.Timer) private timer: TimerInterface,
+    @inject(TYPES.JobRepository) private jobRepository: JobRepositoryInterface,
+  ) {}
+
+  async handle(event: ExitDiscountAppliedEvent): Promise<void> {
+    await this.scheduleExitDiscountWithdraw(event)
+  }
+
+  private async scheduleExitDiscountWithdraw(event: ExitDiscountAppliedEvent): Promise<void> {
+    const job = new Job()
+    job.name = JobName.WITHDRAW_SUBSCRIPTION_EXIT_DISCOUNT
+    job.scheduledAt = this.timer.convertDateToMicroseconds(this.timer.getUTCDateNHoursAhead(24))
+    job.createdAt = this.timer.getTimestampInMicroseconds()
+    job.status = JobStatus.Pending
+    job.userIdentifier = event.payload.userEmail
+    job.userIdentifierType = 'email'
+
+    await this.jobRepository.save(job)
+  }
+}

packages/scheduler/src/Domain/Job/JobDoneInterpreter.spec.ts

@@ -3,6 +3,7 @@ import {
   DiscountWithdrawRequestedEvent,
   DomainEventPublisherInterface,
   EmailMessageRequestedEvent,
+  ExitDiscountWithdrawRequestedEvent,
 } from '@standardnotes/domain-events'
 import { PredicateName } from '@standardnotes/predicates'
 import 'reflect-metadata'
@@ -48,6 +49,9 @@ describe('JobDoneInterpreter', () => {
     domainEventFactory.createDiscountWithdrawRequestedEvent = jest
       .fn()
       .mockReturnValue({} as jest.Mocked<DiscountWithdrawRequestedEvent>)
+    domainEventFactory.createExitDiscountWithdrawRequestedEvent = jest
+      .fn()
+      .mockReturnValue({} as jest.Mocked<ExitDiscountWithdrawRequestedEvent>)
 
     domainEventPublisher = {} as jest.Mocked<DomainEventPublisherInterface>
     domainEventPublisher.publish = jest.fn()
@@ -253,6 +257,35 @@ describe('JobDoneInterpreter', () => {
     expect(domainEventPublisher.publish).not.toHaveBeenCalled()
   })
 
+  it('should request exit discount withdraw', async () => {
+    jobRepository.findOneByUuid = jest.fn().mockReturnValue({
+      name: JobName.WITHDRAW_SUBSCRIPTION_EXIT_DISCOUNT,
+      userIdentifier: 'test@standardnotes.com',
+      userIdentifierType: 'email',
+    } as jest.Mocked<Job>)
+
+    await createInterpreter().interpret('1-2-3')
+
+    expect(domainEventFactory.createExitDiscountWithdrawRequestedEvent).toHaveBeenCalledWith({
+      userEmail: 'test@standardnotes.com',
+      discountCode: 'exit-20',
+    })
+    expect(domainEventPublisher.publish).toHaveBeenCalled()
+  })
+
+  it('should not request exit discount withdraw if email is missing', async () => {
+    jobRepository.findOneByUuid = jest.fn().mockReturnValue({
+      name: JobName.WITHDRAW_SUBSCRIPTION_EXIT_DISCOUNT,
+      userIdentifier: '2-3-4',
+      userIdentifierType: 'uuid',
+    } as jest.Mocked<Job>)
+
+    await createInterpreter().interpret('1-2-3')
+
+    expect(domainEventFactory.createExitDiscountWithdrawRequestedEvent).not.toHaveBeenCalled()
+    expect(domainEventPublisher.publish).not.toHaveBeenCalled()
+  })
+
   it('should do nothing if there is no interpretation for a given job', async () => {
     jobRepository.findOneByUuid = jest.fn().mockReturnValue({
       name: 'foobar' as JobName,

packages/scheduler/src/Domain/Job/JobDoneInterpreter.ts

@@ -65,6 +65,11 @@ export class JobDoneInterpreter implements JobDoneInterpreterInterface {
           await this.requestDiscountWithdraw(job)
         }
         return
+      case JobName.WITHDRAW_SUBSCRIPTION_EXIT_DISCOUNT:
+        if (job.userIdentifierType === 'email') {
+          await this.requestExitDiscountWithdraw(job)
+        }
+        return
       default:
         this.logger.warn(`[${jobUuid}]${job.name}: job is not interpretable.`)
 
@@ -132,6 +137,17 @@ export class JobDoneInterpreter implements JobDoneInterpreterInterface {
     )
   }
 
+  private async requestExitDiscountWithdraw(job: Job): Promise<void> {
+    this.logger.debug(`[${job.uuid}]${job.name}: requesting exit discount withdraw.`)
+
+    await this.domainEventPublisher.publish(
+      this.domainEventFactory.createExitDiscountWithdrawRequestedEvent({
+        userEmail: job.userIdentifier,
+        discountCode: 'exit-20',
+      }),
+    )
+  }
+
   private async predicatesAreFulfilled(job: Job): Promise<boolean> {
     const predicates = await this.predicateRepository.findByJobUuid(job.uuid)
 

packages/scheduler/src/Domain/Job/JobName.ts

@@ -5,4 +5,5 @@ export enum JobName {
   EXIT_INTERVIEW = 'exit-interview',
   APPLY_SUBSCRIPTION_DISCOUNT = 'apply-subscription-discount',
   WITHDRAW_SUBSCRIPTION_DISCOUNT = 'withdraw-subscription-discount',
+  WITHDRAW_SUBSCRIPTION_EXIT_DISCOUNT = 'withdraw-subscription-exit-discount',
 }

packages/security/CHANGELOG.md

@@ -3,6 +3,10 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.5.3](https://github.com/standardnotes/server/compare/@standardnotes/security@1.5.2...@standardnotes/security@1.5.3) (2022-11-03)
+
+**Note:** Version bump only for package @standardnotes/security
+
 ## [1.5.2](https://github.com/standardnotes/server/compare/@standardnotes/security@1.5.1...@standardnotes/security@1.5.2) (2022-11-01)
 
 **Note:** Version bump only for package @standardnotes/security

packages/security/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/security",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },