Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

5.1 KB
Raw Blame
import { FastifyReply, FastifyRequest } from "fastify";
import { DateTime } from "luxon";
import { z } from "zod";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { buildGoalCondition } from "../analytics/goals/goalConditions.js";
import { processResults } from "../analytics/utils/utils.js";
import {
  buildExperimentResultQueries,
  type ExperimentResultsQuery,
  type ExperimentWindow,
  resolveExperimentWindow,
} from "./getExperimentResults.js";
import { getExperimentVariantKeys, getExperimentWithRelations, parseExperimentId, parseSiteId } from "./utils.js";

type DailyRow = { variant: string; day: string; units: number | string; conversions: number | string };

export type ExperimentTimeseriesPoint = { date: string; units: number; conversions: number; conversionRate: number };

const MAX_DAYS = 366;

function windowDay(value: string | null, timeZone: string): string | null {
  if (!value) return null;
  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
  const instant = DateTime.fromSQL(value, { zone: "utc" });
  return instant.isValid ? instant.setZone(timeZone).toISODate() : null;
}

export function buildCumulativeSeries(
  variants: string[],
  rows: DailyRow[],
  window: ExperimentWindow,
  timeZone: string,
  today = DateTime.now().setZone(timeZone).toISODate()!
): { variant: string; points: ExperimentTimeseriesPoint[] }[] {
  const dataDays = rows.map(row => row.day).sort();
  const first = windowDay(window.start, timeZone) ?? dataDays[0];
  const last = windowDay(window.end, timeZone) ?? (window.mode === "experiment" ? today : dataDays[dataDays.length - 1]);
  if (!first || !last) return variants.map(variant => ({ variant, points: [] }));

  const end = DateTime.fromISO(last < first ? first : last, { zone: "utc" });
  const earliest = end.minus({ days: MAX_DAYS - 1 });
  const start = DateTime.max(DateTime.fromISO(first, { zone: "utc" }), earliest);
  const days: string[] = [];
  for (let cursor = start; cursor <= end; cursor = cursor.plus({ days: 1 })) {
    days.push(cursor.toISODate()!);
  }

  const daily = new Map(rows.map(row => [`${row.variant}|${row.day}`, row]));

  return variants.map(variant => {
    let units = 0;
    let conversions = 0;
    for (const row of rows) {
      if (row.variant !== variant || row.day < first || row.day >= days[0]) continue;
      units += Number(row.units);
      conversions += Number(row.conversions);
    }
    return {
      variant,
      points: days.map(date => {
        const row = daily.get(`${variant}|${date}`);
        units += Number(row?.units ?? 0);
        conversions += Number(row?.conversions ?? 0);
        return { date, units, conversions, conversionRate: units > 0 ? conversions / units : 0 };
      }),
    };
  });
}

export async function getExperimentTimeseries(
  request: FastifyRequest<{
    Params: { siteId: string; experimentId: string };
    Querystring: ExperimentResultsQuery;
  }>,
  reply: FastifyReply
) {
  try {
    const siteId = parseSiteId(request.params.siteId, reply);
    if (!siteId) return;

    const experimentId = parseExperimentId(request.params.experimentId, reply);
    if (!experimentId) return;

    const record = await getExperimentWithRelations(siteId, experimentId);
    if (!record) {
      return reply.status(404).send({ error: "Experiment not found" });
    }

    const variants = getExperimentVariantKeys(record.featureFlag);
    const { query, window, exact } = resolveExperimentWindow(request.query, record.experiment);
    const timeZone = query.time_zone || "UTC";
    const goalCondition = record.primaryGoal ? buildGoalCondition(record.primaryGoal) : null;

    if (!record.primaryGoal || !goalCondition || variants.length === 0) {
      return reply.send({ data: { variants: [], measurement: "exposure", window } });
    }

    const { exposureTimeseriesQuery, assignmentTimeseriesQuery } = buildExperimentResultQueries({
      query,
      siteId,
      flagKey: record.featureFlag.key,
      variantKeys: variants,
      goalCondition,
      exact,
    });

    let measurement: "exposure" | "assignment" = "exposure";
    let rows = await processResults<DailyRow>(
      await clickhouse.query({ query: exposureTimeseriesQuery, format: "JSONEachRow" })
    );
    // Same rule as the results: a flag with a variant named "true"/"false" only reports exposures.
    const hasReservedVariant = variants.some(variant => variant === "true" || variant === "false");
    if (rows.length === 0 && !hasReservedVariant) {
      const assignmentRows = await processResults<DailyRow>(
        await clickhouse.query({ query: assignmentTimeseriesQuery, format: "JSONEachRow" })
      );
      if (assignmentRows.length > 0) {
        rows = assignmentRows;
        measurement = "assignment";
      }
    }

    return reply.send({
      data: { variants: buildCumulativeSeries(variants, rows, window, timeZone), measurement, window },
    });
  } catch (error) {
    if (error instanceof z.ZodError) {
      return reply.status(400).send({ error: "Validation error", details: error.errors });
    }
    return reply.status(500).send({ error: "Failed to get experiment time series" });
  }
}