@naturalcycles/abba 2.0.2 → 2.1.1

package/dist/abba.d.ts

@@ -1,4 +1,5 @@
 import type { Unsaved } from '@naturalcycles/js-lib';
+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;
@@ -10,16 +11,16 @@ export declare class Abba {
      * Returns all experiments.
      * Cached (see CACHE_TTL)
      */
-    getAllExperimentsWithBuckets(): Promise<ExperimentWithBuckets[]>;
-    getAllExperimentsWithUserAssignments(userId: string): Promise<UserExperiment[]>;
+    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.
      */
-    getAllExperimentsWithBucketsNoCache(): Promise<ExperimentWithBuckets[]>;
+    updateUserId(oldId: string, newId: string): Promise<void>;
     /**
      * Creates a new experiment.
      * Cold method.
@@ -34,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

package/dist/abba.js

@@ -21,11 +21,22 @@ export class Abba {
      * Returns all experiments.
      * Cached (see CACHE_TTL)
      */
-    async getAllExperimentsWithBuckets() {
-        return await this.getAllExperimentsWithBucketsNoCache();
+    async getAllExperimentsWithBuckets(opts) {
+        return await this.getAllExperimentsWithBucketsNoCache(opts);
     }
-    async getAllExperimentsWithUserAssignments(userId) {
-        const experiments = await this.getAllExperimentsWithBuckets();
+    /**
+     * Returns all experiments.
+     */
+    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 => {
@@ -53,17 +64,6 @@ export class Abba {
         const query = this.userAssignmentDao.query().filterEq('userId', oldId);
         await this.userAssignmentDao.patchByQuery(query, { userId: newId });
     }
-    /**
-     * Returns all experiments.
-     */
-    async getAllExperimentsWithBucketsNoCache() {
-        const experiments = await this.experimentDao.getAll();
-        const buckets = await this.bucketDao.getAll();
-        return experiments.map(experiment => ({
-            ...experiment,
-            buckets: buckets.filter(bucket => bucket.experimentId === experiment.id),
-        }));
-    }
     /**
      * Creates a new experiment.
      * Cold method.
@@ -120,6 +120,10 @@ export class Abba {
         });
         await this.experimentDao.saveBatch(requiresUpdating, { saveMethod: 'update' });
     }
+    async softDeleteExperiment(experimentId) {
+        await this.experimentDao.patchById(experimentId, { deleted: true, exclusions: [] }, { saveMethod: 'update' });
+        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
@@ -131,12 +135,8 @@ export class Abba {
         const hasBeenInactiveFor15Mins = experiment.status === AssignmentStatus.Inactive &&
             localTime(experiment.updated).isOlderThan(15, 'minute');
         _assert(hasBeenInactiveFor15Mins, 'Experiment must be inactive for at least 15 minutes before deletion');
-        const userAssignmentDeleteQuery = this.userAssignmentDao
-            .query()
-            .filterEq('experimentId', experimentId);
-        await this.userAssignmentDao.deleteByQuery(userAssignmentDeleteQuery, { chunkSize: 50000 });
-        const bucketDeleteQuery = this.bucketDao.query().filterEq('experimentId', experimentId);
-        await this.bucketDao.deleteByQuery(bucketDeleteQuery);
+        await this.userAssignmentDao.deleteByExperimentId(experimentId);
+        await this.bucketDao.deleteByExperimentId(experimentId);
         await this.experimentDao.deleteById(experimentId);
         await this.updateExclusions(experimentId, []);
     }
@@ -172,7 +172,7 @@ export class Abba {
         if (existingOnly || experiment.status === AssignmentStatus.Paused) {
             return null;
         }
-        const experiments = await this.getAllExperimentsWithUserAssignments(userId);
+        const experiments = await this.getUserExperiments(userId);
         const exclusionSet = getUserExclusionSet(experiments);
         if (!canGenerateNewAssignments(experiment, exclusionSet)) {
             return null;
@@ -219,7 +219,7 @@ export class Abba {
      * Hot method.
      */
     async generateUserAssignments(userId, segmentationData, existingOnly = false) {
-        const experiments = await this.getAllExperimentsWithUserAssignments(userId);
+        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

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

@@ -6,6 +6,7 @@ type BucketDBM = BaseBucket & {
 };
 export declare class BucketDao extends CommonDao<Bucket, BucketDBM> {
     getByExperimentId(experimentId: string): Promise<Bucket[]>;
+    deleteByExperimentId(experimentId: string): Promise<void>;
 }
 export declare function bucketDao(db: CommonDB): BucketDao;
 export {};

package/dist/dao/bucket.dao.js

@@ -3,6 +3,9 @@ export class BucketDao extends CommonDao {
     async getByExperimentId(experimentId) {
         return await this.query().filterEq('experimentId', experimentId).runQuery();
     }
+    async deleteByExperimentId(experimentId) {
+        await this.query().filterEq('experimentId', experimentId).deleteByQuery();
+    }
 }
 export function bucketDao(db) {
     return new BucketDao({

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 { BaseExperiment, Experiment } from '../types.js';
+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> {
-    getByKey(key: string): Promise<Experiment | null>;
+export interface GetAllExperimentsOpts {
+    includeDeleted?: boolean;
 }
-export declare function experimentDao(db: CommonDB): ExperimentDao;
 export {};

package/dist/dao/experiment.dao.js

@@ -1,6 +1,12 @@
 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);
     }

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

@@ -4,6 +4,7 @@ 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[]>;
+    deleteByExperimentId(experimentId: string): Promise<void>;
     getCountByExperimentId(experimentId: string): Promise<number>;
     getCountByBucketId(bucketId: string): Promise<number>;
 }

package/dist/dao/userAssignment.dao.js

@@ -9,6 +9,9 @@ export class UserAssignmentDao extends CommonDao {
         const query = this.query().filterEq('userId', userId).filterIn('experimentId', experimentIds);
         return await this.runQuery(query);
     }
+    async deleteByExperimentId(experimentId) {
+        await this.query().filterEq('experimentId', experimentId).deleteByQuery();
+    }
     async getCountByExperimentId(experimentId) {
         return await this.query().filterEq('experimentId', experimentId).runQueryCount();
     }

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

@@ -29,6 +29,10 @@ 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[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/abba",
   "type": "module",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build",

package/src/abba.ts

@@ -2,7 +2,7 @@ import type { Unsaved } from '@naturalcycles/js-lib'
 import { _assert, _Memo, _shuffle, localTime, pMap } from '@naturalcycles/js-lib'
 import { LRUMemoCache } from '@naturalcycles/nodejs-lib'
 import { bucketDao } from './dao/bucket.dao.js'
-import { experimentDao } from './dao/experiment.dao.js'
+import { experimentDao, type GetAllExperimentsOpts } from './dao/experiment.dao.js'
 import { userAssignmentDao } from './dao/userAssignment.dao.js'
 import type {
   AbbaConfig,
@@ -41,12 +41,29 @@ export class Abba {
    * Cached (see CACHE_TTL)
    */
   @_Memo({ cacheFactory: () => new LRUMemoCache({ ttl: CACHE_TTL, max: 1 }) })
-  async getAllExperimentsWithBuckets(): Promise<ExperimentWithBuckets[]> {
-    return await this.getAllExperimentsWithBucketsNoCache()
+  async getAllExperimentsWithBuckets(
+    opts?: GetAllExperimentsOpts,
+  ): Promise<ExperimentWithBuckets[]> {
+    return await this.getAllExperimentsWithBucketsNoCache(opts)
   }
 
-  async getAllExperimentsWithUserAssignments(userId: string): Promise<UserExperiment[]> {
-    const experiments = await this.getAllExperimentsWithBuckets()
+  /**
+   * Returns all experiments.
+   */
+  async getAllExperimentsWithBucketsNoCache(
+    opts?: GetAllExperimentsOpts,
+  ): Promise<ExperimentWithBuckets[]> {
+    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: string): Promise<UserExperiment[]> {
+    const experiments = await this.getAllExperimentsWithBuckets({ includeDeleted: false })
 
     const experimentIds = experiments.map(e => e.id)
     const userAssignments = await this.userAssignmentDao.getUserAssigmentsByExperimentIds(
@@ -84,19 +101,6 @@ export class Abba {
     await this.userAssignmentDao.patchByQuery(query, { userId: newId })
   }
 
-  /**
-   * Returns all experiments.
-   */
-  async getAllExperimentsWithBucketsNoCache(): Promise<ExperimentWithBuckets[]> {
-    const experiments = await this.experimentDao.getAll()
-    const buckets = await this.bucketDao.getAll()
-
-    return experiments.map(experiment => ({
-      ...experiment,
-      buckets: buckets.filter(bucket => bucket.experimentId === experiment.id),
-    }))
-  }
-
   /**
    * Creates a new experiment.
    * Cold method.
@@ -180,6 +184,15 @@ export class Abba {
     await this.experimentDao.saveBatch(requiresUpdating, { saveMethod: 'update' })
   }
 
+  async softDeleteExperiment(experimentId: string): Promise<void> {
+    await this.experimentDao.patchById(
+      experimentId,
+      { deleted: true, exclusions: [] },
+      { saveMethod: 'update' },
+    )
+    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
@@ -197,14 +210,8 @@ export class Abba {
       'Experiment must be inactive for at least 15 minutes before deletion',
     )
 
-    const userAssignmentDeleteQuery = this.userAssignmentDao
-      .query()
-      .filterEq('experimentId', experimentId)
-    await this.userAssignmentDao.deleteByQuery(userAssignmentDeleteQuery, { chunkSize: 50000 })
-
-    const bucketDeleteQuery = this.bucketDao.query().filterEq('experimentId', experimentId)
-    await this.bucketDao.deleteByQuery(bucketDeleteQuery)
-
+    await this.userAssignmentDao.deleteByExperimentId(experimentId)
+    await this.bucketDao.deleteByExperimentId(experimentId)
     await this.experimentDao.deleteById(experimentId)
     await this.updateExclusions(experimentId, [])
   }
@@ -253,7 +260,7 @@ export class Abba {
       return null
     }
 
-    const experiments = await this.getAllExperimentsWithUserAssignments(userId)
+    const experiments = await this.getUserExperiments(userId)
     const exclusionSet = getUserExclusionSet(experiments)
     if (!canGenerateNewAssignments(experiment, exclusionSet)) {
       return null
@@ -311,7 +318,7 @@ export class Abba {
     segmentationData: SegmentationData,
     existingOnly = false,
   ): Promise<DecoratedUserAssignment[]> {
-    const experiments = await this.getAllExperimentsWithUserAssignments(userId)
+    const experiments = await this.getUserExperiments(userId)
     const exclusionSet = getUserExclusionSet(experiments)
 
     // Shuffling means that randomisation occurs in the mutual exclusion

package/src/dao/bucket.dao.ts

@@ -10,6 +10,10 @@ export class BucketDao extends CommonDao<Bucket, BucketDBM> {
   async getByExperimentId(experimentId: string): Promise<Bucket[]> {
     return await this.query().filterEq('experimentId', experimentId).runQuery()
   }
+
+  async deleteByExperimentId(experimentId: string): Promise<void> {
+    await this.query().filterEq('experimentId', experimentId).deleteByQuery()
+  }
 }
 
 export function bucketDao(db: CommonDB): BucketDao {

package/src/dao/experiment.dao.ts

@@ -4,13 +4,15 @@ import type { IsoDate } from '@naturalcycles/js-lib'
 import { localDate } from '@naturalcycles/js-lib'
 import type { BaseExperiment, Experiment } from '../types.js'
 
-type ExperimentDBM = BaseExperiment & {
-  rules: string | null
-  exclusions: string | null
-  data: string | null
-}
-
 export class ExperimentDao extends CommonDao<Experiment, ExperimentDBM> {
+  async getAllExperiments(opt?: GetAllExperimentsOpts): Promise<Experiment[]> {
+    if (!opt?.includeDeleted) {
+      return await this.getAll()
+    }
+
+    return await this.query().filterEq('deleted', false).runQuery()
+  }
+
   async getByKey(key: string): Promise<Experiment | null> {
     return await this.getOneBy('key', key)
   }
@@ -58,3 +60,13 @@ function parseMySQLDate(date: string): IsoDate {
   if (date instanceof Date) return localDate(date).toISODate()
   return date as IsoDate
 }
+
+type ExperimentDBM = BaseExperiment & {
+  rules: string | null
+  exclusions: string | null
+  data: string | null
+}
+
+export interface GetAllExperimentsOpts {
+  includeDeleted?: boolean
+}

package/src/dao/userAssignment.dao.ts

@@ -20,6 +20,10 @@ export class UserAssignmentDao extends CommonDao<UserAssignment> {
     return await this.runQuery(query)
   }
 
+  async deleteByExperimentId(experimentId: string): Promise<void> {
+    await this.query().filterEq('experimentId', experimentId).deleteByQuery()
+  }
+
   async getCountByExperimentId(experimentId: string): Promise<number> {
     return await this.query().filterEq('experimentId', experimentId).runQueryCount()
   }

package/src/migrations/init.sql

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

package/src/types.ts

@@ -31,6 +31,10 @@ 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 & {