@naturalcycles/abba 1.23.1 → 1.25.0

package/dist/abba.d.ts

@@ -48,7 +48,7 @@ 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 | null>;
+    getUserAssignment(experimentKey: string, userId: string, existingOnly: boolean, segmentationData?: SegmentationData): Promise<GeneratedUserAssignment>;
     /**
      * Get all existing user assignments.
      * Hot method.

package/dist/abba.js

@@ -129,38 +129,56 @@ class Abba {
         (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;
+            return {
+                experiment,
+                assignment: 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);
             return {
-                ...existing,
-                experimentKey: experiment.key,
-                bucketKey: bucket?.key || null,
-                bucketData: bucket?.data || null,
+                experiment,
+                assignment: {
+                    ...existing,
+                    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 === types_1.AssignmentStatus.Paused)
-            return null;
+            return {
+                experiment,
+                assignment: null,
+            };
         const experiments = await this.getAllExperiments();
         const exclusionSet = (0, util_1.getUserExclusionSet)(experiments, existingAssignments);
         if (!(0, util_1.canGenerateNewAssignments)(experiment, exclusionSet))
-            return null;
+            return {
+                experiment,
+                assignment: null,
+            };
         (0, js_lib_1._assert)(segmentationData, 'Segmentation data required when creating a new assignment');
         const experimentWithBuckets = { ...experiment, buckets };
         const assignment = (0, util_1.generateUserAssignmentData)(experimentWithBuckets, userId, segmentationData);
         if (!assignment)
-            return null;
+            return {
+                experiment,
+                assignment: null,
+            };
         const newAssignment = await this.userAssignmentDao.save(assignment);
         const bucket = buckets.find(b => b.id === newAssignment.bucketId);
         return {
-            ...newAssignment,
-            experimentKey: experiment.key,
-            bucketKey: bucket?.key || null,
-            bucketData: bucket?.data || null,
+            experiment,
+            assignment: {
+                ...newAssignment,
+                experimentKey: experiment.key,
+                bucketKey: bucket?.key || null,
+                bucketData: bucket?.data || null,
+            },
         };
     }
     /**
@@ -175,10 +193,13 @@ class Abba {
             const experiment = await this.experimentDao.requireById(assignment.experimentId);
             const bucket = await this.bucketDao.getById(assignment.bucketId);
             return {
-                ...assignment,
-                experimentKey: experiment.key,
-                bucketKey: bucket?.key || null,
-                bucketData: bucket?.data || null,
+                experiment,
+                assignment: {
+                    ...assignment,
+                    experimentKey: experiment.key,
+                    bucketKey: bucket?.key || null,
+                    bucketData: bucket?.data || null,
+                },
             };
         });
     }
@@ -202,10 +223,13 @@ class Abba {
             if (existing) {
                 const bucket = experiment.buckets.find(b => b.id === existing.bucketId);
                 assignments.push({
-                    ...existing,
-                    experimentKey: experiment.key,
-                    bucketKey: bucket?.key || null,
-                    bucketData: bucket?.data || null,
+                    experiment,
+                    assignment: {
+                        ...existing,
+                        experimentKey: experiment.key,
+                        bucketKey: bucket?.key || null,
+                        bucketData: bucket?.data || null,
+                    },
                 });
             }
             else if (!existingOnly && (0, util_1.canGenerateNewAssignments)(experiment, exclusionSet)) {
@@ -215,10 +239,13 @@ class Abba {
                     newAssignments.push(created);
                     const bucket = experiment.buckets.find(b => b.id === created.bucketId);
                     assignments.push({
-                        ...created,
-                        experimentKey: experiment.key,
-                        bucketKey: bucket?.key || null,
-                        bucketData: bucket?.data || null,
+                        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));

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

@@ -4,6 +4,7 @@ import { BaseExperiment, Experiment } from '../types';
 type ExperimentDBM = Saved<BaseExperiment> & {
     rules: string | null;
     exclusions: string | null;
+    data: string | null;
 };
 export declare class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {
 }

package/dist/dao/experiment.dao.js

@@ -18,6 +18,7 @@ const experimentDao = (db) => new ExperimentDao({
             exclusions: bm.exclusions.length
                 ? JSON.stringify(bm.exclusions.map(exclusion => exclusion.toString()))
                 : null,
+            data: bm.data ? JSON.stringify(bm.data) : null,
         }),
         beforeDBMToBM: dbm => ({
             ...dbm,
@@ -29,6 +30,7 @@ const experimentDao = (db) => new ExperimentDao({
             exclusions: (dbm.exclusions &&
                 JSON.parse(dbm.exclusions).map((exclusion) => exclusion.toString())) ||
                 [],
+            data: dbm.data ? JSON.parse(dbm.data) : null,
         }),
     },
 });

package/dist/migrations/init.sql

@@ -24,6 +24,7 @@ CREATE TABLE IF NOT EXISTS `Experiment` (
     `updated` INT NOT NULL,
     `rules` JSON NULL,
     `exclusions` JSON NULL,
+    `data` JSON NULL,
 
     PRIMARY KEY (`id`),
     UNIQUE INDEX `key_unique` (`key`)

package/dist/types.d.ts

@@ -33,6 +33,7 @@ export type BaseExperiment = BaseDBEntity & {
 export type Experiment = BaseExperiment & {
     rules: SegmentationRule[];
     exclusions: string[];
+    data: AnyObject | null;
 };
 export type ExperimentWithBuckets = Saved<Experiment> & {
     buckets: Saved<Bucket>[];
@@ -50,11 +51,14 @@ export type UserAssignment = BaseDBEntity & {
     experimentId: string;
     bucketId: string | null;
 };
-export type GeneratedUserAssignment = Saved<UserAssignment> & {
-    experimentKey: string;
-    bucketKey: string | null;
-    bucketData: AnyObject | null;
-};
+export interface GeneratedUserAssignment {
+    assignment: (Saved<UserAssignment> & {
+        experimentKey: string;
+        bucketKey: string | null;
+        bucketData: AnyObject | null;
+    }) | null;
+    experiment: Saved<Experiment>;
+}
 export type SegmentationData = AnyObject;
 export declare enum AssignmentStatus {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/abba",
-  "version": "1.23.1",
+  "version": "1.25.0",
   "scripts": {
     "prepare": "husky"
   },

package/src/abba.ts

@@ -178,12 +178,16 @@ export class Abba {
     userId: string,
     existingOnly: boolean,
     segmentationData?: SegmentationData,
-  ): Promise<GeneratedUserAssignment | null> {
+  ): Promise<GeneratedUserAssignment> {
     const experiment = await this.experimentDao.getOneBy('key', experimentKey)
     _assert(experiment, `Experiment does not exist: ${experimentKey}`)
 
     // Inactive experiments should never return an assignment
-    if (experiment.status === AssignmentStatus.Inactive) return null
+    if (experiment.status === AssignmentStatus.Inactive)
+      return {
+        experiment,
+        assignment: null,
+      }
 
     const buckets = await this.bucketDao.getBy('experimentId', experiment.id)
     const existingAssignments = await this.userAssignmentDao.getBy('userId', userId)
@@ -191,35 +195,53 @@ export class Abba {
     if (existing) {
       const bucket = buckets.find(b => b.id === existing.bucketId)
       return {
-        ...existing,
-        experimentKey: experiment.key,
-        bucketKey: bucket?.key || null,
-        bucketData: bucket?.data || null,
+        experiment,
+        assignment: {
+          ...existing,
+          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 null
+    if (existingOnly || experiment.status === AssignmentStatus.Paused)
+      return {
+        experiment,
+        assignment: null,
+      }
 
     const experiments = await this.getAllExperiments()
     const exclusionSet = getUserExclusionSet(experiments, existingAssignments)
-    if (!canGenerateNewAssignments(experiment, exclusionSet)) return null
+    if (!canGenerateNewAssignments(experiment, exclusionSet))
+      return {
+        experiment,
+        assignment: null,
+      }
 
     _assert(segmentationData, 'Segmentation data required when creating a new assignment')
 
     const experimentWithBuckets = { ...experiment, buckets }
     const assignment = generateUserAssignmentData(experimentWithBuckets, userId, segmentationData)
-    if (!assignment) return null
+    if (!assignment)
+      return {
+        experiment,
+        assignment: null,
+      }
 
     const newAssignment = await this.userAssignmentDao.save(assignment)
 
     const bucket = buckets.find(b => b.id === newAssignment.bucketId)
 
     return {
-      ...newAssignment,
-      experimentKey: experiment.key,
-      bucketKey: bucket?.key || null,
-      bucketData: bucket?.data || null,
+      experiment,
+      assignment: {
+        ...newAssignment,
+        experimentKey: experiment.key,
+        bucketKey: bucket?.key || null,
+        bucketData: bucket?.data || null,
+      },
     }
   }
 
@@ -235,10 +257,13 @@ export class Abba {
       const experiment = await this.experimentDao.requireById(assignment.experimentId)
       const bucket = await this.bucketDao.getById(assignment.bucketId)
       return {
-        ...assignment,
-        experimentKey: experiment.key,
-        bucketKey: bucket?.key || null,
-        bucketData: bucket?.data || null,
+        experiment,
+        assignment: {
+          ...assignment,
+          experimentKey: experiment.key,
+          bucketKey: bucket?.key || null,
+          bucketData: bucket?.data || null,
+        },
       }
     })
   }
@@ -273,10 +298,13 @@ export class Abba {
       if (existing) {
         const bucket = experiment.buckets.find(b => b.id === existing.bucketId)
         assignments.push({
-          ...existing,
-          experimentKey: experiment.key,
-          bucketKey: bucket?.key || null,
-          bucketData: bucket?.data || null,
+          experiment,
+          assignment: {
+            ...existing,
+            experimentKey: experiment.key,
+            bucketKey: bucket?.key || null,
+            bucketData: bucket?.data || null,
+          },
         })
       } else if (!existingOnly && canGenerateNewAssignments(experiment, exclusionSet)) {
         const assignment = generateUserAssignmentData(experiment, userId, segmentationData)
@@ -285,10 +313,13 @@ export class Abba {
           newAssignments.push(created)
           const bucket = experiment.buckets.find(b => b.id === created.bucketId)
           assignments.push({
-            ...created,
-            experimentKey: experiment.key,
-            bucketKey: bucket?.key || null,
-            bucketData: bucket?.data || null,
+            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))

package/src/dao/experiment.dao.ts

@@ -5,6 +5,7 @@ import { BaseExperiment, Experiment } from '../types'
 type ExperimentDBM = Saved<BaseExperiment> & {
   rules: string | null
   exclusions: string | null
+  data: string | null
 }
 
 export class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {}
@@ -22,6 +23,7 @@ export const experimentDao = (db: CommonDB): ExperimentDao =>
         exclusions: bm.exclusions.length
           ? JSON.stringify(bm.exclusions.map(exclusion => exclusion.toString()))
           : null,
+        data: bm.data ? JSON.stringify(bm.data) : null,
       }),
       beforeDBMToBM: dbm => ({
         ...dbm,
@@ -34,6 +36,7 @@ export const experimentDao = (db: CommonDB): ExperimentDao =>
           (dbm.exclusions &&
             JSON.parse(dbm.exclusions).map((exclusion: string | number) => exclusion.toString())) ||
           [],
+        data: dbm.data ? JSON.parse(dbm.data) : null,
       }),
     },
   })

package/src/migrations/init.sql

@@ -24,6 +24,7 @@ CREATE TABLE IF NOT EXISTS `Experiment` (
     `updated` INT NOT NULL,
     `rules` JSON NULL,
     `exclusions` JSON NULL,
+    `data` JSON NULL,
 
     PRIMARY KEY (`id`),
     UNIQUE INDEX `key_unique` (`key`)

package/src/types.ts

@@ -36,6 +36,7 @@ export type BaseExperiment = BaseDBEntity & {
 export type Experiment = BaseExperiment & {
   rules: SegmentationRule[]
   exclusions: string[]
+  data: AnyObject | null
 }
 
 export type ExperimentWithBuckets = Saved<Experiment> & {
@@ -58,10 +59,15 @@ export type UserAssignment = BaseDBEntity & {
   bucketId: string | null
 }
 
-export type GeneratedUserAssignment = Saved<UserAssignment> & {
-  experimentKey: string
-  bucketKey: string | null
-  bucketData: AnyObject | null
+export interface GeneratedUserAssignment {
+  assignment:
+    | (Saved<UserAssignment> & {
+        experimentKey: string
+        bucketKey: string | null
+        bucketData: AnyObject | null
+      })
+    | null
+  experiment: Saved<Experiment>
 }
 
 export type SegmentationData = AnyObject