Add register analytics dashboard service and self-initializing registry infrastructure (#2015)

Fixes OPS-3554.

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: cezudas

packages/server/api/src/app/openops-analytics/analytics-dashboard-registry-service.ts

@@ -0,0 +1,78 @@
+import { fetchFinopsDashboardEmbedDetails } from '@openops/common';
+import { logger } from '@openops/server-shared';
+import {
+  AnalyticsDashboard,
+  AnalyticsDashboardRegistry,
+  FlagId,
+  OPENOPS_ANALYTICS_FINOPS_SLUG,
+} from '@openops/shared';
+import { databaseConnection } from '../database/database-connection';
+import { FlagEntity } from '../flags/flag.entity';
+
+async function saveAnalyticsDashboardRegistry(
+  registry: AnalyticsDashboardRegistry,
+): Promise<void> {
+  const flagRepo = databaseConnection().getRepository(FlagEntity);
+  await flagRepo.save({ id: FlagId.ANALYTICS_DASHBOARDS, value: registry });
+}
+
+async function getAnalyticsDashboardRegistry(): Promise<
+  AnalyticsDashboardRegistry | undefined
+> {
+  const flagRepo = databaseConnection().getRepository(FlagEntity);
+  const flag = await flagRepo.findOneBy({ id: FlagId.ANALYTICS_DASHBOARDS });
+  return flag?.value as AnalyticsDashboardRegistry | undefined;
+}
+
+async function buildFinopsDashboardRegistryEntry(
+  accessToken: string,
+): Promise<AnalyticsDashboard> {
+  const {
+    result: { uuid: embedId },
+  } = await fetchFinopsDashboardEmbedDetails(accessToken);
+  return {
+    id: OPENOPS_ANALYTICS_FINOPS_SLUG,
+    name: 'FinOps',
+    slug: OPENOPS_ANALYTICS_FINOPS_SLUG,
+    embedId,
+    enabled: true,
+  };
+}
+
+export async function upsertDashboard(
+  entry: AnalyticsDashboard,
+  accessToken: string,
+): Promise<void> {
+  const registry = await getAnalyticsDashboardRegistry();
+
+  if (!registry) {
+    const finopsEntry = await buildFinopsDashboardRegistryEntry(accessToken);
+    const dashboards =
+      entry.id === OPENOPS_ANALYTICS_FINOPS_SLUG
+        ? [entry]
+        : [finopsEntry, entry];
+    await saveAnalyticsDashboardRegistry({
+      dashboards,
+      defaultDashboardId: OPENOPS_ANALYTICS_FINOPS_SLUG,
+    });
+
+    logger.info('Analytics dashboard registry created', {
+      dashboardId: entry.id,
+    });
+
+    return;
+  }
+
+  const existingIndex = registry.dashboards.findIndex((d) => d.id === entry.id);
+  if (existingIndex >= 0) {
+    registry.dashboards[existingIndex] = entry;
+  } else {
+    registry.dashboards.push(entry);
+  }
+
+  await saveAnalyticsDashboardRegistry(registry);
+
+  logger.info('Updated analytics dashboard registry', {
+    dashboardId: entry.id,
+  });
+}

packages/server/api/test/unit/openops-analytics/analytics-dashboard-registry-service.test.ts

@@ -0,0 +1,188 @@
+const mockFlagRepo = {
+  findOneBy: jest.fn(),
+  save: jest.fn(),
+};
+
+const mockDatabaseConnection = {
+  getRepository: jest.fn().mockReturnValue(mockFlagRepo),
+};
+
+jest.mock('../../../src/app/database/database-connection', () => ({
+  databaseConnection: jest.fn().mockReturnValue(mockDatabaseConnection),
+}));
+
+jest.mock('@openops/server-shared', () => {
+  const originalModule = jest.requireActual('@openops/server-shared');
+  return {
+    __esModule: true,
+    ...originalModule,
+    logger: {
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+    },
+    system: {
+      ...originalModule.system,
+      getBoolean: jest.fn(() => true),
+    },
+  };
+});
+
+const mockFetchFinopsDashboardEmbedDetails = jest.fn();
+jest.mock('@openops/common', () => ({
+  fetchFinopsDashboardEmbedDetails: mockFetchFinopsDashboardEmbedDetails,
+}));
+
+import { AnalyticsDashboard } from '@openops/shared';
+import { upsertDashboard } from '../../../src/app/openops-analytics/analytics-dashboard-registry-service';
+
+const ACCESS_TOKEN = 'test-access-token';
+
+const mockFinopsEntry: AnalyticsDashboard = {
+  id: 'finops',
+  name: 'FinOps',
+  slug: 'finops',
+  embedId: 'finops-embed-uuid',
+  enabled: true,
+};
+
+const mockEntry: AnalyticsDashboard = {
+  id: 'aws_benchmark',
+  name: 'AWS Benchmark',
+  slug: 'aws_benchmark',
+  embedId: 'benchmark-uuid',
+  enabled: true,
+};
+
+describe('upsertDashboard', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFetchFinopsDashboardEmbedDetails.mockResolvedValue({
+      result: { uuid: 'finops-embed-uuid' },
+    });
+  });
+
+  it('creates a new registry with finops as default and the entry when registry does not exist', async () => {
+    mockFlagRepo.findOneBy.mockResolvedValue(null);
+
+    await upsertDashboard(mockEntry, ACCESS_TOKEN);
+
+    expect(mockFetchFinopsDashboardEmbedDetails).toHaveBeenCalledWith(
+      ACCESS_TOKEN,
+    );
+    expect(mockFlagRepo.save).toHaveBeenCalledTimes(1);
+    expect(mockFlagRepo.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        value: {
+          dashboards: [mockFinopsEntry, mockEntry],
+          defaultDashboardId: 'finops',
+        },
+      }),
+    );
+  });
+
+  it('updates an existing dashboard entry in the registry without fetching finops', async () => {
+    const updatedEntry: AnalyticsDashboard = {
+      ...mockEntry,
+      embedId: 'new-uuid',
+    };
+    mockFlagRepo.findOneBy.mockResolvedValue({
+      id: 'analytics-dashboards',
+      value: {
+        dashboards: [mockFinopsEntry, mockEntry],
+        defaultDashboardId: 'finops',
+      },
+    });
+
+    await upsertDashboard(updatedEntry, ACCESS_TOKEN);
+
+    expect(mockFetchFinopsDashboardEmbedDetails).not.toHaveBeenCalled();
+    expect(mockFlagRepo.save).toHaveBeenCalledTimes(1);
+    expect(mockFlagRepo.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        value: {
+          dashboards: [mockFinopsEntry, updatedEntry],
+          defaultDashboardId: 'finops',
+        },
+      }),
+    );
+  });
+
+  it('updates only the matching dashboard and leaves other dashboards unchanged', async () => {
+    const otherDashboard: AnalyticsDashboard = {
+      id: 'other',
+      name: 'Other Dashboard',
+      slug: 'other',
+      embedId: 'other-uuid',
+      enabled: true,
+    };
+    const updatedEntry: AnalyticsDashboard = {
+      ...mockEntry,
+      embedId: 'new-uuid',
+    };
+    mockFlagRepo.findOneBy.mockResolvedValue({
+      id: 'analytics-dashboards',
+      value: {
+        dashboards: [mockEntry, otherDashboard],
+        defaultDashboardId: mockEntry.id,
+      },
+    });
+
+    await upsertDashboard(updatedEntry, ACCESS_TOKEN);
+
+    expect(mockFlagRepo.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        value: {
+          dashboards: [updatedEntry, otherDashboard],
+          defaultDashboardId: mockEntry.id,
+        },
+      }),
+    );
+  });
+
+  it('creates a registry with only one entry when the entry is the FinOps dashboard', async () => {
+    mockFlagRepo.findOneBy.mockResolvedValue(null);
+
+    await upsertDashboard(mockFinopsEntry, ACCESS_TOKEN);
+
+    expect(mockFlagRepo.save).toHaveBeenCalledTimes(1);
+    expect(mockFlagRepo.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        value: {
+          dashboards: [mockFinopsEntry],
+          defaultDashboardId: 'finops',
+        },
+      }),
+    );
+  });
+
+  it('appends a new dashboard entry to an existing registry without fetching finops', async () => {
+    const otherEntry: AnalyticsDashboard = {
+      id: 'other',
+      name: 'Other Dashboard',
+      slug: 'other',
+      embedId: 'other-uuid',
+      enabled: true,
+    };
+    mockFlagRepo.findOneBy.mockResolvedValue({
+      id: 'analytics-dashboards',
+      value: {
+        dashboards: [mockFinopsEntry, mockEntry],
+        defaultDashboardId: 'finops',
+      },
+    });
+
+    await upsertDashboard(otherEntry, ACCESS_TOKEN);
+
+    expect(mockFetchFinopsDashboardEmbedDetails).not.toHaveBeenCalled();
+    expect(mockFlagRepo.save).toHaveBeenCalledTimes(1);
+    expect(mockFlagRepo.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        value: {
+          dashboards: [mockFinopsEntry, mockEntry, otherEntry],
+          defaultDashboardId: 'finops',
+        },
+      }),
+    );
+  });
+});