@naturalcycles/abba 2.0.1 → 2.1.0

package/dist/abba.d.ts

@@ -1,5 +1,6 @@
 import type { Unsaved } from '@naturalcycles/js-lib';
-import type { AbbaConfig, Bucket, Experiment, ExperimentAssignmentStatistics, ExperimentWithBuckets, GeneratedUserAssignment, SegmentationData } from './types.js';
+import { type GetAllExperimentsOpts } from './dao/experiment.dao.js';
+import type { AbbaConfig, Bucket, DecoratedUserAssignment, Experiment, ExperimentAssignmentStatistics, ExperimentWithBuckets, SegmentationData, UserExperiment } from './types.js';
 export declare class Abba {
     cfg: AbbaConfig;
     private experimentDao;
@@ -10,15 +11,16 @@ export declare class Abba {
      * Returns all experiments.
      * Cached (see CACHE_TTL)
      */
-    getAllExperiments(): Promise<ExperimentWithBuckets[]>;
+    getAllExperimentsWithBuckets(opts?: GetAllExperimentsOpts): Promise<ExperimentWithBuckets[]>;
     /**
-     * Updates all user assignments with a given userId with the provided userId.
+     * Returns all experiments.
      */
-    updateUserId(oldId: string, newId: string): Promise<void>;
+    getAllExperimentsWithBucketsNoCache(opts?: GetAllExperimentsOpts): Promise<ExperimentWithBuckets[]>;
+    getUserExperiments(userId: string): Promise<UserExperiment[]>;
     /**
-     * Returns all experiments.
+     * Updates all user assignments with a given userId with the provided userId.
      */
-    getAllExperimentsNoCache(): Promise<ExperimentWithBuckets[]>;
+    updateUserId(oldId: string, newId: string): Promise<void>;
     /**
      * Creates a new experiment.
      * Cold method.
@@ -33,6 +35,7 @@ export declare class Abba {
      * Ensures that mutual exclusions are maintained
      */
     private updateExclusions;
+    softDeleteExperiment(experimentId: string): Promise<void>;
     /**
      * Delete an experiment. Removes all user assignments and buckets.
      * Requires the experiment to have been inactive for at least 15 minutes in order to
@@ -49,20 +52,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,27 +21,49 @@ export class Abba {
      * Returns all experiments.
      * Cached (see CACHE_TTL)
      */
-    async getAllExperiments() {
-        return await this.getAllExperimentsNoCache();
-    }
-    /**
-     * Updates all user assignments with a given userId with the provided userId.
-     */
-    async updateUserId(oldId, newId) {
-        const query = this.userAssignmentDao.query().filterEq('userId', oldId);
-        await this.userAssignmentDao.patchByQuery(query, { userId: newId });
+    async getAllExperimentsWithBuckets(opts) {
+        return await this.getAllExperimentsWithBucketsNoCache(opts);
     }
     /**
      * Returns all experiments.
      */
-    async getAllExperimentsNoCache() {
-        const experiments = await this.experimentDao.getAll();
+    async getAllExperimentsWithBucketsNoCache(opts) {
+        const experiments = await this.experimentDao.getAllExperiments(opts);
         const buckets = await this.bucketDao.getAll();
         return experiments.map(experiment => ({
             ...experiment,
             buckets: buckets.filter(bucket => bucket.experimentId === experiment.id),
         }));
     }
+    async getUserExperiments(userId) {
+        const experiments = await this.getAllExperimentsWithBuckets({ includeDeleted: false });
+        const experimentIds = experiments.map(e => e.id);
+        const userAssignments = await this.userAssignmentDao.getUserAssigmentsByExperimentIds(userId, experimentIds);
+        return experiments.map(experiment => {
+            const existingAssignment = userAssignments.find(ua => ua.experimentId === experiment.id);
+            const existingAssignmentBucket = experiment.buckets.find(b => b.id === existingAssignment?.bucketId);
+            return {
+                ...experiment,
+                ...(existingAssignment && {
+                    userAssignment: {
+                        ...existingAssignment,
+                        experimentId: experiment.id,
+                        experimentData: experiment.data,
+                        experimentKey: experiment.key,
+                        bucketData: existingAssignmentBucket?.data || null,
+                        bucketKey: existingAssignmentBucket?.key || null,
+                    },
+                }),
+            };
+        });
+    }
+    /**
+     * Updates all user assignments with a given userId with the provided userId.
+     */
+    async updateUserId(oldId, newId) {
+        const query = this.userAssignmentDao.query().filterEq('userId', oldId);
+        await this.userAssignmentDao.patchByQuery(query, { userId: newId });
+    }
     /**
      * Creates a new experiment.
      * Cold method.
@@ -98,6 +120,10 @@ export class Abba {
         });
         await this.experimentDao.saveBatch(requiresUpdating, { saveMethod: 'update' });
     }
+    async softDeleteExperiment(experimentId) {
+        await this.experimentDao.patchById(experimentId, { deleted: true, exclusions: [] });
+        await this.updateExclusions(experimentId, []);
+    }
     /**
      * Delete an experiment. Removes all user assignments and buckets.
      * Requires the experiment to have been inactive for at least 15 minutes in order to
@@ -128,64 +154,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.getUserExperiments(userId);
+        const exclusionSet = getUserExclusionSet(experiments);
         if (!canGenerateNewAssignments(experiment, exclusionSet)) {
-            return {
-                experiment,
-                assignment: null,
-            };
+            return null;
         }
         _assert(segmentationData, 'Segmentation data required when creating a new assignment');
         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 +203,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 +223,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.getUserExperiments(userId);
+        const exclusionSet = getUserExclusionSet(experiments);
         // Shuffling means that randomisation occurs in the mutual exclusion
         // as experiments are looped through sequentially, this removes the risk of the same experiment always being assigned first in the list of mutually exclusive experiments
         // 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 +270,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 +287,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,17 @@
 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> & {
+export declare class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {
+    getAllExperiments(opt?: GetAllExperimentsOpts): Promise<Experiment[]>;
+    getByKey(key: string): Promise<Experiment | null>;
+}
+export declare function experimentDao(db: CommonDB): ExperimentDao;
+type ExperimentDBM = BaseExperiment & {
     rules: string | null;
     exclusions: string | null;
     data: string | null;
 };
-export declare class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {
+export interface GetAllExperimentsOpts {
+    includeDeleted?: boolean;
 }
-export declare const experimentDao: (db: CommonDB) => ExperimentDao;
 export {};

package/dist/dao/experiment.dao.js

@@ -1,35 +1,46 @@
 import { CommonDao } from '@naturalcycles/db-lib';
 import { localDate } from '@naturalcycles/js-lib';
 export class ExperimentDao extends CommonDao {
+    async getAllExperiments(opt) {
+        if (!opt?.includeDeleted) {
+            return await this.getAll();
+        }
+        return await this.query().filterEq('deleted', false).runQuery();
+    }
+    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/migrations/init.sql

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

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;
 }
@@ -29,14 +29,18 @@ export type BaseExperiment = BaseDBEntity & {
      * Date range end for the experiment assignments
      */
     endDateExcl: IsoDate;
+    /**
+     * Whether the experiment is flagged as deleted. This acts as a soft delete only.
+     */
+    deleted: boolean;
 };
 export type Experiment = BaseExperiment & {
     rules: SegmentationRule[];
     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 +55,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 +107,6 @@ export interface BucketAssignmentStatistics {
     totalAssignments: number;
 }
 export type ExclusionSet = Set<string>;
+export interface UserExperiment extends ExperimentWithBuckets {
+    userAssignment?: DecoratedUserAssignment;
+}