wip

- @standardnotes/syncing-server@1.25.4

.github/workflows/common-server-application.yml

@@ -187,7 +187,7 @@ jobs:
         tags: standardnotes/${{ inputs.service_name }}:${{ github.sha }}
 
     - name: Run E2E test suite
-      uses: convictional/trigger-workflow-and-wait@v1.6.3
+      uses: convictional/trigger-workflow-and-wait@master
       with:
         owner: standardnotes
         repo: e2e

.pnp.cjs

@@ -66,7 +66,7 @@ const RAW_RUNTIME_STATE =
       "reference": "workspace:packages/security"\
     },\
     {\
-      "name": "@standardnotes/settings",\
+      "name": "@standardnotes/settings-server",\
       "reference": "workspace:packages/settings"\
     },\
     {\
@@ -107,7 +107,7 @@ const RAW_RUNTIME_STATE =
     ["@standardnotes/scheduler-server", ["workspace:packages/scheduler"]],\
     ["@standardnotes/security", ["workspace:packages/security"]],\
     ["@standardnotes/server-monorepo", ["workspace:."]],\
-    ["@standardnotes/settings", ["workspace:packages/settings"]],\
+    ["@standardnotes/settings-server", ["workspace:packages/settings"]],\
     ["@standardnotes/sncrypto-node", ["workspace:packages/sncrypto-node"]],\
     ["@standardnotes/syncing-server", ["workspace:packages/syncing-server"]],\
     ["@standardnotes/time", ["workspace:packages/time"]],\
@@ -2582,6 +2582,20 @@ const RAW_RUNTIME_STATE =
           ["reflect-metadata", "npm:0.1.13"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:1.20.13", {\
+        "packageLocation": "./.yarn/cache/@standardnotes-api-npm-1.20.13-3efe52d749-67bdb982ec.zip/node_modules/@standardnotes/api/",\
+        "packageDependencies": [\
+          ["@standardnotes/api", "npm:1.20.13"],\
+          ["@standardnotes/common", "workspace:packages/common"],\
+          ["@standardnotes/encryption", "npm:1.19.21"],\
+          ["@standardnotes/models", "npm:1.38.0"],\
+          ["@standardnotes/responses", "npm:1.12.9"],\
+          ["@standardnotes/security", "workspace:packages/security"],\
+          ["@standardnotes/utils", "npm:1.13.0"],\
+          ["reflect-metadata", "npm:0.1.13"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["@standardnotes/api-gateway", [\
@@ -2656,7 +2670,6 @@ const RAW_RUNTIME_STATE =
           ["@standardnotes/predicates", "workspace:packages/predicates"],\
           ["@standardnotes/responses", "npm:1.11.1"],\
           ["@standardnotes/security", "workspace:packages/security"],\
-          ["@standardnotes/settings", "workspace:packages/settings"],\
           ["@standardnotes/sncrypto-common", "npm:1.13.0"],\
           ["@standardnotes/sncrypto-node", "workspace:packages/sncrypto-node"],\
           ["@standardnotes/time", "workspace:packages/time"],\
@@ -2812,6 +2825,19 @@ const RAW_RUNTIME_STATE =
           ["reflect-metadata", "npm:0.1.13"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:1.19.21", {\
+        "packageLocation": "./.yarn/cache/@standardnotes-encryption-npm-1.19.21-dfa10f00e6-c8c2c27bfe.zip/node_modules/@standardnotes/encryption/",\
+        "packageDependencies": [\
+          ["@standardnotes/encryption", "npm:1.19.21"],\
+          ["@standardnotes/common", "workspace:packages/common"],\
+          ["@standardnotes/models", "npm:1.38.0"],\
+          ["@standardnotes/responses", "npm:1.12.9"],\
+          ["@standardnotes/sncrypto-common", "npm:1.13.3"],\
+          ["@standardnotes/utils", "npm:1.13.0"],\
+          ["reflect-metadata", "npm:0.1.13"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["@standardnotes/event-store", [\
@@ -2867,6 +2893,17 @@ const RAW_RUNTIME_STATE =
           ["reflect-metadata", "npm:0.1.13"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:1.55.3", {\
+        "packageLocation": "./.yarn/cache/@standardnotes-features-npm-1.55.3-c124505183-b39fe2d49b.zip/node_modules/@standardnotes/features/",\
+        "packageDependencies": [\
+          ["@standardnotes/features", "npm:1.55.3"],\
+          ["@standardnotes/auth", "npm:3.19.4"],\
+          ["@standardnotes/common", "workspace:packages/common"],\
+          ["@standardnotes/security", "workspace:packages/security"],\
+          ["reflect-metadata", "npm:0.1.13"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["@standardnotes/files-server", [\
@@ -2948,6 +2985,13 @@ const RAW_RUNTIME_STATE =
           ["reflect-metadata", "npm:0.1.13"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:1.38.0", {\
+        "packageLocation": "./.yarn/cache/@standardnotes-models-npm-1.38.0-108f602f56-2dc2ac957e.zip/node_modules/@standardnotes/models/",\
+        "packageDependencies": [\
+          ["@standardnotes/models", "npm:1.38.0"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["@standardnotes/payloads", [\
@@ -3001,6 +3045,17 @@ const RAW_RUNTIME_STATE =
           ["reflect-metadata", "npm:0.1.13"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:1.12.9", {\
+        "packageLocation": "./.yarn/cache/@standardnotes-responses-npm-1.12.9-280dc75972-353fe1ca6d.zip/node_modules/@standardnotes/responses/",\
+        "packageDependencies": [\
+          ["@standardnotes/responses", "npm:1.12.9"],\
+          ["@standardnotes/common", "workspace:packages/common"],\
+          ["@standardnotes/features", "npm:1.55.3"],\
+          ["@standardnotes/security", "workspace:packages/security"],\
+          ["reflect-metadata", "npm:0.1.13"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["@standardnotes/revisions-server", [\
@@ -3056,6 +3111,7 @@ const RAW_RUNTIME_STATE =
           ["@newrelic/winston-enricher", "virtual:c66bf20e88479ada0172094776519a9f51acc4731d22079b60a295bcec7ea42d5545cbce58a77a50d932bf953298799135e99707486e343da6d99ba1d167bdbd#npm:4.0.0"],\
           ["@sentry/node", "npm:7.19.0"],\
           ["@standardnotes/common", "workspace:packages/common"],\
+          ["@standardnotes/domain-core", "workspace:packages/domain-core"],\
           ["@standardnotes/domain-events", "workspace:packages/domain-events"],\
           ["@standardnotes/domain-events-infra", "workspace:packages/domain-events-infra"],\
           ["@standardnotes/predicates", "workspace:packages/predicates"],\
@@ -3131,15 +3187,46 @@ const RAW_RUNTIME_STATE =
         "linkType": "SOFT"\
       }]\
     ]],\
-    ["@standardnotes/settings", [\
+    ["@standardnotes/settings-server", [\
       ["workspace:packages/settings", {\
         "packageLocation": "./packages/settings/",\
         "packageDependencies": [\
-          ["@standardnotes/settings", "workspace:packages/settings"],\
-          ["@typescript-eslint/eslint-plugin", "virtual:fd909b174d079e30b336c4ce72c38a88c1e447767b1a8dd7655e07719a1e31b97807f0931368724fc78897ff15e6a6d00b83316c0f76d11f85111f342e08bb79#npm:5.30.5"],\
-          ["eslint-plugin-prettier", "virtual:fd909b174d079e30b336c4ce72c38a88c1e447767b1a8dd7655e07719a1e31b97807f0931368724fc78897ff15e6a6d00b83316c0f76d11f85111f342e08bb79#npm:4.2.1"],\
+          ["@standardnotes/settings-server", "workspace:packages/settings"],\
+          ["@newrelic/winston-enricher", "virtual:c66bf20e88479ada0172094776519a9f51acc4731d22079b60a295bcec7ea42d5545cbce58a77a50d932bf953298799135e99707486e343da6d99ba1d167bdbd#npm:4.0.0"],\
+          ["@sentry/node", "npm:7.19.0"],\
+          ["@standardnotes/api", "npm:1.20.13"],\
+          ["@standardnotes/domain-core", "workspace:packages/domain-core"],\
+          ["@standardnotes/domain-events", "workspace:packages/domain-events"],\
+          ["@standardnotes/domain-events-infra", "workspace:packages/domain-events-infra"],\
+          ["@standardnotes/security", "workspace:packages/security"],\
+          ["@standardnotes/time", "workspace:packages/time"],\
+          ["@types/cors", "npm:2.8.12"],\
+          ["@types/dotenv", "npm:8.2.0"],\
+          ["@types/express", "npm:4.17.14"],\
+          ["@types/inversify-express-utils", "npm:2.0.0"],\
+          ["@types/ioredis", "npm:5.0.0"],\
+          ["@types/jest", "npm:29.1.1"],\
+          ["@types/newrelic", "npm:7.0.4"],\
+          ["@typescript-eslint/eslint-plugin", "virtual:04783e12400851b8a3d76e71495851cc94959db6e62f04cb0a31190080629440b182d8c8eb4d7f2b04e281912f2783a5fd4d2c3c6ab68d38b7097246c93f4c19#npm:5.40.1"],\
+          ["aws-sdk", "npm:2.1260.0"],\
+          ["cors", "npm:2.8.5"],\
+          ["dotenv", "npm:16.0.1"],\
+          ["eslint", "npm:8.25.0"],\
+          ["eslint-plugin-prettier", "virtual:c66bf20e88479ada0172094776519a9f51acc4731d22079b60a295bcec7ea42d5545cbce58a77a50d932bf953298799135e99707486e343da6d99ba1d167bdbd#npm:4.2.1"],\
+          ["express", "npm:4.18.2"],\
+          ["helmet", "npm:6.0.0"],\
+          ["inversify", "npm:6.0.1"],\
+          ["inversify-express-utils", "npm:6.4.3"],\
+          ["ioredis", "npm:5.2.4"],\
+          ["jest", "virtual:fd909b174d079e30b336c4ce72c38a88c1e447767b1a8dd7655e07719a1e31b97807f0931368724fc78897ff15e6a6d00b83316c0f76d11f85111f342e08bb79#npm:29.1.2"],\
+          ["mysql2", "npm:2.3.3"],\
+          ["newrelic", "npm:9.6.0"],\
+          ["npm-check-updates", "npm:16.0.1"],\
           ["reflect-metadata", "npm:0.1.13"],\
-          ["typescript", "patch:typescript@npm%3A4.8.4#optional!builtin<compat/typescript>::version=4.8.4&hash=701156"]\
+          ["ts-jest", "virtual:fd909b174d079e30b336c4ce72c38a88c1e447767b1a8dd7655e07719a1e31b97807f0931368724fc78897ff15e6a6d00b83316c0f76d11f85111f342e08bb79#npm:29.0.3"],\
+          ["typeorm", "virtual:c66bf20e88479ada0172094776519a9f51acc4731d22079b60a295bcec7ea42d5545cbce58a77a50d932bf953298799135e99707486e343da6d99ba1d167bdbd#npm:0.3.10"],\
+          ["typescript", "patch:typescript@npm%3A4.8.4#optional!builtin<compat/typescript>::version=4.8.4&hash=701156"],\
+          ["winston", "npm:3.8.2"]\
         ],\
         "linkType": "SOFT"\
       }]\
@@ -3152,6 +3239,14 @@ const RAW_RUNTIME_STATE =
           ["reflect-metadata", "npm:0.1.13"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:1.13.3", {\
+        "packageLocation": "./.yarn/cache/@standardnotes-sncrypto-common-npm-1.13.3-97ef3850ce-a73af90962.zip/node_modules/@standardnotes/sncrypto-common/",\
+        "packageDependencies": [\
+          ["@standardnotes/sncrypto-common", "npm:1.13.3"],\
+          ["reflect-metadata", "npm:0.1.13"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["@standardnotes/sncrypto-node", [\
@@ -3188,7 +3283,6 @@ const RAW_RUNTIME_STATE =
           ["@standardnotes/payloads", "npm:1.5.1"],\
           ["@standardnotes/responses", "npm:1.11.1"],\
           ["@standardnotes/security", "workspace:packages/security"],\
-          ["@standardnotes/settings", "workspace:packages/settings"],\
           ["@standardnotes/time", "workspace:packages/time"],\
           ["@types/cors", "npm:2.8.12"],\
           ["@types/dotenv", "npm:8.2.0"],\
@@ -3272,6 +3366,17 @@ const RAW_RUNTIME_STATE =
           ["reflect-metadata", "npm:0.1.13"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:1.13.0", {\
+        "packageLocation": "./.yarn/cache/@standardnotes-utils-npm-1.13.0-28780a59f0-1578e8adb7.zip/node_modules/@standardnotes/utils/",\
+        "packageDependencies": [\
+          ["@standardnotes/utils", "npm:1.13.0"],\
+          ["@standardnotes/common", "workspace:packages/common"],\
+          ["dompurify", "npm:2.4.1"],\
+          ["lodash", "npm:4.17.21"],\
+          ["reflect-metadata", "npm:0.1.13"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["@standardnotes/websockets-server", [\
@@ -3323,6 +3428,7 @@ const RAW_RUNTIME_STATE =
           ["@sentry/node", "npm:7.19.0"],\
           ["@standardnotes/api", "npm:1.19.0"],\
           ["@standardnotes/common", "workspace:packages/common"],\
+          ["@standardnotes/domain-core", "workspace:packages/domain-core"],\
           ["@standardnotes/domain-events", "workspace:packages/domain-events"],\
           ["@standardnotes/domain-events-infra", "workspace:packages/domain-events-infra"],\
           ["@standardnotes/models", "npm:1.28.0"],\
@@ -6369,6 +6475,13 @@ const RAW_RUNTIME_STATE =
           ["dompurify", "npm:2.4.0"]\
         ],\
         "linkType": "HARD"\
+      }],\
+      ["npm:2.4.1", {\
+        "packageLocation": "./.yarn/cache/dompurify-npm-2.4.1-1c79f22057-ddc0633356.zip/node_modules/dompurify/",\
+        "packageDependencies": [\
+          ["dompurify", "npm:2.4.1"]\
+        ],\
+        "linkType": "HARD"\
       }]\
     ]],\
     ["dot-prop", [\

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 120,
+  "semi": false
+}

packages/analytics/CHANGELOG.md

@@ -3,6 +3,100 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.12.25](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.24...@standardnotes/analytics@2.12.25) (2022-12-12)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.24](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.23...@standardnotes/analytics@2.12.24) (2022-12-12)
+
+### Bug Fixes
+
+* **analytics:** daily analytics report template ([41906ec](https://github.com/standardnotes/server/commit/41906ec2f9fd4d605b1c002826173e14fb534e00))
+
+## [2.12.23](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.22...@standardnotes/analytics@2.12.23) (2022-12-12)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.22](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.21...@standardnotes/analytics@2.12.22) (2022-12-12)
+
+### Bug Fixes
+
+* **analytics:** report event publishing ([a605660](https://github.com/standardnotes/server/commit/a6056600eb96bf175189ad6d62870c9d736f331b))
+
+## [2.12.21](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.20...@standardnotes/analytics@2.12.21) (2022-12-12)
+
+### Bug Fixes
+
+* **analytics:** add debug logs for report ([48c0cb5](https://github.com/standardnotes/server/commit/48c0cb5e62dc8af930de191deaa1eb3ff6c5a29f))
+
+## [2.12.20](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.19...@standardnotes/analytics@2.12.20) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.19](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.18...@standardnotes/analytics@2.12.19) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.18](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.17...@standardnotes/analytics@2.12.18) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.17](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.16...@standardnotes/analytics@2.12.17) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.16](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.15...@standardnotes/analytics@2.12.16) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.15](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.14...@standardnotes/analytics@2.12.15) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.14](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.13...@standardnotes/analytics@2.12.14) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.13](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.12...@standardnotes/analytics@2.12.13) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.12](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.11...@standardnotes/analytics@2.12.12) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.11](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.10...@standardnotes/analytics@2.12.11) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.10](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.9...@standardnotes/analytics@2.12.10) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.9](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.8...@standardnotes/analytics@2.12.9) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.8](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.7...@standardnotes/analytics@2.12.8) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.7](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.6...@standardnotes/analytics@2.12.7) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.6](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.5...@standardnotes/analytics@2.12.6) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.5](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.4...@standardnotes/analytics@2.12.5) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
+## [2.12.4](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.3...@standardnotes/analytics@2.12.4) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/analytics
+
 ## [2.12.3](https://github.com/standardnotes/server/compare/@standardnotes/analytics@2.12.2...@standardnotes/analytics@2.12.3) (2022-12-06)
 
 **Note:** Version bump only for package @standardnotes/analytics

packages/analytics/bin/report.ts

@@ -4,6 +4,7 @@ import 'newrelic'
 
 import { Logger } from 'winston'
 
+import { EmailLevel } from '@standardnotes/domain-core'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
 import { AnalyticsActivity } from '../src/Domain/Analytics/AnalyticsActivity'
 import { Period } from '../src/Domain/Time/Period'
@@ -16,6 +17,8 @@ import TYPES from '../src/Bootstrap/Types'
 import { Env } from '../src/Bootstrap/Env'
 import { DomainEventFactoryInterface } from '../src/Domain/Event/DomainEventFactoryInterface'
 import { CalculateMonthlyRecurringRevenue } from '../src/Domain/UseCase/CalculateMonthlyRecurringRevenue/CalculateMonthlyRecurringRevenue'
+import { getBody, getSubject } from '../src/Domain/Email/DailyAnalyticsReport'
+import { TimerInterface } from '@standardnotes/time'
 
 const requestReport = async (
   analyticsStore: AnalyticsStoreInterface,
@@ -24,6 +27,8 @@ const requestReport = async (
   domainEventPublisher: DomainEventPublisherInterface,
   periodKeyGenerator: PeriodKeyGeneratorInterface,
   calculateMonthlyRecurringRevenue: CalculateMonthlyRecurringRevenue,
+  timer: TimerInterface,
+  adminEmails: string[],
 ): Promise<void> => {
   await calculateMonthlyRecurringRevenue.execute({})
 
@@ -213,18 +218,29 @@ const requestReport = async (
     })
   }
 
-  const event = domainEventFactory.createDailyAnalyticsReportGeneratedEvent({
-    activityStatistics: yesterdayActivityStatistics,
-    activityStatisticsOverTime: analyticsOverTime,
-    statisticsOverTime,
-    statisticMeasures,
-    churn: {
-      periodKeys: monthlyPeriodKeys,
-      values: churnRates,
-    },
-  })
-
-  await domainEventPublisher.publish(event)
+  for (const adminEmail of adminEmails) {
+    await domainEventPublisher.publish(
+      domainEventFactory.createEmailRequestedEvent({
+        messageIdentifier: 'VERSION_ADOPTION_REPORT',
+        subject: getSubject(),
+        body: getBody(
+          {
+            activityStatistics: yesterdayActivityStatistics,
+            activityStatisticsOverTime: analyticsOverTime,
+            statisticsOverTime,
+            statisticMeasures,
+            churn: {
+              periodKeys: monthlyPeriodKeys,
+              values: churnRates,
+            },
+          },
+          timer,
+        ),
+        level: EmailLevel.LEVELS.System,
+        userEmail: adminEmail,
+      }),
+    )
+  }
 }
 
 const container = new ContainerConfigLoader()
@@ -241,9 +257,13 @@ void container.load().then((container) => {
   const domainEventFactory: DomainEventFactoryInterface = container.get(TYPES.DomainEventFactory)
   const domainEventPublisher: DomainEventPublisherInterface = container.get(TYPES.DomainEventPublisher)
   const periodKeyGenerator: PeriodKeyGeneratorInterface = container.get(TYPES.PeriodKeyGenerator)
+  const timer: TimerInterface = container.get(TYPES.Timer)
   const calculateMonthlyRecurringRevenue: CalculateMonthlyRecurringRevenue = container.get(
     TYPES.CalculateMonthlyRecurringRevenue,
   )
+  const adminEmails = container.get(TYPES.ADMIN_EMAILS) as string[]
+
+  logger.info(`Sending report to following admins: ${adminEmails}`)
 
   Promise.resolve(
     requestReport(
@@ -253,6 +273,8 @@ void container.load().then((container) => {
       domainEventPublisher,
       periodKeyGenerator,
       calculateMonthlyRecurringRevenue,
+      timer,
+      adminEmails,
     ),
   )
     .then(() => {

packages/analytics/docker/entrypoint.sh

@@ -5,17 +5,17 @@ COMMAND=$1 && shift 1
 
 case "$COMMAND" in
   'start-worker' )
-    echo "Starting Worker..."
+    echo "[Docker] Starting Worker..."
     yarn workspace @standardnotes/analytics worker
     ;;
 
   'report' )
-    echo "Starting Usage Report Generation..."
+    echo "[Docker] Starting Usage Report Generation..."
     yarn workspace @standardnotes/analytics report
     ;;
 
    * )
-    echo "Unknown command"
+    echo "[Docker] Unknown command"
     ;;
 esac
 

packages/analytics/jest.config.js

@@ -7,5 +7,5 @@ module.exports = {
   transform: {
     ...tsjPreset.transform,
   },
-  coveragePathIgnorePatterns: ['/Infra/'],
+  coveragePathIgnorePatterns: ['/Infra/', '/Domain/Email/'],
 }

packages/analytics/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/analytics",
-  "version": "2.12.3",
+  "version": "2.12.25",
   "engines": {
     "node": ">=18.0.0 <19.0.0"
   },
@@ -40,7 +40,7 @@
     "@newrelic/winston-enricher": "^4.0.0",
     "@sentry/node": "^7.19.0",
     "@standardnotes/common": "workspace:*",
-    "@standardnotes/domain-core": "workspace:*",
+    "@standardnotes/domain-core": "workspace:^",
     "@standardnotes/domain-events": "workspace:*",
     "@standardnotes/domain-events-infra": "workspace:*",
     "@standardnotes/time": "workspace:*",

packages/analytics/src/Bootstrap/Container.ts

@@ -130,6 +130,7 @@ export class ContainerConfigLoader {
     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))
+    container.bind(TYPES.ADMIN_EMAILS).toConstantValue(env.get('ADMIN_EMAILS').split(','))
 
     // Repositories
     container

packages/analytics/src/Bootstrap/Types.ts

@@ -11,6 +11,7 @@ const TYPES = {
   SQS_AWS_REGION: Symbol.for('SQS_AWS_REGION'),
   REDIS_EVENTS_CHANNEL: Symbol.for('REDIS_EVENTS_CHANNEL'),
   NEW_RELIC_ENABLED: Symbol.for('NEW_RELIC_ENABLED'),
+  ADMIN_EMAILS: Symbol.for('ADMIN_EMAILS'),
   // Repositories
   AnalyticsEntityRepository: Symbol.for('AnalyticsEntityRepository'),
   RevenueModificationRepository: Symbol.for('RevenueModificationRepository'),

packages/analytics/src/Domain/Email/DailyAnalyticsReport.ts

@@ -0,0 +1,11 @@
+import { TimerInterface } from '@standardnotes/time'
+
+import { html } from './daily-analytics-report.html'
+
+export function getSubject(): string {
+  return `Daily analytics report ${new Date().toLocaleDateString('en-US')}`
+}
+
+export function getBody(data: unknown, timer: TimerInterface): string {
+  return html(data, timer)
+}

packages/analytics/src/Domain/Email/daily-analytics-report.html.ts

@@ -0,0 +1,966 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { TimerInterface } from '@standardnotes/time'
+
+import { AnalyticsActivity } from '../Analytics/AnalyticsActivity'
+import { StatisticsMeasure } from '../Statistics/StatisticsMeasure'
+import { Period } from '../Time/Period'
+
+const getChartUrls = (
+  data: any,
+): {
+  subscriptions: string
+  users: string
+  quarterlyPerformance: string
+  churn: string
+  mrr: string
+  mrrMonthly: string
+} => {
+  const subscriptionPurchasingOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionPurchased && a.period === Period.Last30Days,
+  )
+  const subscriptionRenewingOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionRenewed && a.period === Period.Last30Days,
+  )
+  const subscriptionRefundingOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionRefunded && a.period === Period.Last30Days,
+  )
+  const subscriptionCancelledOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionCancelled && a.period === Period.Last30Days,
+  )
+  const subscriptionReactivatedOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionReactivated && a.period === Period.Last30Days,
+  )
+
+  const subscriptionsLinerOverTimeConfig = {
+    type: 'line',
+    data: {
+      labels: subscriptionPurchasingOverTime?.counts.map((count: { periodKey: any }) => count.periodKey),
+      datasets: [
+        {
+          label: 'Subscription Purchases',
+          backgroundColor: 'rgb(25, 255, 140)',
+          borderColor: 'rgb(25, 255, 140)',
+          data: subscriptionPurchasingOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'Subscription Renewals',
+          backgroundColor: 'rgb(54, 162, 235)',
+          borderColor: 'rgb(54, 162, 235)',
+          data: subscriptionRenewingOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'Subscription Refunds',
+          backgroundColor: 'rgb(255, 221, 51)',
+          borderColor: 'rgb(255, 221, 51)',
+          data: subscriptionRefundingOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'Subscription Cancels',
+          backgroundColor: 'rgb(255, 99, 132)',
+          borderColor: 'rgb(255, 99, 132)',
+          data: subscriptionCancelledOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'Subscription Reactivations',
+          backgroundColor: 'rgb(221, 51, 255)',
+          borderColor: 'rgb(221, 51, 255)',
+          data: subscriptionReactivatedOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+      ],
+    },
+  }
+
+  const userRegistrationOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.Register && a.period === Period.Last30Days,
+  )
+  const userDeletionOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.DeleteAccount && a.period === Period.Last30Days,
+  )
+
+  const usersLinerOverTimeConfig = {
+    type: 'line',
+    data: {
+      labels: userRegistrationOverTime?.counts.map((count: { periodKey: any }) => count.periodKey),
+      datasets: [
+        {
+          label: 'User Registrations',
+          backgroundColor: 'rgb(25, 255, 140)',
+          borderColor: 'rgb(25, 255, 140)',
+          data: userRegistrationOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'Account Deletions',
+          backgroundColor: 'rgb(255, 99, 132)',
+          borderColor: 'rgb(255, 99, 132)',
+          data: userDeletionOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+      ],
+    },
+  }
+
+  const quarters = [Period.Q1ThisYear, Period.Q2ThisYear, Period.Q3ThisYear, Period.Q4ThisYear]
+  const quarterlyUserRegistrations = []
+  const quarterlySubscriptionPurchases = []
+  const quarterlySubscriptionRenewals = []
+  for (const quarter of quarters) {
+    const registrations =
+      data.activityStatisticsOverTime.find(
+        (a: { name: AnalyticsActivity; period: Period }) =>
+          a.name === AnalyticsActivity.Register && a.period === quarter,
+      )?.totalCount ?? 0
+    const purchases =
+      data.activityStatisticsOverTime.find(
+        (a: { name: AnalyticsActivity; period: Period }) =>
+          a.name === AnalyticsActivity.SubscriptionPurchased && a.period === quarter,
+      )?.totalCount ?? 0
+    const renewals =
+      data.activityStatisticsOverTime.find(
+        (a: { name: AnalyticsActivity; period: Period }) =>
+          a.name === AnalyticsActivity.SubscriptionRenewed && a.period === quarter,
+      )?.totalCount ?? 0
+    quarterlyUserRegistrations.push(registrations)
+    quarterlySubscriptionPurchases.push(purchases)
+    quarterlySubscriptionRenewals.push(renewals)
+  }
+
+  const quarterlyConfig = {
+    type: 'bar',
+    data: {
+      labels: ['Q1', 'Q2', 'Q3', 'Q4'],
+      datasets: [
+        {
+          label: 'User Registrations',
+          backgroundColor: 'rgba(255, 99, 132, 0.5)',
+          borderColor: 'rgb(255, 99, 132)',
+          borderWidth: 1,
+          data: quarterlyUserRegistrations,
+        },
+        {
+          label: 'Subscription Purchases',
+          backgroundColor: 'rgba(54, 162, 235, 0.5)',
+          borderColor: 'rgb(54, 162, 235)',
+          borderWidth: 1,
+          data: quarterlySubscriptionPurchases,
+        },
+        {
+          label: 'Subscription Renewals',
+          backgroundColor: 'rgb(25, 255, 140, 0.5)',
+          borderColor: 'rgb(25, 255, 140)',
+          borderWidth: 1,
+          data: quarterlySubscriptionRenewals,
+        },
+      ],
+    },
+    options: {
+      title: {
+        display: true,
+        text: 'Quarterly Performance',
+      },
+      plugins: {
+        datalabels: {
+          anchor: 'center',
+          align: 'center',
+          color: '#666',
+          font: {
+            weight: 'normal',
+          },
+        },
+      },
+    },
+  }
+
+  const monthlyChurnRates = data.churn.values.map((value: { rate: number }) => +value.rate.toFixed(2))
+
+  const churnConfig = {
+    type: 'bar',
+    data: {
+      labels: [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December',
+      ],
+      datasets: [
+        {
+          label: 'Churn Percent',
+          backgroundColor: 'rgba(255, 99, 132, 0.5)',
+          borderColor: 'rgb(255, 99, 132)',
+          borderWidth: 1,
+          data: monthlyChurnRates,
+        },
+      ],
+    },
+    options: {
+      title: {
+        display: true,
+        text: 'Monthly Churn Rate',
+      },
+      plugins: {
+        datalabels: {
+          anchor: 'center',
+          align: 'center',
+          color: '#666',
+          font: {
+            weight: 'normal',
+          },
+        },
+      },
+    },
+  }
+
+  const mrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'mrr' && a.period === 27,
+  )
+  const monthlyPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'monthly-plans-mrr' && a.period === 27,
+  )
+  const annualPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'annual-plans-mrr' && a.period === 27,
+  )
+  const fiveYearPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'five-year-plans-mrr' && a.period === 27,
+  )
+  const proPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'pro-plans-mrr' && a.period === 27,
+  )
+  const plusPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'plus-plans-mrr' && a.period === 27,
+  )
+
+  const mrrOverTimeConfig = {
+    type: 'line',
+    data: {
+      labels: mrrOverTime?.counts.map((count: { periodKey: any }) => count.periodKey),
+      datasets: [
+        {
+          label: 'MRR',
+          backgroundColor: 'rgb(25, 255, 140)',
+          borderColor: 'rgb(25, 255, 140)',
+          data: mrrOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'MRR - Monthly Plans',
+          backgroundColor: 'rgb(54, 162, 235)',
+          borderColor: 'rgb(54, 162, 235)',
+          data: monthlyPlansMrrOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'MRR - Annual Plans',
+          backgroundColor: 'rgb(255, 221, 51)',
+          borderColor: 'rgb(255, 221, 51)',
+          data: annualPlansMrrOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'MRR - Five Year Plans',
+          backgroundColor: 'rgb(255, 120, 120)',
+          borderColor: 'rgb(255, 120, 120)',
+          data: fiveYearPlansMrrOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'MRR - PRO Plans',
+          backgroundColor: 'rgb(255, 99, 132)',
+          borderColor: 'rgb(255, 99, 132)',
+          data: proPlansMrrOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+        {
+          label: 'MRR - PLUS Plans',
+          backgroundColor: 'rgb(221, 51, 255)',
+          borderColor: 'rgb(221, 51, 255)',
+          data: plusPlansMrrOverTime?.counts.map((count: { totalCount: any }) => count.totalCount),
+          fill: false,
+          pointRadius: 2,
+        },
+      ],
+    },
+  }
+
+  const mrrMonthlyOverTime = data.statisticsOverTime
+    .find((a: { name: string; period: Period }) => a.name === 'mrr' && a.period === Period.ThisYear)
+    ?.counts.map((count: { totalCount: number }) => +count.totalCount.toFixed(2))
+
+  const mrrMonthlyConfig = {
+    type: 'bar',
+    data: {
+      labels: [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December',
+      ],
+      datasets: [
+        {
+          label: 'MRR',
+          backgroundColor: 'rgba(25, 255, 140, 0.5)',
+          borderColor: 'rgb(25, 255, 140)',
+          borderWidth: 1,
+          data: mrrMonthlyOverTime,
+        },
+      ],
+    },
+    options: {
+      title: {
+        display: true,
+        text: 'Monthly MRR',
+      },
+      plugins: {
+        datalabels: {
+          anchor: 'center',
+          align: 'center',
+          color: '#666',
+          font: {
+            weight: 'normal',
+          },
+        },
+      },
+    },
+  }
+
+  return {
+    subscriptions: `https://quickchart.io/chart?width=800&c=${encodeURIComponent(
+      JSON.stringify(subscriptionsLinerOverTimeConfig),
+    )}`,
+    users: `https://quickchart.io/chart?width=800&c=${encodeURIComponent(JSON.stringify(usersLinerOverTimeConfig))}`,
+    quarterlyPerformance: `https://quickchart.io/chart?width=800&c=${encodeURIComponent(
+      JSON.stringify(quarterlyConfig),
+    )}`,
+    churn: `https://quickchart.io/chart?width=800&c=${encodeURIComponent(JSON.stringify(churnConfig))}`,
+    mrr: `https://quickchart.io/chart?width=800&c=${encodeURIComponent(JSON.stringify(mrrOverTimeConfig))}`,
+    mrrMonthly: `https://quickchart.io/chart?width=800&c=${encodeURIComponent(JSON.stringify(mrrMonthlyConfig))}`,
+  }
+}
+
+export const html = (data: any, timer: TimerInterface) => {
+  const chartUrls = getChartUrls(data)
+
+  const successfullPaymentsActivity = data.activityStatistics.find(
+    (a: { name: AnalyticsActivity }) => a.name === AnalyticsActivity.PaymentSuccess && Period.Yesterday,
+  )
+  const failedPaymentsActivity = data.activityStatistics.find(
+    (a: { name: AnalyticsActivity }) => a.name === AnalyticsActivity.PaymentFailed && Period.Yesterday,
+  )
+  const limitedDiscountPurchasedActivity = data.activityStatistics.find(
+    (a: { name: AnalyticsActivity }) => a.name === AnalyticsActivity.LimitedDiscountOfferPurchased && Period.Yesterday,
+  )
+  const subscriptionPurchasingOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionPurchased && a.period === Period.Last30Days,
+  )
+  const subscriptionRenewingOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionRenewed && a.period === Period.Last30Days,
+  )
+  const subscriptionRefundingOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionRefunded && a.period === Period.Last30Days,
+  )
+  const subscriptionCancelledOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionCancelled && a.period === Period.Last30Days,
+  )
+  const subscriptionReactivatedOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.SubscriptionReactivated && a.period === Period.Last30Days,
+  )
+  const userRegistrationOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.Register && a.period === Period.Last30Days,
+  )
+  const userDeletionOverTime = data.activityStatisticsOverTime.find(
+    (a: { name: AnalyticsActivity; period: Period }) =>
+      a.name === AnalyticsActivity.DeleteAccount && a.period === Period.Last30Days,
+  )
+  const incomeMeasureYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.Income && a.period === Period.Yesterday,
+  )
+  const refundMeasureYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.Refunds && a.period === Period.Yesterday,
+  )
+  const incomeYesterday = incomeMeasureYesterday?.totalValue ?? 0
+  const refundsYesterday = refundMeasureYesterday?.totalValue ?? 0
+  const revenueYesterday = incomeYesterday - refundsYesterday
+
+  const subscriptionLengthMeasureYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.SubscriptionLength && a.period === Period.Yesterday,
+  )
+  const subscriptionLengthDurationYesterday = timer.convertMicrosecondsToTimeStructure(
+    Math.floor(subscriptionLengthMeasureYesterday?.average ?? 0),
+  )
+
+  const subscriptionRemainingTimePercentageMeasureYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.RemainingSubscriptionTimePercentage && a.period === Period.Yesterday,
+  )
+  const subscriptionRemainingTimePercentageYesterday = Math.floor(
+    subscriptionRemainingTimePercentageMeasureYesterday?.average ?? 0,
+  )
+
+  const registrationLengthMeasureYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.RegistrationLength && a.period === Period.Yesterday,
+  )
+  const registrationLengthDurationYesterday = timer.convertMicrosecondsToTimeStructure(
+    Math.floor(registrationLengthMeasureYesterday?.average ?? 0),
+  )
+
+  const registrationToSubscriptionMeasureYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.RegistrationToSubscriptionTime && a.period === Period.Yesterday,
+  )
+  const registrationToSubscriptionDurationYesterday = timer.convertMicrosecondsToTimeStructure(
+    Math.floor(registrationToSubscriptionMeasureYesterday?.average ?? 0),
+  )
+
+  const incomeMeasureThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.Income && a.period === Period.ThisMonth,
+  )
+  const refundMeasureThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.Refunds && a.period === Period.ThisMonth,
+  )
+  const incomeThisMonth = incomeMeasureThisMonth?.totalValue ?? 0
+  const refundsThisMonth = refundMeasureThisMonth?.totalValue ?? 0
+  const revenueThisMonth = incomeThisMonth - refundsThisMonth
+
+  const subscriptionLengthMeasureThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.SubscriptionLength && a.period === Period.ThisMonth,
+  )
+  const subscriptionLengthDurationThisMonth = timer.convertMicrosecondsToTimeStructure(
+    Math.floor(subscriptionLengthMeasureThisMonth?.average ?? 0),
+  )
+
+  const subscriptionRemainingTimePercentageMeasureThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.RemainingSubscriptionTimePercentage && a.period === Period.ThisMonth,
+  )
+  const subscriptionRemainingTimePercentageThisMonth = Math.floor(
+    subscriptionRemainingTimePercentageMeasureThisMonth?.average ?? 0,
+  )
+
+  const registrationLengthMeasureThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.RegistrationLength && a.period === Period.ThisMonth,
+  )
+  const registrationLengthDurationThisMonth = timer.convertMicrosecondsToTimeStructure(
+    Math.floor(registrationLengthMeasureThisMonth?.average ?? 0),
+  )
+
+  const registrationToSubscriptionMeasureThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.RegistrationToSubscriptionTime && a.period === Period.ThisMonth,
+  )
+  const registrationToSubscriptionDurationThisMonth = timer.convertMicrosecondsToTimeStructure(
+    Math.floor(registrationToSubscriptionMeasureThisMonth?.average ?? 0),
+  )
+
+  const plusSubscriptionsInitialAnnualPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionInitialAnnualPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const plusSubscriptionsInitialMonthlyPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionInitialMonthlyPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const plusSubscriptionsRenewingAnnualPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionRenewingAnnualPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const plusSubscriptionsRenewingMonthlyPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionRenewingMonthlyPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const proSubscriptionsInitialAnnualPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionInitialAnnualPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const proSubscriptionsInitialMonthlyPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionInitialMonthlyPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const proSubscriptionsRenewingAnnualPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionRenewingAnnualPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const proSubscriptionsRenewingMonthlyPaymentsYesterday = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionRenewingMonthlyPaymentsIncome && a.period === Period.Yesterday,
+  )
+  const plusSubscriptionsInitialAnnualPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionInitialAnnualPaymentsIncome && a.period === Period.ThisMonth,
+  )
+  const plusSubscriptionsInitialMonthlyPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionInitialMonthlyPaymentsIncome && a.period === Period.ThisMonth,
+  )
+  const plusSubscriptionsRenewingAnnualPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionRenewingAnnualPaymentsIncome && a.period === Period.ThisMonth,
+  )
+  const plusSubscriptionsRenewingMonthlyPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.PlusSubscriptionRenewingMonthlyPaymentsIncome && a.period === Period.ThisMonth,
+  )
+  const proSubscriptionsInitialAnnualPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionInitialAnnualPaymentsIncome && a.period === Period.ThisMonth,
+  )
+  const proSubscriptionsInitialMonthlyPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionInitialMonthlyPaymentsIncome && a.period === Period.ThisMonth,
+  )
+  const proSubscriptionsRenewingAnnualPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionRenewingAnnualPaymentsIncome && a.period === Period.ThisMonth,
+  )
+  const proSubscriptionsRenewingMonthlyPaymentsThisMonth = data.statisticMeasures.find(
+    (a: { name: StatisticsMeasure; period: Period }) =>
+      a.name === StatisticsMeasure.ProSubscriptionRenewingMonthlyPaymentsIncome && a.period === Period.ThisMonth,
+  )
+
+  const mrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'mrr' && a.period === 27,
+  )
+  const monthlyPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'monthly-plans-mrr' && a.period === 27,
+  )
+  const annualPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'annual-plans-mrr' && a.period === 27,
+  )
+  const fiveYearPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'five-year-plans-mrr' && a.period === 27,
+  )
+  const proPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'pro-plans-mrr' && a.period === 27,
+  )
+  const plusPlansMrrOverTime = data.statisticsOverTime.find(
+    (a: { name: string; period: number }) => a.name === 'plus-plans-mrr' && a.period === 27,
+  )
+
+  const today = new Date()
+  const thisMonthPeriodKey = `${today.getFullYear().toString()}-${(today.getMonth() + 1).toString()}`
+  const thisMonthChurn = data.churn.values.find(
+    (value: { periodKey: string }) => value.periodKey === thisMonthPeriodKey,
+  )
+
+  return `      <div>
+<p>Hello,</p>
+<p>
+  <strong>Here are some statistics from yesterday:</strong>
+</p>
+<ul>
+  <li>
+    <b>Payments</b>
+    <ul>
+      <li>
+        Revenue: <b>$${revenueYesterday.toLocaleString('en-US')}</b> (Income: $
+        ${incomeYesterday.toLocaleString('en-US')}, Refunds: $${refundsYesterday.toLocaleString('en-US')})
+      </li>
+      <li>
+        Successfull payments: <b>${successfullPaymentsActivity?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Failed payments: <b>${failedPaymentsActivity?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+    </ul>
+  </li>
+  <li>
+    <b>MRR Breakdown</b>
+    <ul>
+      <li>
+        <b>Total:</b> $${mrrOverTime?.counts[mrrOverTime?.counts.length - 1].totalCount.toLocaleString('en-US')}
+      </li>
+      <li>
+        <b>By Subscription Type:</b>
+        <ul>
+          <li>
+            <b>PLUS:</b> $
+            ${plusPlansMrrOverTime?.counts[plusPlansMrrOverTime?.counts.length - 1].totalCount.toLocaleString('en-US')}
+          </li>
+          <li>
+            <b>PRO:</b> $
+            ${proPlansMrrOverTime?.counts[proPlansMrrOverTime?.counts.length - 1].totalCount.toLocaleString('en-US')}
+          </li>
+        </ul>
+      </li>
+      <li>
+        <b>By Billing Frequency:</b>
+        <ul>
+          <li>
+            <b>Monthly:</b> $
+            ${monthlyPlansMrrOverTime?.counts[monthlyPlansMrrOverTime?.counts.length - 1].totalCount.toLocaleString(
+              'en-US',
+            )}
+          </li>
+          <li>
+            <b>Annual:</b> $
+            ${annualPlansMrrOverTime?.counts[annualPlansMrrOverTime?.counts.length - 1].totalCount.toLocaleString(
+              'en-US',
+            )}
+          </li>
+          <li>
+            <b>5-year:</b> $
+            ${fiveYearPlansMrrOverTime?.counts[fiveYearPlansMrrOverTime?.counts.length - 1].totalCount.toLocaleString(
+              'en-US',
+            )}
+          </li>
+        </ul>
+      </li>
+    </ul>
+  </li>
+  <li>
+    <b>Income Breakdown</b>
+    <ul>
+      <li>
+        <b>Plus Subscription:</b>
+        <ul>
+          <li>
+            <b>${plusSubscriptionsInitialMonthlyPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>monhtly</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsInitialMonthlyPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${plusSubscriptionsInitialAnnualPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsInitialAnnualPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${plusSubscriptionsRenewingMonthlyPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>monthly</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsRenewingMonthlyPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${plusSubscriptionsRenewingAnnualPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsRenewingAnnualPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+        </ul>
+      </li>
+      <li>
+        <b>Pro Subscription:</b>
+        <ul>
+          <li>
+            <b>${proSubscriptionsInitialMonthlyPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>monhtly</u> plan, totaling${' '}
+            <b>$${proSubscriptionsInitialMonthlyPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${proSubscriptionsInitialAnnualPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${proSubscriptionsInitialAnnualPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${proSubscriptionsRenewingMonthlyPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>monthly</u> plan, totaling${' '}
+            <b>$${proSubscriptionsRenewingMonthlyPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${proSubscriptionsRenewingAnnualPaymentsYesterday?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${proSubscriptionsRenewingAnnualPaymentsYesterday?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+        </ul>
+      </li>
+    </ul>
+  </li>
+  <li>
+    <b>Users</b>
+    <ul>
+      <li>
+        Number of users registered:${' '}
+        <b>
+          ${userRegistrationOverTime?.counts[userRegistrationOverTime?.counts.length - 1]?.totalCount.toLocaleString(
+            'en-US',
+          )}
+        </b>
+      </li>
+      <li>
+        Number of users unregistered:${' '}
+        <b>
+          ${userDeletionOverTime?.counts[userDeletionOverTime?.counts.length - 1]?.totalCount.toLocaleString('en-US')}
+        </b>${' '}
+        (average account duration: ${registrationLengthDurationYesterday.days} days${' '}
+        ${registrationLengthDurationYesterday.hours} hours ${registrationLengthDurationYesterday.minutes} minutes)
+      </li>
+    </ul>
+  </li>
+  <li>
+    <b>Subscriptions</b>
+    <ul>
+      <li>
+        Number of subscriptions purchased:${' '}
+        <b>
+          ${subscriptionPurchasingOverTime?.counts[
+            subscriptionPurchasingOverTime?.counts.length - 1
+          ]?.totalCount.toLocaleString('en-US')}
+        </b>${' '}
+        (includes <b>${limitedDiscountPurchasedActivity?.totalCount.toLocaleString('en-US')}</b> limited time
+        offer purchases)
+      </li>
+      <li>
+        Number of subscriptions renewed:${' '}
+        <b>
+          ${subscriptionRenewingOverTime?.counts[
+            subscriptionRenewingOverTime?.counts.length - 1
+          ]?.totalCount.toLocaleString('en-US')}
+        </b>
+      </li>
+      <li>
+        Number of subscriptions refunded:${' '}
+        <b>
+          ${subscriptionRefundingOverTime?.counts[
+            subscriptionRefundingOverTime?.counts.length - 1
+          ]?.totalCount.toLocaleString('en-US')}
+        </b>
+      </li>
+      <li>
+        Number of subscriptions cancelled:${' '}
+        <b>
+          ${subscriptionCancelledOverTime?.counts[
+            subscriptionCancelledOverTime?.counts.length - 1
+          ]?.totalCount.toLocaleString('en-US')}
+        </b>${' '}
+        (average subscription duration: ${subscriptionLengthDurationYesterday.days} days${' '}
+        ${subscriptionLengthDurationYesterday.hours} hours ${subscriptionLengthDurationYesterday.minutes} minutes,
+        average remaining subscription percentage: ${subscriptionRemainingTimePercentageYesterday}%)
+      </li>
+      <li>
+        Number of subscriptions reactivated:${' '}
+        <b>
+          ${subscriptionReactivatedOverTime?.counts[
+            subscriptionReactivatedOverTime?.counts.length - 1
+          ]?.totalCount.toLocaleString('en-US')}
+        </b>
+      </li>
+      <li>
+        Average time from registration to subscription purchase:${' '}
+        <b>
+          ${registrationToSubscriptionDurationYesterday.days} days${' '}
+          ${registrationToSubscriptionDurationYesterday.hours} hours${' '}
+          ${registrationToSubscriptionDurationYesterday.minutes} minutes
+        </b>
+      </li>
+    </ul>
+  </li>
+</ul>
+<p>
+  <strong>Here are some statistics from last 30 days:</strong>
+</p>
+<ul>
+  <li>
+    <b>Payments (This Month)</b>
+    <ul>
+      <li>
+        Revenue: <b>$${revenueThisMonth.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Income: <b>$${incomeThisMonth.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Refunds: <b>$${refundsThisMonth.toLocaleString('en-US')}</b>
+      </li>
+    </ul>
+  </li>
+  <li>
+    <b>Income Breakdown (This Month)</b>
+    <ul>
+      <li>
+        <b>Plus Subscription:</b>
+        <ul>
+          <li>
+            <b>${plusSubscriptionsInitialMonthlyPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>monhtly</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsInitialMonthlyPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${plusSubscriptionsInitialAnnualPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsInitialAnnualPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${plusSubscriptionsRenewingMonthlyPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>monthly</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsRenewingMonthlyPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${plusSubscriptionsRenewingAnnualPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${plusSubscriptionsRenewingAnnualPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+        </ul>
+      </li>
+      <li>
+        <b>Pro Subscription:</b>
+        <ul>
+          <li>
+            <b>${proSubscriptionsInitialMonthlyPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>monhtly</u> plan, totaling${' '}
+            <b>$${proSubscriptionsInitialMonthlyPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${proSubscriptionsInitialAnnualPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>initial</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${proSubscriptionsInitialAnnualPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${proSubscriptionsRenewingMonthlyPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>monthly</u> plan, totaling${' '}
+            <b>$${proSubscriptionsRenewingMonthlyPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+          <li>
+            <b>${proSubscriptionsRenewingAnnualPaymentsThisMonth?.increments.toLocaleString('en-US')}</b>${' '}
+            <i>renewing</i> payments on <u>annual</u> plan, totaling${' '}
+            <b>$${proSubscriptionsRenewingAnnualPaymentsThisMonth?.totalValue.toLocaleString('en-US')}</b>
+          </li>
+        </ul>
+      </li>
+    </ul>
+  </li>
+  <li>
+    <b>Users</b>
+    <ul>
+      <li>
+        Number of users registered: <b>${userRegistrationOverTime?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Number of users unregistered: <b>${userDeletionOverTime?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Average account duration this month:${' '}
+        <b>
+          ${registrationLengthDurationThisMonth.days} days ${registrationLengthDurationThisMonth.hours} hours${' '}
+          ${registrationLengthDurationThisMonth.minutes} minutes
+        </b>
+      </li>
+    </ul>
+  </li>
+  <li>
+    <b>Subscriptions</b>
+    <ul>
+      <li>
+        Number of subscriptions purchased:${' '}
+        <b>${subscriptionPurchasingOverTime?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Number of subscriptions renewed:${' '}
+        <b>${subscriptionRenewingOverTime?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Number of subscriptions refunded:${' '}
+        <b>${subscriptionRefundingOverTime?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Number of subscriptions cancelled:${' '}
+        <b>${subscriptionCancelledOverTime?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Number of subscriptions reactivated:${' '}
+        <b>${subscriptionReactivatedOverTime?.totalCount.toLocaleString('en-US')}</b>
+      </li>
+      <li>
+        Average subscription duration this month:${' '}
+        <b>
+          ${subscriptionLengthDurationThisMonth.days} days ${subscriptionLengthDurationThisMonth.hours} hours${' '}
+          ${subscriptionLengthDurationThisMonth.minutes} minutes
+        </b>
+      </li>
+      <li>
+        Average subscription remaining percentage this month:${' '}
+        <b>${subscriptionRemainingTimePercentageThisMonth}%</b>
+      </li>
+      <li>
+        Average time from registration to subscription purchase this month:${' '}
+        <b>
+          ${registrationToSubscriptionDurationThisMonth.days} days${' '}
+          ${registrationToSubscriptionDurationThisMonth.hours} hours${' '}
+          ${registrationToSubscriptionDurationThisMonth.minutes} minutes
+        </b>
+      </li>
+    </ul>
+  </li>
+</ul>
+<p>
+  <strong>Here is the MRR chart over 30 days:</strong>
+</p>
+<img src=${chartUrls.mrr}></img>
+<p>
+  <strong>Here is the MRR Monthly chart this year:</strong>
+</p>
+<img src=${chartUrls.mrrMonthly}></img>
+<p>
+  <strong>Here is the subscription chart over 30 days:</strong>
+</p>
+<img src=${chartUrls.subscriptions}></img>
+<p>
+  <strong>Here is the users chart over 30 days:</strong>
+</p>
+<img src=${chartUrls.users}></img>
+<p>
+  <strong>Here is the monthly churn rate percentage:</strong>
+</p>
+<p>✅ GREAT! Up to 7% 🔶 OKAY: 8-10% 🩸 BAD: 11 -15 % 🚨 TERRIBLE! 16-20%</p>
+<p>Churn is calculated by the following formula:</p>
+<p>
+  ( Existing Customers Churn [${thisMonthChurn?.existingCustomersChurn}] + New Customers Churn [
+  ${thisMonthChurn?.newCustomersChurn}] ) * 100 / Average Customers Count This Month [
+  ${thisMonthChurn?.averageCustomersCount}]
+</p>
+<img src=${chartUrls.churn}></img>
+<p>
+  <strong>Here is quarterly performance chart:</strong>
+</p>
+<img src=${chartUrls.quarterlyPerformance}></img>
+<p>Thanks,SN</p>
+</div>`
+}

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

@@ -1,6 +1,6 @@
 /* istanbul ignore file */
 
-import { DomainEventService, DailyAnalyticsReportGeneratedEvent } from '@standardnotes/domain-events'
+import { DomainEventService, EmailRequestedEvent } from '@standardnotes/domain-events'
 import { TimerInterface } from '@standardnotes/time'
 import { inject, injectable } from 'inversify'
 import TYPES from '../../Bootstrap/Types'
@@ -9,55 +9,20 @@ import { DomainEventFactoryInterface } from './DomainEventFactoryInterface'
 @injectable()
 export class DomainEventFactory implements DomainEventFactoryInterface {
   constructor(@inject(TYPES.Timer) private timer: TimerInterface) {}
-
-  createDailyAnalyticsReportGeneratedEvent(dto: {
-    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
-    }>
-    statisticsOverTime: Array<{
-      name: string
-      period: number
-      counts: Array<{
-        periodKey: string
-        totalCount: number
-      }>
-    }>
-    churn: {
-      periodKeys: Array<string>
-      values: Array<{
-        rate: number
-        periodKey: string
-        averageCustomersCount: number
-        existingCustomersChurn: number
-        newCustomersChurn: number
-      }>
-    }
-  }): DailyAnalyticsReportGeneratedEvent {
+  createEmailRequestedEvent(dto: {
+    userEmail: string
+    messageIdentifier: string
+    level: string
+    body: string
+    subject: string
+  }): EmailRequestedEvent {
     return {
-      type: 'DAILY_ANALYTICS_REPORT_GENERATED',
+      type: 'EMAIL_REQUESTED',
       createdAt: this.timer.getUTCDate(),
       meta: {
         correlation: {
-          userIdentifier: '',
-          userIdentifierType: 'uuid',
+          userIdentifier: dto.userEmail,
+          userIdentifierType: 'email',
         },
         origin: DomainEventService.Analytics,
       },

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

@@ -1,45 +1,11 @@
-import { DailyAnalyticsReportGeneratedEvent } from '@standardnotes/domain-events'
+import { EmailRequestedEvent } from '@standardnotes/domain-events'
 
 export interface DomainEventFactoryInterface {
-  createDailyAnalyticsReportGeneratedEvent(dto: {
-    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
-    }>
-    statisticsOverTime: Array<{
-      name: string
-      period: number
-      counts: Array<{
-        periodKey: string
-        totalCount: number
-      }>
-    }>
-    churn: {
-      periodKeys: Array<string>
-      values: Array<{
-        rate: number
-        periodKey: string
-        averageCustomersCount: number
-        existingCustomersChurn: number
-        newCustomersChurn: number
-      }>
-    }
-  }): DailyAnalyticsReportGeneratedEvent
+  createEmailRequestedEvent(dto: {
+    userEmail: string
+    messageIdentifier: string
+    level: string
+    body: string
+    subject: string
+  }): EmailRequestedEvent
 }

packages/api-gateway/.env.sample

@@ -11,6 +11,7 @@ WEB_SOCKET_SERVER_URL=http://websockets:3000
 PAYMENTS_SERVER_URL=http://payments:3000
 FILES_SERVER_URL=http://files:3000
 REVISIONS_SERVER_URL=http://revisions:3000
+EMAIL_SERVER_URL=http://email:3000
 
 HTTP_CALL_TIMEOUT=60000
 

packages/api-gateway/CHANGELOG.md

@@ -3,6 +3,84 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.40.2](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.40.1...@standardnotes/api-gateway@1.40.2) (2022-12-12)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.40.1](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.40.0...@standardnotes/api-gateway@1.40.1) (2022-12-12)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+# [1.40.0](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.24...@standardnotes/api-gateway@1.40.0) (2022-12-12)
+
+### Features
+
+* **api-gateway:** add unsubscribe from emails endpoint ([22d6a02](https://github.com/standardnotes/api-gateway/commit/22d6a02d049ba3bde890c7def91e19f013ba3e22))
+
+## [1.39.24](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.23...@standardnotes/api-gateway@1.39.24) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.23](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.22...@standardnotes/api-gateway@1.39.23) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.22](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.21...@standardnotes/api-gateway@1.39.22) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.21](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.20...@standardnotes/api-gateway@1.39.21) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.20](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.19...@standardnotes/api-gateway@1.39.20) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.19](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.18...@standardnotes/api-gateway@1.39.19) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.18](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.17...@standardnotes/api-gateway@1.39.18) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.17](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.16...@standardnotes/api-gateway@1.39.17) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.16](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.15...@standardnotes/api-gateway@1.39.16) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.15](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.14...@standardnotes/api-gateway@1.39.15) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.14](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.13...@standardnotes/api-gateway@1.39.14) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.13](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.12...@standardnotes/api-gateway@1.39.13) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.12](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.11...@standardnotes/api-gateway@1.39.12) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.11](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.10...@standardnotes/api-gateway@1.39.11) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.10](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.9...@standardnotes/api-gateway@1.39.10) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
+## [1.39.9](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.8...@standardnotes/api-gateway@1.39.9) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/api-gateway
+
 ## [1.39.8](https://github.com/standardnotes/api-gateway/compare/@standardnotes/api-gateway@1.39.7...@standardnotes/api-gateway@1.39.8) (2022-12-06)
 
 **Note:** Version bump only for package @standardnotes/api-gateway

packages/api-gateway/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/api-gateway",
-  "version": "1.39.8",
+  "version": "1.40.2",
   "engines": {
     "node": ">=18.0.0 <19.0.0"
   },

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

@@ -55,6 +55,7 @@ export class ContainerConfigLoader {
     container.bind(TYPES.SYNCING_SERVER_JS_URL).toConstantValue(env.get('SYNCING_SERVER_JS_URL'))
     container.bind(TYPES.AUTH_SERVER_URL).toConstantValue(env.get('AUTH_SERVER_URL'))
     container.bind(TYPES.REVISIONS_SERVER_URL).toConstantValue(env.get('REVISIONS_SERVER_URL', true))
+    container.bind(TYPES.EMAIL_SERVER_URL).toConstantValue(env.get('EMAIL_SERVER_URL', true))
     container.bind(TYPES.PAYMENTS_SERVER_URL).toConstantValue(env.get('PAYMENTS_SERVER_URL', true))
     container.bind(TYPES.FILES_SERVER_URL).toConstantValue(env.get('FILES_SERVER_URL', true))
     container.bind(TYPES.AUTH_JWT_SECRET).toConstantValue(env.get('AUTH_JWT_SECRET'))

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

@@ -8,6 +8,7 @@ const TYPES = {
   PAYMENTS_SERVER_URL: Symbol.for('PAYMENTS_SERVER_URL'),
   FILES_SERVER_URL: Symbol.for('FILES_SERVER_URL'),
   REVISIONS_SERVER_URL: Symbol.for('REVISIONS_SERVER_URL'),
+  EMAIL_SERVER_URL: Symbol.for('EMAIL_SERVER_URL'),
   WORKSPACE_SERVER_URL: Symbol.for('WORKSPACE_SERVER_URL'),
   WEB_SOCKET_SERVER_URL: Symbol.for('WEB_SOCKET_SERVER_URL'),
   AUTH_JWT_SECRET: Symbol.for('AUTH_JWT_SECRET'),

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

@@ -29,4 +29,14 @@ export class ActionsController extends BaseHttpController {
   async methods(request: Request, response: Response): Promise<void> {
     await this.httpService.callAuthServer(request, response, 'auth/methods', request.body)
   }
+
+  @httpGet('/unsubscribe/:token')
+  async emailUnsubscribe(request: Request, response: Response): Promise<void> {
+    await this.httpService.callEmailServer(
+      request,
+      response,
+      `subscriptions/actions/unsubscribe/${request.params.token}`,
+      request.body,
+    )
+  }
 }

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

@@ -19,6 +19,7 @@ export class HttpService implements HttpServiceInterface {
     @inject(TYPES.WORKSPACE_SERVER_URL) private workspaceServerUrl: string,
     @inject(TYPES.WEB_SOCKET_SERVER_URL) private webSocketServerUrl: string,
     @inject(TYPES.REVISIONS_SERVER_URL) private revisionsServerUrl: string,
+    @inject(TYPES.EMAIL_SERVER_URL) private emailServerUrl: string,
     @inject(TYPES.HTTP_CALL_TIMEOUT) private httpCallTimeout: number,
     @inject(TYPES.CrossServiceTokenCache) private crossServiceTokenCache: CrossServiceTokenCacheInterface,
     @inject(TYPES.Logger) private logger: Logger,
@@ -65,6 +66,21 @@ export class HttpService implements HttpServiceInterface {
     await this.callServer(this.authServerUrl, request, response, endpoint, payload)
   }
 
+  async callEmailServer(
+    request: Request,
+    response: Response,
+    endpoint: string,
+    payload?: Record<string, unknown> | string,
+  ): Promise<void> {
+    if (!this.emailServerUrl) {
+      response.status(400).send({ message: 'Email Server not configured' })
+
+      return
+    }
+
+    await this.callServer(this.emailServerUrl, request, response, endpoint, payload)
+  }
+
   async callWorkspaceServer(
     request: Request,
     response: Response,

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

@@ -1,6 +1,12 @@
 import { Request, Response } from 'express'
 
 export interface HttpServiceInterface {
+  callEmailServer(
+    request: Request,
+    response: Response,
+    endpoint: string,
+    payload?: Record<string, unknown> | string,
+  ): Promise<void>
   callAuthServer(
     request: Request,
     response: Response,

packages/auth/CHANGELOG.md

@@ -3,6 +3,130 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.67.1](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.67.0...@standardnotes/auth-server@1.67.1) (2022-12-12)
+
+### Bug Fixes
+
+* user signed in email template ([c15e2e2](https://github.com/standardnotes/server/commit/c15e2e2c8f3a6c177e227d25440501fa38dd3d0e))
+
+# [1.67.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.9...@standardnotes/auth-server@1.67.0) (2022-12-12)
+
+### Features
+
+* **auth:** add email subscription unsubscribed event handler ([10e2a26](https://github.com/standardnotes/server/commit/10e2a263522dfa33c06940f29cb77f783f66b20c))
+
+## [1.66.9](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.8...@standardnotes/auth-server@1.66.9) (2022-12-12)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.66.8](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.7...@standardnotes/auth-server@1.66.8) (2022-12-12)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.66.7](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.6...@standardnotes/auth-server@1.66.7) (2022-12-09)
+
+### Bug Fixes
+
+* **auth:** linter issue ([104313c](https://github.com/standardnotes/server/commit/104313c15df79f6308d23e21f65111e5bd3d9c72))
+
+## [1.66.6](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.5...@standardnotes/auth-server@1.66.6) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.66.5](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.4...@standardnotes/auth-server@1.66.5) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.66.4](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.3...@standardnotes/auth-server@1.66.4) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.66.3](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.2...@standardnotes/auth-server@1.66.3) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.66.2](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.1...@standardnotes/auth-server@1.66.2) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.66.1](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.66.0...@standardnotes/auth-server@1.66.1) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+# [1.66.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.65.0...@standardnotes/auth-server@1.66.0) (2022-12-09)
+
+### Features
+
+* **email:** replace offline subscription token created event in favour of email requested ([b595264](https://github.com/standardnotes/server/commit/b595264e313ac5ae5404f6a4a05b90b8c11f7f02))
+
+# [1.65.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.7...@standardnotes/auth-server@1.65.0) (2022-12-09)
+
+### Features
+
+* **auth:** remove offline subscription token created event in favour of email requested ([fd58992](https://github.com/standardnotes/server/commit/fd589922bba29595a0dfd154a42fe158024fad28))
+
+## [1.64.7](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.6...@standardnotes/auth-server@1.64.7) (2022-12-09)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.64.6](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.5...@standardnotes/auth-server@1.64.6) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.64.5](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.4...@standardnotes/auth-server@1.64.5) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.64.4](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.3...@standardnotes/auth-server@1.64.4) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.64.3](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.2...@standardnotes/auth-server@1.64.3) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.64.2](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.1...@standardnotes/auth-server@1.64.2) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.64.1](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.64.0...@standardnotes/auth-server@1.64.1) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+# [1.64.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.63.2...@standardnotes/auth-server@1.64.0) (2022-12-07)
+
+### Features
+
+* **auth:** replace user signed in events with email requested ([e48cca6](https://github.com/standardnotes/server/commit/e48cca6b45b02876f2d82b726c1d2f124d90b587))
+
+## [1.63.2](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.63.1...@standardnotes/auth-server@1.63.2) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/auth-server
+
+## [1.63.1](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.63.0...@standardnotes/auth-server@1.63.1) (2022-12-07)
+
+### Bug Fixes
+
+* **auth:** remove not needed event from factory ([2542cf6](https://github.com/standardnotes/server/commit/2542cf6f9a40c3a5eb4e11ead3cbbc25afefae48))
+
+# [1.63.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.62.1...@standardnotes/auth-server@1.63.0) (2022-12-07)
+
+### Features
+
+* **domain-core:** rename email subscription rejection level to email level ([c87561f](https://github.com/standardnotes/server/commit/c87561fca782883b84f58b4f0b9f85ecc279ca50))
+
+## [1.62.1](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.62.0...@standardnotes/auth-server@1.62.1) (2022-12-06)
+
+### Bug Fixes
+
+* **auth:** remove redundant specs and fix stream query ([fb81d2b](https://github.com/standardnotes/server/commit/fb81d2b9260cf7bee3e3e6911d5a6e8eb1d650e3))
+
+# [1.62.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.61.0...@standardnotes/auth-server@1.62.0) (2022-12-06)
+
+### Features
+
+* **auth:** add procedure for email subscriptions sync ([7848dc0](https://github.com/standardnotes/server/commit/7848dc06d4f4fe8c380ed45c32e23ac0e62014fa))
+
 # [1.61.0](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.60.17...@standardnotes/auth-server@1.61.0) (2022-12-06)
 
 ### Features

packages/auth/bin/backup.ts

@@ -3,20 +3,19 @@ import 'reflect-metadata'
 import 'newrelic'
 
 import { Stream } from 'stream'
-
 import { Logger } from 'winston'
 import * as dayjs from 'dayjs'
 import * as utc from 'dayjs/plugin/utc'
+import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
+import { SettingName } from '@standardnotes/domain-core'
+import { PermissionName } from '@standardnotes/features'
 
 import { ContainerConfigLoader } from '../src/Bootstrap/Container'
 import TYPES from '../src/Bootstrap/Types'
 import { Env } from '../src/Bootstrap/Env'
-import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
 import { DomainEventFactoryInterface } from '../src/Domain/Event/DomainEventFactoryInterface'
 import { SettingRepositoryInterface } from '../src/Domain/Setting/SettingRepositoryInterface'
-import { MuteFailedBackupsEmailsOption, MuteFailedCloudBackupsEmailsOption, SettingName } from '@standardnotes/settings'
 import { RoleServiceInterface } from '../src/Domain/Role/RoleServiceInterface'
-import { PermissionName } from '@standardnotes/features'
 import { SettingServiceInterface } from '../src/Domain/Setting/SettingServiceInterface'
 
 const inputArgs = process.argv.slice(2)
@@ -30,38 +29,38 @@ const requestBackups = async (
   domainEventFactory: DomainEventFactoryInterface,
   domainEventPublisher: DomainEventPublisherInterface,
 ): Promise<void> => {
-  let settingName: SettingName,
+  let settingName: string,
     permissionName: PermissionName,
-    muteEmailsSettingName: SettingName,
+    muteEmailsSettingName: string,
     muteEmailsSettingValue: string,
-    providerTokenSettingName: SettingName
+    providerTokenSettingName: string
   switch (backupProvider) {
     case 'email':
-      settingName = SettingName.EmailBackupFrequency
+      settingName = SettingName.NAMES.EmailBackupFrequency
       permissionName = PermissionName.DailyEmailBackup
-      muteEmailsSettingName = SettingName.MuteFailedBackupsEmails
-      muteEmailsSettingValue = MuteFailedBackupsEmailsOption.Muted
+      muteEmailsSettingName = SettingName.NAMES.MuteFailedBackupsEmails
+      muteEmailsSettingValue = 'muted'
       break
     case 'dropbox':
-      settingName = SettingName.DropboxBackupFrequency
+      settingName = SettingName.NAMES.DropboxBackupFrequency
       permissionName = PermissionName.DailyDropboxBackup
-      muteEmailsSettingName = SettingName.MuteFailedCloudBackupsEmails
-      muteEmailsSettingValue = MuteFailedCloudBackupsEmailsOption.Muted
-      providerTokenSettingName = SettingName.DropboxBackupToken
+      muteEmailsSettingName = SettingName.NAMES.MuteFailedCloudBackupsEmails
+      muteEmailsSettingValue = 'muted'
+      providerTokenSettingName = SettingName.NAMES.DropboxBackupToken
       break
     case 'one_drive':
-      settingName = SettingName.OneDriveBackupFrequency
+      settingName = SettingName.NAMES.OneDriveBackupFrequency
       permissionName = PermissionName.DailyOneDriveBackup
-      muteEmailsSettingName = SettingName.MuteFailedCloudBackupsEmails
-      muteEmailsSettingValue = MuteFailedCloudBackupsEmailsOption.Muted
-      providerTokenSettingName = SettingName.OneDriveBackupToken
+      muteEmailsSettingName = SettingName.NAMES.MuteFailedCloudBackupsEmails
+      muteEmailsSettingValue = 'muted'
+      providerTokenSettingName = SettingName.NAMES.OneDriveBackupToken
       break
     case 'google_drive':
-      settingName = SettingName.GoogleDriveBackupFrequency
+      settingName = SettingName.NAMES.GoogleDriveBackupFrequency
       permissionName = PermissionName.DailyGDriveBackup
-      muteEmailsSettingName = SettingName.MuteFailedCloudBackupsEmails
-      muteEmailsSettingValue = MuteFailedCloudBackupsEmailsOption.Muted
-      providerTokenSettingName = SettingName.GoogleDriveBackupToken
+      muteEmailsSettingName = SettingName.NAMES.MuteFailedCloudBackupsEmails
+      muteEmailsSettingValue = 'muted'
+      providerTokenSettingName = SettingName.NAMES.GoogleDriveBackupToken
       break
     default:
       throw new Error(`Not handled backup provider: ${backupProvider}`)

packages/auth/bin/email.ts

@@ -1,136 +0,0 @@
-import 'reflect-metadata'
-
-import 'newrelic'
-
-import { Stream } from 'stream'
-
-import { Logger } from 'winston'
-import * as dayjs from 'dayjs'
-import * as utc from 'dayjs/plugin/utc'
-
-import { UserRepositoryInterface } from '../src/Domain/User/UserRepositoryInterface'
-import { ContainerConfigLoader } from '../src/Bootstrap/Container'
-import TYPES from '../src/Bootstrap/Types'
-import { Env } from '../src/Bootstrap/Env'
-import { SettingServiceInterface } from '../src/Domain/Setting/SettingServiceInterface'
-import { DomainEventFactoryInterface } from '../src/Domain/Event/DomainEventFactoryInterface'
-import { UserSubscriptionRepositoryInterface } from '../src/Domain/Subscription/UserSubscriptionRepositoryInterface'
-import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
-import { MuteMarketingEmailsOption, SettingName } from '@standardnotes/settings'
-import { EmailMessageIdentifier } from '@standardnotes/common'
-import { TimerInterface } from '@standardnotes/time'
-
-const inputArgs = process.argv.slice(2)
-const emailMessageIdentifier = inputArgs[0]
-
-const sendEmailCampaign = async (
-  userRepository: UserRepositoryInterface,
-  settingService: SettingServiceInterface,
-  userSubscriptionRepository: UserSubscriptionRepositoryInterface,
-  timer: TimerInterface,
-  domainEventFactory: DomainEventFactoryInterface,
-  domainEventPublisher: DomainEventPublisherInterface,
-  logger: Logger,
-): Promise<void> => {
-  const stream = await userRepository.streamAll()
-
-  return new Promise((resolve, reject) => {
-    stream
-      .pipe(
-        new Stream.Transform({
-          objectMode: true,
-          transform: async (rawUserData, _encoding, callback) => {
-            try {
-              const emailsMutedSetting = await settingService.findSettingWithDecryptedValue({
-                userUuid: rawUserData.user_uuid,
-                settingName: SettingName.MuteMarketingEmails,
-              })
-
-              if (emailsMutedSetting === null || emailsMutedSetting.value === MuteMarketingEmailsOption.Muted) {
-                callback()
-
-                return
-              }
-
-              let activeSubscription = false
-              let subscriptionPlanName = null
-
-              const userSubscription = await userSubscriptionRepository.findOneByUserUuid(rawUserData.user_uuid)
-              if (userSubscription !== null) {
-                activeSubscription =
-                  !userSubscription.cancelled && userSubscription.endsAt > timer.getTimestampInMicroseconds()
-                subscriptionPlanName = userSubscription.planName
-              }
-
-              await domainEventPublisher.publish(
-                domainEventFactory.createEmailMessageRequestedEvent({
-                  userEmail: rawUserData.user_email,
-                  messageIdentifier: emailMessageIdentifier as EmailMessageIdentifier,
-                  context: {
-                    activeSubscription,
-                    subscriptionPlanName,
-                    muteEmailsSettingUuid: emailsMutedSetting.uuid,
-                  },
-                }),
-              )
-            } catch (error) {
-              logger.error(`Could not process user ${rawUserData.user_uuid}: ${(error as Error).message}`)
-            }
-
-            callback()
-          },
-        }),
-      )
-      .on('finish', resolve)
-      .on('error', reject)
-  })
-}
-
-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 email campaign for email ${emailMessageIdentifier} ...`)
-
-  if (!emailMessageIdentifier) {
-    logger.error('No email message identifier passed as argument. Skipped sending.')
-
-    process.exit(1)
-  }
-
-  const userRepository: UserRepositoryInterface = container.get(TYPES.UserRepository)
-  const settingService: SettingServiceInterface = container.get(TYPES.SettingService)
-  const userSubscriptionRepository: UserSubscriptionRepositoryInterface = container.get(
-    TYPES.UserSubscriptionRepository,
-  )
-  const timer: TimerInterface = container.get(TYPES.Timer)
-  const domainEventFactory: DomainEventFactoryInterface = container.get(TYPES.DomainEventFactory)
-  const domainEventPublisher: DomainEventPublisherInterface = container.get(TYPES.DomainEventPublisher)
-
-  Promise.resolve(
-    sendEmailCampaign(
-      userRepository,
-      settingService,
-      userSubscriptionRepository,
-      timer,
-      domainEventFactory,
-      domainEventPublisher,
-      logger,
-    ),
-  )
-    .then(() => {
-      logger.info(`${emailMessageIdentifier} email campaign complete.`)
-
-      process.exit(0)
-    })
-    .catch((error) => {
-      logger.error(`Could not finish ${emailMessageIdentifier} email campaign: ${error.message}`)
-
-      process.exit(1)
-    })
-})

packages/auth/bin/user_email_backup.ts

@@ -12,7 +12,7 @@ import { Env } from '../src/Bootstrap/Env'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
 import { DomainEventFactoryInterface } from '../src/Domain/Event/DomainEventFactoryInterface'
 import { SettingRepositoryInterface } from '../src/Domain/Setting/SettingRepositoryInterface'
-import { MuteFailedBackupsEmailsOption, SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { RoleServiceInterface } from '../src/Domain/Role/RoleServiceInterface'
 import { PermissionName } from '@standardnotes/features'
 import { UserRepositoryInterface } from '../src/Domain/User/UserRepositoryInterface'
@@ -28,8 +28,8 @@ const requestBackups = async (
   domainEventPublisher: DomainEventPublisherInterface,
 ): Promise<void> => {
   const permissionName = PermissionName.DailyEmailBackup
-  const muteEmailsSettingName = SettingName.MuteFailedBackupsEmails
-  const muteEmailsSettingValue = MuteFailedBackupsEmailsOption.Muted
+  const muteEmailsSettingName = SettingName.NAMES.MuteFailedBackupsEmails
+  const muteEmailsSettingValue = 'muted'
 
   if (!backupEmail) {
     throw new Error('Could not trigger email backup for user - missing email parameter')

packages/auth/docker/entrypoint.sh

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

packages/auth/jest.config.js

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

packages/auth/migrations/1627638504691-move_mfa_items_to_user_settings.ts

@@ -1,5 +1,5 @@
 import Redis, { Cluster } from 'ioredis'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { MigrationInterface, QueryRunner } from 'typeorm'
 
 import { Setting } from '../src/Domain/Setting/Setting'
@@ -34,7 +34,7 @@ export class moveMfaItemsToUserSettings1627638504691 implements MigrationInterfa
 
       const setting = new Setting()
       setting.uuid = item['uuid']
-      setting.name = SettingName.MfaSecret
+      setting.name = SettingName.NAMES.MfaSecret
       setting.value = item['content']
       if (item['deleted']) {
         setting.value = null

packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/auth-server",
-  "version": "1.61.0",
+  "version": "1.67.1",
   "engines": {
     "node": ">=18.0.0 <19.0.0"
   },
@@ -26,7 +26,6 @@
     "daily-backup:one_drive": "yarn node dist/bin/backup.js one_drive daily",
     "weekly-backup:email": "yarn node dist/bin/backup.js email weekly",
     "content-recalculation": "yarn node dist/bin/content.js",
-    "email-campaign": "yarn node dist/bin/email.js",
     "typeorm": "typeorm-ts-node-commonjs",
     "upgrade:snjs": "yarn ncu -u '@standardnotes/*'"
   },
@@ -42,7 +41,6 @@
     "@standardnotes/predicates": "workspace:*",
     "@standardnotes/responses": "^1.6.39",
     "@standardnotes/security": "workspace:*",
-    "@standardnotes/settings": "workspace:*",
     "@standardnotes/sncrypto-common": "^1.9.0",
     "@standardnotes/sncrypto-node": "workspace:*",
     "@standardnotes/time": "workspace:*",

packages/auth/src/Bootstrap/Container.ts

@@ -193,6 +193,7 @@ import { SubscriptionInvitesController } from '../Controller/SubscriptionInvites
 import { CreateCrossServiceToken } from '../Domain/UseCase/CreateCrossServiceToken/CreateCrossServiceToken'
 import { ProcessUserRequest } from '../Domain/UseCase/ProcessUserRequest/ProcessUserRequest'
 import { UserRequestsController } from '../Controller/UserRequestsController'
+import { EmailSubscriptionUnsubscribedEventHandler } from '../Domain/Handler/EmailSubscriptionUnsubscribedEventHandler'
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const newrelicFormatter = require('@newrelic/winston-enricher')
@@ -560,6 +561,15 @@ export class ContainerConfigLoader {
         )
     }
 
+    container
+      .bind<EmailSubscriptionUnsubscribedEventHandler>(TYPES.EmailSubscriptionUnsubscribedEventHandler)
+      .toConstantValue(
+        new EmailSubscriptionUnsubscribedEventHandler(
+          container.get(TYPES.UserRepository),
+          container.get(TYPES.SettingService),
+        ),
+      )
+
     const eventHandlers: Map<string, DomainEventHandlerInterface> = new Map([
       ['USER_REGISTERED', container.get(TYPES.UserRegisteredEventHandler)],
       ['ACCOUNT_DELETION_REQUESTED', container.get(TYPES.AccountDeletionRequestedEventHandler)],
@@ -582,6 +592,7 @@ export class ContainerConfigLoader {
       ],
       ['SHARED_SUBSCRIPTION_INVITATION_CREATED', container.get(TYPES.SharedSubscriptionInvitationCreatedEventHandler)],
       ['PREDICATE_VERIFICATION_REQUESTED', container.get(TYPES.PredicateVerificationRequestedEventHandler)],
+      ['EMAIL_SUBSCRIPTION_UNSUBSCRIBED', container.get(TYPES.EmailSubscriptionUnsubscribedEventHandler)],
     ])
 
     if (env.get('SQS_QUEUE_URL', true)) {

packages/auth/src/Bootstrap/Types.ts

@@ -138,6 +138,7 @@ const TYPES = {
   UserDisabledSessionUserAgentLoggingEventHandler: Symbol.for('UserDisabledSessionUserAgentLoggingEventHandler'),
   SharedSubscriptionInvitationCreatedEventHandler: Symbol.for('SharedSubscriptionInvitationCreatedEventHandler'),
   PredicateVerificationRequestedEventHandler: Symbol.for('PredicateVerificationRequestedEventHandler'),
+  EmailSubscriptionUnsubscribedEventHandler: Symbol.for('EmailSubscriptionUnsubscribedEventHandler'),
   // Services
   DeviceDetector: Symbol.for('DeviceDetector'),
   SessionService: Symbol.for('SessionService'),

packages/auth/src/Controller/AdminController.ts

@@ -1,4 +1,4 @@
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { Request } from 'express'
 import { inject } from 'inversify'
 import {
@@ -69,7 +69,7 @@ export class AdminController extends BaseHttpController {
     const result = await this.doDeleteSetting.execute({
       uuid,
       userUuid,
-      settingName: SettingName.MfaSecret,
+      settingName: SettingName.NAMES.MfaSecret,
       timestamp: updatedAt,
       softDelete: true,
     })
@@ -115,7 +115,7 @@ export class AdminController extends BaseHttpController {
 
     const result = await this.doDeleteSetting.execute({
       userUuid,
-      settingName: SettingName.EmailBackupFrequency,
+      settingName: SettingName.NAMES.EmailBackupFrequency,
     })
 
     if (result.success) {

packages/auth/src/Controller/SubscriptionSettingsController.ts

@@ -1,4 +1,3 @@
-import { SubscriptionSettingName } from '@standardnotes/settings'
 import { Request, Response } from 'express'
 import { inject } from 'inversify'
 import {
@@ -21,7 +20,7 @@ export class SubscriptionSettingsController extends BaseHttpController {
   async getSubscriptionSetting(request: Request, response: Response): Promise<results.JsonResult> {
     const result = await this.doGetSubscriptionSetting.execute({
       userUuid: response.locals.user.uuid,
-      subscriptionSettingName: request.params.subscriptionSettingName as SubscriptionSettingName,
+      subscriptionSettingName: request.params.subscriptionSettingName,
     })
 
     if (result.success) {

packages/auth/src/Controller/SubscriptionTokensController.ts

@@ -1,6 +1,6 @@
 import { CrossServiceTokenData, TokenEncoderInterface } from '@standardnotes/security'
 import { ErrorTag, RoleName } from '@standardnotes/common'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { Request, Response } from 'express'
 import { inject } from 'inversify'
 import {
@@ -77,7 +77,7 @@ export class SubscriptionTokensController extends BaseHttpController {
     const user = authenticateTokenResponse.user as User
     let extensionKey = undefined
     const extensionKeySetting = await this.settingService.findSettingWithDecryptedValue({
-      settingName: SettingName.ExtensionKey,
+      settingName: SettingName.NAMES.ExtensionKey,
       userUuid: user.uuid,
     })
     if (extensionKeySetting !== null) {

packages/auth/src/Domain/Email/OfflineSubscriptionTokenCreated.ts

@@ -0,0 +1,9 @@
+import { html } from './offline-subscription-token-created.html'
+
+export function getSubject(): string {
+  return 'Access to your Standard Notes Subscription Dashboard'
+}
+
+export function getBody(email: string, offlineSubscriptionDashboardUrl: string): string {
+  return html(email, offlineSubscriptionDashboardUrl)
+}

packages/auth/src/Domain/Email/SharedSubscriptionInvitationCreated.ts

@@ -0,0 +1,9 @@
+import { html } from './shared-subscription-invitation-created.html'
+
+export function getSubject(): string {
+  return 'You have been invited to a Standard Notes subscription'
+}
+
+export function getBody(inviterIdentifier: string, inviteUuid: string): string {
+  return html(inviterIdentifier, inviteUuid)
+}

packages/auth/src/Domain/Email/UserSignedIn.ts

@@ -0,0 +1,9 @@
+import { html } from './user-signed-in.html'
+
+export function getSubject(email: string): string {
+  return `New sign-in for ${email}`
+}
+
+export function getBody(email: string, device: string, browser: string, date: Date): string {
+  return html(email, device, browser, date.toLocaleString())
+}

packages/auth/src/Domain/Email/offline-subscription-token-created.html.ts

@@ -0,0 +1,24 @@
+export const html = (userEmail: string, offlineSubscriptionDashboardUrl: string) => `<div class="sn-component">
+<div class="sk-panel static">
+  <div class="sk-panel-content">
+    <div class="sk-panel-section">
+      <h1 class="h1 title sk-panel-row">
+        <div class="sk-panel-column">
+          Access your Standard Notes Subscription Dashboard,
+        </div>
+      </h1>
+      <div class="faded sk-panel-row small">Registered as ${userEmail}</div>
+    </div>
+    <div class="sk-panel-section">
+      <div class="title">Link to your subscription dashboard: <a
+          href="${offlineSubscriptionDashboardUrl}">${offlineSubscriptionDashboardUrl}</a></div>
+    </div>
+    <div class="sk-panel-section">
+      <p>
+        Get help any time by visiting our <a href="https://standardnotes.com/help">Help page</a>
+        or by replying directly to this email.
+      </p>
+    </div>
+  </div>
+</div>
+</div>`

packages/auth/src/Domain/Email/shared-subscription-invitation-created.html.ts

@@ -0,0 +1,5 @@
+export const html = (inviterIdentifier: string, inviteUuid: string) => `<p>Hello,</p>
+<p>You've been invited to join a Standard Notes premium subscription at no cost. ${inviterIdentifier} has invited you to share the benefits of their subscription plan.</p>
+<p>
+  <a href='https://app.standardnotes.com/?accept-subscription-invite=${inviteUuid}'>Accept Invite</a>
+</p>`

packages/auth/src/Domain/Email/user-signed-in.html.ts

@@ -0,0 +1,24 @@
+export const html = (email: string, device: string, browser: string, timeAndDate: string) => `
+<div>
+<p>Hello,</p>
+<p>We've detected a new sign-in to your account ${email}</p>
+<p>
+  <b>Device type</b>: ${device}
+</p>
+<p>
+  <b>Browser type</b>: ${browser}
+</p>
+<p>
+  <strong>Time and date</strong>: <span>${timeAndDate}</span>
+</p>
+<p>
+  If this was you, please disregard this email. If it wasn't you, we recommend signing into your account and
+  changing your password immediately, then enabling 2FA.
+</p>
+<p>
+  Thanks,
+  <br />
+  SN
+</p>
+</div>
+`

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

@@ -1,26 +1,24 @@
 /* istanbul ignore file */
 
-import { EmailMessageIdentifier, JSONString, ProtocolVersion, RoleName, Uuid } from '@standardnotes/common'
+import { JSONString, ProtocolVersion, RoleName, Uuid } from '@standardnotes/common'
 import {
   AccountDeletionRequestedEvent,
   UserEmailChangedEvent,
   UserRegisteredEvent,
   UserRolesChangedEvent,
-  OfflineSubscriptionTokenCreatedEvent,
   EmailBackupRequestedEvent,
   CloudBackupRequestedEvent,
   ListedAccountRequestedEvent,
-  UserSignedInEvent,
   UserDisabledSessionUserAgentLoggingEvent,
   SharedSubscriptionInvitationCreatedEvent,
   SharedSubscriptionInvitationCanceledEvent,
   PredicateVerifiedEvent,
   DomainEventService,
-  EmailMessageRequestedEvent,
   WebSocketMessageRequestedEvent,
   ExitDiscountApplyRequestedEvent,
   UserContentSizeRecalculationRequestedEvent,
   MuteEmailsSettingChangedEvent,
+  EmailRequestedEvent,
 } from '@standardnotes/domain-events'
 import { Predicate, PredicateVerificationResult } from '@standardnotes/predicates'
 import { TimerInterface } from '@standardnotes/time'
@@ -102,13 +100,15 @@ export class DomainEventFactory implements DomainEventFactoryInterface {
     }
   }
 
-  createEmailMessageRequestedEvent(dto: {
+  createEmailRequestedEvent(dto: {
     userEmail: string
-    messageIdentifier: EmailMessageIdentifier
-    context: Record<string, unknown>
-  }): EmailMessageRequestedEvent {
+    messageIdentifier: string
+    level: string
+    body: string
+    subject: string
+  }): EmailRequestedEvent {
     return {
-      type: 'EMAIL_MESSAGE_REQUESTED',
+      type: 'EMAIL_REQUESTED',
       createdAt: this.timer.getUTCDate(),
       meta: {
         correlation: {
@@ -202,28 +202,6 @@ export class DomainEventFactory implements DomainEventFactoryInterface {
     }
   }
 
-  createUserSignedInEvent(dto: {
-    userUuid: string
-    userEmail: string
-    device: string
-    browser: string
-    signInAlertEnabled: boolean
-    muteSignInEmailsSettingUuid: Uuid
-  }): UserSignedInEvent {
-    return {
-      type: 'USER_SIGNED_IN',
-      createdAt: this.timer.getUTCDate(),
-      meta: {
-        correlation: {
-          userIdentifier: dto.userUuid,
-          userIdentifierType: 'uuid',
-        },
-        origin: DomainEventService.Auth,
-      },
-      payload: dto,
-    }
-  }
-
   createListedAccountRequestedEvent(userUuid: string, userEmail: string): ListedAccountRequestedEvent {
     return {
       type: 'LISTED_ACCOUNT_REQUESTED',
@@ -311,24 +289,6 @@ export class DomainEventFactory implements DomainEventFactoryInterface {
     }
   }
 
-  createOfflineSubscriptionTokenCreatedEvent(token: string, email: string): OfflineSubscriptionTokenCreatedEvent {
-    return {
-      type: 'OFFLINE_SUBSCRIPTION_TOKEN_CREATED',
-      createdAt: this.timer.getUTCDate(),
-      meta: {
-        correlation: {
-          userIdentifier: email,
-          userIdentifierType: 'email',
-        },
-        origin: DomainEventService.Auth,
-      },
-      payload: {
-        token,
-        email,
-      },
-    }
-  }
-
   createUserRegisteredEvent(dto: {
     userUuid: string
     email: string

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

@@ -1,4 +1,4 @@
-import { Uuid, RoleName, EmailMessageIdentifier, ProtocolVersion, JSONString } from '@standardnotes/common'
+import { Uuid, RoleName, ProtocolVersion, JSONString } from '@standardnotes/common'
 import { Predicate, PredicateVerificationResult } from '@standardnotes/predicates'
 import {
   AccountDeletionRequestedEvent,
@@ -6,38 +6,30 @@ import {
   UserRegisteredEvent,
   UserRolesChangedEvent,
   UserEmailChangedEvent,
-  OfflineSubscriptionTokenCreatedEvent,
   EmailBackupRequestedEvent,
   ListedAccountRequestedEvent,
-  UserSignedInEvent,
   UserDisabledSessionUserAgentLoggingEvent,
   SharedSubscriptionInvitationCreatedEvent,
   SharedSubscriptionInvitationCanceledEvent,
   PredicateVerifiedEvent,
-  EmailMessageRequestedEvent,
   WebSocketMessageRequestedEvent,
   ExitDiscountApplyRequestedEvent,
   UserContentSizeRecalculationRequestedEvent,
   MuteEmailsSettingChangedEvent,
+  EmailRequestedEvent,
 } from '@standardnotes/domain-events'
 import { InviteeIdentifierType } from '../SharedSubscription/InviteeIdentifierType'
 
 export interface DomainEventFactoryInterface {
   createUserContentSizeRecalculationRequestedEvent(userUuid: string): UserContentSizeRecalculationRequestedEvent
   createWebSocketMessageRequestedEvent(dto: { userUuid: Uuid; message: JSONString }): WebSocketMessageRequestedEvent
-  createEmailMessageRequestedEvent(dto: {
+  createEmailRequestedEvent(dto: {
     userEmail: string
-    messageIdentifier: EmailMessageIdentifier
-    context: Record<string, unknown>
-  }): EmailMessageRequestedEvent
-  createUserSignedInEvent(dto: {
-    userUuid: string
-    userEmail: string
-    device: string
-    browser: string
-    signInAlertEnabled: boolean
-    muteSignInEmailsSettingUuid: Uuid
-  }): UserSignedInEvent
+    messageIdentifier: string
+    level: string
+    body: string
+    subject: string
+  }): EmailRequestedEvent
   createListedAccountRequestedEvent(userUuid: string, userEmail: string): ListedAccountRequestedEvent
   createUserRegisteredEvent(dto: {
     userUuid: string
@@ -63,7 +55,6 @@ export interface DomainEventFactoryInterface {
   }): AccountDeletionRequestedEvent
   createUserRolesChangedEvent(userUuid: string, email: string, currentRoles: RoleName[]): UserRolesChangedEvent
   createUserEmailChangedEvent(userUuid: string, fromEmail: string, toEmail: string): UserEmailChangedEvent
-  createOfflineSubscriptionTokenCreatedEvent(token: string, email: string): OfflineSubscriptionTokenCreatedEvent
   createUserDisabledSessionUserAgentLoggingEvent(dto: {
     userUuid: Uuid
     email: string

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

@@ -0,0 +1,109 @@
+import { EmailLevel } from '@standardnotes/domain-core'
+import { EmailSubscriptionUnsubscribedEvent } from '@standardnotes/domain-events'
+
+import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
+import { User } from '../User/User'
+import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
+import { EmailSubscriptionUnsubscribedEventHandler } from './EmailSubscriptionUnsubscribedEventHandler'
+
+describe('EmailSubscriptionUnsubscribedEventHandler', () => {
+  let userRepository: UserRepositoryInterface
+  let settingsService: SettingServiceInterface
+  let event: EmailSubscriptionUnsubscribedEvent
+
+  const createHandler = () => new EmailSubscriptionUnsubscribedEventHandler(userRepository, settingsService)
+
+  beforeEach(() => {
+    userRepository = {} as jest.Mocked<UserRepositoryInterface>
+    userRepository.findOneByEmail = jest.fn().mockReturnValue({} as jest.Mocked<User>)
+
+    settingsService = {} as jest.Mocked<SettingServiceInterface>
+    settingsService.createOrReplace = jest.fn()
+
+    event = {
+      payload: {
+        userEmail: 'test@test.te',
+        level: EmailLevel.LEVELS.Marketing,
+      },
+    } as jest.Mocked<EmailSubscriptionUnsubscribedEvent>
+  })
+
+  it('should not do anything if user is not found', async () => {
+    userRepository.findOneByEmail = jest.fn().mockReturnValue(null)
+
+    await createHandler().handle(event)
+
+    expect(settingsService.createOrReplace).not.toHaveBeenCalled()
+  })
+
+  it('should update user marketing email settings', async () => {
+    await createHandler().handle(event)
+
+    expect(settingsService.createOrReplace).toHaveBeenCalledWith({
+      user: {},
+      props: {
+        name: 'MUTE_MARKETING_EMAILS',
+        unencryptedValue: 'muted',
+        sensitive: false,
+      },
+    })
+  })
+
+  it('should update user sign in email settings', async () => {
+    event.payload.level = EmailLevel.LEVELS.SignIn
+
+    await createHandler().handle(event)
+
+    expect(settingsService.createOrReplace).toHaveBeenCalledWith({
+      user: {},
+      props: {
+        name: 'MUTE_SIGN_IN_EMAILS',
+        unencryptedValue: 'muted',
+        sensitive: false,
+      },
+    })
+  })
+
+  it('should update user email backup email settings', async () => {
+    event.payload.level = EmailLevel.LEVELS.FailedEmailBackup
+
+    await createHandler().handle(event)
+
+    expect(settingsService.createOrReplace).toHaveBeenCalledWith({
+      user: {},
+      props: {
+        name: 'MUTE_FAILED_BACKUPS_EMAILS',
+        unencryptedValue: 'muted',
+        sensitive: false,
+      },
+    })
+  })
+
+  it('should update user email backup email settings', async () => {
+    event.payload.level = EmailLevel.LEVELS.FailedCloudBackup
+
+    await createHandler().handle(event)
+
+    expect(settingsService.createOrReplace).toHaveBeenCalledWith({
+      user: {},
+      props: {
+        name: 'MUTE_FAILED_CLOUD_BACKUPS_EMAILS',
+        unencryptedValue: 'muted',
+        sensitive: false,
+      },
+    })
+  })
+
+  it('should throw error for unrecognized level', async () => {
+    event.payload.level = 'foobar'
+
+    let caughtError = null
+    try {
+      await createHandler().handle(event)
+    } catch (error) {
+      caughtError = error
+    }
+
+    expect(caughtError).not.toBeNull()
+  })
+})

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

@@ -0,0 +1,41 @@
+import { EmailLevel } from '@standardnotes/domain-core'
+import { DomainEventHandlerInterface, EmailSubscriptionUnsubscribedEvent } from '@standardnotes/domain-events'
+import { SettingName } from '@standardnotes/settings'
+
+import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
+import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
+
+export class EmailSubscriptionUnsubscribedEventHandler implements DomainEventHandlerInterface {
+  constructor(private userRepository: UserRepositoryInterface, private settingsService: SettingServiceInterface) {}
+
+  async handle(event: EmailSubscriptionUnsubscribedEvent): Promise<void> {
+    const user = await this.userRepository.findOneByEmail(event.payload.userEmail)
+    if (user === null) {
+      return
+    }
+
+    await this.settingsService.createOrReplace({
+      user,
+      props: {
+        name: this.getSettingNameFromLevel(event.payload.level),
+        unencryptedValue: 'muted',
+        sensitive: false,
+      },
+    })
+  }
+
+  private getSettingNameFromLevel(level: string): string {
+    switch (level) {
+      case EmailLevel.LEVELS.FailedCloudBackup:
+        return SettingName.MuteFailedCloudBackupsEmails
+      case EmailLevel.LEVELS.FailedEmailBackup:
+        return SettingName.MuteFailedBackupsEmails
+      case EmailLevel.LEVELS.Marketing:
+        return SettingName.MuteMarketingEmails
+      case EmailLevel.LEVELS.SignIn:
+        return SettingName.MuteSignInEmails
+      default:
+        throw new Error(`Unknown level: ${level}`)
+    }
+  }
+}

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

@@ -1,5 +1,5 @@
 import { DomainEventHandlerInterface, ExtensionKeyGrantedEvent } from '@standardnotes/domain-events'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { OfflineFeaturesTokenData } from '@standardnotes/security'
 import { ContentDecoderInterface } from '@standardnotes/common'
 import { inject, injectable } from 'inversify'
@@ -54,7 +54,7 @@ export class ExtensionKeyGrantedEventHandler implements DomainEventHandlerInterf
     await this.settingService.createOrReplace({
       user,
       props: {
-        name: SettingName.ExtensionKey,
+        name: SettingName.NAMES.ExtensionKey,
         unencryptedValue: event.payload.extensionKey,
         serverEncryptionVersion: EncryptionVersion.Default,
         sensitive: true,

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

@@ -1,5 +1,5 @@
 import { DomainEventHandlerInterface, FileRemovedEvent } from '@standardnotes/domain-events'
-import { SubscriptionSettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 
@@ -38,7 +38,7 @@ export class FileRemovedEventHandler implements DomainEventHandlerInterface {
     const bytesUsedSetting = await this.subscriptionSettingService.findSubscriptionSettingWithDecryptedValue({
       userUuid: user.uuid,
       userSubscriptionUuid: subscription.uuid,
-      subscriptionSettingName: SubscriptionSettingName.FileUploadBytesUsed,
+      subscriptionSettingName: SettingName.NAMES.FileUploadBytesUsed,
     })
     if (bytesUsedSetting === null) {
       this.logger.warn(`Could not find bytes used setting for user with uuid: ${user.uuid}`)
@@ -51,7 +51,7 @@ export class FileRemovedEventHandler implements DomainEventHandlerInterface {
     await this.subscriptionSettingService.createOrReplace({
       userSubscription: subscription,
       props: {
-        name: SubscriptionSettingName.FileUploadBytesUsed,
+        name: SettingName.NAMES.FileUploadBytesUsed,
         unencryptedValue: (+bytesUsed - byteSize).toString(),
         sensitive: false,
         serverEncryptionVersion: EncryptionVersion.Unencrypted,

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

@@ -1,5 +1,5 @@
 import { DomainEventHandlerInterface, FileUploadedEvent } from '@standardnotes/domain-events'
-import { SubscriptionSettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 
@@ -47,7 +47,7 @@ export class FileUploadedEventHandler implements DomainEventHandlerInterface {
     const bytesUsedSetting = await this.subscriptionSettingService.findSubscriptionSettingWithDecryptedValue({
       userUuid: (await subscription.user).uuid,
       userSubscriptionUuid: subscription.uuid,
-      subscriptionSettingName: SubscriptionSettingName.FileUploadBytesUsed,
+      subscriptionSettingName: SettingName.NAMES.FileUploadBytesUsed,
     })
     if (bytesUsedSetting !== null) {
       bytesUsed = bytesUsedSetting.value as string
@@ -56,7 +56,7 @@ export class FileUploadedEventHandler implements DomainEventHandlerInterface {
     await this.subscriptionSettingService.createOrReplace({
       userSubscription: subscription,
       props: {
-        name: SubscriptionSettingName.FileUploadBytesUsed,
+        name: SettingName.NAMES.FileUploadBytesUsed,
         unencryptedValue: (+bytesUsed + byteSize).toString(),
         sensitive: false,
         serverEncryptionVersion: EncryptionVersion.Unencrypted,

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

@@ -1,5 +1,5 @@
 import { DomainEventHandlerInterface, ListedAccountCreatedEvent } from '@standardnotes/domain-events'
-import { ListedAuthorSecretsData, SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 
@@ -25,14 +25,14 @@ export class ListedAccountCreatedEventHandler implements DomainEventHandlerInter
 
     const newSecret = { authorId: event.payload.userId, secret: event.payload.secret, hostUrl: event.payload.hostUrl }
 
-    let authSecrets: ListedAuthorSecretsData = [newSecret]
+    let authSecrets = [newSecret]
 
     const listedAuthorSecretsSetting = await this.settingService.findSettingWithDecryptedValue({
-      settingName: SettingName.ListedAuthorSecrets,
+      settingName: SettingName.NAMES.ListedAuthorSecrets,
       userUuid: user.uuid,
     })
     if (listedAuthorSecretsSetting !== null) {
-      const existingSecrets: ListedAuthorSecretsData = JSON.parse(listedAuthorSecretsSetting.value as string)
+      const existingSecrets = JSON.parse(listedAuthorSecretsSetting.value as string)
       existingSecrets.push(newSecret)
       authSecrets = existingSecrets
     }
@@ -40,7 +40,7 @@ export class ListedAccountCreatedEventHandler implements DomainEventHandlerInter
     await this.settingService.createOrReplace({
       user,
       props: {
-        name: SettingName.ListedAuthorSecrets,
+        name: SettingName.NAMES.ListedAuthorSecrets,
         unencryptedValue: JSON.stringify(authSecrets),
         sensitive: false,
       },

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

@@ -1,5 +1,5 @@
 import { DomainEventHandlerInterface, ListedAccountDeletedEvent } from '@standardnotes/domain-events'
-import { ListedAuthorSecretsData, SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 
@@ -24,7 +24,7 @@ export class ListedAccountDeletedEventHandler implements DomainEventHandlerInter
     }
 
     const listedAuthorSecretsSetting = await this.settingService.findSettingWithDecryptedValue({
-      settingName: SettingName.ListedAuthorSecrets,
+      settingName: SettingName.NAMES.ListedAuthorSecrets,
       userUuid: user.uuid,
     })
     if (listedAuthorSecretsSetting === null) {
@@ -33,9 +33,9 @@ export class ListedAccountDeletedEventHandler implements DomainEventHandlerInter
       return
     }
 
-    const existingSecrets: ListedAuthorSecretsData = JSON.parse(listedAuthorSecretsSetting.value as string)
+    const existingSecrets = JSON.parse(listedAuthorSecretsSetting.value as string)
     const filteredSecrets = existingSecrets.filter(
-      (secret) =>
+      (secret: Record<string, unknown>) =>
         secret.authorId !== event.payload.userId ||
         (secret.authorId === event.payload.userId && secret.hostUrl !== event.payload.hostUrl),
     )
@@ -43,7 +43,7 @@ export class ListedAccountDeletedEventHandler implements DomainEventHandlerInter
     await this.settingService.createOrReplace({
       user,
       props: {
-        name: SettingName.ListedAuthorSecrets,
+        name: SettingName.NAMES.ListedAuthorSecrets,
         unencryptedValue: JSON.stringify(filteredSecrets),
         sensitive: false,
       },

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

@@ -10,7 +10,7 @@ import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 import { UserSubscription } from '../Subscription/UserSubscription'
 import { UserSubscriptionRepositoryInterface } from '../Subscription/UserSubscriptionRepositoryInterface'
 import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { EncryptionVersion } from '../Encryption/EncryptionVersion'
 import { UserSubscriptionType } from '../Subscription/UserSubscriptionType'
 import { SubscriptionSettingServiceInterface } from '../Setting/SubscriptionSettingServiceInterface'
@@ -48,7 +48,7 @@ export class SubscriptionReassignedEventHandler implements DomainEventHandlerInt
     await this.settingService.createOrReplace({
       user,
       props: {
-        name: SettingName.ExtensionKey,
+        name: SettingName.NAMES.ExtensionKey,
         unencryptedValue: event.payload.extensionKey,
         serverEncryptionVersion: EncryptionVersion.Default,
         sensitive: true,

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

@@ -15,7 +15,7 @@ import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
 import { OfflineSettingServiceInterface } from '../Setting/OfflineSettingServiceInterface'
 import { ContentDecoderInterface } from '@standardnotes/common'
 import { OfflineSettingName } from '../Setting/OfflineSettingName'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { EncryptionVersion } from '../Encryption/EncryptionVersion'
 import { UserSubscriptionType } from '../Subscription/UserSubscriptionType'
 import { SubscriptionSettingServiceInterface } from '../Setting/SubscriptionSettingServiceInterface'
@@ -95,7 +95,7 @@ export class SubscriptionSyncRequestedEventHandler implements DomainEventHandler
     await this.settingService.createOrReplace({
       user,
       props: {
-        name: SettingName.ExtensionKey,
+        name: SettingName.NAMES.ExtensionKey,
         unencryptedValue: event.payload.extensionKey,
         serverEncryptionVersion: EncryptionVersion.Default,
         sensitive: true,

packages/auth/src/Domain/Session/SessionService.spec.ts

@@ -12,7 +12,6 @@ import { EphemeralSession } from './EphemeralSession'
 import { RevokedSessionRepositoryInterface } from './RevokedSessionRepositoryInterface'
 import { RevokedSession } from './RevokedSession'
 import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
-import { LogSessionUserAgentOption } from '@standardnotes/settings'
 import { Setting } from '../Setting/Setting'
 import { CryptoNode } from '@standardnotes/sncrypto-node'
 
@@ -171,7 +170,7 @@ describe('SessionService', () => {
     user.uuid = '123'
 
     settingService.findSettingWithDecryptedValue = jest.fn().mockReturnValue({
-      value: LogSessionUserAgentOption.Disabled,
+      value: 'disabled',
     } as jest.Mocked<Setting>)
 
     const sessionPayload = await createService().createNewSessionForUser({

packages/auth/src/Domain/Session/SessionService.ts

@@ -16,7 +16,7 @@ import { EphemeralSession } from './EphemeralSession'
 import { RevokedSession } from './RevokedSession'
 import { RevokedSessionRepositoryInterface } from './RevokedSessionRepositoryInterface'
 import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
-import { LogSessionUserAgentOption, SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { SessionBody } from '@standardnotes/responses'
 import { Uuid } from '@standardnotes/common'
 import { CryptoNode } from '@standardnotes/sncrypto-node'
@@ -291,7 +291,7 @@ export class SessionService implements SessionServiceInterface {
 
   private async isLoggingUserAgentEnabledOnSessions(user: User): Promise<boolean> {
     const loggingSetting = await this.settingService.findSettingWithDecryptedValue({
-      settingName: SettingName.LogSessionUserAgent,
+      settingName: SettingName.NAMES.LogSessionUserAgent,
       userUuid: user.uuid,
     })
 
@@ -299,6 +299,6 @@ export class SessionService implements SessionServiceInterface {
       return true
     }
 
-    return loggingSetting.value === LogSessionUserAgentOption.Enabled
+    return loggingSetting.value === 'enabled'
   }
 }

packages/auth/src/Domain/Setting/FindSettingDTO.ts

@@ -1,8 +1,7 @@
 import { Uuid } from '@standardnotes/common'
-import { SettingName } from '@standardnotes/settings'
 
 export type FindSettingDTO = {
   userUuid: string
-  settingName: SettingName
+  settingName: string
   settingUuid?: Uuid
 }

packages/auth/src/Domain/Setting/FindSubscriptionSettingDTO.ts

@@ -1,9 +1,8 @@
 import { Uuid } from '@standardnotes/common'
-import { SubscriptionSettingName } from '@standardnotes/settings'
 
 export type FindSubscriptionSettingDTO = {
   userUuid: Uuid
   userSubscriptionUuid: Uuid
-  subscriptionSettingName: SubscriptionSettingName
+  subscriptionSettingName: string
   settingUuid?: Uuid
 }

packages/auth/src/Domain/Setting/SettingInterpreter.spec.ts

@@ -5,13 +5,8 @@ import {
   MuteEmailsSettingChangedEvent,
   UserDisabledSessionUserAgentLoggingEvent,
 } from '@standardnotes/domain-events'
-import {
-  EmailBackupFrequency,
-  LogSessionUserAgentOption,
-  MuteMarketingEmailsOption,
-  OneDriveBackupFrequency,
-  SettingName,
-} from '@standardnotes/settings'
+import { MuteMarketingEmailsOption } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import 'reflect-metadata'
 import { Logger } from 'winston'
 import { DomainEventFactoryInterface } from '../Event/DomainEventFactoryInterface'
@@ -71,11 +66,11 @@ describe('SettingInterpreter', () => {
 
   it('should trigger session cleanup if user is disabling session user agent logging', async () => {
     const setting = {
-      name: SettingName.LogSessionUserAgent,
-      value: LogSessionUserAgentOption.Disabled,
+      name: SettingName.NAMES.LogSessionUserAgent,
+      value: 'disabled',
     } as jest.Mocked<Setting>
 
-    await createInterpreter().interpretSettingUpdated(setting, user, LogSessionUserAgentOption.Disabled)
+    await createInterpreter().interpretSettingUpdated(setting, user, 'disabled')
 
     expect(domainEventPublisher.publish).toHaveBeenCalled()
     expect(domainEventFactory.createUserDisabledSessionUserAgentLoggingEvent).toHaveBeenCalledWith({
@@ -86,11 +81,11 @@ describe('SettingInterpreter', () => {
 
   it('should trigger backup if email backup setting is created - emails not muted', async () => {
     const setting = {
-      name: SettingName.EmailBackupFrequency,
-      value: EmailBackupFrequency.Daily,
+      name: SettingName.NAMES.EmailBackupFrequency,
+      value: 'daily',
     } as jest.Mocked<Setting>
 
-    await createInterpreter().interpretSettingUpdated(setting, user, EmailBackupFrequency.Daily)
+    await createInterpreter().interpretSettingUpdated(setting, user, 'daily')
 
     expect(domainEventPublisher.publish).toHaveBeenCalled()
     expect(domainEventFactory.createEmailBackupRequestedEvent).toHaveBeenCalledWith('4-5-6', '', false)
@@ -98,16 +93,16 @@ describe('SettingInterpreter', () => {
 
   it('should trigger backup if email backup setting is created - emails muted', async () => {
     const setting = {
-      name: SettingName.EmailBackupFrequency,
-      value: EmailBackupFrequency.Daily,
+      name: SettingName.NAMES.EmailBackupFrequency,
+      value: 'daily',
     } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue({
-      name: SettingName.MuteFailedBackupsEmails,
+      name: SettingName.NAMES.MuteFailedBackupsEmails,
       uuid: '6-7-8',
       value: 'muted',
     } as jest.Mocked<Setting>)
 
-    await createInterpreter().interpretSettingUpdated(setting, user, EmailBackupFrequency.Daily)
+    await createInterpreter().interpretSettingUpdated(setting, user, 'daily')
 
     expect(domainEventPublisher.publish).toHaveBeenCalled()
     expect(domainEventFactory.createEmailBackupRequestedEvent).toHaveBeenCalledWith('4-5-6', '6-7-8', true)
@@ -115,12 +110,12 @@ describe('SettingInterpreter', () => {
 
   it('should not trigger backup if email backup setting is disabled', async () => {
     const setting = {
-      name: SettingName.EmailBackupFrequency,
-      value: EmailBackupFrequency.Disabled,
+      name: SettingName.NAMES.EmailBackupFrequency,
+      value: 'disabled',
     } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue(null)
 
-    await createInterpreter().interpretSettingUpdated(setting, user, EmailBackupFrequency.Disabled)
+    await createInterpreter().interpretSettingUpdated(setting, user, 'disabled')
 
     expect(domainEventPublisher.publish).not.toHaveBeenCalled()
     expect(domainEventFactory.createEmailBackupRequestedEvent).not.toHaveBeenCalled()
@@ -128,7 +123,7 @@ describe('SettingInterpreter', () => {
 
   it('should trigger cloud backup if dropbox backup setting is created', async () => {
     const setting = {
-      name: SettingName.DropboxBackupToken,
+      name: SettingName.NAMES.DropboxBackupToken,
       value: 'test-token',
     } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue(null)
@@ -147,11 +142,11 @@ describe('SettingInterpreter', () => {
 
   it('should trigger cloud backup if dropbox backup setting is created - muted emails', async () => {
     const setting = {
-      name: SettingName.DropboxBackupToken,
+      name: SettingName.NAMES.DropboxBackupToken,
       value: 'test-token',
     } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue({
-      name: SettingName.MuteFailedCloudBackupsEmails,
+      name: SettingName.NAMES.MuteFailedCloudBackupsEmails,
       uuid: '6-7-8',
       value: 'muted',
     } as jest.Mocked<Setting>)
@@ -170,7 +165,7 @@ describe('SettingInterpreter', () => {
 
   it('should trigger cloud backup if google drive backup setting is created', async () => {
     const setting = {
-      name: SettingName.GoogleDriveBackupToken,
+      name: SettingName.NAMES.GoogleDriveBackupToken,
       value: 'test-token',
     } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue(null)
@@ -189,7 +184,7 @@ describe('SettingInterpreter', () => {
 
   it('should trigger cloud backup if one drive backup setting is created', async () => {
     const setting = {
-      name: SettingName.OneDriveBackupToken,
+      name: SettingName.NAMES.OneDriveBackupToken,
       value: 'test-token',
     } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue(null)
@@ -225,13 +220,13 @@ describe('SettingInterpreter', () => {
 
   it('should trigger cloud backup if backup frequency setting is updated and a backup token setting is present', async () => {
     settingRepository.findLastByNameAndUserUuid = jest.fn().mockReturnValueOnce({
-      name: SettingName.OneDriveBackupToken,
+      name: SettingName.NAMES.OneDriveBackupToken,
       serverEncryptionVersion: 1,
       value: 'encrypted-backup-token',
       sensitive: true,
     } as jest.Mocked<Setting>)
     const setting = {
-      name: SettingName.OneDriveBackupFrequency,
+      name: SettingName.NAMES.OneDriveBackupFrequency,
       serverEncryptionVersion: 0,
       value: 'daily',
       sensitive: false,
@@ -251,19 +246,19 @@ describe('SettingInterpreter', () => {
 
   it('should not trigger cloud backup if backup frequency setting is updated as disabled', async () => {
     settingRepository.findLastByNameAndUserUuid = jest.fn().mockReturnValueOnce({
-      name: SettingName.OneDriveBackupToken,
+      name: SettingName.NAMES.OneDriveBackupToken,
       serverEncryptionVersion: 1,
       value: 'encrypted-backup-token',
       sensitive: true,
     } as jest.Mocked<Setting>)
     const setting = {
-      name: SettingName.OneDriveBackupFrequency,
+      name: SettingName.NAMES.OneDriveBackupFrequency,
       serverEncryptionVersion: 0,
-      value: OneDriveBackupFrequency.Disabled,
+      value: 'disabled',
       sensitive: false,
     } as jest.Mocked<Setting>
 
-    await createInterpreter().interpretSettingUpdated(setting, user, OneDriveBackupFrequency.Disabled)
+    await createInterpreter().interpretSettingUpdated(setting, user, 'disabled')
 
     expect(domainEventPublisher.publish).not.toHaveBeenCalled()
     expect(domainEventFactory.createCloudBackupRequestedEvent).not.toHaveBeenCalled()
@@ -272,7 +267,7 @@ describe('SettingInterpreter', () => {
   it('should not trigger cloud backup if backup frequency setting is updated and a backup token setting is not present', async () => {
     settingRepository.findLastByNameAndUserUuid = jest.fn().mockReturnValueOnce(null)
     const setting = {
-      name: SettingName.OneDriveBackupFrequency,
+      name: SettingName.NAMES.OneDriveBackupFrequency,
       serverEncryptionVersion: 0,
       value: 'daily',
       sensitive: false,

packages/auth/src/Domain/Setting/SettingInterpreter.ts

@@ -1,15 +1,5 @@
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
-import { EmailSubscriptionRejectionLevel } from '@standardnotes/domain-core'
-import {
-  DropboxBackupFrequency,
-  EmailBackupFrequency,
-  GoogleDriveBackupFrequency,
-  LogSessionUserAgentOption,
-  MuteFailedBackupsEmailsOption,
-  MuteFailedCloudBackupsEmailsOption,
-  OneDriveBackupFrequency,
-  SettingName,
-} from '@standardnotes/settings'
+import { EmailLevel, SettingName } from '@standardnotes/domain-core'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 import TYPES from '../../Bootstrap/Types'
@@ -23,28 +13,24 @@ import { SettingRepositoryInterface } from './SettingRepositoryInterface'
 @injectable()
 export class SettingInterpreter implements SettingInterpreterInterface {
   private readonly cloudBackupTokenSettings = [
-    SettingName.DropboxBackupToken,
-    SettingName.GoogleDriveBackupToken,
-    SettingName.OneDriveBackupToken,
+    SettingName.NAMES.DropboxBackupToken,
+    SettingName.NAMES.GoogleDriveBackupToken,
+    SettingName.NAMES.OneDriveBackupToken,
   ]
 
   private readonly cloudBackupFrequencySettings = [
-    SettingName.DropboxBackupFrequency,
-    SettingName.GoogleDriveBackupFrequency,
-    SettingName.OneDriveBackupFrequency,
+    SettingName.NAMES.DropboxBackupFrequency,
+    SettingName.NAMES.GoogleDriveBackupFrequency,
+    SettingName.NAMES.OneDriveBackupFrequency,
   ]
 
-  private readonly cloudBackupFrequencyDisabledValues = [
-    DropboxBackupFrequency.Disabled,
-    GoogleDriveBackupFrequency.Disabled,
-    OneDriveBackupFrequency.Disabled,
-  ]
+  private readonly cloudBackupFrequencyDisabledValues = ['disabled']
 
   private readonly emailSettingToSubscriptionRejectionLevelMap: Map<SettingName, string> = new Map([
-    [SettingName.MuteFailedBackupsEmails, EmailSubscriptionRejectionLevel.LEVELS.FailedEmailBackup],
-    [SettingName.MuteFailedCloudBackupsEmails, EmailSubscriptionRejectionLevel.LEVELS.FailedCloudBackup],
-    [SettingName.MuteMarketingEmails, EmailSubscriptionRejectionLevel.LEVELS.Marketing],
-    [SettingName.MuteSignInEmails, EmailSubscriptionRejectionLevel.LEVELS.SignIn],
+    [SettingName.MuteFailedBackupsEmails, EmailLevel.LEVELS.FailedEmailBackup],
+    [SettingName.MuteFailedCloudBackupsEmails, EmailLevel.LEVELS.FailedCloudBackup],
+    [SettingName.MuteMarketingEmails, EmailLevel.LEVELS.Marketing],
+    [SettingName.MuteSignInEmails, EmailLevel.LEVELS.SignIn],
   ])
 
   constructor(
@@ -77,11 +63,11 @@ export class SettingInterpreter implements SettingInterpreterInterface {
     let userHasEmailsMuted = false
     let muteEmailsSettingUuid = ''
     const muteFailedEmailsBackupSetting = await this.settingRepository.findOneByNameAndUserUuid(
-      SettingName.MuteFailedBackupsEmails,
+      SettingName.NAMES.MuteFailedBackupsEmails,
       userUuid,
     )
     if (muteFailedEmailsBackupSetting !== null) {
-      userHasEmailsMuted = muteFailedEmailsBackupSetting.value === MuteFailedBackupsEmailsOption.Muted
+      userHasEmailsMuted = muteFailedEmailsBackupSetting.value === 'muted'
       muteEmailsSettingUuid = muteFailedEmailsBackupSetting.uuid
     }
 
@@ -100,21 +86,19 @@ export class SettingInterpreter implements SettingInterpreterInterface {
   }
 
   private isEnablingEmailBackupSetting(setting: Setting): boolean {
-    return setting.name === SettingName.EmailBackupFrequency && setting.value !== EmailBackupFrequency.Disabled
+    return setting.name === SettingName.NAMES.EmailBackupFrequency && setting.value !== 'disabled'
   }
 
   private isEnablingCloudBackupSetting(setting: Setting): boolean {
     return (
-      (this.cloudBackupFrequencySettings.includes(setting.name as SettingName) ||
-        this.cloudBackupTokenSettings.includes(setting.name as SettingName)) &&
-      !this.cloudBackupFrequencyDisabledValues.includes(
-        setting.value as DropboxBackupFrequency | OneDriveBackupFrequency | GoogleDriveBackupFrequency,
-      )
+      (this.cloudBackupFrequencySettings.includes(setting.name) ||
+        this.cloudBackupTokenSettings.includes(setting.name)) &&
+      !this.cloudBackupFrequencyDisabledValues.includes(setting.value as string)
     )
   }
 
   private isDisablingSessionUserAgentLogging(setting: Setting): boolean {
-    return SettingName.LogSessionUserAgent === setting.name && LogSessionUserAgentOption.Disabled === setting.value
+    return SettingName.NAMES.LogSessionUserAgent === setting.name && 'disabled' === setting.value
   }
 
   private async triggerEmailSubscriptionChange(
@@ -144,29 +128,26 @@ export class SettingInterpreter implements SettingInterpreterInterface {
     let cloudProvider
     let tokenSettingName
     switch (setting.name) {
-      case SettingName.DropboxBackupToken:
-      case SettingName.DropboxBackupFrequency:
+      case SettingName.NAMES.DropboxBackupToken:
+      case SettingName.NAMES.DropboxBackupFrequency:
         cloudProvider = 'DROPBOX'
-        tokenSettingName = SettingName.DropboxBackupToken
+        tokenSettingName = SettingName.NAMES.DropboxBackupToken
         break
-      case SettingName.GoogleDriveBackupToken:
-      case SettingName.GoogleDriveBackupFrequency:
+      case SettingName.NAMES.GoogleDriveBackupToken:
+      case SettingName.NAMES.GoogleDriveBackupFrequency:
         cloudProvider = 'GOOGLE_DRIVE'
-        tokenSettingName = SettingName.GoogleDriveBackupToken
+        tokenSettingName = SettingName.NAMES.GoogleDriveBackupToken
         break
-      case SettingName.OneDriveBackupToken:
-      case SettingName.OneDriveBackupFrequency:
+      case SettingName.NAMES.OneDriveBackupToken:
+      case SettingName.NAMES.OneDriveBackupFrequency:
         cloudProvider = 'ONE_DRIVE'
-        tokenSettingName = SettingName.OneDriveBackupToken
+        tokenSettingName = SettingName.NAMES.OneDriveBackupToken
         break
     }
 
     let backupToken = null
-    if (this.cloudBackupFrequencySettings.includes(setting.name as SettingName)) {
-      const tokenSetting = await this.settingRepository.findLastByNameAndUserUuid(
-        tokenSettingName as SettingName,
-        userUuid,
-      )
+    if (this.cloudBackupFrequencySettings.includes(setting.name)) {
+      const tokenSetting = await this.settingRepository.findLastByNameAndUserUuid(tokenSettingName as string, userUuid)
       if (tokenSetting !== null) {
         backupToken = await this.settingDecrypter.decryptSettingValue(tokenSetting, userUuid)
       }
@@ -183,11 +164,11 @@ export class SettingInterpreter implements SettingInterpreterInterface {
     let userHasEmailsMuted = false
     let muteEmailsSettingUuid = ''
     const muteFailedCloudBackupSetting = await this.settingRepository.findOneByNameAndUserUuid(
-      SettingName.MuteFailedCloudBackupsEmails,
+      SettingName.NAMES.MuteFailedCloudBackupsEmails,
       userUuid,
     )
     if (muteFailedCloudBackupSetting !== null) {
-      userHasEmailsMuted = muteFailedCloudBackupSetting.value === MuteFailedCloudBackupsEmailsOption.Muted
+      userHasEmailsMuted = muteFailedCloudBackupSetting.value === 'muted'
       muteEmailsSettingUuid = muteFailedCloudBackupSetting.uuid
     }
 

packages/auth/src/Domain/Setting/SettingRepositoryInterface.ts

@@ -1,16 +1,15 @@
 import { ReadStream } from 'fs'
 
-import { SettingName } from '@standardnotes/settings'
 import { DeleteSettingDto } from '../UseCase/DeleteSetting/DeleteSettingDto'
 import { Setting } from './Setting'
 
 export interface SettingRepositoryInterface {
   findOneByUuid(uuid: string): Promise<Setting | null>
-  findOneByUuidAndNames(uuid: string, names: SettingName[]): Promise<Setting | null>
+  findOneByUuidAndNames(uuid: string, names: string[]): Promise<Setting | null>
   findOneByNameAndUserUuid(name: string, userUuid: string): Promise<Setting | null>
   findLastByNameAndUserUuid(name: string, userUuid: string): Promise<Setting | null>
   findAllByUserUuid(userUuid: string): Promise<Setting[]>
-  streamAllByNameAndValue(name: SettingName, value: string): Promise<ReadStream>
+  streamAllByNameAndValue(name: string, value: string): Promise<ReadStream>
   deleteByUserUuid(dto: DeleteSettingDto): Promise<void>
   save(setting: Setting): Promise<Setting>
 }

packages/auth/src/Domain/Setting/SettingService.spec.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata'
 
-import { LogSessionUserAgentOption, MuteSignInEmailsOption, SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { Logger } from 'winston'
 import { EncryptionVersion } from '../Encryption/EncryptionVersion'
 import { User } from '../User/User'
@@ -54,9 +54,9 @@ describe('SettingService', () => {
     settingsAssociationService.getDefaultSettingsAndValuesForNewUser = jest.fn().mockReturnValue(
       new Map([
         [
-          SettingName.MuteSignInEmails,
+          SettingName.NAMES.MuteSignInEmails,
           {
-            value: MuteSignInEmailsOption.NotMuted,
+            value: 'not_muted',
             sensitive: 0,
             serverEncryptionVersion: EncryptionVersion.Unencrypted,
           },
@@ -67,11 +67,11 @@ describe('SettingService', () => {
     settingsAssociationService.getDefaultSettingsAndValuesForNewVaultAccount = jest.fn().mockReturnValue(
       new Map([
         [
-          SettingName.LogSessionUserAgent,
+          SettingName.NAMES.LogSessionUserAgent,
           {
             sensitive: false,
             serverEncryptionVersion: EncryptionVersion.Unencrypted,
-            value: LogSessionUserAgentOption.Disabled,
+            value: 'disabled',
           },
         ],
       ]),
@@ -173,9 +173,7 @@ describe('SettingService', () => {
 
     settingRepository.findLastByNameAndUserUuid = jest.fn().mockReturnValue(setting)
 
-    expect(
-      await createService().findSettingWithDecryptedValue({ userUuid: '1-2-3', settingName: 'test' as SettingName }),
-    ).toEqual({
+    expect(await createService().findSettingWithDecryptedValue({ userUuid: '1-2-3', settingName: 'test' })).toEqual({
       serverEncryptionVersion: 1,
       value: 'decrypted',
     })

packages/auth/src/Domain/Setting/SettingService.ts

@@ -1,4 +1,3 @@
-import { SettingName } from '@standardnotes/settings'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 import TYPES from '../../Bootstrap/Types'
@@ -74,7 +73,7 @@ export class SettingService implements SettingServiceInterface {
 
     const existing = await this.findSettingWithDecryptedValue({
       userUuid: user.uuid,
-      settingName: props.name as SettingName,
+      settingName: props.name,
       settingUuid: props.uuid,
     })
 

packages/auth/src/Domain/Setting/SettingsAssociationService.spec.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata'
 
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { PermissionName } from '@standardnotes/features'
 
 import { SettingsAssociationService } from './SettingsAssociationService'
@@ -11,52 +11,54 @@ describe('SettingsAssociationService', () => {
   const createService = () => new SettingsAssociationService()
 
   it('should tell if a setting is mutable by the client', () => {
-    expect(createService().isSettingMutableByClient(SettingName.DropboxBackupFrequency)).toBeTruthy()
+    expect(createService().isSettingMutableByClient(SettingName.NAMES.DropboxBackupFrequency)).toBeTruthy()
   })
 
   it('should tell if a setting is immutable by the client', () => {
-    expect(createService().isSettingMutableByClient(SettingName.ListedAuthorSecrets)).toBeFalsy()
+    expect(createService().isSettingMutableByClient(SettingName.NAMES.ListedAuthorSecrets)).toBeFalsy()
   })
 
   it('should return default encryption version for a setting which enecryption version is not strictly defined', () => {
-    expect(createService().getEncryptionVersionForSetting(SettingName.MfaSecret)).toEqual(EncryptionVersion.Default)
+    expect(createService().getEncryptionVersionForSetting(SettingName.NAMES.MfaSecret)).toEqual(
+      EncryptionVersion.Default,
+    )
   })
 
   it('should return a defined encryption version for a setting which enecryption version is strictly defined', () => {
-    expect(createService().getEncryptionVersionForSetting(SettingName.EmailBackupFrequency)).toEqual(
+    expect(createService().getEncryptionVersionForSetting(SettingName.NAMES.EmailBackupFrequency)).toEqual(
       EncryptionVersion.Unencrypted,
     )
   })
 
   it('should return default sensitivity for a setting which sensitivity is not strictly defined', () => {
-    expect(createService().getSensitivityForSetting(SettingName.DropboxBackupToken)).toBeTruthy()
+    expect(createService().getSensitivityForSetting(SettingName.NAMES.DropboxBackupToken)).toBeTruthy()
   })
 
   it('should return a defined sensitivity for a setting which sensitivity is strictly defined', () => {
-    expect(createService().getSensitivityForSetting(SettingName.DropboxBackupFrequency)).toBeFalsy()
+    expect(createService().getSensitivityForSetting(SettingName.NAMES.DropboxBackupFrequency)).toBeFalsy()
   })
 
   it('should return the default set of settings for a newly registered user', () => {
     const settings = createService().getDefaultSettingsAndValuesForNewUser()
-    const flatSettings = [...(settings as Map<SettingName, SettingDescription>).keys()]
+    const flatSettings = [...(settings as Map<string, SettingDescription>).keys()]
     expect(flatSettings).toEqual(['MUTE_SIGN_IN_EMAILS', 'MUTE_MARKETING_EMAILS', 'LOG_SESSION_USER_AGENT'])
   })
 
   it('should return the default set of settings for a newly registered vault account', () => {
     const settings = createService().getDefaultSettingsAndValuesForNewVaultAccount()
-    const flatSettings = [...(settings as Map<SettingName, SettingDescription>).keys()]
+    const flatSettings = [...(settings as Map<string, SettingDescription>).keys()]
     expect(flatSettings).toEqual(['MUTE_SIGN_IN_EMAILS', 'MUTE_MARKETING_EMAILS', 'LOG_SESSION_USER_AGENT'])
 
-    expect(settings.get(SettingName.LogSessionUserAgent)?.value).toEqual('disabled')
+    expect(settings.get(SettingName.NAMES.LogSessionUserAgent)?.value).toEqual('disabled')
   })
 
   it('should return a permission name associated to a given setting', () => {
-    expect(createService().getPermissionAssociatedWithSetting(SettingName.EmailBackupFrequency)).toEqual(
+    expect(createService().getPermissionAssociatedWithSetting(SettingName.NAMES.EmailBackupFrequency)).toEqual(
       PermissionName.DailyEmailBackup,
     )
   })
 
   it('should not return a permission name if not associated to a given setting', () => {
-    expect(createService().getPermissionAssociatedWithSetting(SettingName.ExtensionKey)).toBeUndefined()
+    expect(createService().getPermissionAssociatedWithSetting(SettingName.NAMES.ExtensionKey)).toBeUndefined()
   })
 })

packages/auth/src/Domain/Setting/SettingsAssociationService.ts

@@ -1,10 +1,5 @@
 import { PermissionName } from '@standardnotes/features'
-import {
-  LogSessionUserAgentOption,
-  MuteMarketingEmailsOption,
-  MuteSignInEmailsOption,
-  SettingName,
-} from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { injectable } from 'inversify'
 
 import { EncryptionVersion } from '../Encryption/EncryptionVersion'
@@ -15,79 +10,79 @@ import { SettingsAssociationServiceInterface } from './SettingsAssociationServic
 @injectable()
 export class SettingsAssociationService implements SettingsAssociationServiceInterface {
   private readonly UNENCRYPTED_SETTINGS = [
-    SettingName.EmailBackupFrequency,
-    SettingName.MuteFailedBackupsEmails,
-    SettingName.MuteFailedCloudBackupsEmails,
-    SettingName.MuteSignInEmails,
-    SettingName.MuteMarketingEmails,
-    SettingName.DropboxBackupFrequency,
-    SettingName.GoogleDriveBackupFrequency,
-    SettingName.OneDriveBackupFrequency,
-    SettingName.LogSessionUserAgent,
+    SettingName.NAMES.EmailBackupFrequency,
+    SettingName.NAMES.MuteFailedBackupsEmails,
+    SettingName.NAMES.MuteFailedCloudBackupsEmails,
+    SettingName.NAMES.MuteSignInEmails,
+    SettingName.NAMES.MuteMarketingEmails,
+    SettingName.NAMES.DropboxBackupFrequency,
+    SettingName.NAMES.GoogleDriveBackupFrequency,
+    SettingName.NAMES.OneDriveBackupFrequency,
+    SettingName.NAMES.LogSessionUserAgent,
   ]
 
   private readonly UNSENSITIVE_SETTINGS = [
-    SettingName.DropboxBackupFrequency,
-    SettingName.GoogleDriveBackupFrequency,
-    SettingName.OneDriveBackupFrequency,
-    SettingName.EmailBackupFrequency,
-    SettingName.MuteFailedBackupsEmails,
-    SettingName.MuteFailedCloudBackupsEmails,
-    SettingName.MuteSignInEmails,
-    SettingName.MuteMarketingEmails,
-    SettingName.ListedAuthorSecrets,
-    SettingName.LogSessionUserAgent,
+    SettingName.NAMES.DropboxBackupFrequency,
+    SettingName.NAMES.GoogleDriveBackupFrequency,
+    SettingName.NAMES.OneDriveBackupFrequency,
+    SettingName.NAMES.EmailBackupFrequency,
+    SettingName.NAMES.MuteFailedBackupsEmails,
+    SettingName.NAMES.MuteFailedCloudBackupsEmails,
+    SettingName.NAMES.MuteSignInEmails,
+    SettingName.NAMES.MuteMarketingEmails,
+    SettingName.NAMES.ListedAuthorSecrets,
+    SettingName.NAMES.LogSessionUserAgent,
   ]
 
-  private readonly CLIENT_IMMUTABLE_SETTINGS = [SettingName.ListedAuthorSecrets]
+  private readonly CLIENT_IMMUTABLE_SETTINGS = [SettingName.NAMES.ListedAuthorSecrets]
 
-  private readonly permissionsAssociatedWithSettings = new Map<SettingName, PermissionName>([
-    [SettingName.EmailBackupFrequency, PermissionName.DailyEmailBackup],
+  private readonly permissionsAssociatedWithSettings = new Map<string, PermissionName>([
+    [SettingName.NAMES.EmailBackupFrequency, PermissionName.DailyEmailBackup],
   ])
 
-  private readonly defaultSettings = new Map<SettingName, SettingDescription>([
+  private readonly defaultSettings = new Map<string, SettingDescription>([
     [
-      SettingName.MuteSignInEmails,
+      SettingName.NAMES.MuteSignInEmails,
       {
         sensitive: false,
         serverEncryptionVersion: EncryptionVersion.Unencrypted,
-        value: MuteSignInEmailsOption.NotMuted,
+        value: 'not_muted',
         replaceable: false,
       },
     ],
     [
-      SettingName.MuteMarketingEmails,
+      SettingName.NAMES.MuteMarketingEmails,
       {
         sensitive: false,
         serverEncryptionVersion: EncryptionVersion.Unencrypted,
-        value: MuteMarketingEmailsOption.NotMuted,
+        value: 'not_muted',
         replaceable: false,
       },
     ],
     [
-      SettingName.LogSessionUserAgent,
+      SettingName.NAMES.LogSessionUserAgent,
       {
         sensitive: false,
         serverEncryptionVersion: EncryptionVersion.Unencrypted,
-        value: LogSessionUserAgentOption.Enabled,
+        value: 'enabled',
         replaceable: false,
       },
     ],
   ])
 
-  private readonly vaultAccountDefaultSettingsOverwrites = new Map<SettingName, SettingDescription>([
+  private readonly vaultAccountDefaultSettingsOverwrites = new Map<string, SettingDescription>([
     [
-      SettingName.LogSessionUserAgent,
+      SettingName.NAMES.LogSessionUserAgent,
       {
         sensitive: false,
         serverEncryptionVersion: EncryptionVersion.Unencrypted,
-        value: LogSessionUserAgentOption.Disabled,
+        value: 'disabled',
         replaceable: false,
       },
     ],
   ])
 
-  isSettingMutableByClient(settingName: SettingName): boolean {
+  isSettingMutableByClient(settingName: string): boolean {
     if (this.CLIENT_IMMUTABLE_SETTINGS.includes(settingName)) {
       return false
     }
@@ -95,7 +90,7 @@ export class SettingsAssociationService implements SettingsAssociationServiceInt
     return true
   }
 
-  getSensitivityForSetting(settingName: SettingName): boolean {
+  getSensitivityForSetting(settingName: string): boolean {
     if (this.UNSENSITIVE_SETTINGS.includes(settingName)) {
       return false
     }
@@ -103,7 +98,7 @@ export class SettingsAssociationService implements SettingsAssociationServiceInt
     return true
   }
 
-  getEncryptionVersionForSetting(settingName: SettingName): EncryptionVersion {
+  getEncryptionVersionForSetting(settingName: string): EncryptionVersion {
     if (this.UNENCRYPTED_SETTINGS.includes(settingName)) {
       return EncryptionVersion.Unencrypted
     }
@@ -111,7 +106,7 @@ export class SettingsAssociationService implements SettingsAssociationServiceInt
     return EncryptionVersion.Default
   }
 
-  getPermissionAssociatedWithSetting(settingName: SettingName): PermissionName | undefined {
+  getPermissionAssociatedWithSetting(settingName: string): PermissionName | undefined {
     if (!this.permissionsAssociatedWithSettings.has(settingName)) {
       return undefined
     }
@@ -119,11 +114,11 @@ export class SettingsAssociationService implements SettingsAssociationServiceInt
     return this.permissionsAssociatedWithSettings.get(settingName)
   }
 
-  getDefaultSettingsAndValuesForNewUser(): Map<SettingName, SettingDescription> {
+  getDefaultSettingsAndValuesForNewUser(): Map<string, SettingDescription> {
     return this.defaultSettings
   }
 
-  getDefaultSettingsAndValuesForNewVaultAccount(): Map<SettingName, SettingDescription> {
+  getDefaultSettingsAndValuesForNewVaultAccount(): Map<string, SettingDescription> {
     const defaultVaultSettings = new Map(this.defaultSettings)
 
     for (const vaultAccountDefaultSettingOverwriteKey of this.vaultAccountDefaultSettingsOverwrites.keys()) {

packages/auth/src/Domain/Setting/SettingsAssociationServiceInterface.ts

@@ -1,13 +1,12 @@
 import { PermissionName } from '@standardnotes/features'
-import { SettingName, SubscriptionSettingName } from '@standardnotes/settings'
 import { EncryptionVersion } from '../Encryption/EncryptionVersion'
 import { SettingDescription } from './SettingDescription'
 
 export interface SettingsAssociationServiceInterface {
-  getDefaultSettingsAndValuesForNewUser(): Map<SettingName, SettingDescription>
-  getDefaultSettingsAndValuesForNewVaultAccount(): Map<SettingName, SettingDescription>
-  getPermissionAssociatedWithSetting(settingName: SettingName): PermissionName | undefined
-  getEncryptionVersionForSetting(settingName: SettingName): EncryptionVersion
-  getSensitivityForSetting(settingName: SettingName): boolean
-  isSettingMutableByClient(settingName: SettingName | SubscriptionSettingName): boolean
+  getDefaultSettingsAndValuesForNewUser(): Map<string, SettingDescription>
+  getDefaultSettingsAndValuesForNewVaultAccount(): Map<string, SettingDescription>
+  getPermissionAssociatedWithSetting(settingName: string): PermissionName | undefined
+  getEncryptionVersionForSetting(settingName: string): EncryptionVersion
+  getSensitivityForSetting(settingName: string): boolean
+  isSettingMutableByClient(settingName: string): boolean
 }

packages/auth/src/Domain/Setting/SubscriptionSettingService.spec.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata'
 
-import { SubscriptionSettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { Logger } from 'winston'
 import { EncryptionVersion } from '../Encryption/EncryptionVersion'
 
@@ -68,7 +68,7 @@ describe('SubscriptionSettingService', () => {
     subscriptionSettingsAssociationService.getDefaultSettingsAndValuesForSubscriptionName = jest.fn().mockReturnValue(
       new Map([
         [
-          SubscriptionSettingName.FileUploadBytesUsed,
+          SettingName.NAMES.FileUploadBytesUsed,
           {
             value: '0',
             sensitive: 0,
@@ -102,7 +102,7 @@ describe('SubscriptionSettingService', () => {
     subscriptionSettingsAssociationService.getDefaultSettingsAndValuesForSubscriptionName = jest.fn().mockReturnValue(
       new Map([
         [
-          SubscriptionSettingName.FileUploadBytesUsed,
+          SettingName.NAMES.FileUploadBytesUsed,
           {
             value: '0',
             sensitive: 0,
@@ -127,7 +127,7 @@ describe('SubscriptionSettingService', () => {
     subscriptionSettingsAssociationService.getDefaultSettingsAndValuesForSubscriptionName = jest.fn().mockReturnValue(
       new Map([
         [
-          SubscriptionSettingName.FileUploadBytesUsed,
+          SettingName.NAMES.FileUploadBytesUsed,
           {
             value: '0',
             sensitive: 0,
@@ -152,7 +152,7 @@ describe('SubscriptionSettingService', () => {
     subscriptionSettingsAssociationService.getDefaultSettingsAndValuesForSubscriptionName = jest.fn().mockReturnValue(
       new Map([
         [
-          SubscriptionSettingName.FileUploadBytesUsed,
+          SettingName.NAMES.FileUploadBytesUsed,
           {
             value: '0',
             sensitive: 0,
@@ -266,7 +266,7 @@ describe('SubscriptionSettingService', () => {
       await createService().findSubscriptionSettingWithDecryptedValue({
         userSubscriptionUuid: '2-3-4',
         userUuid: '1-2-3',
-        subscriptionSettingName: 'test' as SubscriptionSettingName,
+        subscriptionSettingName: 'test',
       }),
     ).toEqual({
       serverEncryptionVersion: 1,

packages/auth/src/Domain/Setting/SubscriptionSettingService.ts

@@ -1,5 +1,4 @@
 import { SubscriptionName, Uuid } from '@standardnotes/common'
-import { SubscriptionSettingName } from '@standardnotes/settings'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 
@@ -98,7 +97,7 @@ export class SubscriptionSettingService implements SubscriptionSettingServiceInt
     const existing = await this.findSubscriptionSettingWithDecryptedValue({
       userUuid: (await userSubscription.user).uuid,
       userSubscriptionUuid: userSubscription.uuid,
-      subscriptionSettingName: props.name as SubscriptionSettingName,
+      subscriptionSettingName: props.name,
       settingUuid: props.uuid,
     })
 
@@ -128,7 +127,7 @@ export class SubscriptionSettingService implements SubscriptionSettingServiceInt
   }
 
   private async findPreviousSubscriptionSetting(
-    settingName: SubscriptionSettingName,
+    settingName: string,
     currentUserSubscriptionUuid: Uuid,
     userUuid: Uuid,
   ): Promise<SubscriptionSetting | null> {

packages/auth/src/Domain/Setting/SubscriptionSettingsAssociationService.spec.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata'
 
 import { RoleName, SubscriptionName } from '@standardnotes/common'
-import { SubscriptionSettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 
 import { PermissionName } from '@standardnotes/features'
 import { EncryptionVersion } from '../Encryption/EncryptionVersion'
@@ -50,14 +50,11 @@ describe('SubscriptionSettingsAssociationService', () => {
 
     const flatSettings = [
       ...(
-        settings as Map<
-          SubscriptionSettingName,
-          { value: string; sensitive: boolean; serverEncryptionVersion: EncryptionVersion }
-        >
+        settings as Map<string, { value: string; sensitive: boolean; serverEncryptionVersion: EncryptionVersion }>
       ).keys(),
     ]
     expect(flatSettings).toEqual(['FILE_UPLOAD_BYTES_USED', 'FILE_UPLOAD_BYTES_LIMIT'])
-    expect(settings?.get(SubscriptionSettingName.FileUploadBytesLimit)).toEqual({
+    expect(settings?.get(SettingName.NAMES.FileUploadBytesLimit)).toEqual({
       sensitive: false,
       serverEncryptionVersion: 0,
       value: '107374182400',
@@ -78,14 +75,11 @@ describe('SubscriptionSettingsAssociationService', () => {
 
     const flatSettings = [
       ...(
-        settings as Map<
-          SubscriptionSettingName,
-          { value: string; sensitive: boolean; serverEncryptionVersion: EncryptionVersion }
-        >
+        settings as Map<string, { value: string; sensitive: boolean; serverEncryptionVersion: EncryptionVersion }>
       ).keys(),
     ]
     expect(flatSettings).toEqual(['FILE_UPLOAD_BYTES_USED', 'FILE_UPLOAD_BYTES_LIMIT'])
-    expect(settings?.get(SubscriptionSettingName.FileUploadBytesLimit)).toEqual({
+    expect(settings?.get(SettingName.NAMES.FileUploadBytesLimit)).toEqual({
       sensitive: false,
       serverEncryptionVersion: 0,
       value: '104857600',

packages/auth/src/Domain/Setting/SubscriptionSettingsAssociationService.ts

@@ -1,6 +1,6 @@
 import { RoleName, SubscriptionName } from '@standardnotes/common'
 import { PermissionName } from '@standardnotes/features'
-import { SubscriptionSettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { inject, injectable } from 'inversify'
 
 import TYPES from '../../Bootstrap/Types'
@@ -19,15 +19,12 @@ export class SubscriptionSettingsAssociationService implements SubscriptionSetti
     @inject(TYPES.RoleRepository) private roleRepository: RoleRepositoryInterface,
   ) {}
 
-  private readonly settingsToSubscriptionNameMap = new Map<
-    SubscriptionName,
-    Map<SubscriptionSettingName, SettingDescription>
-  >([
+  private readonly settingsToSubscriptionNameMap = new Map<SubscriptionName, Map<string, SettingDescription>>([
     [
       SubscriptionName.PlusPlan,
       new Map([
         [
-          SubscriptionSettingName.FileUploadBytesUsed,
+          SettingName.NAMES.FileUploadBytesUsed,
           { sensitive: false, serverEncryptionVersion: EncryptionVersion.Unencrypted, value: '0', replaceable: false },
         ],
       ]),
@@ -36,7 +33,7 @@ export class SubscriptionSettingsAssociationService implements SubscriptionSetti
       SubscriptionName.ProPlan,
       new Map([
         [
-          SubscriptionSettingName.FileUploadBytesUsed,
+          SettingName.NAMES.FileUploadBytesUsed,
           { sensitive: false, serverEncryptionVersion: EncryptionVersion.Unencrypted, value: '0', replaceable: false },
         ],
       ]),
@@ -45,14 +42,14 @@ export class SubscriptionSettingsAssociationService implements SubscriptionSetti
 
   async getDefaultSettingsAndValuesForSubscriptionName(
     subscriptionName: SubscriptionName,
-  ): Promise<Map<SubscriptionSettingName, SettingDescription> | undefined> {
+  ): Promise<Map<string, SettingDescription> | undefined> {
     const defaultSettings = this.settingsToSubscriptionNameMap.get(subscriptionName)
 
     if (defaultSettings === undefined) {
       return undefined
     }
 
-    defaultSettings.set(SubscriptionSettingName.FileUploadBytesLimit, {
+    defaultSettings.set(SettingName.NAMES.FileUploadBytesLimit, {
       sensitive: false,
       serverEncryptionVersion: EncryptionVersion.Unencrypted,
       value: (await this.getFileUploadLimit(subscriptionName)).toString(),

packages/auth/src/Domain/Setting/SubscriptionSettingsAssociationServiceInterface.ts

@@ -1,11 +1,10 @@
 import { SubscriptionName } from '@standardnotes/common'
-import { SubscriptionSettingName } from '@standardnotes/settings'
 
 import { SettingDescription } from './SettingDescription'
 
 export interface SubscriptionSettingsAssociationServiceInterface {
   getDefaultSettingsAndValuesForSubscriptionName(
     subscriptionName: SubscriptionName,
-  ): Promise<Map<SubscriptionSettingName, SettingDescription> | undefined>
+  ): Promise<Map<string, SettingDescription> | undefined>
   getFileUploadLimit(subscriptionName: SubscriptionName): Promise<number>
 }

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

@@ -5,7 +5,7 @@ import { TimerInterface } from '@standardnotes/time'
 import { OfflineSubscriptionTokenRepositoryInterface } from '../../Auth/OfflineSubscriptionTokenRepositoryInterface'
 
 import { CreateOfflineSubscriptionToken } from './CreateOfflineSubscriptionToken'
-import { DomainEventPublisherInterface, OfflineSubscriptionTokenCreatedEvent } from '@standardnotes/domain-events'
+import { DomainEventPublisherInterface, EmailRequestedEvent } from '@standardnotes/domain-events'
 import { DomainEventFactoryInterface } from '../../Event/DomainEventFactoryInterface'
 import { OfflineUserSubscriptionRepositoryInterface } from '../../Subscription/OfflineUserSubscriptionRepositoryInterface'
 import { OfflineUserSubscription } from '../../Subscription/OfflineUserSubscription'
@@ -47,9 +47,7 @@ describe('CreateOfflineSubscriptionToken', () => {
     domainEventPublisher.publish = jest.fn()
 
     domainEventFactory = {} as jest.Mocked<DomainEventFactoryInterface>
-    domainEventFactory.createOfflineSubscriptionTokenCreatedEvent = jest
-      .fn()
-      .mockReturnValue({} as jest.Mocked<OfflineSubscriptionTokenCreatedEvent>)
+    domainEventFactory.createEmailRequestedEvent = jest.fn().mockReturnValue({} as jest.Mocked<EmailRequestedEvent>)
 
     timer = {} as jest.Mocked<TimerInterface>
     timer.convertStringDateToMicroseconds = jest.fn().mockReturnValue(1)
@@ -71,10 +69,7 @@ describe('CreateOfflineSubscriptionToken', () => {
       expiresAt: 1,
     })
 
-    expect(domainEventFactory.createOfflineSubscriptionTokenCreatedEvent).toHaveBeenCalledWith(
-      'random-string',
-      'test@test.com',
-    )
+    expect(domainEventFactory.createEmailRequestedEvent).toHaveBeenCalled()
     expect(domainEventPublisher.publish).toHaveBeenCalled()
   })
 
@@ -91,7 +86,7 @@ describe('CreateOfflineSubscriptionToken', () => {
     })
 
     expect(offlineSubscriptionTokenRepository.save).not.toHaveBeenCalled()
-    expect(domainEventFactory.createOfflineSubscriptionTokenCreatedEvent).not.toHaveBeenCalled()
+    expect(domainEventFactory.createEmailRequestedEvent).not.toHaveBeenCalled()
     expect(domainEventPublisher.publish).not.toHaveBeenCalled()
   })
 
@@ -110,7 +105,7 @@ describe('CreateOfflineSubscriptionToken', () => {
     })
 
     expect(offlineSubscriptionTokenRepository.save).not.toHaveBeenCalled()
-    expect(domainEventFactory.createOfflineSubscriptionTokenCreatedEvent).not.toHaveBeenCalled()
+    expect(domainEventFactory.createEmailRequestedEvent).not.toHaveBeenCalled()
     expect(domainEventPublisher.publish).not.toHaveBeenCalled()
   })
 
@@ -129,7 +124,7 @@ describe('CreateOfflineSubscriptionToken', () => {
     })
 
     expect(offlineSubscriptionTokenRepository.save).not.toHaveBeenCalled()
-    expect(domainEventFactory.createOfflineSubscriptionTokenCreatedEvent).not.toHaveBeenCalled()
+    expect(domainEventFactory.createEmailRequestedEvent).not.toHaveBeenCalled()
     expect(domainEventPublisher.publish).not.toHaveBeenCalled()
   })
 })

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

@@ -1,4 +1,5 @@
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
+import { EmailLevel } from '@standardnotes/domain-core'
 import { CryptoNode } from '@standardnotes/sncrypto-node'
 import { TimerInterface } from '@standardnotes/time'
 import { inject, injectable } from 'inversify'
@@ -6,6 +7,7 @@ import { Logger } from 'winston'
 
 import TYPES from '../../../Bootstrap/Types'
 import { OfflineSubscriptionTokenRepositoryInterface } from '../../Auth/OfflineSubscriptionTokenRepositoryInterface'
+import { getBody, getSubject } from '../../Email/OfflineSubscriptionTokenCreated'
 import { DomainEventFactoryInterface } from '../../Event/DomainEventFactoryInterface'
 import { OfflineUserSubscriptionRepositoryInterface } from '../../Subscription/OfflineUserSubscriptionRepositoryInterface'
 import { UseCaseInterface } from '../UseCaseInterface'
@@ -62,7 +64,13 @@ export class CreateOfflineSubscriptionToken implements UseCaseInterface {
     await this.offlineSubscriptionTokenRepository.save(offlineSubscriptionToken)
 
     await this.domainEventPublisher.publish(
-      this.domainEventFactory.createOfflineSubscriptionTokenCreatedEvent(token, dto.userEmail),
+      this.domainEventFactory.createEmailRequestedEvent({
+        body: getBody(dto.userEmail, `https://standardnotes.com/dashboard/offline?subscription_token=${token}`),
+        level: EmailLevel.LEVELS.System,
+        subject: getSubject(),
+        messageIdentifier: 'OFFLINE_SUBSCRIPTION_ACCESS',
+        userEmail: dto.userEmail,
+      }),
     )
 
     return {

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

@@ -3,7 +3,7 @@ import { SubscriptionName } from '@standardnotes/common'
 import { TimerInterface } from '@standardnotes/time'
 import { TokenEncoderInterface, ValetTokenData } from '@standardnotes/security'
 import { CreateValetTokenPayload, CreateValetTokenResponseData } from '@standardnotes/responses'
-import { SubscriptionSettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 
 import TYPES from '../../../Bootstrap/Types'
 import { UseCaseInterface } from '../UseCaseInterface'
@@ -56,7 +56,7 @@ export class CreateValetToken implements UseCaseInterface {
     const uploadBytesUsedSetting = await this.subscriptionSettingService.findSubscriptionSettingWithDecryptedValue({
       userUuid: regularSubscriptionUserUuid,
       userSubscriptionUuid: regularSubscription.uuid,
-      subscriptionSettingName: SubscriptionSettingName.FileUploadBytesUsed,
+      subscriptionSettingName: SettingName.NAMES.FileUploadBytesUsed,
     })
     if (uploadBytesUsedSetting !== null) {
       uploadBytesUsed = +(uploadBytesUsedSetting.value as string)
@@ -70,7 +70,7 @@ export class CreateValetToken implements UseCaseInterface {
       await this.subscriptionSettingService.findSubscriptionSettingWithDecryptedValue({
         userUuid: regularSubscriptionUserUuid,
         userSubscriptionUuid: regularSubscription.uuid,
-        subscriptionSettingName: SubscriptionSettingName.FileUploadBytesLimit,
+        subscriptionSettingName: SettingName.NAMES.FileUploadBytesLimit,
       })
     if (overwriteWithUserUploadBytesLimitSetting !== null) {
       uploadBytesLimit = +(overwriteWithUserUploadBytesLimitSetting.value as string)

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

@@ -1,4 +1,4 @@
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import 'reflect-metadata'
 import { SettingProjector } from '../../../Projection/SettingProjector'
 import { Setting } from '../../Setting/Setting'
@@ -45,12 +45,12 @@ describe('GetSetting', () => {
   it('should not retrieve a sensitive setting for user', async () => {
     setting = {
       sensitive: true,
-      name: SettingName.MfaSecret,
+      name: SettingName.NAMES.MfaSecret,
     } as jest.Mocked<Setting>
 
     settingService.findSettingWithDecryptedValue = jest.fn().mockReturnValue(setting)
 
-    expect(await createUseCase().execute({ userUuid: '1-2-3', settingName: SettingName.MfaSecret })).toEqual({
+    expect(await createUseCase().execute({ userUuid: '1-2-3', settingName: SettingName.NAMES.MfaSecret })).toEqual({
       success: true,
       sensitive: true,
     })
@@ -59,7 +59,7 @@ describe('GetSetting', () => {
   it('should retrieve a sensitive setting for user if explicitly told to', async () => {
     setting = {
       sensitive: true,
-      name: SettingName.MfaSecret,
+      name: SettingName.NAMES.MfaSecret,
     } as jest.Mocked<Setting>
 
     settingService.findSettingWithDecryptedValue = jest.fn().mockReturnValue(setting)

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

@@ -1,4 +1,3 @@
-import { SettingName } from '@standardnotes/settings'
 import { inject, injectable } from 'inversify'
 import { GetSettingDto } from './GetSettingDto'
 import { GetSettingResponse } from './GetSettingResponse'
@@ -19,7 +18,7 @@ export class GetSetting implements UseCaseInterface {
 
     const setting = await this.settingService.findSettingWithDecryptedValue({
       userUuid,
-      settingName: settingName as SettingName,
+      settingName: settingName,
     })
 
     if (setting === null) {

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

@@ -1,6 +1,6 @@
 import 'reflect-metadata'
 
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 
 import { SettingProjector } from '../../../Projection/SettingProjector'
 import { Setting } from '../../Setting/Setting'
@@ -31,7 +31,7 @@ describe('GetSettings', () => {
     } as jest.Mocked<Setting>
 
     mfaSetting = {
-      name: SettingName.MfaSecret,
+      name: SettingName.NAMES.MfaSecret,
       updatedAt: 122,
       sensitive: true,
     } as jest.Mocked<Setting>

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

@@ -1,6 +1,6 @@
 import 'reflect-metadata'
 
-import { SubscriptionSettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 
 import { SubscriptionSettingProjector } from '../../../Projection/SubscriptionSettingProjector'
 import { SubscriptionSetting } from '../../Setting/SubscriptionSetting'
@@ -54,7 +54,7 @@ describe('GetSubscriptionSetting', () => {
     expect(
       await createUseCase().execute({
         userUuid: '1-2-3',
-        subscriptionSettingName: SubscriptionSettingName.FileUploadBytesUsed,
+        subscriptionSettingName: SettingName.NAMES.FileUploadBytesUsed,
       }),
     ).toEqual({
       success: true,
@@ -70,7 +70,7 @@ describe('GetSubscriptionSetting', () => {
     expect(
       await createUseCase().execute({
         userUuid: '1-2-3',
-        subscriptionSettingName: SubscriptionSettingName.FileUploadBytesLimit,
+        subscriptionSettingName: SettingName.NAMES.FileUploadBytesLimit,
       }),
     ).toEqual({
       success: false,
@@ -86,7 +86,7 @@ describe('GetSubscriptionSetting', () => {
     expect(
       await createUseCase().execute({
         userUuid: '1-2-3',
-        subscriptionSettingName: SubscriptionSettingName.FileUploadBytesLimit,
+        subscriptionSettingName: SettingName.NAMES.FileUploadBytesLimit,
       }),
     ).toEqual({
       success: false,
@@ -99,7 +99,7 @@ describe('GetSubscriptionSetting', () => {
   it('should not retrieve a sensitive setting for user', async () => {
     subscriptionSetting = {
       sensitive: true,
-      name: SubscriptionSettingName.FileUploadBytesLimit,
+      name: SettingName.NAMES.FileUploadBytesLimit,
     } as jest.Mocked<SubscriptionSetting>
 
     subscriptionSettingService.findSubscriptionSettingWithDecryptedValue = jest
@@ -109,7 +109,7 @@ describe('GetSubscriptionSetting', () => {
     expect(
       await createUseCase().execute({
         userUuid: '1-2-3',
-        subscriptionSettingName: SubscriptionSettingName.FileUploadBytesLimit,
+        subscriptionSettingName: SettingName.NAMES.FileUploadBytesLimit,
       }),
     ).toEqual({
       success: true,
@@ -120,7 +120,7 @@ describe('GetSubscriptionSetting', () => {
   it('should retrieve a sensitive setting for user if explicitly told to', async () => {
     subscriptionSetting = {
       sensitive: true,
-      name: SubscriptionSettingName.FileUploadBytesLimit,
+      name: SettingName.NAMES.FileUploadBytesLimit,
     } as jest.Mocked<SubscriptionSetting>
 
     subscriptionSettingService.findSubscriptionSettingWithDecryptedValue = jest
@@ -130,7 +130,7 @@ describe('GetSubscriptionSetting', () => {
     expect(
       await createUseCase().execute({
         userUuid: '1-2-3',
-        subscriptionSettingName: SubscriptionSettingName.FileUploadBytesLimit,
+        subscriptionSettingName: SettingName.NAMES.FileUploadBytesLimit,
         allowSensitiveRetrieval: true,
       }),
     ).toEqual({

packages/auth/src/Domain/UseCase/GetSubscriptionSetting/GetSubscriptionSettingDTO.ts

@@ -1,8 +1,7 @@
 import { Uuid } from '@standardnotes/common'
-import { SubscriptionSettingName } from '@standardnotes/settings'
 
 export type GetSubscriptionSettingDTO = {
   userUuid: Uuid
-  subscriptionSettingName: SubscriptionSettingName
+  subscriptionSettingName: string
   allowSensitiveRetrieval?: boolean
 }

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

@@ -1,6 +1,10 @@
 import 'reflect-metadata'
 
-import { DomainEventPublisherInterface, SharedSubscriptionInvitationCreatedEvent } from '@standardnotes/domain-events'
+import {
+  DomainEventPublisherInterface,
+  SharedSubscriptionInvitationCreatedEvent,
+  EmailRequestedEvent,
+} from '@standardnotes/domain-events'
 import { TimerInterface } from '@standardnotes/time'
 import { DomainEventFactoryInterface } from '../../Event/DomainEventFactoryInterface'
 import { SharedSubscriptionInvitationRepositoryInterface } from '../../SharedSubscription/SharedSubscriptionInvitationRepositoryInterface'
@@ -51,6 +55,7 @@ describe('InviteToSharedSubscription', () => {
     domainEventFactory.createSharedSubscriptionInvitationCreatedEvent = jest
       .fn()
       .mockReturnValue({} as jest.Mocked<SharedSubscriptionInvitationCreatedEvent>)
+    domainEventFactory.createEmailRequestedEvent = jest.fn().mockReturnValue({} as jest.Mocked<EmailRequestedEvent>)
   })
 
   it('should not create an inivitation for sharing the subscription if inviter has no subscription', async () => {

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

@@ -1,9 +1,11 @@
 import { RoleName } from '@standardnotes/common'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
+import { EmailLevel } from '@standardnotes/domain-core'
 import { TimerInterface } from '@standardnotes/time'
 import { inject, injectable } from 'inversify'
 
 import TYPES from '../../../Bootstrap/Types'
+import { getBody, getSubject } from '../../Email/SharedSubscriptionInvitationCreated'
 import { DomainEventFactoryInterface } from '../../Event/DomainEventFactoryInterface'
 import { InvitationStatus } from '../../SharedSubscription/InvitationStatus'
 import { InviteeIdentifierType } from '../../SharedSubscription/InviteeIdentifierType'
@@ -89,6 +91,16 @@ export class InviteToSharedSubscription implements UseCaseInterface {
       }),
     )
 
+    await this.domainEventPublisher.publish(
+      this.domainEventFactory.createEmailRequestedEvent({
+        userEmail: dto.inviteeIdentifier,
+        level: EmailLevel.LEVELS.System,
+        body: getBody(dto.inviterEmail, savedInvitation.uuid),
+        messageIdentifier: 'SHARED_SUBSCRIPTION_INVITATION',
+        subject: getSubject(),
+      }),
+    )
+
     return {
       success: true,
       sharedSubscriptionInvitationUuid: savedInvitation.uuid,

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

@@ -1,6 +1,6 @@
 import 'reflect-metadata'
 
-import { DomainEventPublisherInterface, UserSignedInEvent } from '@standardnotes/domain-events'
+import { DomainEventPublisherInterface, EmailRequestedEvent } from '@standardnotes/domain-events'
 import { Logger } from 'winston'
 
 import { AuthResponseFactoryInterface } from '../Auth/AuthResponseFactoryInterface'
@@ -10,10 +10,6 @@ import { SessionServiceInterface } from '../Session/SessionServiceInterface'
 import { User } from '../User/User'
 import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 import { SignIn } from './SignIn'
-import { RoleServiceInterface } from '../Role/RoleServiceInterface'
-import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
-import { Setting } from '../Setting/Setting'
-import { MuteSignInEmailsOption } from '@standardnotes/settings'
 import { PKCERepositoryInterface } from '../User/PKCERepositoryInterface'
 import { CrypterInterface } from '../Encryption/CrypterInterface'
 import { ProtocolVersion } from '@standardnotes/common'
@@ -26,10 +22,7 @@ describe('SignIn', () => {
   let domainEventPublisher: DomainEventPublisherInterface
   let domainEventFactory: DomainEventFactoryInterface
   let sessionService: SessionServiceInterface
-  let roleService: RoleServiceInterface
   let logger: Logger
-  let settingService: SettingServiceInterface
-  let setting: Setting
   let pkceRepository: PKCERepositoryInterface
   let crypter: CrypterInterface
 
@@ -40,8 +33,6 @@ describe('SignIn', () => {
       domainEventPublisher,
       domainEventFactory,
       sessionService,
-      roleService,
-      settingService,
       pkceRepository,
       crypter,
       logger,
@@ -68,27 +59,12 @@ describe('SignIn', () => {
     domainEventPublisher.publish = jest.fn()
 
     domainEventFactory = {} as jest.Mocked<DomainEventFactoryInterface>
-    domainEventFactory.createUserSignedInEvent = jest.fn().mockReturnValue({} as jest.Mocked<UserSignedInEvent>)
+    domainEventFactory.createEmailRequestedEvent = jest.fn().mockReturnValue({} as jest.Mocked<EmailRequestedEvent>)
 
     sessionService = {} as jest.Mocked<SessionServiceInterface>
     sessionService.getOperatingSystemInfoFromUserAgent = jest.fn().mockReturnValue('iOS 1')
     sessionService.getBrowserInfoFromUserAgent = jest.fn().mockReturnValue('Firefox 1')
 
-    roleService = {} as jest.Mocked<RoleServiceInterface>
-    roleService.userHasPermission = jest.fn().mockReturnValue(true)
-
-    setting = {
-      uuid: '3-4-5',
-      value: MuteSignInEmailsOption.NotMuted,
-    } as jest.Mocked<Setting>
-
-    settingService = {} as jest.Mocked<SettingServiceInterface>
-    settingService.findSettingWithDecryptedValue = jest.fn().mockReturnValue(setting)
-    settingService.createOrReplace = jest.fn().mockReturnValue({
-      status: 'created',
-      setting,
-    })
-
     pkceRepository = {} as jest.Mocked<PKCERepositoryInterface>
     pkceRepository.removeCodeChallenge = jest.fn().mockReturnValue(true)
 
@@ -118,18 +94,33 @@ describe('SignIn', () => {
       authResponse: { foo: 'bar' },
     })
 
-    expect(domainEventFactory.createUserSignedInEvent).toHaveBeenCalledWith({
-      browser: 'Firefox 1',
-      device: 'iOS 1',
-      userEmail: 'test@test.com',
-      userUuid: '1-2-3',
-      signInAlertEnabled: true,
-      muteSignInEmailsSettingUuid: '3-4-5',
-    })
+    expect(domainEventFactory.createEmailRequestedEvent).toHaveBeenCalled()
     expect(domainEventPublisher.publish).toHaveBeenCalled()
   })
 
-  it('should not sign in a user without code verifier', async () => {
+  it('should not sign in 004 user without code verifier', async () => {
+    expect(
+      await createUseCase().execute({
+        email: 'test@test.te',
+        password: 'qweqwe123123',
+        userAgent: 'Google Chrome',
+        apiVersion: '20190520',
+        ephemeralSession: false,
+      }),
+    ).toEqual({
+      success: false,
+      errorCode: 410,
+      errorMessage: 'Please update your client application.',
+    })
+  })
+
+  it('should not sign in 005 user without code verifier', async () => {
+    user = {
+      uuid: '1-2-3',
+      email: 'test@test.com',
+      version: '005',
+    } as jest.Mocked<User>
+
     expect(
       await createUseCase().execute({
         email: 'test@test.te',
@@ -160,92 +151,10 @@ describe('SignIn', () => {
       authResponse: { foo: 'bar' },
     })
 
-    expect(domainEventFactory.createUserSignedInEvent).toHaveBeenCalledWith({
-      browser: 'Firefox 1',
-      device: 'iOS 1',
-      userEmail: 'test@test.com',
-      userUuid: '1-2-3',
-      signInAlertEnabled: true,
-      muteSignInEmailsSettingUuid: '3-4-5',
-    })
+    expect(domainEventFactory.createEmailRequestedEvent).toHaveBeenCalled()
     expect(domainEventPublisher.publish).toHaveBeenCalled()
   })
 
-  it('should sign in a user and disable sign in alert if setting is configured', async () => {
-    setting = {
-      uuid: '3-4-5',
-      value: MuteSignInEmailsOption.Muted,
-    } as jest.Mocked<Setting>
-
-    settingService.findSettingWithDecryptedValue = jest.fn().mockReturnValue(setting)
-
-    expect(
-      await createUseCase().execute({
-        email: 'test@test.te',
-        password: 'qweqwe123123',
-        userAgent: 'Google Chrome',
-        apiVersion: '20190520',
-        ephemeralSession: false,
-        codeVerifier: 'test',
-      }),
-    ).toEqual({
-      success: true,
-      authResponse: { foo: 'bar' },
-    })
-
-    expect(domainEventFactory.createUserSignedInEvent).toHaveBeenCalledWith({
-      browser: 'Firefox 1',
-      device: 'iOS 1',
-      userEmail: 'test@test.com',
-      userUuid: '1-2-3',
-      signInAlertEnabled: false,
-      muteSignInEmailsSettingUuid: '3-4-5',
-    })
-    expect(domainEventPublisher.publish).toHaveBeenCalled()
-  })
-
-  it('should sign in a user and create mute sign in email setting if it does not exist', async () => {
-    settingService.findSettingWithDecryptedValue = jest.fn().mockReturnValue(null)
-
-    expect(
-      await createUseCase().execute({
-        email: 'test@test.te',
-        password: 'qweqwe123123',
-        userAgent: 'Google Chrome',
-        apiVersion: '20190520',
-        ephemeralSession: false,
-        codeVerifier: 'test',
-      }),
-    ).toEqual({
-      success: true,
-      authResponse: { foo: 'bar' },
-    })
-
-    expect(domainEventFactory.createUserSignedInEvent).toHaveBeenCalledWith({
-      browser: 'Firefox 1',
-      device: 'iOS 1',
-      userEmail: 'test@test.com',
-      userUuid: '1-2-3',
-      signInAlertEnabled: true,
-      muteSignInEmailsSettingUuid: '3-4-5',
-    })
-    expect(domainEventPublisher.publish).toHaveBeenCalled()
-    expect(settingService.createOrReplace).toHaveBeenCalledWith({
-      props: {
-        name: 'MUTE_SIGN_IN_EMAILS',
-        sensitive: false,
-        serverEncryptionVersion: 0,
-        unencryptedValue: 'not_muted',
-      },
-      user: {
-        email: 'test@test.com',
-        encryptedPassword: '$2a$11$K3g6XoTau8VmLJcai1bB0eD9/YvBSBRtBhMprJOaVZ0U3SgasZH3a',
-        uuid: '1-2-3',
-        version: '004',
-      },
-    })
-  })
-
   it('should sign in a user even if publishing a sign in event fails', async () => {
     domainEventPublisher.publish = jest.fn().mockImplementation(() => {
       throw new Error('Oops')

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

@@ -1,18 +1,12 @@
 import * as bcrypt from 'bcryptjs'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
-import { PermissionName } from '@standardnotes/features'
-import { MuteSignInEmailsOption, SettingName } from '@standardnotes/settings'
 
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 import TYPES from '../../Bootstrap/Types'
 import { AuthResponseFactoryResolverInterface } from '../Auth/AuthResponseFactoryResolverInterface'
-import { EncryptionVersion } from '../Encryption/EncryptionVersion'
 import { DomainEventFactoryInterface } from '../Event/DomainEventFactoryInterface'
-import { RoleServiceInterface } from '../Role/RoleServiceInterface'
 import { SessionServiceInterface } from '../Session/SessionServiceInterface'
-import { Setting } from '../Setting/Setting'
-import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
 import { User } from '../User/User'
 import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 import { SignInDTO } from './SignInDTO'
@@ -21,8 +15,10 @@ import { UseCaseInterface } from './UseCaseInterface'
 import { PKCERepositoryInterface } from '../User/PKCERepositoryInterface'
 import { CrypterInterface } from '../Encryption/CrypterInterface'
 import { SignInDTOV2Challenged } from './SignInDTOV2Challenged'
-import { ProtocolVersion } from '@standardnotes/common'
+import { leftVersionGreaterThanOrEqualToRight, ProtocolVersion } from '@standardnotes/common'
 import { HttpStatusCode } from '@standardnotes/api'
+import { EmailLevel } from '@standardnotes/domain-core'
+import { getBody, getSubject } from '../Email/UserSignedIn'
 
 @injectable()
 export class SignIn implements UseCaseInterface {
@@ -33,8 +29,6 @@ export class SignIn implements UseCaseInterface {
     @inject(TYPES.DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
     @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
     @inject(TYPES.SessionService) private sessionService: SessionServiceInterface,
-    @inject(TYPES.RoleService) private roleService: RoleServiceInterface,
-    @inject(TYPES.SettingService) private settingService: SettingServiceInterface,
     @inject(TYPES.PKCERepository) private pkceRepository: PKCERepositoryInterface,
     @inject(TYPES.Crypter) private crypter: CrypterInterface,
     @inject(TYPES.Logger) private logger: Logger,
@@ -65,7 +59,12 @@ export class SignIn implements UseCaseInterface {
       }
     }
 
-    if (user.version === ProtocolVersion.V004 && !performingCodeChallengedSignIn) {
+    const userVersionIs004OrGreater = leftVersionGreaterThanOrEqualToRight(
+      user.version as ProtocolVersion,
+      ProtocolVersion.V004,
+    )
+
+    if (userVersionIs004OrGreater && !performingCodeChallengedSignIn) {
       return {
         success: false,
         errorMessage: 'Please update your client application.',
@@ -109,18 +108,18 @@ export class SignIn implements UseCaseInterface {
 
   private async sendSignInEmailNotification(user: User, userAgent: string): Promise<void> {
     try {
-      const muteSignInEmailsSetting = await this.findOrCreateMuteSignInEmailsSetting(user)
-
       await this.domainEventPublisher.publish(
-        this.domainEventFactory.createUserSignedInEvent({
-          userUuid: user.uuid,
+        this.domainEventFactory.createEmailRequestedEvent({
           userEmail: user.email,
-          device: this.sessionService.getOperatingSystemInfoFromUserAgent(userAgent),
-          browser: this.sessionService.getBrowserInfoFromUserAgent(userAgent),
-          signInAlertEnabled:
-            (await this.roleService.userHasPermission(user.uuid, PermissionName.SignInAlerts)) &&
-            muteSignInEmailsSetting.value === MuteSignInEmailsOption.NotMuted,
-          muteSignInEmailsSettingUuid: muteSignInEmailsSetting.uuid,
+          level: EmailLevel.LEVELS.SignIn,
+          body: getBody(
+            user.email,
+            this.sessionService.getOperatingSystemInfoFromUserAgent(userAgent),
+            this.sessionService.getBrowserInfoFromUserAgent(userAgent),
+            new Date(),
+          ),
+          messageIdentifier: 'SIGN_IN',
+          subject: getSubject(user.email),
         }),
       )
     } catch (error) {
@@ -128,29 +127,6 @@ export class SignIn implements UseCaseInterface {
     }
   }
 
-  private async findOrCreateMuteSignInEmailsSetting(user: User): Promise<Setting> {
-    const existingMuteSignInEmailsSetting = await this.settingService.findSettingWithDecryptedValue({
-      userUuid: user.uuid,
-      settingName: SettingName.MuteSignInEmails,
-    })
-
-    if (existingMuteSignInEmailsSetting !== null) {
-      return existingMuteSignInEmailsSetting
-    }
-
-    const createSettingResult = await this.settingService.createOrReplace({
-      user,
-      props: {
-        name: SettingName.MuteSignInEmails,
-        sensitive: false,
-        unencryptedValue: MuteSignInEmailsOption.NotMuted,
-        serverEncryptionVersion: EncryptionVersion.Unencrypted,
-      },
-    })
-
-    return createSettingResult.setting
-  }
-
   private isCodeChallengedVersion(dto: SignInDTO): dto is SignInDTOV2Challenged {
     return (dto as SignInDTOV2Challenged).codeVerifier !== undefined
   }

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

@@ -13,7 +13,7 @@ import { SimpleSetting } from '../../Setting/SimpleSetting'
 import { User } from '../../User/User'
 import { UserRepositoryInterface } from '../../User/UserRepositoryInterface'
 import { UpdateSetting } from './UpdateSetting'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 
 describe('UpdateSetting', () => {
   let settingService: SettingServiceInterface
@@ -59,7 +59,7 @@ describe('UpdateSetting', () => {
 
   it('should create a setting', async () => {
     const props = {
-      name: SettingName.ExtensionKey,
+      name: SettingName.NAMES.ExtensionKey,
       unencryptedValue: 'test-setting-value',
       serverEncryptionVersion: EncryptionVersion.Default,
       sensitive: false,
@@ -88,7 +88,7 @@ describe('UpdateSetting', () => {
     userRepository.findOneByUuid = jest.fn().mockReturnValue(null)
 
     const props = {
-      name: SettingName.ExtensionKey,
+      name: SettingName.NAMES.ExtensionKey,
       unencryptedValue: 'test-setting-value',
       serverEncryptionVersion: EncryptionVersion.Unencrypted,
       sensitive: false,
@@ -136,7 +136,7 @@ describe('UpdateSetting', () => {
     roleService.userHasPermission = jest.fn().mockReturnValue(false)
 
     const props = {
-      name: SettingName.ExtensionKey,
+      name: SettingName.NAMES.ExtensionKey,
       unencryptedValue: 'test-setting-value',
       serverEncryptionVersion: EncryptionVersion.Unencrypted,
       sensitive: false,
@@ -159,7 +159,7 @@ describe('UpdateSetting', () => {
     settingsAssociationService.isSettingMutableByClient = jest.fn().mockReturnValue(false)
 
     const props = {
-      name: SettingName.ExtensionKey,
+      name: SettingName.NAMES.ExtensionKey,
       unencryptedValue: 'test-setting-value',
       serverEncryptionVersion: EncryptionVersion.Unencrypted,
       sensitive: false,

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

@@ -9,7 +9,7 @@ import { SettingProjector } from '../../../Projection/SettingProjector'
 import { Logger } from 'winston'
 import { SettingServiceInterface } from '../../Setting/SettingServiceInterface'
 import { User } from '../../User/User'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { RoleServiceInterface } from '../../Role/RoleServiceInterface'
 import { SettingsAssociationServiceInterface } from '../../Setting/SettingsAssociationServiceInterface'
 
@@ -25,7 +25,7 @@ export class UpdateSetting implements UseCaseInterface {
   ) {}
 
   async execute(dto: UpdateSettingDto): Promise<UpdateSettingResponse> {
-    if (!Object.values(SettingName).includes(dto.props.name as SettingName)) {
+    if (!Object.values(SettingName.NAMES).includes(dto.props.name)) {
       return {
         success: false,
         error: {
@@ -51,7 +51,7 @@ export class UpdateSetting implements UseCaseInterface {
       }
     }
 
-    if (!(await this.userHasPermissionToUpdateSetting(user, props.name as SettingName))) {
+    if (!(await this.userHasPermissionToUpdateSetting(user, props.name))) {
       return {
         success: false,
         error: {
@@ -61,10 +61,8 @@ export class UpdateSetting implements UseCaseInterface {
       }
     }
 
-    props.serverEncryptionVersion = this.settingsAssociationService.getEncryptionVersionForSetting(
-      props.name as SettingName,
-    )
-    props.sensitive = this.settingsAssociationService.getSensitivityForSetting(props.name as SettingName)
+    props.serverEncryptionVersion = this.settingsAssociationService.getEncryptionVersionForSetting(props.name)
+    props.sensitive = this.settingsAssociationService.getSensitivityForSetting(props.name)
 
     const response = await this.settingService.createOrReplace({
       user,
@@ -91,8 +89,8 @@ export class UpdateSetting implements UseCaseInterface {
     throw new Error(`Unrecognized status: ${exhaustiveCheck}!`)
   }
 
-  private async userHasPermissionToUpdateSetting(user: User, settingName: SettingName): Promise<boolean> {
-    const settingIsMutableByClient = await this.settingsAssociationService.isSettingMutableByClient(settingName)
+  private async userHasPermissionToUpdateSetting(user: User, settingName: string): Promise<boolean> {
+    const settingIsMutableByClient = this.settingsAssociationService.isSettingMutableByClient(settingName)
     if (!settingIsMutableByClient) {
       return false
     }

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

@@ -6,7 +6,7 @@ import { UserRepositoryInterface } from '../User/UserRepositoryInterface'
 import { VerifyMFA } from './VerifyMFA'
 import { Setting } from '../Setting/Setting'
 import { SettingServiceInterface } from '../Setting/SettingServiceInterface'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { SelectorInterface } from '@standardnotes/security'
 import { LockRepositoryInterface } from '../User/LockRepositoryInterface'
 
@@ -36,7 +36,7 @@ describe('VerifyMFA', () => {
     lockRepository.lockSuccessfullOTP = jest.fn()
 
     setting = {
-      name: SettingName.MfaSecret,
+      name: SettingName.NAMES.MfaSecret,
       value: 'shhhh',
     } as jest.Mocked<Setting>
 
@@ -58,7 +58,7 @@ describe('VerifyMFA', () => {
 
   it('should pass MFA verification if user has MFA deleted', async () => {
     setting = {
-      name: SettingName.MfaSecret,
+      name: SettingName.NAMES.MfaSecret,
       value: null,
     } as jest.Mocked<Setting>
 
@@ -148,7 +148,7 @@ describe('VerifyMFA', () => {
 
   it('should not pass MFA verification if mfa is not correct', async () => {
     setting = {
-      name: SettingName.MfaSecret,
+      name: SettingName.NAMES.MfaSecret,
       value: 'shhhh2',
     } as jest.Mocked<Setting>
 

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

@@ -1,6 +1,6 @@
 import * as crypto from 'crypto'
 import { ErrorTag } from '@standardnotes/common'
-import { SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { v4 as uuidv4 } from 'uuid'
 import { inject, injectable } from 'inversify'
 import { authenticator } from 'otplib'
@@ -50,7 +50,7 @@ export class VerifyMFA implements UseCaseInterface {
 
       const mfaSecret = await this.settingService.findSettingWithDecryptedValue({
         userUuid: user.uuid,
-        settingName: SettingName.MfaSecret,
+        settingName: SettingName.NAMES.MfaSecret,
       })
       if (mfaSecret === null || mfaSecret.value === null) {
         return {

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

@@ -8,7 +8,6 @@ import { UserSubscription } from '../../Subscription/UserSubscription'
 import { UserSubscriptionRepositoryInterface } from '../../Subscription/UserSubscriptionRepositoryInterface'
 
 import { VerifyPredicate } from './VerifyPredicate'
-import { EmailBackupFrequency } from '@standardnotes/settings'
 
 describe('VerifyPredicate', () => {
   let settingRepository: SettingRepositoryInterface
@@ -30,7 +29,7 @@ describe('VerifyPredicate', () => {
   })
 
   it('should tell that a user has enabled email backups', async () => {
-    setting = { value: EmailBackupFrequency.Weekly } as jest.Mocked<Setting>
+    setting = { value: 'weekly' } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue(setting)
 
     expect(
@@ -44,7 +43,7 @@ describe('VerifyPredicate', () => {
   })
 
   it('should tell that a user has disabled email backups', async () => {
-    setting = { value: EmailBackupFrequency.Disabled } as jest.Mocked<Setting>
+    setting = { value: 'disabled' } as jest.Mocked<Setting>
     settingRepository.findOneByNameAndUserUuid = jest.fn().mockReturnValue(setting)
 
     expect(

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

@@ -1,6 +1,6 @@
 import { Uuid } from '@standardnotes/common'
 import { PredicateName, PredicateVerificationResult } from '@standardnotes/predicates'
-import { EmailBackupFrequency, SettingName } from '@standardnotes/settings'
+import { SettingName } from '@standardnotes/domain-core'
 import { inject, injectable } from 'inversify'
 
 import TYPES from '../../../Bootstrap/Types'
@@ -40,9 +40,12 @@ export class VerifyPredicate implements UseCaseInterface {
   }
 
   private async hasUserEnabledEmailBackups(userUuid: Uuid): Promise<boolean> {
-    const setting = await this.settingRepository.findOneByNameAndUserUuid(SettingName.EmailBackupFrequency, userUuid)
+    const setting = await this.settingRepository.findOneByNameAndUserUuid(
+      SettingName.NAMES.EmailBackupFrequency,
+      userUuid,
+    )
 
-    if (setting === null || setting.value === EmailBackupFrequency.Disabled) {
+    if (setting === null || setting.value === 'disabled') {
       return false
     }
 

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

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

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

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

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

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

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

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

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

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