@naturalcycles/abba 2.0.1 → 2.1.0

package/dist/util.d.ts

@@ -1,11 +1,11 @@
 import type { Unsaved } from '@naturalcycles/js-lib';
-import type { Bucket, ExclusionSet, Experiment, ExperimentWithBuckets, SegmentationData, SegmentationRule, SegmentationRuleFn, UserAssignment } from './types.js';
+import type { Bucket, ExclusionSet, Experiment, ExperimentWithBuckets, SegmentationData, SegmentationRule, SegmentationRuleFn, UserAssignment, UserExperiment } from './types.js';
 import { SegmentationRuleOperator } from './types.js';
 /**
  * Generate a new assignment for a given user.
  * Doesn't save it.
  */
-export declare const generateUserAssignmentData: (experiment: ExperimentWithBuckets, userId: string, segmentationData: SegmentationData) => UserAssignment | null;
+export declare function generateUserAssignmentData(experiment: ExperimentWithBuckets, userId: string, segmentationData: SegmentationData): Unsaved<UserAssignment> | null;
 declare class RandomService {
     /**
      * Generate a random number between 0 and 100
@@ -16,15 +16,15 @@ export declare const randomService: RandomService;
 /**
  * Determines a users assignment for this experiment. Returns null if they are not considered to be in the sampling group
  */
-export declare const determineAssignment: (sampling: number, buckets: Bucket[]) => Bucket | null;
+export declare function determineAssignment(sampling: number, buckets: Bucket[]): Bucket | null;
 /**
  * Determines which bucket a user assignment will recieve
  */
-export declare const determineBucket: (buckets: Bucket[]) => Bucket;
+export declare function determineBucket(buckets: Bucket[]): Bucket;
 /**
  * Validate the total ratio of the buckets equals 100
  */
-export declare const validateTotalBucketRatio: (buckets: Unsaved<Bucket>[]) => void;
+export declare function validateTotalBucketRatio(buckets: Unsaved<Bucket>[]): void;
 /**
  * Validate a users segmentation data against multiple rules. Returns false if any fail
  *
@@ -32,7 +32,7 @@ export declare const validateTotalBucketRatio: (buckets: Unsaved<Bucket>[]) => v
  * @param segmentationData
  * @returns
  */
-export declare const validateSegmentationRules: (rules: SegmentationRule[], segmentationData: SegmentationData) => boolean;
+export declare function validateSegmentationRules(rules: SegmentationRule[], segmentationData: SegmentationData): boolean;
 /**
  * Map of segmentation rule validators
  */
@@ -40,10 +40,10 @@ export declare const segmentationRuleMap: Record<SegmentationRuleOperator, Segme
 /**
  * Returns true if an experiment is able to generate new assignments based on status and start/end dates
  */
-export declare const canGenerateNewAssignments: (experiment: Experiment, exclusionSet: ExclusionSet) => boolean;
+export declare function canGenerateNewAssignments(experiment: Experiment, exclusionSet: ExclusionSet): boolean;
 /**
  * Returns an object that includes keys of all experimentIds a user should not be assigned to
  * based on a combination of existing assignments and mutual exclusion configuration
  */
-export declare const getUserExclusionSet: (experiments: Experiment[], existingAssignments: UserAssignment[]) => ExclusionSet;
+export declare function getUserExclusionSet(experiments: UserExperiment[]): ExclusionSet;
 export {};

package/dist/util.js

@@ -5,7 +5,7 @@ import { AssignmentStatus, SegmentationRuleOperator } from './types.js';
  * Generate a new assignment for a given user.
  * Doesn't save it.
  */
-export const generateUserAssignmentData = (experiment, userId, segmentationData) => {
+export function generateUserAssignmentData(experiment, userId, segmentationData) {
     const segmentationMatch = validateSegmentationRules(experiment.rules, segmentationData);
     if (!segmentationMatch)
         return null;
@@ -15,7 +15,7 @@ export const generateUserAssignmentData = (experiment, userId, segmentationData)
         experimentId: experiment.id,
         bucketId: bucket?.id || null,
     };
-};
+}
 class RandomService {
     /**
      * Generate a random number between 0 and 100
@@ -28,18 +28,18 @@ export const randomService = new RandomService();
 /**
  * Determines a users assignment for this experiment. Returns null if they are not considered to be in the sampling group
  */
-export const determineAssignment = (sampling, buckets) => {
+export function determineAssignment(sampling, buckets) {
     // Should this person be considered for the experiment?
     if (randomService.rollDie() > sampling) {
         return null;
     }
     // get their bucket
     return determineBucket(buckets);
-};
+}
 /**
  * Determines which bucket a user assignment will recieve
  */
-export const determineBucket = (buckets) => {
+export function determineBucket(buckets) {
     const bucketRoll = randomService.rollDie();
     let range;
     const bucket = buckets.find(b => {
@@ -57,16 +57,16 @@ export const determineBucket = (buckets) => {
         throw new Error('Could not detetermine bucket from ratios');
     }
     return bucket;
-};
+}
 /**
  * Validate the total ratio of the buckets equals 100
  */
-export const validateTotalBucketRatio = (buckets) => {
+export function validateTotalBucketRatio(buckets) {
     const bucketSum = buckets.reduce((sum, current) => sum + current.ratio, 0);
     if (bucketSum !== 100) {
         throw new Error('Total bucket ratio must be 100 before you can activate an experiment');
     }
-};
+}
 /**
  * Validate a users segmentation data against multiple rules. Returns false if any fail
  *
@@ -74,14 +74,14 @@ export const validateTotalBucketRatio = (buckets) => {
  * @param segmentationData
  * @returns
  */
-export const validateSegmentationRules = (rules, segmentationData) => {
+export function validateSegmentationRules(rules, segmentationData) {
     for (const rule of rules) {
         const { key, value, operator } = rule;
         if (!segmentationRuleMap[operator](segmentationData[key], value))
             return false;
     }
     return true;
-};
+}
 /**
  * Map of segmentation rule validators
  */
@@ -115,24 +115,24 @@ export const segmentationRuleMap = {
 /**
  * Returns true if an experiment is able to generate new assignments based on status and start/end dates
  */
-export const canGenerateNewAssignments = (experiment, exclusionSet) => {
+export function canGenerateNewAssignments(experiment, exclusionSet) {
     return (!exclusionSet.has(experiment.id) &&
         experiment.status === AssignmentStatus.Active &&
         localDate.today().isBetween(experiment.startDateIncl, experiment.endDateExcl, '[)'));
-};
+}
 /**
  * Returns an object that includes keys of all experimentIds a user should not be assigned to
  * based on a combination of existing assignments and mutual exclusion configuration
  */
-export const getUserExclusionSet = (experiments, existingAssignments) => {
+export function getUserExclusionSet(experiments) {
     const exclusionSet = new Set();
-    existingAssignments.forEach(assignment => {
+    experiments.forEach(experiment => {
+        const { userAssignment } = experiment;
         // Users who are excluded from an experiment due to sampling
         // should not prevent potential assignment to other mutually exclusive experiments
-        if (assignment.bucketId === null)
+        if (!userAssignment || userAssignment?.bucketId === null)
             return;
-        const experiment = experiments.find(e => e.id === assignment.experimentId);
-        experiment?.exclusions.forEach(experimentId => exclusionSet.add(experimentId));
+        experiment.exclusions.forEach(experimentId => exclusionSet.add(experimentId));
     });
     return exclusionSet;
-};
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/abba",
   "type": "module",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build",
@@ -46,5 +46,6 @@
   },
   "description": "AB test assignment configuration tool for Node.js",
   "author": "Natural Cycles Team",
-  "license": "MIT"
+  "license": "MIT",
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/src/abba.ts

@@ -2,18 +2,19 @@ import type { Unsaved } from '@naturalcycles/js-lib'
 import { _assert, _Memo, _shuffle, localTime, pMap } from '@naturalcycles/js-lib'
 import { LRUMemoCache } from '@naturalcycles/nodejs-lib'
 import { bucketDao } from './dao/bucket.dao.js'
-import { experimentDao } from './dao/experiment.dao.js'
+import { experimentDao, type GetAllExperimentsOpts } from './dao/experiment.dao.js'
 import { userAssignmentDao } from './dao/userAssignment.dao.js'
 import type {
   AbbaConfig,
   Bucket,
   BucketAssignmentStatistics,
+  DecoratedUserAssignment,
   Experiment,
   ExperimentAssignmentStatistics,
   ExperimentWithBuckets,
-  GeneratedUserAssignment,
   SegmentationData,
   UserAssignment,
+  UserExperiment,
 } from './types.js'
 import { AssignmentStatus } from './types.js'
 import {
@@ -40,23 +41,19 @@ export class Abba {
    * Cached (see CACHE_TTL)
    */
   @_Memo({ cacheFactory: () => new LRUMemoCache({ ttl: CACHE_TTL, max: 1 }) })
-  async getAllExperiments(): Promise<ExperimentWithBuckets[]> {
-    return await this.getAllExperimentsNoCache()
-  }
-
-  /**
-   * Updates all user assignments with a given userId with the provided userId.
-   */
-  async updateUserId(oldId: string, newId: string): Promise<void> {
-    const query = this.userAssignmentDao.query().filterEq('userId', oldId)
-    await this.userAssignmentDao.patchByQuery(query, { userId: newId })
+  async getAllExperimentsWithBuckets(
+    opts?: GetAllExperimentsOpts,
+  ): Promise<ExperimentWithBuckets[]> {
+    return await this.getAllExperimentsWithBucketsNoCache(opts)
   }
 
   /**
    * Returns all experiments.
    */
-  async getAllExperimentsNoCache(): Promise<ExperimentWithBuckets[]> {
-    const experiments = await this.experimentDao.getAll()
+  async getAllExperimentsWithBucketsNoCache(
+    opts?: GetAllExperimentsOpts,
+  ): Promise<ExperimentWithBuckets[]> {
+    const experiments = await this.experimentDao.getAllExperiments(opts)
     const buckets = await this.bucketDao.getAll()
 
     return experiments.map(experiment => ({
@@ -65,6 +62,45 @@ export class Abba {
     }))
   }
 
+  async getUserExperiments(userId: string): Promise<UserExperiment[]> {
+    const experiments = await this.getAllExperimentsWithBuckets({ includeDeleted: false })
+
+    const experimentIds = experiments.map(e => e.id)
+    const userAssignments = await this.userAssignmentDao.getUserAssigmentsByExperimentIds(
+      userId,
+      experimentIds,
+    )
+
+    return experiments.map(experiment => {
+      const existingAssignment = userAssignments.find(ua => ua.experimentId === experiment.id)
+      const existingAssignmentBucket = experiment.buckets.find(
+        b => b.id === existingAssignment?.bucketId,
+      )
+
+      return {
+        ...experiment,
+        ...(existingAssignment && {
+          userAssignment: {
+            ...existingAssignment,
+            experimentId: experiment.id,
+            experimentData: experiment.data,
+            experimentKey: experiment.key,
+            bucketData: existingAssignmentBucket?.data || null,
+            bucketKey: existingAssignmentBucket?.key || null,
+          },
+        }),
+      }
+    })
+  }
+
+  /**
+   * Updates all user assignments with a given userId with the provided userId.
+   */
+  async updateUserId(oldId: string, newId: string): Promise<void> {
+    const query = this.userAssignmentDao.query().filterEq('userId', oldId)
+    await this.userAssignmentDao.patchByQuery(query, { userId: newId })
+  }
+
   /**
    * Creates a new experiment.
    * Cold method.
@@ -148,6 +184,11 @@ export class Abba {
     await this.experimentDao.saveBatch(requiresUpdating, { saveMethod: 'update' })
   }
 
+  async softDeleteExperiment(experimentId: string): Promise<void> {
+    await this.experimentDao.patchById(experimentId, { deleted: true, exclusions: [] })
+    await this.updateExclusions(experimentId, [])
+  }
+
   /**
    * Delete an experiment. Removes all user assignments and buckets.
    * Requires the experiment to have been inactive for at least 15 minutes in order to
@@ -191,49 +232,40 @@ export class Abba {
     userId: string,
     existingOnly: boolean,
     segmentationData?: SegmentationData,
-  ): Promise<GeneratedUserAssignment> {
-    const experiment = await this.experimentDao.getOneBy('key', experimentKey)
+  ): Promise<DecoratedUserAssignment | null> {
+    const experiment = await this.experimentDao.getByKey(experimentKey)
     _assert(experiment, `Experiment does not exist: ${experimentKey}`)
 
     // Inactive experiments should never return an assignment
     if (experiment.status === AssignmentStatus.Inactive) {
-      return {
-        experiment,
-        assignment: null,
-      }
+      return null
     }
 
-    const buckets = await this.bucketDao.getBy('experimentId', experiment.id)
-    const existingAssignments = await this.userAssignmentDao.getBy('userId', userId)
-    const existing = existingAssignments.find(a => a.experimentId === experiment.id)
-    if (existing) {
-      const bucket = buckets.find(b => b.id === existing.bucketId)
+    const buckets = await this.bucketDao.getByExperimentId(experiment.id)
+    const userAssignment = await this.userAssignmentDao.getUserAssignmentByExperimentId(
+      userId,
+      experiment.id,
+    )
+    if (userAssignment) {
+      const bucket = buckets.find(b => b.id === userAssignment.bucketId)
       return {
-        experiment,
-        assignment: {
-          ...existing,
-          experimentKey: experiment.key,
-          bucketKey: bucket?.key || null,
-          bucketData: bucket?.data || null,
-        },
+        ...userAssignment,
+        experimentData: experiment.data,
+        experimentKey: experiment.key,
+        bucketKey: bucket?.key || null,
+        bucketData: bucket?.data || null,
       }
     }
 
     // No existing assignment, but we don't want to generate a new one
     if (existingOnly || experiment.status === AssignmentStatus.Paused) {
-      return {
-        experiment,
-        assignment: null,
-      }
+      return null
     }
 
-    const experiments = await this.getAllExperiments()
-    const exclusionSet = getUserExclusionSet(experiments, existingAssignments)
+    const experiments = await this.getUserExperiments(userId)
+    const exclusionSet = getUserExclusionSet(experiments)
     if (!canGenerateNewAssignments(experiment, exclusionSet)) {
-      return {
-        experiment,
-        assignment: null,
-      }
+      return null
     }
 
     _assert(segmentationData, 'Segmentation data required when creating a new assignment')
@@ -241,10 +273,7 @@ export class Abba {
     const experimentWithBuckets = { ...experiment, buckets }
     const assignment = generateUserAssignmentData(experimentWithBuckets, userId, segmentationData)
     if (!assignment) {
-      return {
-        experiment,
-        assignment: null,
-      }
+      return null
     }
 
     const newAssignment = await this.userAssignmentDao.save(assignment)
@@ -252,13 +281,11 @@ export class Abba {
     const bucket = buckets.find(b => b.id === newAssignment.bucketId)
 
     return {
-      experiment,
-      assignment: {
-        ...newAssignment,
-        experimentKey: experiment.key,
-        bucketKey: bucket?.key || null,
-        bucketData: bucket?.data || null,
-      },
+      ...newAssignment,
+      experimentData: experiment.data,
+      experimentKey: experiment.key,
+      bucketKey: bucket?.key || null,
+      bucketData: bucket?.data || null,
     }
   }
 
@@ -268,19 +295,17 @@ export class Abba {
    * Not cached, because Assignments are fast-changing.
    * Only to be used for testing
    */
-  async getAllExistingGeneratedUserAssignments(userId: string): Promise<GeneratedUserAssignment[]> {
+  async getAllExistingUserAssignments(userId: string): Promise<DecoratedUserAssignment[]> {
     const assignments = await this.userAssignmentDao.getBy('userId', userId)
     return await pMap(assignments, async assignment => {
       const experiment = await this.experimentDao.requireById(assignment.experimentId)
       const bucket = await this.bucketDao.getById(assignment.bucketId)
       return {
-        experiment,
-        assignment: {
-          ...assignment,
-          experimentKey: experiment.key,
-          bucketKey: bucket?.key || null,
-          bucketData: bucket?.data || null,
-        },
+        ...assignment,
+        experimentData: experiment.data,
+        experimentKey: experiment.key,
+        bucketKey: bucket?.key || null,
+        bucketData: bucket?.data || null,
       }
     })
   }
@@ -294,12 +319,9 @@ export class Abba {
     userId: string,
     segmentationData: SegmentationData,
     existingOnly = false,
-  ): Promise<GeneratedUserAssignment[]> {
-    const experiments = await this.getAllExperiments()
-    const existingAssignments = await this.userAssignmentDao.getBy('userId', userId)
-    const exclusionSet = getUserExclusionSet(experiments, existingAssignments)
-    const assignments: GeneratedUserAssignment[] = []
-    const newAssignments: UserAssignment[] = []
+  ): Promise<DecoratedUserAssignment[]> {
+    const experiments = await this.getUserExperiments(userId)
+    const exclusionSet = getUserExclusionSet(experiments)
 
     // Shuffling means that randomisation occurs in the mutual exclusion
     // as experiments are looped through sequentially, this removes the risk of the same experiment always being assigned first in the list of mutually exclusive experiments
@@ -310,41 +332,43 @@ export class Abba {
       ),
     )
 
+    const assignments: DecoratedUserAssignment[] = []
+    const newAssignments: Unsaved<UserAssignment>[] = []
+
     for (const experiment of availableExperiments) {
-      const existing = existingAssignments.find(ua => ua.experimentId === experiment.id)
-      if (existing) {
-        const bucket = experiment.buckets.find(b => b.id === existing.bucketId)
+      const { userAssignment } = experiment
+      // Already assigned to this experiment
+      if (userAssignment) {
+        assignments.push(userAssignment)
+        continue
+      }
+
+      // Not already assigned, but we don't want to generate a new assignment
+      if (existingOnly) continue
+      // We are not allowed to generate new assignments for this experiment
+      if (!canGenerateNewAssignments(experiment, exclusionSet)) continue
+
+      const assignment = generateUserAssignmentData(experiment, userId, segmentationData)
+      if (assignment) {
+        // Add to list of new assignments to be saved
+        const newAssignment = this.userAssignmentDao.create(assignment)
+        newAssignments.push(newAssignment)
+        // Add the assignment to the list of assignments
+        const bucket = experiment.buckets.find(b => b.id === assignment.bucketId)
         assignments.push({
-          experiment,
-          assignment: {
-            ...existing,
-            experimentKey: experiment.key,
-            bucketKey: bucket?.key || null,
-            bucketData: bucket?.data || null,
-          },
+          ...newAssignment,
+          experimentKey: experiment.key,
+          experimentData: experiment.data,
+          bucketKey: bucket?.key || null,
+          bucketData: bucket?.data || null,
         })
-      } else if (!existingOnly && canGenerateNewAssignments(experiment, exclusionSet)) {
-        const assignment = generateUserAssignmentData(experiment, userId, segmentationData)
-        if (assignment) {
-          const created = this.userAssignmentDao.create(assignment)
-          newAssignments.push(created)
-          const bucket = experiment.buckets.find(b => b.id === created.bucketId)
-          assignments.push({
-            experiment,
-            assignment: {
-              ...created,
-              experimentKey: experiment.key,
-              bucketKey: bucket?.key || null,
-              bucketData: bucket?.data || null,
-            },
-          })
-          // Prevent future exclusion clashes
-          experiment.exclusions.forEach(experimentId => exclusionSet.add(experimentId))
-        }
+        // Prevent future exclusion clashes
+        experiment.exclusions.forEach(experimentId => exclusionSet.add(experimentId))
       }
     }
 
     await this.userAssignmentDao.saveBatch(newAssignments)
+
     return assignments
   }
 
@@ -355,18 +379,11 @@ export class Abba {
   async getExperimentAssignmentStatistics(
     experimentId: string,
   ): Promise<ExperimentAssignmentStatistics> {
-    const totalAssignments = await this.userAssignmentDao
-      .query()
-      .filterEq('experimentId', experimentId)
-      .runQueryCount()
+    const totalAssignments = await this.userAssignmentDao.getCountByExperimentId(experimentId)
+    const buckets = await this.bucketDao.getByExperimentId(experimentId)
 
-    const buckets = await this.bucketDao.getBy('experimentId', experimentId)
     const bucketAssignments: BucketAssignmentStatistics[] = await pMap(buckets, async bucket => {
-      const totalAssignments = await this.userAssignmentDao
-        .query()
-        .filterEq('bucketId', bucket.id)
-        .runQueryCount()
-
+      const totalAssignments = await this.userAssignmentDao.getCountByBucketId(bucket.id)
       return {
         bucketId: bucket.id,
         totalAssignments,

package/src/dao/bucket.dao.ts

@@ -1,16 +1,19 @@
 import type { CommonDB } from '@naturalcycles/db-lib'
 import { CommonDao } from '@naturalcycles/db-lib'
-import type { Saved } from '@naturalcycles/js-lib'
 import type { BaseBucket, Bucket } from '../types.js'
 
-type BucketDBM = Saved<BaseBucket> & {
+type BucketDBM = BaseBucket & {
   data: string | null
 }
 
-export class BucketDao extends CommonDao<Bucket, BucketDBM> {}
+export class BucketDao extends CommonDao<Bucket, BucketDBM> {
+  async getByExperimentId(experimentId: string): Promise<Bucket[]> {
+    return await this.query().filterEq('experimentId', experimentId).runQuery()
+  }
+}
 
-export const bucketDao = (db: CommonDB): BucketDao =>
-  new BucketDao({
+export function bucketDao(db: CommonDB): BucketDao {
+  return new BucketDao({
     db,
     table: 'Bucket',
     hooks: {
@@ -26,3 +29,4 @@ export const bucketDao = (db: CommonDB): BucketDao =>
       }),
     },
   })
+}

package/src/dao/experiment.dao.ts

@@ -1,19 +1,25 @@
 import type { CommonDB } from '@naturalcycles/db-lib'
 import { CommonDao } from '@naturalcycles/db-lib'
-import type { IsoDate, Saved } from '@naturalcycles/js-lib'
+import type { IsoDate } from '@naturalcycles/js-lib'
 import { localDate } from '@naturalcycles/js-lib'
 import type { BaseExperiment, Experiment } from '../types.js'
 
-type ExperimentDBM = Saved<BaseExperiment> & {
-  rules: string | null
-  exclusions: string | null
-  data: string | null
-}
+export class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {
+  async getAllExperiments(opt?: GetAllExperimentsOpts): Promise<Experiment[]> {
+    if (!opt?.includeDeleted) {
+      return await this.getAll()
+    }
 
-export class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {}
+    return await this.query().filterEq('deleted', false).runQuery()
+  }
 
-export const experimentDao = (db: CommonDB): ExperimentDao =>
-  new ExperimentDao({
+  async getByKey(key: string): Promise<Experiment | null> {
+    return await this.getOneBy('key', key)
+  }
+}
+
+export function experimentDao(db: CommonDB): ExperimentDao {
+  return new ExperimentDao({
     db,
     table: 'Experiment',
     hooks: {
@@ -42,6 +48,7 @@ export const experimentDao = (db: CommonDB): ExperimentDao =>
       }),
     },
   })
+}
 
 /**
  * https://nc1.slack.com/archives/CCNTHJT7V/p1682514277002739
@@ -53,3 +60,13 @@ function parseMySQLDate(date: string): IsoDate {
   if (date instanceof Date) return localDate(date).toISODate()
   return date as IsoDate
 }
+
+type ExperimentDBM = BaseExperiment & {
+  rules: string | null
+  exclusions: string | null
+  data: string | null
+}
+
+export interface GetAllExperimentsOpts {
+  includeDeleted?: boolean
+}

package/src/dao/userAssignment.dao.ts

@@ -2,10 +2,36 @@ import type { CommonDB } from '@naturalcycles/db-lib'
 import { CommonDao } from '@naturalcycles/db-lib'
 import type { UserAssignment } from '../types.js'
 
-export class UserAssignmentDao extends CommonDao<UserAssignment> {}
+export class UserAssignmentDao extends CommonDao<UserAssignment> {
+  async getUserAssignmentByExperimentId(
+    userId: string,
+    experimentId: string,
+  ): Promise<UserAssignment | null> {
+    const query = this.query().filterEq('userId', userId).filterEq('experimentId', experimentId)
+    const [userAssignment] = await this.runQuery(query)
+    return userAssignment || null
+  }
 
-export const userAssignmentDao = (db: CommonDB): UserAssignmentDao =>
-  new UserAssignmentDao({
+  async getUserAssigmentsByExperimentIds(
+    userId: string,
+    experimentIds: string[],
+  ): Promise<UserAssignment[]> {
+    const query = this.query().filterEq('userId', userId).filterIn('experimentId', experimentIds)
+    return await this.runQuery(query)
+  }
+
+  async getCountByExperimentId(experimentId: string): Promise<number> {
+    return await this.query().filterEq('experimentId', experimentId).runQueryCount()
+  }
+
+  async getCountByBucketId(bucketId: string): Promise<number> {
+    return await this.query().filterEq('bucketId', bucketId).runQueryCount()
+  }
+}
+
+export function userAssignmentDao(db: CommonDB): UserAssignmentDao {
+  return new UserAssignmentDao({
     db,
     table: 'UserAssignment',
   })
+}

package/src/migrations/init.sql

@@ -25,6 +25,7 @@ CREATE TABLE IF NOT EXISTS `Experiment` (
     `rules` JSON NULL,
     `exclusions` JSON NULL,
     `data` JSON NULL,
+    `deleted` BOOLEAN NOT NULL DEFAULT FALSE,
 
     PRIMARY KEY (`id`),
     UNIQUE INDEX `key_unique` (`key`)