Feature: Experiment Archive State

backend/packages/Upgrade/src/api/controllers/QueryController.ts

@@ -50,4 +50,40 @@ export class QueryController {
   ): Promise<any> {
     return this.queryService.analyze(dataLogParams.queryIds, request.logger);
   }
+
+  /**
+   * @swagger
+   * /query/archive:
+   *    post:
+   *       description: Data log analysis
+   *       consumes:
+   *         - application/json
+   *       parameters:
+   *         - in: body
+   *           name: params
+   *           required: true
+   *           schema:
+   *             type: object
+   *             properties:
+   *               queryIds:
+   *                 type: array
+   *                 items:
+   *                  type: string
+   *           description: Data analysis
+   *       tags:
+   *         - Query
+   *       produces:
+   *         - application/json
+   *       responses:
+   *          '200':
+   *            description: Get data analysis
+   */
+  @Post('/archive')
+  public archive(
+    @Body()
+    dataLogParams: DataLogAnalysisValidator,
+    @Req() request: AppRequest
+  ): Promise<any> {
+    return this.queryService.getArchivedStats(dataLogParams.queryIds, request.logger);
+  }
 }

backend/packages/Upgrade/src/api/models/ArchivedStats.ts

@@ -0,0 +1,18 @@
+import { Entity, PrimaryColumn, Column, OneToOne, JoinColumn } from 'typeorm';
+import { IsNotEmpty } from 'class-validator';
+import { BaseModel } from './base/BaseModel';
+import { Query } from './Query';
+
+@Entity()
+export class ArchivedStats extends BaseModel {
+  @PrimaryColumn('uuid')
+  public id: string;
+
+  @IsNotEmpty()
+  @Column('jsonb')
+  public result: any;
+
+  @OneToOne(() => Query, (query) => query.archivedStats, { onDelete: 'CASCADE' })
+  @JoinColumn()
+  public query: Query;
+}

backend/packages/Upgrade/src/api/models/Query.ts

@@ -1,9 +1,11 @@
-import { Entity, ManyToOne, Column, PrimaryColumn } from 'typeorm';
+import { Entity, ManyToOne, Column, PrimaryColumn, OneToOne } from 'typeorm';
 import { BaseModel } from './base/BaseModel';
 import { Metric } from './Metric';
 import { Experiment } from './Experiment';
 import { IsDefined } from 'class-validator';
 import { REPEATED_MEASURE } from 'upgrade_types';
+import { ArchivedStats } from './ArchivedStats';
+import { Type } from 'class-transformer';
 
 @Entity()
 export class Query extends BaseModel {
@@ -23,6 +25,10 @@ export class Query extends BaseModel {
   @ManyToOne(() => Experiment, (experiment) => experiment.queries, { onDelete: 'CASCADE' })
   public experiment: Experiment;
 
+  @OneToOne(() => ArchivedStats, (archivedStats) => archivedStats.query, { onDelete: 'CASCADE' })
+  @Type(() => ArchivedStats)
+  public archivedStats: ArchivedStats;
+
   @Column({
     type: 'enum',
     enum: REPEATED_MEASURE,

backend/packages/Upgrade/src/api/repositories/ArchivedStatsRepository.ts

@@ -0,0 +1,24 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { ArchivedStats } from '../models/ArchivedStats';
+import repositoryError from './utils/repositoryError';
+
+@EntityRepository(ArchivedStats)
+export class ArchivedStatsRepository extends Repository<ArchivedStats> {
+  public async saveRawJson(
+    rawDataArray: Array<Omit<ArchivedStats, 'createdAt' | 'updatedAt' | 'versionNumber'>>
+  ): Promise<ArchivedStats> {
+    const result = await this.createQueryBuilder('ArchivedStats')
+      .insert()
+      .into(ArchivedStats)
+      .values(rawDataArray)
+      .onConflict(`DO NOTHING`)
+      .returning('*')
+      .execute()
+      .catch((errorMsg: any) => {
+        const errorMsgString = repositoryError(this.constructor.name, 'saveRawJson', { rawDataArray }, errorMsg);
+        throw errorMsgString;
+      });
+
+    return result.raw;
+  }
+}

backend/packages/Upgrade/src/api/repositories/MetricRepository.ts

@@ -1,6 +1,7 @@
 import { Metric } from '../models/Metric';
 import { EntityRepository, Repository } from 'typeorm';
 import repositoryError from './utils/repositoryError';
+import { EXPERIMENT_STATE } from 'upgrade_types';
 
 @EntityRepository(Metric)
 export class MetricRepository extends Repository<Metric> {
@@ -32,7 +33,9 @@ export class MetricRepository extends Repository<Metric> {
   public async findMetricsWithQueries(ids: string[]): Promise<Metric[]> {
     return this.createQueryBuilder('metrics')
       .innerJoin('metrics.queries', 'queries')
+      .innerJoin('queries.experiment', 'experiment')
       .where('key IN (:...ids)', { ids })
+      .andWhere('experiment.state NOT IN (:...archived)', { archived: [EXPERIMENT_STATE.ARCHIVED] })
       .getMany()
       .catch((errorMsg: any) => {
         const errorMsgString = repositoryError(this.constructor.name, 'findMetricsWithQueries', { ids }, errorMsg);

backend/packages/Upgrade/src/api/services/ExperimentService.ts

@@ -72,6 +72,9 @@ import {
 import { ConditionPayloadDTO } from '../DTO/ConditionPayloadDTO';
 import { FactorDTO } from '../DTO/FactorDTO';
 import { LevelDTO } from '../DTO/LevelDTO';
+import { QueryService } from './QueryService';
+import { ArchivedStats } from '../models/ArchivedStats';
+import { ArchivedStatsRepository } from '../repositories/ArchivedStatsRepository';
 
 @Service()
 export class ExperimentService {
@@ -93,10 +96,12 @@ export class ExperimentService {
     @OrmRepository() private factorRepository: FactorRepository,
     @OrmRepository() private levelRepository: LevelRepository,
     @OrmRepository() private levelCombinationElementsRepository: LevelCombinationElementRepository,
+    @OrmRepository() private archivedStatsRepository: ArchivedStatsRepository,
     public previewUserService: PreviewUserService,
     public segmentService: SegmentService,
     public scheduledJobService: ScheduledJobService,
-    public errorService: ErrorService
+    public errorService: ErrorService,
+    public queryService: QueryService
   ) {}
 
   public async find(logger?: UpgradeLogger): Promise<ExperimentDTO[]> {
@@ -384,7 +389,7 @@ export class ExperimentService {
   ): Promise<Experiment> {
     const oldExperiment = await this.experimentRepository.findOne(
       { id: experimentId },
-      { relations: ['stateTimeLogs'] }
+      { relations: ['stateTimeLogs', 'queries', 'queries.metric'] }
     );
 
     if (
@@ -394,6 +399,24 @@ export class ExperimentService {
       await this.populateExclusionTable(experimentId, state, logger);
     }
 
+    if (state === EXPERIMENT_STATE.ARCHIVED) {
+      const queryIds = oldExperiment.queries.map((query) => query.id);
+      const results = await this.queryService.analyze(queryIds, logger);
+      const archivedStatsData: Array<Omit<ArchivedStats, 'createdAt' | 'updatedAt' | 'versionNumber'>> = results.map(
+        (result) => {
+          const queryId = result.id;
+          delete result.id;
+          const archivedStats: Partial<ArchivedStats> = {
+            id: uuid(),
+            result: result,
+            query: queryId,
+          };
+          return archivedStats;
+        }
+      );
+      await this.archivedStatsRepository.saveRawJson(archivedStatsData);
+    }
+
     let data: AuditLogData = {
       experimentId,
       experimentName: oldExperiment.name,

backend/packages/Upgrade/src/api/services/QueryService.ts

@@ -8,6 +8,8 @@ import { ErrorService } from './ErrorService';
 import { ExperimentError } from '../models/ExperimentError';
 import { UpgradeLogger } from '../../lib/logger/UpgradeLogger';
 import { Experiment } from '../models/Experiment';
+import { ArchivedStatsRepository } from '../repositories/ArchivedStatsRepository';
+import { In } from 'typeorm';
 
 interface queryResult {
   conditionId?: string;
@@ -21,6 +23,7 @@ export class QueryService {
   constructor(
     @OrmRepository() private queryRepository: QueryRepository,
     @OrmRepository() private logRepository: LogRepository,
+    @OrmRepository() private archivedStatsRepository: ArchivedStatsRepository,
     public errorService: ErrorService
   ) {}
 
@@ -35,6 +38,17 @@ export class QueryService {
     });
   }
 
+  public async getArchivedStats(queryIds: string[], logger: UpgradeLogger): Promise<any> {
+    logger.info({ message: `Get archivedStats of query with queryIds ${queryIds}` });
+    const archiveData = await this.archivedStatsRepository.find({
+      relations: ['query'],
+      where: { query: In(queryIds) },
+    });
+    return archiveData.map((data) => {
+      return { ...data.result, id: data.query.id };
+    });
+  }
+
   public async analyze(queryIds: string[], logger: UpgradeLogger): Promise<any> {
     logger.info({ message: `Get analysis of query with queryIds ${queryIds}` });
     const promiseArray = queryIds.map((queryId) =>

backend/packages/Upgrade/src/database/migrations/1692936809279-archivedState.ts

@@ -0,0 +1,79 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class archivedState1692936809279 implements MigrationInterface {
+  name = 'archivedState1692936809279';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "archived_stats" ("createdAt" TIMESTAMP NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP NOT NULL DEFAULT now(), "versionNumber" integer NOT NULL, "id" uuid NOT NULL, "result" jsonb NOT NULL, "queryId" uuid, CONSTRAINT "REL_df18fe5ea7298a1dc7bfb33b06" UNIQUE ("queryId"), CONSTRAINT "PK_afc8a335c8d9d48cefaf1aa2c09" PRIMARY KEY ("id"))`
+    );
+    await queryRunner.query(
+      `ALTER TYPE "public"."state_time_log_fromstate_enum" RENAME TO "state_time_log_fromstate_enum_old"`
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."state_time_log_fromstate_enum" AS ENUM('inactive', 'preview', 'scheduled', 'enrolling', 'enrollmentComplete', 'cancelled', 'archived')`
+    );
+    await queryRunner.query(
+      `ALTER TABLE "public"."state_time_log" ALTER COLUMN "fromState" TYPE "public"."state_time_log_fromstate_enum" USING "fromState"::"text"::"public"."state_time_log_fromstate_enum"`
+    );
+    await queryRunner.query(`DROP TYPE "public"."state_time_log_fromstate_enum_old"`);
+    await queryRunner.query(
+      `ALTER TYPE "public"."state_time_log_tostate_enum" RENAME TO "state_time_log_tostate_enum_old"`
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."state_time_log_tostate_enum" AS ENUM('inactive', 'preview', 'scheduled', 'enrolling', 'enrollmentComplete', 'cancelled', 'archived')`
+    );
+    await queryRunner.query(
+      `ALTER TABLE "public"."state_time_log" ALTER COLUMN "toState" TYPE "public"."state_time_log_tostate_enum" USING "toState"::"text"::"public"."state_time_log_tostate_enum"`
+    );
+    await queryRunner.query(`DROP TYPE "public"."state_time_log_tostate_enum_old"`);
+    await queryRunner.query(`ALTER TYPE "public"."experiment_state_enum" RENAME TO "experiment_state_enum_old"`);
+    await queryRunner.query(
+      `CREATE TYPE "public"."experiment_state_enum" AS ENUM('inactive', 'preview', 'scheduled', 'enrolling', 'enrollmentComplete', 'cancelled', 'archived')`
+    );
+    await queryRunner.query(`ALTER TABLE "public"."experiment" ALTER COLUMN "state" DROP DEFAULT`);
+    await queryRunner.query(
+      `ALTER TABLE "public"."experiment" ALTER COLUMN "state" TYPE "public"."experiment_state_enum" USING "state"::"text"::"public"."experiment_state_enum"`
+    );
+    await queryRunner.query(`ALTER TABLE "public"."experiment" ALTER COLUMN "state" SET DEFAULT 'inactive'`);
+    await queryRunner.query(`DROP TYPE "public"."experiment_state_enum_old"`);
+    await queryRunner.query(
+      `ALTER TABLE "archived_stats" ADD CONSTRAINT "FK_df18fe5ea7298a1dc7bfb33b06f" FOREIGN KEY ("queryId") REFERENCES "query"("id") ON DELETE CASCADE ON UPDATE NO ACTION`
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "archived_stats" DROP CONSTRAINT "FK_df18fe5ea7298a1dc7bfb33b06f"`);
+    await queryRunner.query(
+      `CREATE TYPE "public"."experiment_state_enum_old" AS ENUM('cancelled', 'enrolling', 'enrollmentComplete', 'inactive', 'preview', 'scheduled')`
+    );
+    await queryRunner.query(`ALTER TABLE "public"."experiment" ALTER COLUMN "state" DROP DEFAULT`);
+    await queryRunner.query(
+      `ALTER TABLE "public"."experiment" ALTER COLUMN "state" TYPE "public"."experiment_state_enum_old" USING "state"::"text"::"public"."experiment_state_enum_old"`
+    );
+    await queryRunner.query(`ALTER TABLE "public"."experiment" ALTER COLUMN "state" SET DEFAULT 'inactive'`);
+    await queryRunner.query(`DROP TYPE "public"."experiment_state_enum"`);
+    await queryRunner.query(`ALTER TYPE "public"."experiment_state_enum_old" RENAME TO "experiment_state_enum"`);
+    await queryRunner.query(
+      `CREATE TYPE "public"."state_time_log_tostate_enum_old" AS ENUM('cancelled', 'enrolling', 'enrollmentComplete', 'inactive', 'preview', 'scheduled')`
+    );
+    await queryRunner.query(
+      `ALTER TABLE "public"."state_time_log" ALTER COLUMN "toState" TYPE "public"."state_time_log_tostate_enum_old" USING "toState"::"text"::"public"."state_time_log_tostate_enum_old"`
+    );
+    await queryRunner.query(`DROP TYPE "public"."state_time_log_tostate_enum"`);
+    await queryRunner.query(
+      `ALTER TYPE "public"."state_time_log_tostate_enum_old" RENAME TO "state_time_log_tostate_enum"`
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."state_time_log_fromstate_enum_old" AS ENUM('cancelled', 'enrolling', 'enrollmentComplete', 'inactive', 'preview', 'scheduled')`
+    );
+    await queryRunner.query(
+      `ALTER TABLE "public"."state_time_log" ALTER COLUMN "fromState" TYPE "public"."state_time_log_fromstate_enum_old" USING "fromState"::"text"::"public"."state_time_log_fromstate_enum_old"`
+    );
+    await queryRunner.query(`DROP TYPE "public"."state_time_log_fromstate_enum"`);
+    await queryRunner.query(
+      `ALTER TYPE "public"."state_time_log_fromstate_enum_old" RENAME TO "state_time_log_fromstate_enum"`
+    );
+    await queryRunner.query(`DROP TABLE "archived_stats"`);
+  }
+}

backend/packages/Upgrade/test/unit/repositories/MetricRepository.test.ts

@@ -26,7 +26,7 @@ afterEach(() => {
 });
 
 describe('MetricRepository Testing', () => {
-  it('should delete a  metric', async () => {
+  it('should delete a metric', async () => {
     createQueryBuilderStub = sandbox.stub(MetricRepository.prototype, 'createQueryBuilder').returns(deleteQueryBuilder);
     const result = {
       identifiers: [{ id: metric.key }],
@@ -106,8 +106,9 @@ describe('MetricRepository Testing', () => {
       raw: [metric],
     };
 
-    selectMock.expects('innerJoin').once().returns(selectQueryBuilder);
+    selectMock.expects('innerJoin').twice().returns(selectQueryBuilder);
     selectMock.expects('where').once().returns(selectQueryBuilder);
+    selectMock.expects('andWhere').once().returns(selectQueryBuilder);
     selectMock.expects('getMany').once().returns(Promise.resolve(result));
 
     const res = await repo.findMetricsWithQueries([metric.key]);
@@ -121,8 +122,9 @@ describe('MetricRepository Testing', () => {
   it('should throw an error when get monitored experiment metric by date range fails', async () => {
     createQueryBuilderStub = sandbox.stub(MetricRepository.prototype, 'createQueryBuilder').returns(selectQueryBuilder);
 
-    selectMock.expects('innerJoin').once().returns(selectQueryBuilder);
+    selectMock.expects('innerJoin').twice().returns(selectQueryBuilder);
     selectMock.expects('where').once().returns(selectQueryBuilder);
+    selectMock.expects('andWhere').once().returns(selectQueryBuilder);
     selectMock.expects('getMany').once().returns(Promise.reject(err));
 
     expect(async () => {