umami/src/queries/analytics/reports/getJourney.ts

import clickhouse from 'lib/clickhouse';
import { CLICKHOUSE, PRISMA, runQuery } from 'lib/db';
import prisma from 'lib/prisma';

interface JourneyResult {
  e1: string;
  e2: string;
  e3: string;
  e4: string;
  e5: string;
  e6: string;
  e7: string;
  count: string;
}

export async function getJourney(
  ...args: [
    websiteId: string,
    filters: {
      startDate: Date;
      endDate: Date;
      steps: number;
      startStep?: string;
      endStep?: string;
    },
  ]
) {
  return runQuery({
    [PRISMA]: () => relationalQuery(...args),
    [CLICKHOUSE]: () => clickhouseQuery(...args),
  });
}

async function relationalQuery(
  websiteId: string,
  filters: {
    startDate: Date;
    endDate: Date;
  },
): Promise<JourneyResult[]> {
  const { startDate, endDate } = filters;
  const { rawQuery } = prisma;

  return rawQuery(
    `
    WITH events AS (
      select distinct
          session_id,
          referrer_path,
          COALESCE(event_name, url_path) event,
          ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY created_at) AS event_number
      from website_event 
      where website_id = {{websiteId::uuid}}
          and created_at between {{startDate}} and {{endDate}}
          and referrer_path != url_path), 
    sequences as (
      select s.e1,
            s.e2,
            s.e3,
            s.e4,
            s.e5,
            count(*) count
      FROM (
          select session_id,
              MAX(CASE WHEN event_number = 1 THEN event ELSE NULL END) AS e1,
              MAX(CASE WHEN event_number = 2 THEN event ELSE NULL END) AS e2,
              MAX(CASE WHEN event_number = 3 THEN event ELSE NULL END) AS e3,
              MAX(CASE WHEN event_number = 4 THEN event ELSE NULL END) AS e4,
              MAX(CASE WHEN event_number = 5 THEN event ELSE NULL END) AS e5
          FROM events
          group by session_id) s
      group by s.e1,
            s.e2,
            s.e3,
            s.e4,
            s.e5)
    select *
    from sequences
    order by count desc
    limit 100
    `,
    {
      websiteId,
      startDate,
      endDate,
    },
  ).then(parseResult);
}

async function clickhouseQuery(
  websiteId: string,
  filters: {
    startDate: Date;
    endDate: Date;
    steps: number;
    startStep?: string;
    endStep?: string;
  },
): Promise<JourneyResult[]> {
  const { startDate, endDate, steps, startStep, endStep } = filters;
  const { rawQuery } = clickhouse;
  const { sequenceQuery, startStepQuery, endStepQuery, params } = getJourneyQuery(
    steps,
    startStep,
    endStep,
  );

  function getJourneyQuery(
    steps: number,
    startStep?: string,
    endStep?: string,
  ): {
    sequenceQuery: string;
    startStepQuery: string;
    endStepQuery: string;
    params: { [key: string]: string };
  } {
    const params = {};
    let sequenceQuery = '';
    let startStepQuery = '';
    let endStepQuery = '';

    // create sequence query
    let selectQuery = '';
    let maxQuery = '';
    let groupByQuery = '';

    for (let i = 1; i <= steps; i++) {
      const endQuery = i < steps ? ',' : '';
      selectQuery += `s.e${i},`;
      maxQuery += `\nmax(CASE WHEN event_number = ${i} THEN event ELSE NULL END) AS e${i}${endQuery}`;
      groupByQuery += `s.e${i}${endQuery} `;
    }

    sequenceQuery = `\nsequences as (
          select ${selectQuery}
          count(*) count
      FROM (
        select visit_id,
            ${maxQuery}
        FROM events
        group by visit_id) s
      group by ${groupByQuery})
    `;

    // create start Step params query
    if (startStep) {
      startStepQuery = `and e1 = {startStep:String}`;
      params['startStep'] = startStep;
    }

    // create end Step params query
    if (endStep) {
      for (let i = 1; i < steps; i++) {
        const startQuery = i === 1 ? 'and (' : '\nor ';
        endStepQuery += `${startQuery}(e${i} = {endStep:String} and e${i + 1} is null) `;
      }
      endStepQuery += `\nor (e${steps} = {endStep:String}))`;

      params['endStep'] = endStep;
    }

    return {
      sequenceQuery,
      startStepQuery,
      endStepQuery,
      params,
    };
  }

  return rawQuery(
    `
    WITH events AS (
      select distinct
          visit_id,
          referrer_path,
          coalesce(nullIf(event_name, ''), url_path) event,
          row_number() OVER (PARTITION BY visit_id ORDER BY created_at) AS event_number
      from umami.website_event
      where website_id = {websiteId:UUID}
        and created_at between {startDate:DateTime64} and {endDate:DateTime64}),
    ${sequenceQuery}
    select *
    from sequences
    where 1 = 1
    ${startStepQuery}
    ${endStepQuery}
    order by count desc
    limit 100
    `,
    {
      websiteId,
      startDate,
      endDate,
      ...params,
    },
  ).then(parseResult);
}

function combineSequentialDuplicates(array: any) {
  if (array.length === 0) return array;

  const result = [array[0]];

  for (let i = 1; i < array.length; i++) {
    if (array[i] !== array[i - 1]) {
      result.push(array[i]);
    }
  }

  return result;
}

function parseResult(data: any) {
  return data.map(({ e1, e2, e3, e4, e5, e6, e7, count }) => ({
    items: combineSequentialDuplicates([e1, e2, e3, e4, e5, e6, e7]),
    count,
  }));
}