📈 Open source, privacy-first web analytics — a cookie-less Google Analytics alternative with built-in error tracking and performance monitoring. Self-host it or use our cloud. Get started for free!
TypeScript chartsclickhousedockergdprgoogle-analyticsmetricsmonitoringmysqlnestjsprivacyredisself-hostedselfhostedstatisticstailwindcssweb-analyticswebanalyticswebsite
import { Injectable } from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm'
import {
FindManyOptions,
FindOneOptions,
Repository,
EntityManager,
} from 'typeorm'
import { Pagination, PaginationOptionsInterface } from '../common/pagination'
import { Experiment } from './entity/experiment.entity'
import { ExperimentVariant } from './entity/experiment-variant.entity'
@Injectable()
export class ExperimentService {
constructor(
@InjectRepository(Experiment)
private experimentRepository: Repository<Experiment>,
@InjectRepository(ExperimentVariant)
private variantRepository: Repository<ExperimentVariant>,
) {}
async paginate(
options: PaginationOptionsInterface,
projectId: string,
search?: string,
): Promise<Pagination<Experiment>> {
const queryBuilder = this.experimentRepository
.createQueryBuilder('experiment')
.leftJoinAndSelect('experiment.project', 'project')
.leftJoinAndSelect('experiment.variants', 'variants')
.leftJoinAndSelect('experiment.goal', 'goal')
.leftJoinAndSelect('experiment.featureFlag', 'featureFlag')
.where('project.id = :projectId', { projectId })
if (search && search.trim()) {
const searchTerm = `%${search.trim()}%`
queryBuilder.andWhere(
'(LOWER(experiment.name) LIKE LOWER(:search) OR LOWER(experiment.description) LIKE LOWER(:search))',
{ search: searchTerm },
)
}
queryBuilder
.orderBy('experiment.created', 'DESC')
.take(options.take || 100)
.skip(options.skip || 0)
const [results, total] = await queryBuilder.getManyAndCount()
return new Pagination<Experiment>({
results,
total,
})
}
findOneWithRelations(id: string): Promise<Experiment | null> {
return this.experimentRepository.findOne({
where: { id },
relations: [
'project',
'project.admin',
'project.share',
'project.share.user',
'project.organisation',
'project.organisation.members',
'project.organisation.members.user',
'variants',
'goal',
'featureFlag',
],
})
}
async count(options: FindManyOptions<Experiment> = {}): Promise<number> {
return this.experimentRepository.count(options)
}
findOne(options: FindOneOptions<Experiment>): Promise<Experiment | null> {
return this.experimentRepository.findOne(options)
}
find(options: FindManyOptions<Experiment>): Promise<Experiment[]> {
return this.experimentRepository.find(options)
}
findByProject(projectId: string): Promise<Experiment[]> {
return this.experimentRepository.find({
where: { project: { id: projectId } },
relations: ['variants', 'goal', 'featureFlag'],
order: { created: 'DESC' },
})
}
async create(
experimentData: Partial<Experiment>,
manager?: EntityManager,
): Promise<Experiment> {
const repository = manager
? manager.getRepository(Experiment)
: this.experimentRepository
return repository.save(experimentData)
}
async update(
id: string,
experimentData: Partial<Experiment>,
manager?: EntityManager,
): Promise<any> {
const repository = manager
? manager.getRepository(Experiment)
: this.experimentRepository
return repository.update(id, experimentData)
}
async delete(id: string): Promise<any> {
return this.experimentRepository.delete(id)
}
async createVariant(
variantData: Partial<ExperimentVariant>,
): Promise<ExperimentVariant> {
return this.variantRepository.save(variantData)
}
async updateVariant(
id: string,
variantData: Partial<ExperimentVariant>,
): Promise<any> {
return this.variantRepository.update(id, variantData)
}
async deleteVariant(id: string): Promise<any> {
return this.variantRepository.delete(id)
}
async deleteVariantsByExperiment(experimentId: string): Promise<any> {
return this.variantRepository.delete({ experiment: { id: experimentId } })
}
async findVariantsByExperiment(
experimentId: string,
): Promise<ExperimentVariant[]> {
return this.variantRepository.find({
where: { experiment: { id: experimentId } },
})
}
async recreateVariants(
experiment: Experiment,
variantsData: Partial<ExperimentVariant>[],
manager?: EntityManager,
): Promise<void> {
const runInTransaction = async (
transactionalEntityManager: EntityManager,
) => {
await transactionalEntityManager.delete(ExperimentVariant, {
experiment: { id: experiment.id },
})
const variants = variantsData.map((v) => {
const variant = new ExperimentVariant()
variant.name = v.name
variant.key = v.key
variant.description = v.description || null
variant.rolloutPercentage = v.rolloutPercentage
variant.isControl = v.isControl
variant.experiment = experiment
return variant
})
await transactionalEntityManager.save(ExperimentVariant, variants)
}
if (manager) {
await runInTransaction(manager)
} else {
await this.experimentRepository.manager.transaction(runInTransaction)
}
}
}