Fixed identify. Closes #3409

src/app/api/send/route.ts

@@ -187,26 +187,19 @@ export async function POST(request: Request) {
         websiteId,
         sessionId,
         visitId,
+        createdAt,
+
+        // Page
+        pageTitle: safeDecodeURIComponent(title),
+        hostname: hostname || urlDomain,
         urlPath: safeDecodeURI(urlPath),
         urlQuery,
-        utmSource,
-        utmMedium,
-        utmCampaign,
-        utmContent,
-        utmTerm,
         referrerPath: safeDecodeURI(referrerPath),
         referrerQuery,
         referrerDomain,
-        pageTitle: safeDecodeURIComponent(title),
+
-        gclid,
+        // Session
-        fbclid,
+        distinctId: id,
-        msclkid,
-        ttclid,
-        lifatid,
-        twclid,
-        eventName: name,
-        eventData: data,
-        hostname: hostname || urlDomain,
         browser,
         os,
         device,
@@ -215,24 +208,39 @@ export async function POST(request: Request) {
         country,
         region,
         city,
+
+        // Events
+        eventName: name,
+        eventData: data,
         tag,
-        distinctId: id,
+
-        createdAt,
+        // UTM
+        utmSource,
+        utmMedium,
+        utmCampaign,
+        utmContent,
+        utmTerm,
+
+        // Click IDs
+        gclid,
+        fbclid,
+        msclkid,
+        ttclid,
+        lifatid,
+        twclid,
       });
     }
 
     if (type === COLLECTION_TYPE.identify) {
-      if (!data) {
+      if (data) {
-        return badRequest('Data required.');
+        await saveSessionData({
+          websiteId,
+          sessionId,
+          sessionData: data,
+          distinctId: id,
+          createdAt,
+        });
       }
-
-      await saveSessionData({
-        websiteId,
-        sessionId,
-        sessionData: data,
-        distinctId: id,
-        createdAt,
-      });
     }
 
     const token = createToken({ websiteId, sessionId, visitId, iat }, secret());

src/queries/sql/events/saveEvent.ts

@@ -6,30 +6,23 @@ import prisma from '@/lib/prisma';
 import { uuid } from '@/lib/crypto';
 import { saveEventData } from './saveEventData';
 
-export async function saveEvent(args: {
+export interface SaveEventArgs {
   websiteId: string;
   sessionId: string;
   visitId: string;
+  createdAt?: Date;
+
+  // Page
+  pageTitle?: string;
+  hostname?: string;
   urlPath: string;
   urlQuery?: string;
-  utmSource?: string;
-  utmMedium?: string;
-  utmCampaign?: string;
-  utmContent?: string;
-  utmTerm?: string;
   referrerPath?: string;
   referrerQuery?: string;
   referrerDomain?: string;
-  pageTitle?: string;
+
-  gclid?: string;
+  // Session
-  fbclid?: string;
+  distinctId?: string;
-  msclkid?: string;
-  ttclid?: string;
-  lifatid?: string;
-  twclid?: string;
-  eventName?: string;
-  eventData?: any;
-  hostname?: string;
   browser?: string;
   os?: string;
   device?: string;
@@ -38,73 +31,65 @@ export async function saveEvent(args: {
   country?: string;
   region?: string;
   city?: string;
-  tag?: string;
-  distinctId?: string;
-  createdAt?: Date;
-}) {
-  return runQuery({
-    [PRISMA]: () => relationalQuery(args),
-    [CLICKHOUSE]: () => clickhouseQuery(args),
-  });
-}
 
-async function relationalQuery(data: {
+  // Events
-  websiteId: string;
+  eventName?: string;
-  sessionId: string;
+  eventData?: any;
-  visitId: string;
+  tag?: string;
-  urlPath: string;
+
-  urlQuery?: string;
+  // UTM
   utmSource?: string;
   utmMedium?: string;
   utmCampaign?: string;
   utmContent?: string;
   utmTerm?: string;
-  referrerPath?: string;
+
-  referrerQuery?: string;
+  // Click IDs
-  referrerDomain?: string;
   gclid?: string;
   fbclid?: string;
   msclkid?: string;
   ttclid?: string;
   lifatid?: string;
   twclid?: string;
-  pageTitle?: string;
+}
-  eventName?: string;
+
-  eventData?: any;
+export async function saveEvent(args: SaveEventArgs) {
-  tag?: string;
+  return runQuery({
-  hostname?: string;
+    [PRISMA]: () => relationalQuery(args),
-  createdAt?: Date;
+    [CLICKHOUSE]: () => clickhouseQuery(args),
-}) {
+  });
-  const {
+}
-    websiteId,
+
-    sessionId,
+async function relationalQuery({
-    visitId,
+  websiteId,
-    urlPath,
+  sessionId,
-    urlQuery,
+  visitId,
-    utmSource,
+  createdAt,
-    utmMedium,
+  pageTitle,
-    utmCampaign,
+  tag,
-    utmContent,
+  hostname,
-    utmTerm,
+  urlPath,
-    referrerPath,
+  urlQuery,
-    referrerQuery,
+  referrerPath,
-    referrerDomain,
+  referrerQuery,
-    eventName,
+  referrerDomain,
-    eventData,
+  eventName,
-    pageTitle,
+  eventData,
-    gclid,
+  utmSource,
-    fbclid,
+  utmMedium,
-    msclkid,
+  utmCampaign,
-    ttclid,
+  utmContent,
-    lifatid,
+  utmTerm,
-    twclid,
+  gclid,
-    tag,
+  fbclid,
-    hostname,
+  msclkid,
-    createdAt,
+  ttclid,
-  } = data;
+  lifatid,
+  twclid,
+}: SaveEventArgs) {
   const websiteEventId = uuid();
 
-  const websiteEvent = prisma.client.websiteEvent.create({
+  await prisma.client.websiteEvent.create({
     data: {
       id: websiteEventId,
       websiteId,
@@ -146,83 +131,49 @@ async function relationalQuery(data: {
       createdAt,
     });
   }
-
-  return websiteEvent;
 }
 
-async function clickhouseQuery(data: {
+async function clickhouseQuery({
-  websiteId: string;
+  websiteId,
-  sessionId: string;
+  sessionId,
-  visitId: string;
+  visitId,
-  urlPath: string;
+  distinctId,
-  urlQuery?: string;
+  createdAt,
-  utmSource?: string;
+  pageTitle,
-  utmMedium?: string;
+  browser,
-  utmCampaign?: string;
+  os,
-  utmContent?: string;
+  device,
-  utmTerm?: string;
+  screen,
-  referrerPath?: string;
+  language,
-  referrerQuery?: string;
+  country,
-  referrerDomain?: string;
+  region,
-  pageTitle?: string;
+  city,
-  gclid?: string;
+  tag,
-  fbclid?: string;
+  hostname,
-  msclkid?: string;
+  urlPath,
-  ttclid?: string;
+  urlQuery,
-  lifatid?: string;
+  referrerPath,
-  twclid?: string;
+  referrerQuery,
-  eventName?: string;
+  referrerDomain,
-  eventData?: any;
+  eventName,
-  hostname?: string;
+  eventData,
-  browser?: string;
+  utmSource,
-  os?: string;
+  utmMedium,
-  device?: string;
+  utmCampaign,
-  screen?: string;
+  utmContent,
-  language?: string;
+  utmTerm,
-  country?: string;
+  gclid,
-  region?: string;
+  fbclid,
-  city?: string;
+  msclkid,
-  tag?: string;
+  ttclid,
-  distinctId?: string;
+  lifatid,
-  createdAt?: Date;
+  twclid,
-}) {
+}: SaveEventArgs) {
-  const {
-    websiteId,
-    sessionId,
-    visitId,
-    urlPath,
-    urlQuery,
-    utmSource,
-    utmMedium,
-    utmCampaign,
-    utmContent,
-    utmTerm,
-    referrerPath,
-    referrerQuery,
-    referrerDomain,
-    gclid,
-    fbclid,
-    msclkid,
-    ttclid,
-    lifatid,
-    twclid,
-    pageTitle,
-    eventName,
-    eventData,
-    country,
-    region,
-    city,
-    tag,
-    distinctId,
-    createdAt,
-    ...args
-  } = data;
   const { insert, getUTCString } = clickhouse;
   const { sendMessage } = kafka;
   const eventId = uuid();
 
   const message = {
-    ...args,
     website_id: websiteId,
     session_id: sessionId,
     visit_id: visitId,
@@ -252,6 +203,12 @@ async function clickhouseQuery(data: {
     tag: tag,
     distinct_id: distinctId,
     created_at: getUTCString(createdAt),
+    browser,
+    os,
+    device,
+    screen,
+    language,
+    hostname,
   };
 
   if (kafka.enabled) {
@@ -271,6 +228,4 @@ async function clickhouseQuery(data: {
       createdAt,
     });
   }
-
-  return data;
 }

src/queries/sql/events/saveEventData.ts

@@ -1,4 +1,3 @@
-import { Prisma } from '@prisma/client';
 import { DATA_TYPE } from '@/lib/constants';
 import { uuid } from '@/lib/crypto';
 import { CLICKHOUSE, PRISMA, runQuery } from '@/lib/db';
@@ -8,7 +7,7 @@ import kafka from '@/lib/kafka';
 import prisma from '@/lib/prisma';
 import { DynamicData } from '@/lib/types';
 
-export async function saveEventData(data: {
+export interface SaveEventDataArgs {
   websiteId: string;
   eventId: string;
   sessionId?: string;
@@ -16,19 +15,16 @@ export async function saveEventData(data: {
   eventName?: string;
   eventData: DynamicData;
   createdAt?: Date;
-}) {
+}
+
+export async function saveEventData(data: SaveEventDataArgs) {
   return runQuery({
     [PRISMA]: () => relationalQuery(data),
     [CLICKHOUSE]: () => clickhouseQuery(data),
   });
 }
 
-async function relationalQuery(data: {
+async function relationalQuery(data: SaveEventDataArgs) {
-  websiteId: string;
-  eventId: string;
-  eventData: DynamicData;
-  createdAt?: Date;
-}): Promise<Prisma.BatchPayload> {
   const { websiteId, eventId, eventData, createdAt } = data;
 
   const jsonKeys = flattenJSON(eventData);
@@ -46,20 +42,12 @@ async function relationalQuery(data: {
     createdAt,
   }));
 
-  return prisma.client.eventData.createMany({
+  await prisma.client.eventData.createMany({
     data: flattenedData,
   });
 }
 
-async function clickhouseQuery(data: {
+async function clickhouseQuery(data: SaveEventDataArgs) {
-  websiteId: string;
-  eventId: string;
-  sessionId?: string;
-  urlPath?: string;
-  eventName?: string;
-  eventData: DynamicData;
-  createdAt?: Date;
-}) {
   const { websiteId, sessionId, eventId, urlPath, eventName, eventData, createdAt } = data;
 
   const { insert, getUTCString } = clickhouse;
@@ -88,6 +76,4 @@ async function clickhouseQuery(data: {
   } else {
     await insert('event_data', messages);
   }
-
-  return data;
 }

src/queries/sql/sessions/saveSessionData.ts

@@ -7,28 +7,29 @@ import { CLICKHOUSE, PRISMA, runQuery } from '@/lib/db';
 import kafka from '@/lib/kafka';
 import clickhouse from '@/lib/clickhouse';
 
-export async function saveSessionData(data: {
+export interface SaveSessionDataArgs {
   websiteId: string;
   sessionId: string;
   sessionData: DynamicData;
   distinctId?: string;
   createdAt?: Date;
-}) {
+}
+
+export async function saveSessionData(data: SaveSessionDataArgs) {
   return runQuery({
     [PRISMA]: () => relationalQuery(data),
     [CLICKHOUSE]: () => clickhouseQuery(data),
   });
 }
 
-export async function relationalQuery(data: {
+export async function relationalQuery({
-  websiteId: string;
+  websiteId,
-  sessionId: string;
+  sessionId,
-  sessionData: DynamicData;
+  sessionData,
-  distinctId?: string;
+  distinctId,
-  createdAt?: Date;
+  createdAt,
-}) {
+}: SaveSessionDataArgs) {
   const { client } = prisma;
-  const { websiteId, sessionId, sessionData, distinctId, createdAt } = data;
 
   const jsonKeys = flattenJSON(sessionData);
 
@@ -75,19 +76,15 @@ export async function relationalQuery(data: {
       });
     }
   }
-
-  return flattenedData;
 }
 
-async function clickhouseQuery(data: {
+async function clickhouseQuery({
-  websiteId: string;
+  websiteId,
-  sessionId: string;
+  sessionId,
-  sessionData: DynamicData;
+  sessionData,
-  distinctId?: string;
+  distinctId,
-  createdAt?: Date;
+  createdAt,
-}) {
+}: SaveSessionDataArgs) {
-  const { websiteId, sessionId, sessionData, distinctId, createdAt } = data;
-
   const { insert, getUTCString } = clickhouse;
   const { sendMessage } = kafka;
 
@@ -112,6 +109,4 @@ async function clickhouseQuery(data: {
   } else {
     await insert('session_data', messages);
   }
-
-  return data;
 }