@naturalcycles/abba 1.16.0 → 1.17.1

package/dist/abba.d.ts

@@ -1,6 +1,6 @@
 import { Saved } from '@naturalcycles/js-lib';
-import { AbbaConfig, Bucket, BucketInput, Experiment, ExperimentWithBuckets, GeneratedUserAssignment, UserAssignment } from './types';
-import { SegmentationData, AssignmentStatistics } from '.';
+import { AbbaConfig, Bucket, Experiment, ExperimentAssignmentStatistics, ExperimentWithBuckets, GeneratedUserAssignment, UserAssignment } from './types';
+import { SegmentationData } from '.';
 export declare class Abba {
     cfg: AbbaConfig;
     private experimentDao;
@@ -20,14 +20,12 @@ export declare class Abba {
      * Creates a new experiment.
      * Cold method.
      */
-    createExperiment(experiment: Experiment, buckets: BucketInput[]): Promise<ExperimentWithBuckets>;
+    createExperiment(experiment: Experiment, buckets: Bucket[]): Promise<ExperimentWithBuckets>;
     /**
      * Update experiment information, will also validate the buckets' ratio if experiment.active is true
      * Cold method.
      */
-    saveExperiment(experiment: Experiment & {
-        id: number;
-    }, buckets: Bucket[]): Promise<ExperimentWithBuckets>;
+    saveExperiment(experiment: Experiment, buckets: Bucket[]): Promise<ExperimentWithBuckets>;
     /**
      * Ensures that mutual exclusions are maintained
      */
@@ -36,7 +34,7 @@ export declare class Abba {
      * Delete an experiment. Removes all user assignments and buckets.
      * Cold method.
      */
-    deleteExperiment(experimentId: number): Promise<void>;
+    deleteExperiment(experimentId: string): Promise<void>;
     /**
      * Get an assignment for a given user. If existingOnly is false, it will attempt to generate a new assignment
      * Cold method.
@@ -46,7 +44,7 @@ export declare class Abba {
      * @param existingOnly Do not generate any new assignments for this experiment
      * @param segmentationData Required if existingOnly is false
      */
-    getUserAssignment(experimentId: number, userId: string, existingOnly: boolean, segmentationData?: SegmentationData): Promise<GeneratedUserAssignment | null>;
+    getUserAssignment(experimentKey: string, userId: string, existingOnly: boolean, segmentationData?: SegmentationData): Promise<GeneratedUserAssignment | null>;
     /**
      * Get all existing user assignments.
      * Hot method.
@@ -63,5 +61,5 @@ export declare class Abba {
      * Get assignment statistics for an experiment.
      * Cold method.
      */
-    getExperimentAssignmentStatistics(experimentId: number): Promise<AssignmentStatistics>;
+    getExperimentAssignmentStatistics(experimentId: string): Promise<ExperimentAssignmentStatistics>;
 }

package/dist/abba.js

@@ -47,7 +47,7 @@ class Abba {
             (0, util_1.validateTotalBucketRatio)(buckets);
         }
         const created = await this.experimentDao.save(experiment);
-        const createdbuckets = await this.bucketDao.saveBatch(buckets.map(b => ({ ...b, experimentId: experiment.id })));
+        const createdbuckets = await this.bucketDao.saveBatch(buckets.map(b => ({ ...b, experimentId: created.id })));
         await this.updateExclusions(created.id, created.exclusions);
         return {
             ...created,
@@ -63,7 +63,7 @@ class Abba {
             (0, util_1.validateTotalBucketRatio)(buckets);
         }
         const updatedExperiment = await this.experimentDao.save(experiment, { saveMethod: 'update' });
-        const updatedBuckets = await this.bucketDao.saveBatch(buckets.map(b => ({ ...b, experimentId: experiment.id })));
+        const updatedBuckets = await this.bucketDao.saveBatch(buckets.map(b => ({ ...b, experimentId: updatedExperiment.id })));
         await this.updateExclusions(updatedExperiment.id, updatedExperiment.exclusions);
         return {
             ...updatedExperiment,
@@ -109,33 +109,39 @@ class Abba {
      * @param existingOnly Do not generate any new assignments for this experiment
      * @param segmentationData Required if existingOnly is false
      */
-    async getUserAssignment(experimentId, userId, existingOnly, segmentationData) {
+    async getUserAssignment(experimentKey, userId, existingOnly, segmentationData) {
+        const experiment = await this.experimentDao.getOneBy('key', experimentKey);
+        (0, js_lib_1._assert)(experiment, `Experiment does not exist: ${experimentKey}`);
+        // Inactive experiments should never return an assignment
+        if (experiment.status === types_1.AssignmentStatus.Inactive)
+            return null;
+        const buckets = await this.bucketDao.getBy('experimentId', experiment.id);
         const existingAssignments = await this.getAllExistingUserAssignments(userId);
-        const existing = existingAssignments.find(a => a.experimentId === experimentId);
+        const existing = existingAssignments.find(a => a.experimentId === experiment.id);
         if (existing) {
-            let bucketKey = null;
-            if (existing.bucketId) {
-                const { key } = await this.bucketDao.requireById(existing.bucketId);
-                bucketKey = key;
-            }
-            return { ...existing, bucketKey };
+            return {
+                ...existing,
+                experimentKey: experiment.key,
+                bucketKey: buckets.find(b => b.id === existing.bucketId)?.key || null,
+            };
         }
-        if (existingOnly)
+        // No existing assignment, but we don't want to generate a new one
+        if (existingOnly || experiment.status === types_1.AssignmentStatus.Paused)
             return null;
         const experiments = await this.getAllExperiments();
-        const experiment = experiments.find(e => e.id === experimentId);
-        (0, js_lib_1._assert)(experiment, `Experiment does not exist: ${experimentId}`);
         const exclusionSet = (0, util_1.getUserExclusionSet)(experiments, existingAssignments);
         if (!(0, util_1.canGenerateNewAssignments)(experiment, exclusionSet))
             return null;
         (0, js_lib_1._assert)(segmentationData, 'Segmentation data required when creating a new assignment');
-        const assignment = (0, util_1.generateUserAssignmentData)(experiment, userId, segmentationData);
+        const experimentWithBuckets = { ...experiment, buckets };
+        const assignment = (0, util_1.generateUserAssignmentData)(experimentWithBuckets, userId, segmentationData);
         if (!assignment)
             return null;
-        const saved = await this.userAssignmentDao.save(assignment);
+        const newAssignment = await this.userAssignmentDao.save(assignment);
         return {
-            ...saved,
-            bucketKey: experiment.buckets.find(b => b.id === saved.bucketId)?.key || null,
+            ...newAssignment,
+            experimentKey: experiment.key,
+            bucketKey: buckets.find(b => b.id === newAssignment.bucketId)?.key || null,
         };
     }
     /**
@@ -166,6 +172,7 @@ class Abba {
             if (existing) {
                 assignments.push({
                     ...existing,
+                    experimentKey: experiment.key,
                     bucketKey: experiment.buckets.find(b => b.id === existing.bucketId)?.key || null,
                 });
             }
@@ -176,6 +183,7 @@ class Abba {
                     newAssignments.push(created);
                     assignments.push({
                         ...created,
+                        experimentKey: experiment.key,
                         bucketKey: experiment.buckets.find(b => b.id === created.bucketId)?.key || null,
                     });
                     // Prevent future exclusion clashes
@@ -191,21 +199,25 @@ class Abba {
      * Cold method.
      */
     async getExperimentAssignmentStatistics(experimentId) {
-        const statistics = {
-            sampled: await this.userAssignmentDao
-                .query()
-                .filterEq('experimentId', experimentId)
-                .runQueryCount(),
-            buckets: {},
-        };
+        const totalAssignments = await this.userAssignmentDao
+            .query()
+            .filterEq('experimentId', experimentId)
+            .runQueryCount();
         const buckets = await this.bucketDao.getBy('experimentId', experimentId);
-        await (0, js_lib_1.pMap)(buckets, async (bucket) => {
-            statistics.buckets[bucket.id] = await this.userAssignmentDao
+        const bucketAssignments = await (0, js_lib_1.pMap)(buckets, async (bucket) => {
+            const totalAssignments = await this.userAssignmentDao
                 .query()
                 .filterEq('bucketId', bucket.id)
                 .runQueryCount();
+            return {
+                bucketId: bucket.id,
+                totalAssignments,
+            };
         });
-        return statistics;
+        return {
+            totalAssignments,
+            bucketAssignments,
+        };
     }
 }
 exports.Abba = Abba;

package/dist/dao/bucket.dao.js

@@ -8,8 +8,5 @@ exports.BucketDao = BucketDao;
 const bucketDao = (db) => new BucketDao({
     db,
     table: 'Bucket',
-    createId: false, // mysql auto_increment is used instead
-    idType: 'number',
-    assignGeneratedIds: true,
 });
 exports.bucketDao = bucketDao;

package/dist/dao/experiment.dao.js

@@ -9,20 +9,26 @@ exports.ExperimentDao = ExperimentDao;
 const experimentDao = (db) => new ExperimentDao({
     db,
     table: 'Experiment',
-    createId: false, // Always provided on create
-    idType: 'number',
     hooks: {
         beforeBMToDBM: bm => ({
             ...bm,
             rules: bm.rules.length ? JSON.stringify(bm.rules) : null,
-            exclusions: bm.exclusions.length ? JSON.stringify(bm.exclusions) : 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,
         }),
         beforeDBMToBM: dbm => ({
             ...dbm,
             startDateIncl: parseMySQLDate(dbm.startDateIncl),
             endDateExcl: parseMySQLDate(dbm.endDateExcl),
             rules: (dbm.rules && JSON.parse(dbm.rules)) || [],
-            exclusions: (dbm.exclusions && JSON.parse(dbm.exclusions)) || [],
+            // 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())) ||
+                [],
         }),
     },
 });

package/dist/dao/userAssignment.dao.js

@@ -8,8 +8,5 @@ exports.UserAssignmentDao = UserAssignmentDao;
 const userAssignmentDao = (db) => new UserAssignmentDao({
     db,
     table: 'UserAssignment',
-    createId: false, // mysql auto_increment is used instead
-    idType: 'number',
-    assignGeneratedIds: true,
 });
 exports.userAssignmentDao = userAssignmentDao;

package/dist/migrations/init.sql

@@ -1,39 +1,41 @@
 -- CreateTable
 CREATE TABLE IF NOT EXISTS `Bucket` (
-    `id` INTEGER NOT NULL AUTO_INCREMENT,
-    `experimentId` INTEGER NOT NULL,
+    `id` VARCHAR(50) NOT NULL,
+    `experimentId` VARCHAR(50) NOT NULL,
     `key` VARCHAR(10) NOT NULL,
     `ratio` INTEGER NOT NULL,
-    `created` INTEGER(11) NOT NULL,
-    `updated` INTEGER(11) NOT NULL,
+    `created` INT NOT NULL,
+    `updated` INT NOT NULL,
 
     PRIMARY KEY (`id`)
 ) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 
 -- CreateTable
 CREATE TABLE IF NOT EXISTS `Experiment` (
-    `id` INTEGER NOT NULL AUTO_INCREMENT,
+    `id` VARCHAR(50) NOT NULL,
+    `key` VARCHAR(50) NOT NULL,
     `status` INTEGER NOT NULL,
     `sampling` INTEGER NOT NULL,
     `description` VARCHAR(240) NULL,
     `startDateIncl` DATE NOT NULL,
     `endDateExcl` DATE NOT NULL,
-    `created` INTEGER(11) NOT NULL,
-    `updated` INTEGER(11) NOT NULL,
+    `created` INT NOT NULL,
+    `updated` INT NOT NULL,
     `rules` JSON NULL,
     `exclusions` JSON NULL,
 
-    PRIMARY KEY (`id`)
+    PRIMARY KEY (`id`),
+    UNIQUE INDEX `key_unique` (`key`)
 ) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 
 -- CreateTable
 CREATE TABLE IF NOT EXISTS `UserAssignment` (
-    `id` INTEGER NOT NULL AUTO_INCREMENT,
+    `id` VARCHAR(50) NOT NULL,
     `userId` VARCHAR(191) NOT NULL,
-    `experimentId` INTEGER NOT NULL,
-    `bucketId` INTEGER NULL,
-    `created` INTEGER(11) NOT NULL,
-    `updated` INTEGER(11) NOT NULL,
+    `experimentId` VARCHAR(50) NOT NULL,
+    `bucketId` VARCHAR(50) NULL,
+    `created` INT NOT NULL,
+    `updated` INT NOT NULL,
 
     UNIQUE INDEX `UserAssignment_userId_experimentId_key`(`userId`, `experimentId`),
     PRIMARY KEY (`id`)

package/dist/types.d.ts

@@ -3,33 +3,52 @@ import { AnyObject, BaseDBEntity, IsoDateString, Saved } from '@naturalcycles/js
 export interface AbbaConfig {
     db: CommonDB;
 }
-export type BaseExperiment = BaseDBEntity<number> & {
-    id: number;
-    status: number;
+export type BaseExperiment = BaseDBEntity & {
+    /**
+     * Human readable name of the experiment
+     * To be used for referencing the experiment in the UI
+     */
+    key: string;
+    /**
+     * Status of the experiment
+     */
+    status: AssignmentStatus;
+    /**
+     * Percentage of eligible users to include in the experiment
+     */
     sampling: number;
+    /**
+     * Description of the experiment, such as the hypothesis
+     */
     description: string | null;
+    /**
+     * Date range start for the experiment assignments
+     */
     startDateIncl: IsoDateString;
+    /**
+     * Date range end for the experiment assignments
+     */
     endDateExcl: IsoDateString;
 };
 export type Experiment = BaseExperiment & {
     rules: SegmentationRule[];
-    exclusions: number[];
+    exclusions: string[];
 };
 export type ExperimentWithBuckets = Saved<Experiment> & {
     buckets: Saved<Bucket>[];
 };
-export interface BucketInput {
-    experimentId: number;
+export type Bucket = BaseDBEntity & {
+    experimentId: string;
     key: string;
     ratio: number;
-}
-export type Bucket = BaseDBEntity<number> & BucketInput;
-export type UserAssignment = BaseDBEntity<number> & {
+};
+export type UserAssignment = BaseDBEntity & {
     userId: string;
-    experimentId: number;
-    bucketId: number | null;
+    experimentId: string;
+    bucketId: string | null;
 };
 export type GeneratedUserAssignment = Saved<UserAssignment> & {
+    experimentKey: string;
     bucketKey: string | null;
 };
 export type SegmentationData = AnyObject;
@@ -59,21 +78,22 @@ export declare enum SegmentationRuleOperator {
     NotEqualsText = "notEqualsText",
     Semver = "semver",
     Regex = "regex",
-    Boolean = "boolean",
+    Boolean = "boolean"
+}
+export type SegmentationRuleFn = (segmentationProp: string | boolean | number | null | undefined, ruleValue: SegmentationRule['value']) => boolean;
+export interface ExperimentAssignmentStatistics {
     /**
-     * @deprecated
+     * Total number of users that were included in the experiment.
+     * This includes the users who were sampled and assigned to a bucket.
      */
-    Equals = "==",
+    totalAssignments: number;
     /**
-     * @deprecated
+     * Number of users that were assigned to each bucket in the experiment
      */
-    NotEquals = "!="
+    bucketAssignments: BucketAssignmentStatistics[];
 }
-export type SegmentationRuleFn = (segmentationProp: string | boolean | number | null | undefined, ruleValue: SegmentationRule['value']) => boolean;
-export interface AssignmentStatistics {
-    sampled: number;
-    buckets: {
-        [id: string]: number;
-    };
+export interface BucketAssignmentStatistics {
+    bucketId: string;
+    totalAssignments: number;
 }
-export type ExclusionSet = Set<number>;
+export type ExclusionSet = Set<string>;

package/dist/types.js

@@ -26,12 +26,4 @@ var SegmentationRuleOperator;
     SegmentationRuleOperator["Regex"] = "regex";
     /* eslint-disable id-blacklist*/
     SegmentationRuleOperator["Boolean"] = "boolean";
-    /**
-     * @deprecated
-     */
-    SegmentationRuleOperator["Equals"] = "==";
-    /**
-     * @deprecated
-     */
-    SegmentationRuleOperator["NotEquals"] = "!=";
 })(SegmentationRuleOperator || (exports.SegmentationRuleOperator = SegmentationRuleOperator = {}));

package/dist/util.d.ts

@@ -36,7 +36,7 @@ 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 const canGenerateNewAssignments: (experiment: Saved<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

package/dist/util.js

@@ -117,9 +117,6 @@ exports.segmentationRuleMap = {
         // Anything else cannot be true
         return keyValue?.toString() !== 'true';
     },
-    // Deprecated
-    [types_1.SegmentationRuleOperator.Equals]: (keyValue, ruleValue) => keyValue === ruleValue,
-    [types_1.SegmentationRuleOperator.NotEquals]: (keyValue, ruleValue) => keyValue !== ruleValue,
 };
 /**
  * Returns true if an experiment is able to generate new assignments based on status and start/end dates

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/abba",
-  "version": "1.16.0",
+  "version": "1.17.1",
   "scripts": {
     "prepare": "husky install",
     "build": "build",

package/src/abba.ts

@@ -7,8 +7,9 @@ import {
   AbbaConfig,
   AssignmentStatus,
   Bucket,
-  BucketInput,
+  BucketAssignmentStatistics,
   Experiment,
+  ExperimentAssignmentStatistics,
   ExperimentWithBuckets,
   GeneratedUserAssignment,
   UserAssignment,
@@ -19,7 +20,7 @@ import {
   getUserExclusionSet,
   validateTotalBucketRatio,
 } from './util'
-import { SegmentationData, AssignmentStatistics } from '.'
+import { SegmentationData } from '.'
 
 /**
  * 10 minutes
@@ -61,7 +62,7 @@ export class Abba {
    */
   async createExperiment(
     experiment: Experiment,
-    buckets: BucketInput[],
+    buckets: Bucket[],
   ): Promise<ExperimentWithBuckets> {
     if (experiment.status === AssignmentStatus.Active) {
       validateTotalBucketRatio(buckets)
@@ -69,7 +70,7 @@ export class Abba {
 
     const created = await this.experimentDao.save(experiment)
     const createdbuckets = await this.bucketDao.saveBatch(
-      buckets.map(b => ({ ...b, experimentId: experiment.id })),
+      buckets.map(b => ({ ...b, experimentId: created.id })),
     )
 
     await this.updateExclusions(created.id, created.exclusions)
@@ -84,17 +85,14 @@ export class Abba {
    * Update experiment information, will also validate the buckets' ratio if experiment.active is true
    * Cold method.
    */
-  async saveExperiment(
-    experiment: Experiment & { id: number },
-    buckets: Bucket[],
-  ): Promise<ExperimentWithBuckets> {
+  async saveExperiment(experiment: Experiment, buckets: Bucket[]): Promise<ExperimentWithBuckets> {
     if (experiment.status === AssignmentStatus.Active) {
       validateTotalBucketRatio(buckets)
     }
 
     const updatedExperiment = await this.experimentDao.save(experiment, { saveMethod: 'update' })
     const updatedBuckets = await this.bucketDao.saveBatch(
-      buckets.map(b => ({ ...b, experimentId: experiment.id })),
+      buckets.map(b => ({ ...b, experimentId: updatedExperiment.id })),
     )
 
     await this.updateExclusions(updatedExperiment.id, updatedExperiment.exclusions)
@@ -108,7 +106,7 @@ export class Abba {
   /**
    * Ensures that mutual exclusions are maintained
    */
-  private async updateExclusions(experimentId: number, updatedExclusions: number[]): Promise<void> {
+  private async updateExclusions(experimentId: string, updatedExclusions: string[]): Promise<void> {
     const experiments = await this.experimentDao.getAll()
 
     const requiresUpdating: Experiment[] = []
@@ -139,7 +137,7 @@ export class Abba {
    * Delete an experiment. Removes all user assignments and buckets.
    * Cold method.
    */
-  async deleteExperiment(experimentId: number): Promise<void> {
+  async deleteExperiment(experimentId: string): Promise<void> {
     await this.experimentDao.deleteById(experimentId)
     await this.updateExclusions(experimentId, [])
   }
@@ -154,42 +152,47 @@ export class Abba {
    * @param segmentationData Required if existingOnly is false
    */
   async getUserAssignment(
-    experimentId: number,
+    experimentKey: string,
     userId: string,
     existingOnly: boolean,
     segmentationData?: SegmentationData,
   ): Promise<GeneratedUserAssignment | null> {
-    const existingAssignments = await this.getAllExistingUserAssignments(userId)
+    const experiment = await this.experimentDao.getOneBy('key', experimentKey)
+    _assert(experiment, `Experiment does not exist: ${experimentKey}`)
 
-    const existing = existingAssignments.find(a => a.experimentId === experimentId)
+    // Inactive experiments should never return an assignment
+    if (experiment.status === AssignmentStatus.Inactive) return null
+
+    const buckets = await this.bucketDao.getBy('experimentId', experiment.id)
+    const existingAssignments = await this.getAllExistingUserAssignments(userId)
+    const existing = existingAssignments.find(a => a.experimentId === experiment.id)
     if (existing) {
-      let bucketKey = null
-      if (existing.bucketId) {
-        const { key } = await this.bucketDao.requireById(existing.bucketId)
-        bucketKey = key
+      return {
+        ...existing,
+        experimentKey: experiment.key,
+        bucketKey: buckets.find(b => b.id === existing.bucketId)?.key || null,
       }
-      return { ...existing, bucketKey }
     }
 
-    if (existingOnly) return null
+    // No existing assignment, but we don't want to generate a new one
+    if (existingOnly || experiment.status === AssignmentStatus.Paused) return null
 
     const experiments = await this.getAllExperiments()
-    const experiment = experiments.find(e => e.id === experimentId)
-    _assert(experiment, `Experiment does not exist: ${experimentId}`)
-
     const exclusionSet = getUserExclusionSet(experiments, existingAssignments)
     if (!canGenerateNewAssignments(experiment, exclusionSet)) return null
 
     _assert(segmentationData, 'Segmentation data required when creating a new assignment')
 
-    const assignment = generateUserAssignmentData(experiment, userId, segmentationData)
+    const experimentWithBuckets = { ...experiment, buckets }
+    const assignment = generateUserAssignmentData(experimentWithBuckets, userId, segmentationData)
     if (!assignment) return null
 
-    const saved = await this.userAssignmentDao.save(assignment)
+    const newAssignment = await this.userAssignmentDao.save(assignment)
 
     return {
-      ...saved,
-      bucketKey: experiment.buckets.find(b => b.id === saved.bucketId)?.key || null,
+      ...newAssignment,
+      experimentKey: experiment.key,
+      bucketKey: buckets.find(b => b.id === newAssignment.bucketId)?.key || null,
     }
   }
 
@@ -215,7 +218,6 @@ export class Abba {
     const experiments = await this.getAllExperiments()
     const existingAssignments = await this.getAllExistingUserAssignments(userId)
     const exclusionSet = getUserExclusionSet(experiments, existingAssignments)
-
     const assignments: GeneratedUserAssignment[] = []
     const newAssignments: UserAssignment[] = []
 
@@ -233,6 +235,7 @@ export class Abba {
       if (existing) {
         assignments.push({
           ...existing,
+          experimentKey: experiment.key,
           bucketKey: experiment.buckets.find(b => b.id === existing.bucketId)?.key || null,
         })
       } else if (!existingOnly && canGenerateNewAssignments(experiment, exclusionSet)) {
@@ -242,6 +245,7 @@ export class Abba {
           newAssignments.push(created)
           assignments.push({
             ...created,
+            experimentKey: experiment.key,
             bucketKey: experiment.buckets.find(b => b.id === created.bucketId)?.key || null,
           })
           // Prevent future exclusion clashes
@@ -258,23 +262,30 @@ export class Abba {
    * Get assignment statistics for an experiment.
    * Cold method.
    */
-  async getExperimentAssignmentStatistics(experimentId: number): Promise<AssignmentStatistics> {
-    const statistics: AssignmentStatistics = {
-      sampled: await this.userAssignmentDao
-        .query()
-        .filterEq('experimentId', experimentId)
-        .runQueryCount(),
-      buckets: {},
-    }
+  async getExperimentAssignmentStatistics(
+    experimentId: string,
+  ): Promise<ExperimentAssignmentStatistics> {
+    const totalAssignments = await this.userAssignmentDao
+      .query()
+      .filterEq('experimentId', experimentId)
+      .runQueryCount()
 
     const buckets = await this.bucketDao.getBy('experimentId', experimentId)
-    await pMap(buckets, async bucket => {
-      statistics.buckets[bucket.id] = await this.userAssignmentDao
+    const bucketAssignments: BucketAssignmentStatistics[] = await pMap(buckets, async bucket => {
+      const totalAssignments = await this.userAssignmentDao
         .query()
         .filterEq('bucketId', bucket.id)
         .runQueryCount()
+
+      return {
+        bucketId: bucket.id,
+        totalAssignments,
+      }
     })
 
-    return statistics
+    return {
+      totalAssignments,
+      bucketAssignments,
+    }
   }
 }

package/src/dao/bucket.dao.ts

@@ -7,7 +7,4 @@ export const bucketDao = (db: CommonDB): BucketDao =>
   new BucketDao({
     db,
     table: 'Bucket',
-    createId: false, // mysql auto_increment is used instead
-    idType: 'number',
-    assignGeneratedIds: true,
   })

package/src/dao/experiment.dao.ts

@@ -13,20 +13,27 @@ export const experimentDao = (db: CommonDB): ExperimentDao =>
   new ExperimentDao({
     db,
     table: 'Experiment',
-    createId: false, // Always provided on create
-    idType: 'number',
     hooks: {
       beforeBMToDBM: bm => ({
         ...bm,
         rules: bm.rules.length ? JSON.stringify(bm.rules) : null,
-        exclusions: bm.exclusions.length ? JSON.stringify(bm.exclusions) : 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,
       }),
       beforeDBMToBM: dbm => ({
         ...dbm,
         startDateIncl: parseMySQLDate(dbm.startDateIncl),
         endDateExcl: parseMySQLDate(dbm.endDateExcl),
         rules: (dbm.rules && JSON.parse(dbm.rules)) || [],
-        exclusions: (dbm.exclusions && JSON.parse(dbm.exclusions)) || [],
+        // 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: string | number) => exclusion.toString())) ||
+          [],
       }),
     },
   })

package/src/dao/userAssignment.dao.ts

@@ -7,7 +7,4 @@ export const userAssignmentDao = (db: CommonDB): UserAssignmentDao =>
   new UserAssignmentDao({
     db,
     table: 'UserAssignment',
-    createId: false, // mysql auto_increment is used instead
-    idType: 'number',
-    assignGeneratedIds: true,
   })

package/src/migrations/init.sql

@@ -1,39 +1,41 @@
 -- CreateTable
 CREATE TABLE IF NOT EXISTS `Bucket` (
-    `id` INTEGER NOT NULL AUTO_INCREMENT,
-    `experimentId` INTEGER NOT NULL,
+    `id` VARCHAR(50) NOT NULL,
+    `experimentId` VARCHAR(50) NOT NULL,
     `key` VARCHAR(10) NOT NULL,
     `ratio` INTEGER NOT NULL,
-    `created` INTEGER(11) NOT NULL,
-    `updated` INTEGER(11) NOT NULL,
+    `created` INT NOT NULL,
+    `updated` INT NOT NULL,
 
     PRIMARY KEY (`id`)
 ) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 
 -- CreateTable
 CREATE TABLE IF NOT EXISTS `Experiment` (
-    `id` INTEGER NOT NULL AUTO_INCREMENT,
+    `id` VARCHAR(50) NOT NULL,
+    `key` VARCHAR(50) NOT NULL,
     `status` INTEGER NOT NULL,
     `sampling` INTEGER NOT NULL,
     `description` VARCHAR(240) NULL,
     `startDateIncl` DATE NOT NULL,
     `endDateExcl` DATE NOT NULL,
-    `created` INTEGER(11) NOT NULL,
-    `updated` INTEGER(11) NOT NULL,
+    `created` INT NOT NULL,
+    `updated` INT NOT NULL,
     `rules` JSON NULL,
     `exclusions` JSON NULL,
 
-    PRIMARY KEY (`id`)
+    PRIMARY KEY (`id`),
+    UNIQUE INDEX `key_unique` (`key`)
 ) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 
 -- CreateTable
 CREATE TABLE IF NOT EXISTS `UserAssignment` (
-    `id` INTEGER NOT NULL AUTO_INCREMENT,
+    `id` VARCHAR(50) NOT NULL,
     `userId` VARCHAR(191) NOT NULL,
-    `experimentId` INTEGER NOT NULL,
-    `bucketId` INTEGER NULL,
-    `created` INTEGER(11) NOT NULL,
-    `updated` INTEGER(11) NOT NULL,
+    `experimentId` VARCHAR(50) NOT NULL,
+    `bucketId` VARCHAR(50) NULL,
+    `created` INT NOT NULL,
+    `updated` INT NOT NULL,
 
     UNIQUE INDEX `UserAssignment_userId_experimentId_key`(`userId`, `experimentId`),
     PRIMARY KEY (`id`)

package/src/types.ts

@@ -5,39 +5,57 @@ export interface AbbaConfig {
   db: CommonDB
 }
 
-export type BaseExperiment = BaseDBEntity<number> & {
-  id: number
-  status: number
+export type BaseExperiment = BaseDBEntity & {
+  /**
+   * Human readable name of the experiment
+   * To be used for referencing the experiment in the UI
+   */
+  key: string
+  /**
+   * Status of the experiment
+   */
+  status: AssignmentStatus
+  /**
+   * Percentage of eligible users to include in the experiment
+   */
   sampling: number
+  /**
+   * Description of the experiment, such as the hypothesis
+   */
   description: string | null
+  /**
+   * Date range start for the experiment assignments
+   */
   startDateIncl: IsoDateString
+  /**
+   * Date range end for the experiment assignments
+   */
   endDateExcl: IsoDateString
 }
 
 export type Experiment = BaseExperiment & {
   rules: SegmentationRule[]
-  exclusions: number[]
+  exclusions: string[]
 }
 
 export type ExperimentWithBuckets = Saved<Experiment> & {
   buckets: Saved<Bucket>[]
 }
 
-export interface BucketInput {
-  experimentId: number
+export type Bucket = BaseDBEntity & {
+  experimentId: string
   key: string
   ratio: number
 }
 
-export type Bucket = BaseDBEntity<number> & BucketInput
-
-export type UserAssignment = BaseDBEntity<number> & {
+export type UserAssignment = BaseDBEntity & {
   userId: string
-  experimentId: number
-  bucketId: number | null
+  experimentId: string
+  bucketId: string | null
 }
 
 export type GeneratedUserAssignment = Saved<UserAssignment> & {
+  experimentKey: string
   bucketKey: string | null
 }
 
@@ -73,14 +91,6 @@ export enum SegmentationRuleOperator {
   Regex = 'regex',
   /* eslint-disable id-blacklist*/
   Boolean = 'boolean',
-  /**
-   * @deprecated
-   */
-  Equals = '==',
-  /**
-   * @deprecated
-   */
-  NotEquals = '!=',
 }
 
 export type SegmentationRuleFn = (
@@ -88,11 +98,21 @@ export type SegmentationRuleFn = (
   ruleValue: SegmentationRule['value'],
 ) => boolean
 
-export interface AssignmentStatistics {
-  sampled: number
-  buckets: {
-    [id: string]: number
-  }
+export interface ExperimentAssignmentStatistics {
+  /**
+   * Total number of users that were included in the experiment.
+   * This includes the users who were sampled and assigned to a bucket.
+   */
+  totalAssignments: number
+  /**
+   * Number of users that were assigned to each bucket in the experiment
+   */
+  bucketAssignments: BucketAssignmentStatistics[]
+}
+
+export interface BucketAssignmentStatistics {
+  bucketId: string
+  totalAssignments: number
 }
 
-export type ExclusionSet = Set<number>
+export type ExclusionSet = Set<string>

package/src/util.ts

@@ -135,16 +135,13 @@ export const segmentationRuleMap: Record<SegmentationRuleOperator, SegmentationR
     // Anything else cannot be true
     return keyValue?.toString() !== 'true'
   },
-  // Deprecated
-  [SegmentationRuleOperator.Equals]: (keyValue, ruleValue) => keyValue === ruleValue,
-  [SegmentationRuleOperator.NotEquals]: (keyValue, ruleValue) => keyValue !== ruleValue,
 }
 
 /**
  * Returns true if an experiment is able to generate new assignments based on status and start/end dates
  */
 export const canGenerateNewAssignments = (
-  experiment: Experiment,
+  experiment: Saved<Experiment>,
   exclusionSet: ExclusionSet,
 ): boolean => {
   return (