@naturalcycles/abba 2.0.1 → 2.0.2

package/dist/abba.d.ts

@@ -1,5 +1,5 @@
 import type { Unsaved } from '@naturalcycles/js-lib';
-import type { AbbaConfig, Bucket, Experiment, ExperimentAssignmentStatistics, ExperimentWithBuckets, GeneratedUserAssignment, SegmentationData } from './types.js';
+import type { AbbaConfig, Bucket, DecoratedUserAssignment, Experiment, ExperimentAssignmentStatistics, ExperimentWithBuckets, SegmentationData, UserExperiment } from './types.js';
 export declare class Abba {
     cfg: AbbaConfig;
     private experimentDao;
@@ -10,7 +10,8 @@ export declare class Abba {
      * Returns all experiments.
      * Cached (see CACHE_TTL)
      */
-    getAllExperiments(): Promise<ExperimentWithBuckets[]>;
+    getAllExperimentsWithBuckets(): Promise<ExperimentWithBuckets[]>;
+    getAllExperimentsWithUserAssignments(userId: string): Promise<UserExperiment[]>;
     /**
      * Updates all user assignments with a given userId with the provided userId.
      */
@@ -18,7 +19,7 @@ export declare class Abba {
     /**
      * Returns all experiments.
      */
-    getAllExperimentsNoCache(): Promise<ExperimentWithBuckets[]>;
+    getAllExperimentsWithBucketsNoCache(): Promise<ExperimentWithBuckets[]>;
     /**
      * Creates a new experiment.
      * Cold method.
@@ -49,20 +50,20 @@ export declare class Abba {
      * @param existingOnly Do not generate any new assignments for this experiment
      * @param segmentationData Required if existingOnly is false
      */
-    getUserAssignment(experimentKey: string, userId: string, existingOnly: boolean, segmentationData?: SegmentationData): Promise<GeneratedUserAssignment>;
+    getUserAssignment(experimentKey: string, userId: string, existingOnly: boolean, segmentationData?: SegmentationData): Promise<DecoratedUserAssignment | null>;
     /**
      * Get all existing user assignments.
      * Hot method.
      * Not cached, because Assignments are fast-changing.
      * Only to be used for testing
      */
-    getAllExistingGeneratedUserAssignments(userId: string): Promise<GeneratedUserAssignment[]>;
+    getAllExistingUserAssignments(userId: string): Promise<DecoratedUserAssignment[]>;
     /**
      * Generate user assignments for all active experiments.
      * Will return any existing and attempt to generate any new assignments if existingOnly is false.
      * Hot method.
      */
-    generateUserAssignments(userId: string, segmentationData: SegmentationData, existingOnly?: boolean): Promise<GeneratedUserAssignment[]>;
+    generateUserAssignments(userId: string, segmentationData: SegmentationData, existingOnly?: boolean): Promise<DecoratedUserAssignment[]>;
     /**
      * Get assignment statistics for an experiment.
      * Cold method.

package/dist/abba.js

@@ -21,8 +21,30 @@ export class Abba {
      * Returns all experiments.
      * Cached (see CACHE_TTL)
      */
-    async getAllExperiments() {
-        return await this.getAllExperimentsNoCache();
+    async getAllExperimentsWithBuckets() {
+        return await this.getAllExperimentsWithBucketsNoCache();
+    }
+    async getAllExperimentsWithUserAssignments(userId) {
+        const experiments = await this.getAllExperimentsWithBuckets();
+        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.
@@ -34,7 +56,7 @@ export class Abba {
     /**
      * Returns all experiments.
      */
-    async getAllExperimentsNoCache() {
+    async getAllExperimentsWithBucketsNoCache() {
         const experiments = await this.experimentDao.getAll();
         const buckets = await this.bucketDao.getAll();
         return experiments.map(experiment => ({
@@ -128,64 +150,47 @@ export class Abba {
      * @param segmentationData Required if existingOnly is false
      */
     async getUserAssignment(experimentKey, userId, existingOnly, segmentationData) {
-        const experiment = await this.experimentDao.getOneBy('key', experimentKey);
+        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.getAllExperimentsWithUserAssignments(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');
         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);
         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,
         };
     }
     /**
@@ -194,19 +199,17 @@ export class Abba {
      * Not cached, because Assignments are fast-changing.
      * Only to be used for testing
      */
-    async getAllExistingGeneratedUserAssignments(userId) {
+    async getAllExistingUserAssignments(userId) {
         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,
             };
         });
     }
@@ -216,47 +219,43 @@ export class Abba {
      * Hot method.
      */
     async generateUserAssignments(userId, segmentationData, existingOnly = false) {
-        const experiments = await this.getAllExperiments();
-        const existingAssignments = await this.userAssignmentDao.getBy('userId', userId);
-        const exclusionSet = getUserExclusionSet(experiments, existingAssignments);
-        const assignments = [];
-        const newAssignments = [];
+        const experiments = await this.getAllExperimentsWithUserAssignments(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
         // This is simmpler than trying to resolve after assignments have already been determined
         const availableExperiments = _shuffle(experiments.filter(e => e.status === AssignmentStatus.Active || e.status === AssignmentStatus.Paused));
+        const assignments = [];
+        const newAssignments = [];
         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);
@@ -267,16 +266,10 @@ export class Abba {
      * Cold method.
      */
     async getExperimentAssignmentStatistics(experimentId) {
-        const totalAssignments = await this.userAssignmentDao
-            .query()
-            .filterEq('experimentId', experimentId)
-            .runQueryCount();
-        const buckets = await this.bucketDao.getBy('experimentId', experimentId);
+        const totalAssignments = await this.userAssignmentDao.getCountByExperimentId(experimentId);
+        const buckets = await this.bucketDao.getByExperimentId(experimentId);
         const bucketAssignments = 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,
@@ -290,4 +283,4 @@ export class Abba {
 }
 __decorate([
     _Memo({ cacheFactory: () => new LRUMemoCache({ ttl: CACHE_TTL, max: 1 }) })
-], Abba.prototype, "getAllExperiments", null);
+], Abba.prototype, "getAllExperimentsWithBuckets", null);

package/dist/dao/bucket.dao.d.ts

@@ -1,11 +1,11 @@
 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 declare class BucketDao extends CommonDao<Bucket, BucketDBM> {
+    getByExperimentId(experimentId: string): Promise<Bucket[]>;
 }
-export declare const bucketDao: (db: CommonDB) => BucketDao;
+export declare function bucketDao(db: CommonDB): BucketDao;
 export {};

package/dist/dao/bucket.dao.js

@@ -1,19 +1,24 @@
 import { CommonDao } from '@naturalcycles/db-lib';
 export class BucketDao extends CommonDao {
+    async getByExperimentId(experimentId) {
+        return await this.query().filterEq('experimentId', experimentId).runQuery();
+    }
 }
-export const bucketDao = (db) => new BucketDao({
-    db,
-    table: 'Bucket',
-    hooks: {
-        beforeBMToDBM: bm => {
-            return {
-                ...bm,
-                data: bm.data ? JSON.stringify(bm.data) : null,
-            };
+export function bucketDao(db) {
+    return new BucketDao({
+        db,
+        table: 'Bucket',
+        hooks: {
+            beforeBMToDBM: bm => {
+                return {
+                    ...bm,
+                    data: bm.data ? JSON.stringify(bm.data) : null,
+                };
+            },
+            beforeDBMToBM: dbm => ({
+                ...dbm,
+                data: dbm.data ? JSON.parse(dbm.data) : null,
+            }),
         },
-        beforeDBMToBM: dbm => ({
-            ...dbm,
-            data: dbm.data ? JSON.parse(dbm.data) : null,
-        }),
-    },
-});
+    });
+}

package/dist/dao/experiment.dao.d.ts

@@ -1,13 +1,13 @@
 import type { CommonDB } from '@naturalcycles/db-lib';
 import { CommonDao } from '@naturalcycles/db-lib';
-import type { Saved } from '@naturalcycles/js-lib';
 import type { BaseExperiment, Experiment } from '../types.js';
-type ExperimentDBM = Saved<BaseExperiment> & {
+type ExperimentDBM = BaseExperiment & {
     rules: string | null;
     exclusions: string | null;
     data: string | null;
 };
 export declare class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {
+    getByKey(key: string): Promise<Experiment | null>;
 }
-export declare const experimentDao: (db: CommonDB) => ExperimentDao;
+export declare function experimentDao(db: CommonDB): ExperimentDao;
 export {};

package/dist/dao/experiment.dao.js

@@ -1,35 +1,40 @@
 import { CommonDao } from '@naturalcycles/db-lib';
 import { localDate } from '@naturalcycles/js-lib';
 export class ExperimentDao extends CommonDao {
+    async getByKey(key) {
+        return await this.getOneBy('key', key);
+    }
+}
+export function experimentDao(db) {
+    return new ExperimentDao({
+        db,
+        table: 'Experiment',
+        hooks: {
+            beforeBMToDBM: bm => ({
+                ...bm,
+                rules: bm.rules.length ? JSON.stringify(bm.rules) : null,
+                // We add the map here to account for backwards compatibility where exclusion experimentIds were stored as a number
+                // TODO: Remove after some time when we are certain only strings are stored
+                exclusions: bm.exclusions.length
+                    ? JSON.stringify(bm.exclusions.map(exclusion => exclusion.toString()))
+                    : null,
+                data: bm.data ? JSON.stringify(bm.data) : null,
+            }),
+            beforeDBMToBM: dbm => ({
+                ...dbm,
+                startDateIncl: parseMySQLDate(dbm.startDateIncl),
+                endDateExcl: parseMySQLDate(dbm.endDateExcl),
+                rules: (dbm.rules && JSON.parse(dbm.rules)) || [],
+                // We add the map here to account for backwards compatibility where exclusion experimentIds were stored as a number
+                // TODO: Remove after some time when we are certain only strings are stored
+                exclusions: (dbm.exclusions &&
+                    JSON.parse(dbm.exclusions).map((exclusion) => exclusion.toString())) ||
+                    [],
+                data: dbm.data ? JSON.parse(dbm.data) : null,
+            }),
+        },
+    });
 }
-export const experimentDao = (db) => new ExperimentDao({
-    db,
-    table: 'Experiment',
-    hooks: {
-        beforeBMToDBM: bm => ({
-            ...bm,
-            rules: bm.rules.length ? JSON.stringify(bm.rules) : null,
-            // We add the map here to account for backwards compatibility where exclusion experimentIds were stored as a number
-            // TODO: Remove after some time when we are certain only strings are stored
-            exclusions: bm.exclusions.length
-                ? JSON.stringify(bm.exclusions.map(exclusion => exclusion.toString()))
-                : null,
-            data: bm.data ? JSON.stringify(bm.data) : null,
-        }),
-        beforeDBMToBM: dbm => ({
-            ...dbm,
-            startDateIncl: parseMySQLDate(dbm.startDateIncl),
-            endDateExcl: parseMySQLDate(dbm.endDateExcl),
-            rules: (dbm.rules && JSON.parse(dbm.rules)) || [],
-            // We add the map here to account for backwards compatibility where exclusion experimentIds were stored as a number
-            // TODO: Remove after some time when we are certain only strings are stored
-            exclusions: (dbm.exclusions &&
-                JSON.parse(dbm.exclusions).map((exclusion) => exclusion.toString())) ||
-                [],
-            data: dbm.data ? JSON.parse(dbm.data) : null,
-        }),
-    },
-});
 /**
  * https://nc1.slack.com/archives/CCNTHJT7V/p1682514277002739
  * MySQL Automatically parses Date fields as Date objects

package/dist/dao/userAssignment.dao.d.ts

@@ -2,5 +2,9 @@ import type { CommonDB } from '@naturalcycles/db-lib';
 import { CommonDao } from '@naturalcycles/db-lib';
 import type { UserAssignment } from '../types.js';
 export declare class UserAssignmentDao extends CommonDao<UserAssignment> {
+    getUserAssignmentByExperimentId(userId: string, experimentId: string): Promise<UserAssignment | null>;
+    getUserAssigmentsByExperimentIds(userId: string, experimentIds: string[]): Promise<UserAssignment[]>;
+    getCountByExperimentId(experimentId: string): Promise<number>;
+    getCountByBucketId(bucketId: string): Promise<number>;
 }
-export declare const userAssignmentDao: (db: CommonDB) => UserAssignmentDao;
+export declare function userAssignmentDao(db: CommonDB): UserAssignmentDao;

package/dist/dao/userAssignment.dao.js

@@ -1,7 +1,24 @@
 import { CommonDao } from '@naturalcycles/db-lib';
 export class UserAssignmentDao extends CommonDao {
+    async getUserAssignmentByExperimentId(userId, experimentId) {
+        const query = this.query().filterEq('userId', userId).filterEq('experimentId', experimentId);
+        const [userAssignment] = await this.runQuery(query);
+        return userAssignment || null;
+    }
+    async getUserAssigmentsByExperimentIds(userId, experimentIds) {
+        const query = this.query().filterEq('userId', userId).filterIn('experimentId', experimentIds);
+        return await this.runQuery(query);
+    }
+    async getCountByExperimentId(experimentId) {
+        return await this.query().filterEq('experimentId', experimentId).runQueryCount();
+    }
+    async getCountByBucketId(bucketId) {
+        return await this.query().filterEq('bucketId', bucketId).runQueryCount();
+    }
+}
+export function userAssignmentDao(db) {
+    return new UserAssignmentDao({
+        db,
+        table: 'UserAssignment',
+    });
 }
-export const userAssignmentDao = (db) => new UserAssignmentDao({
-    db,
-    table: 'UserAssignment',
-});

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { CommonDB } from '@naturalcycles/db-lib';
-import type { AnyObject, BaseDBEntity, IsoDate, Saved } from '@naturalcycles/js-lib';
+import type { AnyObject, BaseDBEntity, IsoDate } from '@naturalcycles/js-lib';
 export interface AbbaConfig {
     db: CommonDB;
 }
@@ -35,8 +35,8 @@ export type Experiment = BaseExperiment & {
     exclusions: string[];
     data: AnyObject | null;
 };
-export type ExperimentWithBuckets = Saved<Experiment> & {
-    buckets: Saved<Bucket>[];
+export type ExperimentWithBuckets = Experiment & {
+    buckets: Bucket[];
 };
 export type BaseBucket = BaseDBEntity & {
     experimentId: string;
@@ -51,14 +51,12 @@ export type UserAssignment = BaseDBEntity & {
     experimentId: string;
     bucketId: string | null;
 };
-export interface GeneratedUserAssignment {
-    assignment: (Saved<UserAssignment> & {
-        experimentKey: string;
-        bucketKey: string | null;
-        bucketData: AnyObject | null;
-    }) | null;
-    experiment: Saved<Experiment>;
-}
+export type DecoratedUserAssignment = UserAssignment & {
+    experimentKey: Experiment['key'];
+    experimentData: Experiment['data'];
+    bucketKey: Bucket['key'] | null;
+    bucketData: Bucket['data'];
+};
 export type SegmentationData = AnyObject;
 export declare enum AssignmentStatus {
     /**
@@ -105,3 +103,6 @@ export interface BucketAssignmentStatistics {
     totalAssignments: number;
 }
 export type ExclusionSet = Set<string>;
+export interface UserExperiment extends ExperimentWithBuckets {
+    userAssignment?: DecoratedUserAssignment;
+}

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.0.2",
   "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

@@ -8,12 +8,13 @@ import type {
   AbbaConfig,
   Bucket,
   BucketAssignmentStatistics,
+  DecoratedUserAssignment,
   Experiment,
   ExperimentAssignmentStatistics,
   ExperimentWithBuckets,
-  GeneratedUserAssignment,
   SegmentationData,
   UserAssignment,
+  UserExperiment,
 } from './types.js'
 import { AssignmentStatus } from './types.js'
 import {
@@ -40,8 +41,39 @@ export class Abba {
    * Cached (see CACHE_TTL)
    */
   @_Memo({ cacheFactory: () => new LRUMemoCache({ ttl: CACHE_TTL, max: 1 }) })
-  async getAllExperiments(): Promise<ExperimentWithBuckets[]> {
-    return await this.getAllExperimentsNoCache()
+  async getAllExperimentsWithBuckets(): Promise<ExperimentWithBuckets[]> {
+    return await this.getAllExperimentsWithBucketsNoCache()
+  }
+
+  async getAllExperimentsWithUserAssignments(userId: string): Promise<UserExperiment[]> {
+    const experiments = await this.getAllExperimentsWithBuckets()
+
+    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,
+          },
+        }),
+      }
+    })
   }
 
   /**
@@ -55,7 +87,7 @@ export class Abba {
   /**
    * Returns all experiments.
    */
-  async getAllExperimentsNoCache(): Promise<ExperimentWithBuckets[]> {
+  async getAllExperimentsWithBucketsNoCache(): Promise<ExperimentWithBuckets[]> {
     const experiments = await this.experimentDao.getAll()
     const buckets = await this.bucketDao.getAll()
 
@@ -191,49 +223,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.getAllExperimentsWithUserAssignments(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 +264,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 +272,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 +286,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 +310,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.getAllExperimentsWithUserAssignments(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 +323,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 +370,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,23 @@
 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> & {
+type ExperimentDBM = BaseExperiment & {
   rules: string | null
   exclusions: string | null
   data: string | null
 }
 
-export class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {}
+export class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {
+  async getByKey(key: string): Promise<Experiment | null> {
+    return await this.getOneBy('key', key)
+  }
+}
 
-export const experimentDao = (db: CommonDB): ExperimentDao =>
-  new ExperimentDao({
+export function experimentDao(db: CommonDB): ExperimentDao {
+  return new ExperimentDao({
     db,
     table: 'Experiment',
     hooks: {
@@ -42,6 +46,7 @@ export const experimentDao = (db: CommonDB): ExperimentDao =>
       }),
     },
   })
+}
 
 /**
  * https://nc1.slack.com/archives/CCNTHJT7V/p1682514277002739

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/types.ts

@@ -1,5 +1,5 @@
 import type { CommonDB } from '@naturalcycles/db-lib'
-import type { AnyObject, BaseDBEntity, IsoDate, Saved } from '@naturalcycles/js-lib'
+import type { AnyObject, BaseDBEntity, IsoDate } from '@naturalcycles/js-lib'
 
 export interface AbbaConfig {
   db: CommonDB
@@ -39,8 +39,8 @@ export type Experiment = BaseExperiment & {
   data: AnyObject | null
 }
 
-export type ExperimentWithBuckets = Saved<Experiment> & {
-  buckets: Saved<Bucket>[]
+export type ExperimentWithBuckets = Experiment & {
+  buckets: Bucket[]
 }
 
 export type BaseBucket = BaseDBEntity & {
@@ -59,15 +59,11 @@ export type UserAssignment = BaseDBEntity & {
   bucketId: string | null
 }
 
-export interface GeneratedUserAssignment {
-  assignment:
-    | (Saved<UserAssignment> & {
-        experimentKey: string
-        bucketKey: string | null
-        bucketData: AnyObject | null
-      })
-    | null
-  experiment: Saved<Experiment>
+export type DecoratedUserAssignment = UserAssignment & {
+  experimentKey: Experiment['key']
+  experimentData: Experiment['data']
+  bucketKey: Bucket['key'] | null
+  bucketData: Bucket['data']
 }
 
 export type SegmentationData = AnyObject
@@ -127,3 +123,7 @@ export interface BucketAssignmentStatistics {
 }
 
 export type ExclusionSet = Set<string>
+
+export interface UserExperiment extends ExperimentWithBuckets {
+  userAssignment?: DecoratedUserAssignment
+}

package/src/util.ts

@@ -10,6 +10,7 @@ import type {
   SegmentationRule,
   SegmentationRuleFn,
   UserAssignment,
+  UserExperiment,
 } from './types.js'
 import { AssignmentStatus, SegmentationRuleOperator } from './types.js'
 
@@ -17,11 +18,11 @@ import { AssignmentStatus, SegmentationRuleOperator } from './types.js'
  * Generate a new assignment for a given user.
  * Doesn't save it.
  */
-export const generateUserAssignmentData = (
+export function generateUserAssignmentData(
   experiment: ExperimentWithBuckets,
   userId: string,
   segmentationData: SegmentationData,
-): UserAssignment | null => {
+): Unsaved<UserAssignment> | null {
   const segmentationMatch = validateSegmentationRules(experiment.rules, segmentationData)
   if (!segmentationMatch) return null
 
@@ -31,7 +32,7 @@ export const generateUserAssignmentData = (
     userId,
     experimentId: experiment.id,
     bucketId: bucket?.id || null,
-  } as UserAssignment
+  }
 }
 
 class RandomService {
@@ -48,7 +49,7 @@ 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: number, buckets: Bucket[]): Bucket | null => {
+export function determineAssignment(sampling: number, buckets: Bucket[]): Bucket | null {
   // Should this person be considered for the experiment?
   if (randomService.rollDie() > sampling) {
     return null
@@ -61,7 +62,7 @@ export const determineAssignment = (sampling: number, buckets: Bucket[]): Bucket
 /**
  * Determines which bucket a user assignment will recieve
  */
-export const determineBucket = (buckets: Bucket[]): Bucket => {
+export function determineBucket(buckets: Bucket[]): Bucket {
   const bucketRoll = randomService.rollDie()
   let range: [number, number] | undefined
   const bucket = buckets.find(b => {
@@ -86,7 +87,7 @@ export const determineBucket = (buckets: Bucket[]): Bucket => {
 /**
  * Validate the total ratio of the buckets equals 100
  */
-export const validateTotalBucketRatio = (buckets: Unsaved<Bucket>[]): void => {
+export function validateTotalBucketRatio(buckets: Unsaved<Bucket>[]): void {
   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')
@@ -100,10 +101,10 @@ export const validateTotalBucketRatio = (buckets: Unsaved<Bucket>[]): void => {
  * @param segmentationData
  * @returns
  */
-export const validateSegmentationRules = (
+export function validateSegmentationRules(
   rules: SegmentationRule[],
   segmentationData: SegmentationData,
-): boolean => {
+): boolean {
   for (const rule of rules) {
     const { key, value, operator } = rule
     if (!segmentationRuleMap[operator](segmentationData[key], value)) return false
@@ -144,10 +145,10 @@ export const segmentationRuleMap: Record<SegmentationRuleOperator, SegmentationR
 /**
  * Returns true if an experiment is able to generate new assignments based on status and start/end dates
  */
-export const canGenerateNewAssignments = (
+export function canGenerateNewAssignments(
   experiment: Experiment,
   exclusionSet: ExclusionSet,
-): boolean => {
+): boolean {
   return (
     !exclusionSet.has(experiment.id) &&
     experiment.status === AssignmentStatus.Active &&
@@ -159,18 +160,15 @@ export const canGenerateNewAssignments = (
  * 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: Experiment[],
-  existingAssignments: UserAssignment[],
-): ExclusionSet => {
+export function getUserExclusionSet(experiments: UserExperiment[]): ExclusionSet {
   const exclusionSet: 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) return
+    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
 }