Moved code into src folder. Added build for component library.

src/queries/analytics/eventData/getEventDataEvents.ts

@@ -0,0 +1,104 @@
+import prisma from 'lib/prisma';
+import clickhouse from 'lib/clickhouse';
+import { CLICKHOUSE, PRISMA, runQuery } from 'lib/db';
+import { QueryFilters, WebsiteEventData } from 'lib/types';
+
+export async function getEventDataEvents(
+  ...args: [websiteId: string, filters: QueryFilters]
+): Promise<WebsiteEventData[]> {
+  return runQuery({
+    [PRISMA]: () => relationalQuery(...args),
+    [CLICKHOUSE]: () => clickhouseQuery(...args),
+  });
+}
+
+async function relationalQuery(websiteId: string, filters: QueryFilters) {
+  const { rawQuery, parseFilters } = prisma;
+  const { event } = filters;
+  const { params } = await parseFilters(websiteId, filters);
+
+  if (event) {
+    return rawQuery(
+      `
+      select
+        website_event.event_name as "eventName",
+        event_data.event_key as "fieldName",
+        event_data.data_type as "dataType",
+        event_data.string_value as "fieldValue",
+        count(*) as "total"
+      from event_data
+      inner join website_event
+        on website_event.event_id = event_data.website_event_id
+      where event_data.website_id = {{websiteId::uuid}}
+        and event_data.created_at between {{startDate}} and {{endDate}}
+        and website_event.event_name = {{event}}
+      group by website_event.event_name, event_data.event_key, event_data.data_type, event_data.string_value
+      order by 1 asc, 2 asc, 3 asc, 4 desc
+      `,
+      params,
+    );
+  }
+
+  return rawQuery(
+    `
+    select
+      website_event.event_name as "eventName",
+      event_data.event_key as "fieldName",
+      event_data.data_type as "dataType",
+      count(*) as "total"
+    from event_data
+    inner join website_event
+      on website_event.event_id = event_data.website_event_id
+    where event_data.website_id = {{websiteId::uuid}}
+      and event_data.created_at between {{startDate}} and {{endDate}}
+    group by website_event.event_name, event_data.event_key, event_data.data_type
+    order by 1 asc, 2 asc
+    limit 100
+    `,
+    params,
+  );
+}
+
+async function clickhouseQuery(websiteId: string, filters: QueryFilters) {
+  const { rawQuery, parseFilters } = clickhouse;
+  const { event } = filters;
+  const { params } = await parseFilters(websiteId, filters);
+
+  if (event) {
+    return rawQuery(
+      `
+      select
+        event_name as eventName,
+        event_key as fieldName,
+        data_type as dataType,
+        string_value as fieldValue,
+        count(*) as total
+      from event_data
+      where website_id = {websiteId:UUID}
+        and created_at between {startDate:DateTime} and {endDate:DateTime}
+        and event_name = {event:String}
+      group by event_key, data_type, string_value, event_name
+      order by 1 asc, 2 asc, 3 asc, 4 desc
+      limit 100
+      `,
+      params,
+    );
+  }
+
+  return rawQuery(
+    `
+    select
+      event_name as eventName,
+      event_key as fieldName,
+      data_type as dataType,
+      count(*) as total
+    from event_data
+    where website_id = {websiteId:UUID}
+      and created_at between {startDate:DateTime} and {endDate:DateTime}
+    group by event_key, data_type, event_name
+    order by 1 asc, 2 asc
+    limit 100
+    `,
+    params,
+  );
+}

src/queries/analytics/eventData/getEventDataFields.ts

@@ -0,0 +1,63 @@
+import prisma from 'lib/prisma';
+import clickhouse from 'lib/clickhouse';
+import { CLICKHOUSE, PRISMA, runQuery } from 'lib/db';
+import { QueryFilters, WebsiteEventData } from 'lib/types';
+
+export async function getEventDataFields(
+  ...args: [websiteId: string, filters: QueryFilters & { field?: string }]
+): Promise<WebsiteEventData[]> {
+  return runQuery({
+    [PRISMA]: () => relationalQuery(...args),
+    [CLICKHOUSE]: () => clickhouseQuery(...args),
+  });
+}
+
+async function relationalQuery(websiteId: string, filters: QueryFilters & { field?: string }) {
+  const { rawQuery, parseFilters } = prisma;
+  const { filterQuery, params } = await parseFilters(websiteId, filters, {
+    columns: { field: 'event_key' },
+  });
+
+  return rawQuery(
+    `
+    select
+      event_key as "fieldName",
+      data_type as "dataType",
+      string_value as "fieldValue",
+      count(*) as "total"
+    from event_data
+    where website_id = {{websiteId::uuid}}
+      and created_at between {{startDate}} and {{endDate}}
+    ${filterQuery}
+    group by event_key, data_type, string_value
+    order by 3 desc, 2 desc, 1 asc
+    limit 100
+    `,
+    params,
+  );
+}
+
+async function clickhouseQuery(websiteId: string, filters: QueryFilters & { field?: string }) {
+  const { rawQuery, parseFilters } = clickhouse;
+  const { filterQuery, params } = await parseFilters(websiteId, filters, {
+    columns: { field: 'event_key' },
+  });
+
+  return rawQuery(
+    `
+    select
+      event_key as fieldName,
+      data_type as dataType,
+      string_value as fieldValue,
+      count(*) as total
+    from event_data
+    where website_id = {websiteId:UUID}
+      and created_at between {startDate:DateTime} and {endDate:DateTime}
+    ${filterQuery}
+    group by event_key, data_type, string_value
+    order by 3 desc, 2 desc, 1 asc
+    limit 100
+    `,
+    params,
+  );
+}

src/queries/analytics/eventData/getEventDataStats.ts

@@ -0,0 +1,69 @@
+import prisma from 'lib/prisma';
+import clickhouse from 'lib/clickhouse';
+import { CLICKHOUSE, PRISMA, runQuery } from 'lib/db';
+import { QueryFilters } from 'lib/types';
+
+export async function getEventDataStats(
+  ...args: [websiteId: string, filters: QueryFilters]
+): Promise<{
+  events: number;
+  fields: number;
+  records: number;
+}> {
+  return runQuery({
+    [PRISMA]: () => relationalQuery(...args),
+    [CLICKHOUSE]: () => clickhouseQuery(...args),
+  }).then(results => results[0]);
+}
+
+async function relationalQuery(websiteId: string, filters: QueryFilters) {
+  const { rawQuery, parseFilters } = prisma;
+  const { filterQuery, params } = await parseFilters(websiteId, filters);
+
+  return rawQuery(
+    `
+    select 
+      count(distinct t.website_event_id) as "events",
+      count(distinct t.event_key) as "fields",
+      sum(t.total) as "records"
+    from (
+      select
+        website_event_id,
+        event_key,
+        count(*) as "total"
+      from event_data
+      where website_id = {{websiteId::uuid}}
+        and created_at between {{startDate}} and {{endDate}}
+      ${filterQuery}
+      group by website_event_id, event_key
+      ) as t
+    `,
+    params,
+  );
+}
+
+async function clickhouseQuery(websiteId: string, filters: QueryFilters) {
+  const { rawQuery, parseFilters } = clickhouse;
+  const { filterQuery, params } = await parseFilters(websiteId, filters);
+
+  return rawQuery(
+    `
+    select 
+      count(distinct t.event_id) as "events",
+      count(distinct t.event_key) as "fields",
+      sum(t.total) as "records"
+    from (
+      select
+        event_id,
+        event_key,
+        count(*) as "total"
+      from event_data
+      where website_id = {websiteId:UUID}
+        and created_at between {startDate:DateTime} and {endDate:DateTime}
+      ${filterQuery}
+      group by event_id, event_key
+      ) as t
+    `,
+    params,
+  );
+}

src/queries/analytics/eventData/getEventDataUsage.ts

@@ -0,0 +1,30 @@
+import clickhouse from 'lib/clickhouse';
+import { CLICKHOUSE, PRISMA, runQuery, notImplemented } from 'lib/db';
+
+export function getEventDataUsage(...args: [websiteIds: string[], startDate: Date, endDate: Date]) {
+  return runQuery({
+    [PRISMA]: notImplemented,
+    [CLICKHOUSE]: () => clickhouseQuery(...args),
+  });
+}
+
+function clickhouseQuery(websiteIds: string[], startDate: Date, endDate: Date) {
+  const { rawQuery } = clickhouse;
+
+  return rawQuery(
+    `
+    select 
+      website_id as websiteId,
+      count(*) as count
+    from event_data 
+    where created_at between {startDate:DateTime64} and {endDate:DateTime64}
+      and website_id in {websiteIds:Array(UUID)}
+    group by website_id
+    `,
+    {
+      websiteIds,
+      startDate,
+      endDate,
+    },
+  );
+}

src/queries/analytics/eventData/saveEventData.ts

@@ -0,0 +1,91 @@
+import { Prisma } from '@prisma/client';
+import { DATA_TYPE } from 'lib/constants';
+import { uuid } from 'lib/crypto';
+import { CLICKHOUSE, PRISMA, runQuery } from 'lib/db';
+import { flattenJSON } from 'lib/data';
+import kafka from 'lib/kafka';
+import prisma from 'lib/prisma';
+import { DynamicData } from 'lib/types';
+
+export async function saveEventData(args: {
+  websiteId: string;
+  eventId: string;
+  sessionId?: string;
+  urlPath?: string;
+  eventName?: string;
+  eventData: DynamicData;
+  createdAt?: string;
+}) {
+  return runQuery({
+    [PRISMA]: () => relationalQuery(args),
+    [CLICKHOUSE]: () => clickhouseQuery(args),
+  });
+}
+
+async function relationalQuery(data: {
+  websiteId: string;
+  eventId: string;
+  eventData: DynamicData;
+}): Promise<Prisma.BatchPayload> {
+  const { websiteId, eventId, eventData } = data;
+
+  const jsonKeys = flattenJSON(eventData);
+
+  // id, websiteEventId, eventStringValue
+  const flattendData = jsonKeys.map(a => ({
+    id: uuid(),
+    websiteEventId: eventId,
+    websiteId,
+    eventKey: a.key,
+    stringValue:
+      a.dynamicDataType === DATA_TYPE.number
+        ? parseFloat(a.value).toFixed(4)
+        : a.dynamicDataType === DATA_TYPE.date
+        ? a.value.split('.')[0] + 'Z'
+        : a.value.toString(),
+    numberValue: a.dynamicDataType === DATA_TYPE.number ? a.value : null,
+    dateValue: a.dynamicDataType === DATA_TYPE.date ? new Date(a.value) : null,
+    dataType: a.dynamicDataType,
+  }));
+
+  return prisma.client.eventData.createMany({
+    data: flattendData,
+  });
+}
+
+async function clickhouseQuery(data: {
+  websiteId: string;
+  eventId: string;
+  sessionId?: string;
+  urlPath?: string;
+  eventName?: string;
+  eventData: DynamicData;
+  createdAt?: string;
+}) {
+  const { websiteId, sessionId, eventId, urlPath, eventName, eventData, createdAt } = data;
+
+  const { getDateFormat, sendMessages } = kafka;
+
+  const jsonKeys = flattenJSON(eventData);
+
+  const messages = jsonKeys.map(a => ({
+    website_id: websiteId,
+    session_id: sessionId,
+    event_id: eventId,
+    url_path: urlPath,
+    event_name: eventName,
+    event_key: a.key,
+    string_value:
+      a.dynamicDataType === DATA_TYPE.date
+        ? getDateFormat(a.value, 'isoUtcDateTime')
+        : a.value.toString(),
+    number_value: a.dynamicDataType === DATA_TYPE.number ? a.value : null,
+    date_value: a.dynamicDataType === DATA_TYPE.date ? getDateFormat(a.value) : null,
+    data_type: a.dynamicDataType,
+    created_at: createdAt,
+  }));
+
+  await sendMessages(messages, 'event_data');
+
+  return data;
+}