feat(medusa): add analytics config (#2442)

**What**
- Adds new entity AnalyticsConfig
- Adds new service AnalyticsConfigService
- Adds new repository AnalyticsConfigRepository
- Adds new endpoints to get, create, update, and delete analytics configs

**Why**
As we begin gathering usage insights to help us improve Medusa, we want to give each individual users the ability to control what data they share with us, or not share any data with us at all. The AnalyticsConfig holds information that is used to check if the user wishes for their data to be anonymized or if they have opted out of sharing usage data.

The entire feature can be disabled on a store level by setting the feature flag `MEDUSA_FF_ANALYTICS=false` in their environment variables, the feature is enabled by default. 

**Testing**
Adds integration test for each of the new endpoints

Resolves CORE-656, CORE-655, CORE-654

Also resolves CORE-574

packages/medusa/src/api/index.js

@@ -16,6 +16,7 @@ export default (container, config) => {
 }
 
 // Admin
+export * from "./routes/admin/analytics-configs"
 export * from "./routes/admin/auth"
 export * from "./routes/admin/batch"
 export * from "./routes/admin/collections"

packages/medusa/src/api/routes/admin/analytics-configs/create-analytics-config.ts

@@ -0,0 +1,33 @@
+import { IsBoolean } from "class-validator"
+import { Request, Response } from "express"
+import { EntityManager } from "typeorm"
+import { AnalyticsConfigService } from "../../../../services"
+import { CreateAnalyticsConfig } from "../../../../types/analytics-config"
+
+// No OAS for this route, for internal use only.
+export default async (req: Request, res: Response) => {
+  const userId = (req.user?.userId ?? req.user?.id)!
+  const validatedBody = req.validatedBody as CreateAnalyticsConfig
+  const analyticsConfigService: AnalyticsConfigService = req.scope.resolve(
+    "analyticsConfigService"
+  )
+
+  const manager: EntityManager = req.scope.resolve("manager")
+  const analyticsConfig = await manager.transaction(
+    async (transactionManager) => {
+      return await analyticsConfigService
+        .withTransaction(transactionManager)
+        .create(userId, validatedBody)
+    }
+  )
+
+  res.status(200).json({ analytics_config: analyticsConfig })
+}
+
+export class AdminPostAnalyticsConfigReq {
+  @IsBoolean()
+  opt_out: boolean
+
+  @IsBoolean()
+  anonymize?: boolean = false
+}

packages/medusa/src/api/routes/admin/analytics-configs/delete-analytics-config.ts

@@ -0,0 +1,23 @@
+import { Request, Response } from "express"
+import { EntityManager } from "typeorm"
+import { AnalyticsConfigService } from "../../../../services"
+
+// No OAS for this route, for internal use only.
+export default async (req: Request, res: Response) => {
+  const userId = (req.user?.userId ?? req.user?.id)!
+
+  const analyticsConfigService: AnalyticsConfigService = req.scope.resolve(
+    "analyticsConfigService"
+  )
+  const manager: EntityManager = req.scope.resolve("manager")
+
+  await manager.transaction(async (transactionManager) => {
+    return await analyticsConfigService
+      .withTransaction(transactionManager)
+      .delete(userId)
+  })
+
+  res
+    .status(200)
+    .json({ user_id: userId, object: "analytics_config", deleted: true })
+}

packages/medusa/src/api/routes/admin/analytics-configs/get-analytics-config.ts

@@ -0,0 +1,14 @@
+import { Request, Response } from "express"
+import { AnalyticsConfigService } from "../../../../services"
+
+// No OAS for this route, for internal use only.
+export default async (req: Request, res: Response): Promise<void> => {
+  const userId = (req.user?.userId ?? req.user?.id)!
+
+  const analyticsConfigService: AnalyticsConfigService = req.scope.resolve(
+    "analyticsConfigService"
+  )
+
+  const analyticsConfig = await analyticsConfigService.retrieve(userId)
+  res.status(200).json({ analytics_config: analyticsConfig })
+}

packages/medusa/src/api/routes/admin/analytics-configs/index.ts

@@ -0,0 +1,43 @@
+import { Router } from "express"
+import { AnalyticsConfig } from "../../../.."
+import { DeleteResponse } from "../../../../types/common"
+import middlewares, { transformBody } from "../../../middlewares"
+import { isFeatureFlagEnabled } from "../../../middlewares/feature-flag-enabled"
+import { AdminPostAnalyticsConfigReq } from "./create-analytics-config"
+import { AdminPostAnalyticsConfigAnalyticsConfigReq } from "./update-analytics-config"
+
+const route = Router()
+
+export default (app: Router) => {
+  app.use("/analytics-configs", isFeatureFlagEnabled("analytics"), route)
+
+  route.get("/", middlewares.wrap(require("./get-analytics-config").default))
+
+  route.post(
+    "/",
+    transformBody(AdminPostAnalyticsConfigReq),
+    middlewares.wrap(require("./create-analytics-config").default)
+  )
+
+  route.post(
+    "/update",
+    transformBody(AdminPostAnalyticsConfigAnalyticsConfigReq),
+    middlewares.wrap(require("./update-analytics-config").default)
+  )
+
+  route.delete(
+    "/",
+    middlewares.wrap(require("./delete-analytics-config").default)
+  )
+
+  return app
+}
+
+export type AdminAnalyticsConfigRes = {
+  analytics_config: AnalyticsConfig
+}
+
+export type AdminAnalyticsConfigDeleteRes = DeleteResponse
+
+export * from "./create-analytics-config"
+export * from "./update-analytics-config"

packages/medusa/src/api/routes/admin/analytics-configs/update-analytics-config.ts

@@ -0,0 +1,35 @@
+import { IsBoolean, IsOptional } from "class-validator"
+import { Request, Response } from "express"
+import { EntityManager } from "typeorm"
+import { AnalyticsConfigService } from "../../../../services"
+import { UpdateAnalyticsConfig } from "../../../../types/analytics-config"
+
+// No OAS for this route, for internal use only.
+export default async (req: Request, res: Response) => {
+  const userId = (req.user?.userId ?? req.user?.id)!
+  const validatedBody = req.validatedBody as UpdateAnalyticsConfig
+  const analyticsConfigService: AnalyticsConfigService = req.scope.resolve(
+    "analyticsConfigService"
+  )
+
+  const manager: EntityManager = req.scope.resolve("manager")
+  const analyticsConfig = await manager.transaction(
+    async (transactionManager) => {
+      return await analyticsConfigService
+        .withTransaction(transactionManager)
+        .update(userId, validatedBody)
+    }
+  )
+
+  res.status(200).json({ analytics_config: analyticsConfig })
+}
+
+export class AdminPostAnalyticsConfigAnalyticsConfigReq {
+  @IsOptional()
+  @IsBoolean()
+  opt_out?: boolean
+
+  @IsOptional()
+  @IsBoolean()
+  anonymize?: boolean
+}

packages/medusa/src/api/routes/admin/index.js

@@ -1,6 +1,7 @@
 import cors from "cors"
 import { Router } from "express"
 import middlewares from "../../middlewares"
+import analyticsConfigs from "./analytics-configs"
 import appRoutes from "./apps"
 import authRoutes from "./auth"
 import batchRoutes from "./batch"
@@ -67,6 +68,7 @@ export default (app, container, config) => {
   // Calls all middleware that has been registered to run after authentication.
   middlewareService.usePostAuthentication(app)
 
+  analyticsConfigs(route)
   appRoutes(route)
   batchRoutes(route)
   collectionRoutes(route)

packages/medusa/src/loaders/feature-flags/analytics.ts

@@ -0,0 +1,11 @@
+import { FlagSettings } from "../../types/feature-flags"
+
+const AnalyticsFeatureFlag: FlagSettings = {
+  key: "analytics",
+  default_val: false,
+  env_key: "MEDUSA_FF_ANALYTICS",
+  description:
+    "Enable Medusa to collect data on usage, errors and performance for the purpose of improving the product",
+}
+
+export default AnalyticsFeatureFlag

packages/medusa/src/migrations/1666173221888-add_analytics_config.ts

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from "typeorm"
+import AnalyticsFeatureFlag from "../loaders/feature-flags/analytics"
+
+export const featureFlag = AnalyticsFeatureFlag.key
+
+export class addAnalyticsConfig1666173221888 implements MigrationInterface {
+  name = "addAnalyticsConfig1666173221888"
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "analytics_config" ("id" character varying NOT NULL, "created_at" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updated_at" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deleted_at" TIMESTAMP WITH TIME ZONE, "user_id" character varying NOT NULL, "opt_out" boolean NOT NULL DEFAULT false, "anonymize" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_93505647c5d7cb479becb810b0f" PRIMARY KEY ("id"))`
+    )
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "IDX_379ca70338ce9991f3affdeedf" ON "analytics_config" ("id", "user_id") WHERE deleted_at IS NULL`
+    )
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_379ca70338ce9991f3affdeedf"`
+    )
+    await queryRunner.query(`DROP TABLE "analytics_config"`)
+  }
+}

packages/medusa/src/models/analytics-config.ts

@@ -0,0 +1,23 @@
+import { BeforeInsert, Column, Index } from "typeorm"
+import { SoftDeletableEntity } from "../interfaces"
+import AnalyticsFeatureFlag from "../loaders/feature-flags/analytics"
+import { generateEntityId } from "../utils"
+import { FeatureFlagEntity } from "../utils/feature-flag-decorators"
+
+@FeatureFlagEntity(AnalyticsFeatureFlag.key)
+export class AnalyticsConfig extends SoftDeletableEntity {
+  @Index({ unique: true, where: "deleted_at IS NULL" })
+  @Column()
+  user_id: string
+
+  @Column({ default: false })
+  opt_out: boolean
+
+  @Column({ default: false })
+  anonymize: boolean
+
+  @BeforeInsert()
+  private beforeInsert(): void {
+    this.id = generateEntityId(this.id, "acfg")
+  }
+}

packages/medusa/src/models/index.ts

@@ -1,4 +1,5 @@
 export * from "./address"
+export * from "./analytics-config"
 export * from "./batch-job"
 export * from "./cart"
 export * from "./claim-image"

packages/medusa/src/repositories/analytics-config.ts

@@ -0,0 +1,5 @@
+import { EntityRepository, Repository } from "typeorm"
+import { AnalyticsConfig } from "../models/analytics-config"
+
+@EntityRepository(AnalyticsConfig)
+export class AnalyticsConfigRepository extends Repository<AnalyticsConfig> {}

packages/medusa/src/services/analytics-config.ts

@@ -0,0 +1,119 @@
+import { MedusaError } from "medusa-core-utils"
+import { EntityManager } from "typeorm"
+import { TransactionBaseService } from "../interfaces"
+import { AnalyticsConfig } from "../models"
+import { AnalyticsConfigRepository as AnalyticsRepository } from "../repositories/analytics-config"
+import {
+  CreateAnalyticsConfig,
+  UpdateAnalyticsConfig,
+} from "../types/analytics-config"
+import UserService from "./user"
+
+type InjectedDependencies = {
+  analyticsConfigRepository: typeof AnalyticsRepository
+  manager: EntityManager
+}
+
+class AnalyticsConfigService extends TransactionBaseService {
+  protected manager_: EntityManager
+  protected transactionManager_: EntityManager | undefined
+
+  protected readonly analyticsConfigRepository_: typeof AnalyticsRepository
+  protected readonly userService_: UserService
+
+  constructor({ analyticsConfigRepository, manager }: InjectedDependencies) {
+    // eslint-disable-next-line prefer-rest-params
+    super(arguments[0])
+
+    this.manager_ = manager
+    this.analyticsConfigRepository_ = analyticsConfigRepository
+  }
+
+  async retrieve(userId: string): Promise<AnalyticsConfig> {
+    const manager = this.manager_
+
+    const analyticsRepo = manager.getCustomRepository(
+      this.analyticsConfigRepository_
+    )
+
+    const analyticsConfig = await analyticsRepo.findOne({
+      where: { user_id: userId },
+    })
+
+    if (!analyticsConfig) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `No analytics config found for user with id: ${userId}`
+      )
+    }
+
+    return analyticsConfig
+  }
+
+  /**
+   * Creates an analytics config.
+   */
+  async create(
+    userId: string,
+    data: CreateAnalyticsConfig
+  ): Promise<AnalyticsConfig> {
+    const manager = this.transactionManager_ || this.manager_
+    const analyticsRepo = manager.getCustomRepository(
+      this.analyticsConfigRepository_
+    )
+
+    const config = analyticsRepo.create({ user_id: userId, ...data })
+    return await analyticsRepo.save(config)
+  }
+
+  /**
+   * Updates an analytics config. If the config does not exist, it will be created instead.
+   */
+  async update(
+    userId: string,
+    update: UpdateAnalyticsConfig
+  ): Promise<AnalyticsConfig> {
+    const manager = this.transactionManager_ || this.manager_
+
+    const analyticsRepo = manager.getCustomRepository(
+      this.analyticsConfigRepository_
+    )
+
+    const config = await this.retrieve(userId).catch(() => undefined)
+
+    if (!config) {
+      return this.create(userId, {
+        opt_out: update.opt_out ?? false,
+        anonymize: update.anonymize ?? false,
+      })
+    }
+
+    for (const [key, value] of Object.entries(update)) {
+      if (value !== undefined) {
+        config[key] = value
+      }
+    }
+
+    return await analyticsRepo.save(config)
+  }
+
+  /**
+   * Deletes an analytics config.
+   */
+  async delete(userId: string): Promise<void> {
+    const manager = this.transactionManager_ || this.manager_
+    const analyticsRepo = manager.getCustomRepository(
+      this.analyticsConfigRepository_
+    )
+
+    const config = await this.retrieve(userId).catch(() => undefined)
+
+    if (!config) {
+      return
+    }
+
+    await analyticsRepo.softRemove(config)
+  }
+}
+
+export default AnalyticsConfigService

packages/medusa/src/services/index.ts

@@ -1,3 +1,4 @@
+export { default as AnalyticsConfigService } from "./analytics-config"
 export { default as AuthService } from "./auth"
 export { default as BatchJobService } from "./batch-job"
 export { default as CartService } from "./cart"

packages/medusa/src/services/user.ts

@@ -3,6 +3,7 @@ import { MedusaError } from "medusa-core-utils"
 import Scrypt from "scrypt-kdf"
 import { EntityManager } from "typeorm"
 import { TransactionBaseService } from "../interfaces"
+import AnalyticsFeatureFlag from "../loaders/feature-flags/analytics"
 import { User } from "../models"
 import { UserRepository } from "../repositories/user"
 import { FindConfig } from "../types/common"
@@ -12,13 +13,17 @@ import {
   UpdateUserInput,
 } from "../types/user"
 import { buildQuery, setMetadata } from "../utils"
+import { FlagRouter } from "../utils/flag-router"
 import { validateEmail } from "../utils/is-email"
+import AnalyticsConfigService from "./analytics-config"
 import EventBusService from "./event-bus"
 
 type UserServiceProps = {
   userRepository: typeof UserRepository
+  analyticsConfigService: AnalyticsConfigService
   eventBusService: EventBusService
   manager: EntityManager
+  featureFlagRouter: FlagRouter
 }
 
 /**
@@ -34,13 +39,24 @@ class UserService extends TransactionBaseService {
 
   protected manager_: EntityManager
   protected transactionManager_: EntityManager
+  protected readonly analyticsConfigService_: AnalyticsConfigService
   protected readonly userRepository_: typeof UserRepository
   protected readonly eventBus_: EventBusService
+  protected readonly featureFlagRouter_: FlagRouter
 
-  constructor({ userRepository, eventBusService, manager }: UserServiceProps) {
-    super({ userRepository, eventBusService, manager })
+  constructor({
+    userRepository,
+    eventBusService,
+    analyticsConfigService,
+    featureFlagRouter,
+    manager,
+  }: UserServiceProps) {
+    // eslint-disable-next-line prefer-rest-params
+    super(arguments[0])
 
     this.userRepository_ = userRepository
+    this.analyticsConfigService_ = analyticsConfigService
+    this.featureFlagRouter_ = featureFlagRouter
     this.eventBus_ = eventBusService
     this.manager_ = manager
   }
@@ -236,6 +252,8 @@ class UserService extends TransactionBaseService {
   async delete(userId: string): Promise<void> {
     return await this.atomicPhase_(async (manager: EntityManager) => {
       const userRepo = manager.getCustomRepository(this.userRepository_)
+      const analyticsServiceTx =
+        this.analyticsConfigService_.withTransaction(manager)
 
       // Should not fail, if user does not exist, since delete is idempotent
       const user = await userRepo.findOne({ where: { id: userId } })
@@ -244,6 +262,10 @@ class UserService extends TransactionBaseService {
         return Promise.resolve()
       }
 
+      if (this.featureFlagRouter_.isFeatureEnabled(AnalyticsFeatureFlag.key)) {
+        await analyticsServiceTx.delete(userId)
+      }
+
       await userRepo.softRemove(user)
 
       await this.eventBus_.emit(UserService.Events.DELETED, { id: user.id })

packages/medusa/src/types/analytics-config.ts

@@ -0,0 +1,9 @@
+export type CreateAnalyticsConfig = {
+  opt_out: boolean
+  anonymize: boolean
+}
+
+export type UpdateAnalyticsConfig = {
+  opt_out?: boolean
+  anonymize?: boolean
+}