feat: profile views

.infra/crons.ts

@@ -130,6 +130,14 @@ export const crons: Cron[] = [
     name: 'post-analytics-history-day-clickhouse',
     schedule: '3-59/5 * * * *',
   },
+  {
+    name: 'user-profile-analytics-clickhouse',
+    schedule: '7 */1 * * *',
+  },
+  {
+    name: 'user-profile-analytics-history-clickhouse',
+    schedule: '15 */1 * * *',
+  },
   {
     name: 'clean-zombie-opportunities',
     schedule: '30 6 * * *',

__tests__/cron/userProfileAnalyticsClickhouse.ts

@@ -0,0 +1,220 @@
+import { crons } from '../../src/cron/index';
+import { userProfileAnalyticsClickhouseCron as cron } from '../../src/cron/userProfileAnalyticsClickhouse';
+import {
+  expectSuccessfulCron,
+  mockClickhouseClientOnce,
+  mockClickhouseQueryJSONOnce,
+  saveFixtures,
+} from '../helpers';
+import { userProfileAnalyticsFixture } from '../fixture/userProfileAnalytics';
+import { usersFixture, plusUsersFixture } from '../fixture/user';
+import createOrGetConnection from '../../src/db';
+import type { DataSource } from 'typeorm';
+import { UserProfileAnalytics } from '../../src/entity/user/UserProfileAnalytics';
+import { User } from '../../src/entity/user/User';
+import { deleteRedisKey, getRedisHash } from '../../src/redis';
+import { generateStorageKey, StorageTopic } from '../../src/config';
+import { format, startOfToday } from 'date-fns';
+
+let con: DataSource;
+
+beforeAll(async () => {
+  con = await createOrGetConnection();
+});
+
+const cronConfigRedisKey = generateStorageKey(
+  StorageTopic.Cron,
+  cron.name,
+  'config',
+);
+
+beforeEach(async () => {
+  jest.clearAllMocks();
+  await deleteRedisKey(cronConfigRedisKey);
+  await saveFixtures(con, User, [...usersFixture, ...plusUsersFixture]);
+});
+
+const userIds = ['1', '2', '3', '4', '5'];
+
+describe('userProfileAnalyticsClickhouse cron', () => {
+  it('should be registered', () => {
+    const registeredWorker = crons.find((item) => item.name === cron.name);
+
+    expect(registeredWorker).toBeDefined();
+  });
+
+  it('should sync user profile analytics data', async () => {
+    const clickhouseClientMock = mockClickhouseClientOnce();
+
+    const queryJSONSpy = mockClickhouseQueryJSONOnce(
+      clickhouseClientMock,
+      userProfileAnalyticsFixture.map((item, index) => ({
+        ...item,
+        updatedAt: new Date(Date.now() + index * 1000).toISOString(),
+        id: userIds[index],
+      })),
+    );
+
+    const now = new Date();
+
+    await expectSuccessfulCron(cron);
+
+    expect(queryJSONSpy).toHaveBeenCalledTimes(1);
+    expect(queryJSONSpy).toHaveBeenCalledWith({
+      query: expect.stringContaining('SELECT'),
+      format: 'JSONEachRow',
+      query_params: {
+        lastRunAt: format(startOfToday(), 'yyyy-MM-dd HH:mm:ss'),
+      },
+    });
+
+    const userProfileAnalytics = await con
+      .getRepository(UserProfileAnalytics)
+      .find({
+        order: {
+          updatedAt: 'ASC',
+        },
+      });
+
+    expect(userProfileAnalytics.length).toBe(
+      userProfileAnalyticsFixture.length,
+    );
+
+    userProfileAnalytics.forEach((item, index) => {
+      expect(item).toEqual({
+        id: userIds[index],
+        updatedAt: expect.any(Date),
+        createdAt: expect.any(Date),
+        uniqueVisitors: userProfileAnalyticsFixture[index].uniqueVisitors,
+      } as UserProfileAnalytics);
+    });
+
+    const cronConfig = await getRedisHash(cronConfigRedisKey);
+
+    expect(cronConfig).toBeDefined();
+    expect(cronConfig.lastRunAt).toBeDefined();
+    expect(new Date(cronConfig.lastRunAt).getTime()).toBeGreaterThan(
+      now.getTime(),
+    );
+  });
+
+  it('should use lastRunAt from previous run', async () => {
+    let clickhouseClientMock = mockClickhouseClientOnce();
+
+    mockClickhouseQueryJSONOnce(
+      clickhouseClientMock,
+      userProfileAnalyticsFixture.map((item, index) => ({
+        ...item,
+        updatedAt: new Date(Date.now() + index * 1000).toISOString(),
+        id: userIds[index],
+      })),
+    );
+
+    await expectSuccessfulCron(cron);
+
+    const userProfileAnalytics = await con
+      .getRepository(UserProfileAnalytics)
+      .find({
+        order: {
+          updatedAt: 'ASC',
+        },
+      });
+
+    expect(userProfileAnalytics.length).toBe(
+      userProfileAnalyticsFixture.length,
+    );
+
+    userProfileAnalytics.forEach((item, index) => {
+      expect(item).toEqual({
+        id: userIds[index],
+        updatedAt: expect.any(Date),
+        createdAt: expect.any(Date),
+        uniqueVisitors: userProfileAnalyticsFixture[index].uniqueVisitors,
+      } as UserProfileAnalytics);
+    });
+
+    const lastCronConfig = await getRedisHash(cronConfigRedisKey);
+
+    clickhouseClientMock = mockClickhouseClientOnce();
+
+    const queryJSONSpy = mockClickhouseQueryJSONOnce(
+      clickhouseClientMock,
+      userProfileAnalyticsFixture.map((item, index) => ({
+        ...item,
+        updatedAt: new Date(Date.now() + index * 1000).toISOString(),
+        id: userIds[index],
+      })),
+    );
+
+    await expectSuccessfulCron(cron);
+
+    expect(queryJSONSpy).toHaveBeenCalledTimes(1);
+    expect(queryJSONSpy).toHaveBeenCalledWith({
+      query: expect.stringContaining('SELECT'),
+      format: 'JSONEachRow',
+      query_params: {
+        lastRunAt: format(
+          new Date(lastCronConfig.lastRunAt),
+          'yyyy-MM-dd HH:mm:ss',
+        ),
+      },
+    });
+
+    const cronConfig = await getRedisHash(cronConfigRedisKey);
+
+    expect(cronConfig).toBeDefined();
+    expect(cronConfig.lastRunAt).toBeDefined();
+    expect(new Date(cronConfig.lastRunAt).getTime()).toBeGreaterThan(
+      new Date(lastCronConfig.lastRunAt).getTime(),
+    );
+  });
+
+  it('should upsert user profile analytics data on repeated runs', async () => {
+    let clickhouseClientMock = mockClickhouseClientOnce();
+
+    mockClickhouseQueryJSONOnce(
+      clickhouseClientMock,
+      userProfileAnalyticsFixture.map((item, index) => ({
+        ...item,
+        updatedAt: new Date(Date.now() + index * 1000).toISOString(),
+        id: userIds[index],
+      })),
+    );
+
+    await expectSuccessfulCron(cron);
+
+    clickhouseClientMock = mockClickhouseClientOnce();
+
+    mockClickhouseQueryJSONOnce(
+      clickhouseClientMock,
+      userProfileAnalyticsFixture.map((item, index) => ({
+        ...item,
+        updatedAt: new Date(Date.now() + index * 1000).toISOString(),
+        id: userIds[index],
+        uniqueVisitors: item.uniqueVisitors + 100,
+      })),
+    );
+
+    await expectSuccessfulCron(cron);
+
+    const userProfileAnalytics = await con
+      .getRepository(UserProfileAnalytics)
+      .find({
+        select: ['id', 'uniqueVisitors'],
+        order: {
+          updatedAt: 'ASC',
+        },
+      });
+
+    expect(userProfileAnalytics.length).toBe(
+      userProfileAnalyticsFixture.length,
+    );
+
+    userProfileAnalytics.forEach((item, index) => {
+      expect(item).toEqual({
+        id: userIds[index],
+        uniqueVisitors: userProfileAnalyticsFixture[index].uniqueVisitors + 100,
+      } as UserProfileAnalytics);
+    });
+  });
+});