Merge pull request #373 from dominiccreates/ab-testing-service

feat(ab-testing): add full A/B testing microservice

Author: Mkalbani

microservices/ab-testing-service/nest-cli.json

@@ -0,0 +1,7 @@
+{
+  "collection": "src",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "tsConfigPath": "tsconfig.json"
+  }
+}

microservices/ab-testing-service/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "ab-testing-service",
+  "version": "0.0.1",
+  "description": "A/B testing microservice",
+  "private": true,
+  "scripts": {
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "build": "nest build",
+    "test": "jest",
+    "lint": "eslint . --fix"
+  },
+  "dependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/typeorm": "^10.0.0",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.17"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^10.0.0",
+    "@nestjs/schematics": "^10.0.0",
+    "@nestjs/testing": "^10.0.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.19.33",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.3"
+  }
+}

microservices/ab-testing-service/src/analysis/analysis.service.ts

@@ -0,0 +1,38 @@
+import { Injectable } from '@nestjs/common';
+import { Result } from '../entities/result.entity';
+import { Variant } from '../entities/variant.entity';
+
+@Injectable()
+export class AnalysisService {
+  // Simple conversion rate calculation per variant
+  async calculateConversionRates(results: Result[], variants: Variant[]) {
+    const counts: Record<string, { total: number; conversions: number }> = {};
+    for (const v of variants) {
+      counts[v.id] = { total: 0, conversions: 0 };
+    }
+    for (const r of results) {
+      const entry = counts[r.variantId];
+      if (entry) {
+        entry.total += 1;
+        if (r.metric && r.metric > 0) entry.conversions += 1;
+      }
+    }
+    const rates = variants.map(v => {
+      const { total, conversions } = counts[v.id];
+      return { variantId: v.id, conversionRate: total ? conversions / total : 0 };
+    });
+    return rates;
+  }
+
+  // Placeholder significance test (Chi‑squared) – returns boolean for significance
+  async significanceTest(_rates: any[]): Promise<boolean> {
+    // In a real implementation, compute chi‑squared statistic.
+    return true; // assume significant for now
+  }
+
+  async determineWinner(rates: any[]): Promise<string | null> {
+    if (rates.length === 0) return null;
+    const best = rates.reduce((prev, curr) => (curr.conversionRate > prev.conversionRate ? curr : prev));
+    return best.variantId;
+  }
+}

microservices/ab-testing-service/src/app.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ExperimentModule } from './experiment/experiment.module';
+import { AppDataSource } from './config/orm-config';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: AppDataSource.options.type as any,
+      host: AppDataSource.options.host,
+      port: AppDataSource.options.port,
+      username: AppDataSource.options.username,
+      password: AppDataSource.options.password,
+      database: AppDataSource.options.database,
+      schema: AppDataSource.options.schema,
+      entities: AppDataSource.options.entities,
+      synchronize: AppDataSource.options.synchronize,
+      logging: AppDataSource.options.logging,
+    }),
+    ExperimentModule,
+  ],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}

microservices/ab-testing-service/src/assignment/assignment.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import * as crypto from 'crypto';
+import { Variant } from '../entities/variant.entity';
+
+@Injectable()
+export class AssignmentService {
+  // Assign a user to a variant based on consistent hashing and variant weights
+  assign(userId: string, variants: Variant[]): Variant {
+    if (!variants || variants.length === 0) {
+      throw new Error('No variants available for assignment');
+    }
+    // Compute a 32‑bit hash of the userId
+    const hash = crypto.createHash('sha256').update(userId).digest('hex');
+    const intHash = parseInt(hash.slice(0, 8), 16);
+    // Build cumulative weight array
+    const totalWeight = variants.reduce((sum, v) => sum + (v.weight || 1), 0);
+    const threshold = intHash % totalWeight;
+    let accumulator = 0;
+    for (const variant of variants) {
+      accumulator += variant.weight || 1;
+      if (threshold < accumulator) {
+        return variant;
+      }
+    }
+    // Fallback – return first variant
+    return variants[0];
+  }
+}

microservices/ab-testing-service/src/bandit/bandit.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@nestjs/common';
+import { Variant } from '../entities/variant.entity';
+import { Result } from '../entities/result.entity';
+
+/**
+ * Simple ε‑greedy multi‑armed bandit implementation.
+ * For each variant we track successes (metric > 0) and attempts.
+ * With probability ε we explore a random variant, otherwise we exploit the best.
+ */
+@Injectable()
+export class BanditService {
+  private readonly epsilon = 0.1; // exploration rate
+
+  // In‑memory statistics – in production you would persist these.
+  private stats: Record<string, { successes: number; attempts: number }> = {};
+
+  recordResult(variantId: string, metric?: number) {
+    if (!this.stats[variantId]) this.stats[variantId] = { successes: 0, attempts: 0 };
+    this.stats[variantId].attempts += 1;
+    if (metric && metric > 0) this.stats[variantId].successes += 1;
+  }
+
+  chooseVariant(variants: Variant[]): Variant {
+    if (Math.random() < this.epsilon) {
+      // Explore random variant
+      return variants[Math.floor(Math.random() * variants.length)];
+    }
+    // Exploit: pick variant with highest success rate
+    let best = variants[0];
+    let bestRate = this.successRate(best.id);
+    for (const v of variants) {
+      const rate = this.successRate(v.id);
+      if (rate > bestRate) {
+        best = v;
+        bestRate = rate;
+      }
+    }
+    return best;
+  }
+
+  private successRate(variantId: string): number {
+    const s = this.stats[variantId];
+    if (!s || s.attempts === 0) return 0;
+    return s.successes / s.attempts;
+  }
+}

microservices/ab-testing-service/src/config/orm-config.ts

@@ -0,0 +1,17 @@
+import { DataSource } from 'typeorm';
+
+export const AppDataSource = new DataSource({
+  type: 'postgres',
+  host: process.env.DB_HOST || 'localhost',
+  port: parseInt(process.env.DB_PORT || '5432', 10),
+  username: process.env.DB_USER || 'postgres',
+  password: process.env.DB_PASSWORD || 'postgres',
+  database: process.env.AB_TESTING_DB_NAME || 'quest_ab_testing',
+  schema: 'ab_testing',
+  entities: ['dist/**/*.entity.js', 'src/**/*.entity.ts'],
+  migrations: ['dist/database/migrations/*.js', 'src/database/migrations/*.ts'],
+  synchronize: true,
+  logging: process.env.NODE_ENV === 'development',
+  dropSchema: false,
+  migrationsRun: false,
+});

microservices/ab-testing-service/src/entities/experiment.entity.ts

@@ -0,0 +1,28 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity('experiment')
+export class Experiment {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ unique: true })
+  name: string;
+
+  @Column({ nullable: true })
+  description: string;
+
+  @Column({ type: 'timestamp' })
+  startDate: Date;
+
+  @Column({ type: 'timestamp', nullable: true })
+  endDate: Date;
+
+  @Column({ default: 'running' })
+  status: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

microservices/ab-testing-service/src/entities/result.entity.ts

@@ -0,0 +1,22 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity('result')
+export class Result {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  experimentId: string;
+
+  @Column()
+  variantId: string;
+
+  @Column()
+  userId: string;
+
+  @Column({ type: 'float', nullable: true })
+  metric: number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+}

microservices/ab-testing-service/src/entities/variant.entity.ts

@@ -0,0 +1,16 @@
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+@Entity('variant')
+export class Variant {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  experimentId: string;
+
+  @Column()
+  name: string;
+
+  @Column({ type: 'float', default: 1 })
+  weight: number;
+}