Skip to content

📈 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!

5.9 KB
Raw Blame
import { Injectable } from '@nestjs/common'
import { InjectRepository } from '@nestjs/typeorm'
import {
  FindManyOptions,
  FindOneOptions,
  Repository,
  EntityManager,
  DeleteResult,
  UpdateResult,
} from 'typeorm'
import { Pagination, PaginationOptionsInterface } from '../common/pagination'
import { clickhouse } from '../common/integrations/clickhouse'
import { AppLoggerService } from '../logger/logger.service'
import { FeatureFlag } from './entity/feature-flag.entity'
import {
  evaluateFlag as sharedEvaluateFlag,
  evaluateFlags as sharedEvaluateFlags,
  isScheduledChangeDue,
} from './evaluation'

@Injectable()
export class FeatureFlagService {
  constructor(
    @InjectRepository(FeatureFlag)
    private featureFlagRepository: Repository<FeatureFlag>,
    private readonly logger: AppLoggerService,
  ) {}

  async paginate(
    options: PaginationOptionsInterface,
    projectId: string,
    search?: string,
  ): Promise<Pagination<FeatureFlag>> {
    const safeTake =
      typeof options.take === 'number' && Number.isFinite(options.take)
        ? Math.min(Math.max(options.take, 0), 100)
        : 100
    const safeSkip =
      typeof options.skip === 'number' && Number.isFinite(options.skip)
        ? Math.max(options.skip, 0)
        : 0

    const queryBuilder = this.featureFlagRepository
      .createQueryBuilder('flag')
      .leftJoinAndSelect('flag.project', 'project')
      .where('project.id = :projectId', { projectId })

    if (search && search.trim()) {
      const searchTerm = `%${search.trim()}%`
      queryBuilder.andWhere(
        '(LOWER(flag.key) LIKE LOWER(:search) OR LOWER(flag.description) LIKE LOWER(:search))',
        { search: searchTerm },
      )
    }

    queryBuilder.orderBy('flag.key', 'ASC').take(safeTake).skip(safeSkip)

    const [results, total] = await queryBuilder.getManyAndCount()

    return new Pagination<FeatureFlag>({
      results,
      total,
    })
  }

  findOneWithRelations(id: string): Promise<FeatureFlag | null> {
    return this.featureFlagRepository.findOne({
      where: { id },
      relations: [
        'project',
        'project.admin',
        'project.share',
        'project.share.user',
        'project.organisation',
        'project.organisation.members',
        'project.organisation.members.user',
      ],
    })
  }

  async count(options: FindManyOptions<FeatureFlag> = {}): Promise<number> {
    return this.featureFlagRepository.count(options)
  }

  findOne(options: FindOneOptions<FeatureFlag>): Promise<FeatureFlag | null> {
    return this.featureFlagRepository.findOne(options)
  }

  find(options: FindManyOptions<FeatureFlag>): Promise<FeatureFlag[]> {
    return this.featureFlagRepository.find(options)
  }

  findByProject(projectId: string): Promise<FeatureFlag[]> {
    return this.featureFlagRepository.find({
      where: { project: { id: projectId } },
      order: { key: 'ASC' },
    })
  }

  findEnabledByProject(projectId: string): Promise<FeatureFlag[]> {
    return this.featureFlagRepository.find({
      where: { project: { id: projectId }, enabled: true },
      order: { key: 'ASC' },
    })
  }

  async applyDueScheduledChanges(projectId: string): Promise<void> {
    const flags = await this.featureFlagRepository.find({
      where: { project: { id: projectId } },
    })

    await Promise.all(
      flags
        .filter((flag) => isScheduledChangeDue(flag.scheduledChange))
        .map((flag) =>
          this.featureFlagRepository.update(flag.id, {
            enabled: flag.scheduledChange?.enabled ?? flag.enabled,
            rolloutPercentage:
              flag.scheduledChange?.rolloutPercentage ?? flag.rolloutPercentage,
            scheduledChange: null,
          }),
        ),
    )
  }

  async getLastEvaluatedAtByFlagIds(
    projectId: string,
    flagIds: string[],
  ): Promise<Map<string, string>> {
    const result = new Map<string, string>()

    if (flagIds.length === 0) {
      return result
    }

    const query = `
      SELECT
        flagId,
        max(created) as lastEvaluatedAt
      FROM feature_flag_evaluations
      WHERE
        pid = {pid:FixedString(12)}
        AND flagId IN {flagIds:Array(String)}
      GROUP BY flagId
    `

    try {
      const resultSet = await clickhouse.query({
        query,
        query_params: { pid: projectId, flagIds },
      })
      const { data } = await resultSet.json<{
        flagId: string
        lastEvaluatedAt: string
      }>()

      for (const row of data) {
        result.set(row.flagId, row.lastEvaluatedAt)
      }
    } catch (err) {
      this.logger.error(
        { err, projectId, flagIds },
        'Failed to get feature flag evaluation timestamps',
      )
      throw err
    }

    return result
  }

  async create(
    flagData: Partial<FeatureFlag>,
    manager?: EntityManager,
  ): Promise<FeatureFlag> {
    const repository = manager
      ? manager.getRepository(FeatureFlag)
      : this.featureFlagRepository
    return repository.save(flagData)
  }

  async update(
    id: string,
    flagData: Partial<FeatureFlag>,
    manager?: EntityManager,
  ): Promise<UpdateResult> {
    const repository = manager
      ? manager.getRepository(FeatureFlag)
      : this.featureFlagRepository
    return repository.update(id, flagData)
  }

  async delete(id: string, manager?: EntityManager): Promise<DeleteResult> {
    const repository = manager
      ? manager.getRepository(FeatureFlag)
      : this.featureFlagRepository
    return repository.delete(id)
  }

  /**
   * Evaluates all feature flags for a project given visitor attributes
   */
  evaluateFlags(
    flags: FeatureFlag[],
    profileId: string,
    attributes?: Record<string, string>,
  ): Record<string, boolean> {
    return sharedEvaluateFlags(flags, profileId, attributes)
  }

  /**
   * Evaluates a single feature flag for a visitor
   */
  evaluateFlag(
    flag: FeatureFlag,
    profileId: string,
    attributes?: Record<string, string>,
  ): boolean {
    return sharedEvaluateFlag(flag, profileId, attributes)
  }
}