cleanup

atlas-metrics/app/api/data/dashboard/route.ts

@@ -1,24 +1,24 @@
-import {NextRequest, NextResponse} from "next/server";
+import { NextRequest, NextResponse } from "next/server";
 import {
-    ErrorResponse,
-    SearchParamDateOrUndefined,
-    SearchParamStringOrUndefined
+  ErrorResponse,
+  SearchParamDateOrUndefined,
+  SearchParamStringOrUndefined,
 } from "@lib/api-utils";
 import applicationContainer from "@server/applicationContainer";
 
 export async function GET(request: NextRequest) {
+  try {
+    const service = SearchParamStringOrUndefined(request.nextUrl.searchParams, "service");
+    const from = SearchParamDateOrUndefined(request.nextUrl.searchParams, "from");
+    const to = SearchParamDateOrUndefined(request.nextUrl.searchParams, "to");
     try {
-        const service = SearchParamStringOrUndefined(request.nextUrl.searchParams, "service");
-        const from = SearchParamDateOrUndefined(request.nextUrl.searchParams, "from");
-        const to = SearchParamDateOrUndefined(request.nextUrl.searchParams, "to");
-        try {
-            const metricsController = applicationContainer.getMetricsController();
-            const metrics = await metricsController.GetMetricsForDashboard(service, from, to);
-            return NextResponse.json(metrics, { status: 200 });
-        } catch (error) {
-            return ErrorResponse(error, 500);
-        }
+      const metricsController = applicationContainer.getMetricsController();
+      const metrics = await metricsController.GetMetricsForDashboard(service, from, to);
+      return NextResponse.json(metrics, { status: 200 });
     } catch (error) {
-        return ErrorResponse(error, 400);
+      return ErrorResponse(error, 500);
     }
-}
+  } catch (error) {
+    return ErrorResponse(error, 400);
+  }
+}

atlas-metrics/app/components/custom/DateRangePicker.tsx

@@ -49,7 +49,7 @@ export function DateRangePicker({ className }: React.HTMLAttributes<HTMLDivEleme
         <PopoverTrigger asChild>
           <Button
             id="date"
-            variant={"outline"}
+            variant="outline"
             className={cn(
               "w-[300px] justify-start text-left font-normal",
               !date && "text-muted-foreground",

atlas-metrics/app/dashboard/dashboard.tsx

@@ -1,12 +1,11 @@
 import { EndpointActivity } from "@components/custom/EndpointActivity";
 import { PieChartDonut } from "@components/custom/PieChartDonut";
 import { Menu } from "@components/custom/Menu";
-import {useEffect, useState} from "react";
-import {DashboardDataDAO, DashboardDataSchema} from "@server/domain/dao/dashboardData";
+import { useEffect, useState } from "react";
+import { DashboardDataDAO, DashboardDataSchema } from "@server/domain/dao/dashboardData";
 
 export default function Dashboard() {
-
-  const [metrics, setMetrics] = useState<DashboardDataDAO|undefined>(undefined);
+  const [metrics, setMetrics] = useState<DashboardDataDAO | undefined>(undefined);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
@@ -30,9 +29,9 @@ export default function Dashboard() {
     fetchMetrics().finally(() => setLoading(false));
   }, []);
 
-    if (loading) {
-        return <div>Loading...</div>;
-    }
+  if (loading) {
+    return <div>Loading...</div>;
+  }
 
   if (error) {
     return <p>Error: {error}</p>;

atlas-metrics/app/server/domain/dao/ChartDataItem.ts

@@ -1,4 +1,4 @@
-import {z} from "zod";
+import { z } from "zod";
 
 export interface ChartDataItemDAO {
   label: string;
@@ -15,6 +15,8 @@ export interface TimeSeriesChartDataItemDAO {
   [key: string]: number | string;
 }
 
-export const TimeSeriesChartDataItemSchema = z.object({
-  date: z.string(),
-}).catchall(z.union([z.number(), z.string()]));
+export const TimeSeriesChartDataItemSchema = z
+  .object({
+    date: z.string(),
+  })
+  .catchall(z.union([z.number(), z.string()]));

atlas-metrics/app/server/domain/dao/RequestTypes.ts

@@ -31,4 +31,4 @@ export function mapRequestTypeToCategory(requestType: RequestType): RequestCateg
     case RequestType.CONNECT:
       return RequestCategory.CONNECT;
   }
-}
+}

atlas-metrics/app/server/domain/dao/dashboardData.ts

@@ -1,13 +1,13 @@
 import {
-    EndpointActivityDashboardDAO,
-    EndpointActivityDashboardSchema
+  EndpointActivityDashboardDAO,
+  EndpointActivityDashboardSchema,
 } from "@server/domain/dao/endpointActivityDashboard";
-import {z} from "zod";
+import { z } from "zod";
 
 export interface DashboardDataDAO {
-    endpointActivity: EndpointActivityDashboardDAO;
+  endpointActivity: EndpointActivityDashboardDAO;
 }
 
 export const DashboardDataSchema = z.object({
-    endpointActivity: EndpointActivityDashboardSchema,
-});
+  endpointActivity: EndpointActivityDashboardSchema,
+});

atlas-metrics/app/server/domain/dao/endpointActivityBucket.ts

@@ -1,6 +1,6 @@
-import {z} from "zod";
-import {RequestType} from "@server/domain/dao/RequestTypes";
-import {z_stringOrDateToDate} from "@lib/zod-utils";
+import { z } from "zod";
+import { RequestType } from "@server/domain/dao/RequestTypes";
+import { z_stringOrDateToDate } from "@lib/zod-utils";
 
 export type EndpointActivityBucketDAO = {
   endpoint: string;

atlas-metrics/app/server/domain/dao/endpointActivityDashboard.ts

@@ -1,14 +1,19 @@
-import {z} from "zod";
-import {TimeSeriesChartDataItemDAO, TimeSeriesChartDataItemSchema, ChartDataItemDAO, ChartDataItemSchema} from "@server/domain/dao/ChartDataItem";
+import { z } from "zod";
+import {
+  TimeSeriesChartDataItemDAO,
+  TimeSeriesChartDataItemSchema,
+  ChartDataItemDAO,
+  ChartDataItemSchema,
+} from "@server/domain/dao/ChartDataItem";
 
 export interface EndpointActivityDashboardDAO {
-    timeSeries: TimeSeriesChartDataItemDAO[];
-    byType: ChartDataItemDAO[];
-    byCategory: ChartDataItemDAO[];
+  timeSeries: TimeSeriesChartDataItemDAO[];
+  byType: ChartDataItemDAO[];
+  byCategory: ChartDataItemDAO[];
 }
 
 export const EndpointActivityDashboardSchema = z.object({
-    timeSeries: TimeSeriesChartDataItemSchema.array(),
-    byType: ChartDataItemSchema.array(),
-    byCategory: ChartDataItemSchema.array(),
-});
+  timeSeries: TimeSeriesChartDataItemSchema.array(),
+  byType: ChartDataItemSchema.array(),
+  byCategory: ChartDataItemSchema.array(),
+});

atlas-metrics/app/server/domain/service/metrics.service.ts

@@ -2,7 +2,6 @@ import { IMetricsRepository } from "@server/domain/repository/metrics.repository
 import { EndpointActivityBucketDAO } from "@server/domain/dao/endpointActivityBucket";
 import { RequestType } from "@server/domain/dao/RequestTypes";
 import { EndpointActivityFullDAO } from "@server/domain/dao/endpointActivity";
-import {TimeSeriesChartDataItemDAO} from "@server/domain/dao/ChartDataItem";
 
 export interface IMetricsService {
   /**
@@ -105,11 +104,11 @@ export class MetricsServiceImpl implements IMetricsService {
       service,
       version,
       endpoint,
-        type,
-        from,
-        to,
+      type,
+      from,
+      to,
     );
-    const groupedData = new Map<string, { type: RequestType, date: Date; count: number }>();
+    const groupedData = new Map<string, { type: RequestType; date: Date; count: number }>();
 
     endpointActivity.forEach(({ endpoint, type, date }) => {
       const normalizedDate = new Date(date);
@@ -118,7 +117,7 @@ export class MetricsServiceImpl implements IMetricsService {
       const key = `${endpoint}_${type}_${normalizedDate.toISOString()}`;
 
       if (!groupedData.has(key)) {
-        groupedData.set(key, {type: type, date: normalizedDate, count: 0 });
+        groupedData.set(key, { type: type, date: normalizedDate, count: 0 });
       }
       groupedData.get(key)!.count += 1;
     });

atlas-metrics/app/server/infrastructure/influx/influx.ts

@@ -35,8 +35,8 @@ export class InfluxClient {
   public async collectRows(fluxQuery: string) {
     try {
       return await this.client.getQueryApi(this.org).collectRows(fluxQuery);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
     } catch (error) {
-      console.log(error);
       throw new Error("Failed to collect rows");
     }
   }

atlas-metrics/app/server/presentation/controller/metrics.controller.ts

@@ -1,11 +1,10 @@
 import { IMetricsService } from "@server/domain/service/metrics.service";
-import {DashboardDataDAO} from "@server/domain/dao/dashboardData";
-import {EndpointActivityBucketDAO} from "@server/domain/dao/endpointActivityBucket";
-import {TimeSeriesChartDataItemDAO, ChartDataItemDAO} from "@server/domain/dao/ChartDataItem";
-import {mapRequestTypeToCategory} from "@server/domain/dao/RequestTypes";
+import { DashboardDataDAO } from "@server/domain/dao/dashboardData";
+import { EndpointActivityBucketDAO } from "@server/domain/dao/endpointActivityBucket";
+import { TimeSeriesChartDataItemDAO, ChartDataItemDAO } from "@server/domain/dao/ChartDataItem";
+import { mapRequestTypeToCategory } from "@server/domain/dao/RequestTypes";
 
 export interface IMetricsController {
-
   /**
    * Get metrics for the dashboard.
    *
@@ -19,9 +18,19 @@ export interface IMetricsController {
 export class MetricsControllerImpl implements IMetricsController {
   constructor(private readonly metricsService: IMetricsService) {}
 
-  async GetMetricsForDashboard(service?: string, from?: Date, to?: Date) : Promise<DashboardDataDAO> {
-
-    const endpointActivityByDay = await this.metricsService.getEndpointActivityByDay(service, undefined, undefined, undefined, from, to);
+  async GetMetricsForDashboard(
+    service?: string,
+    from?: Date,
+    to?: Date,
+  ): Promise<DashboardDataDAO> {
+    const endpointActivityByDay = await this.metricsService.getEndpointActivityByDay(
+      service,
+      undefined,
+      undefined,
+      undefined,
+      from,
+      to,
+    );
 
     const timeSeries = this.transformEndpointActivityToChartData(endpointActivityByDay);
     const byType = this.transformEndpointActivityToTypeChartData(endpointActivityByDay);
@@ -36,7 +45,9 @@ export class MetricsControllerImpl implements IMetricsController {
     };
   }
 
-  private transformEndpointActivityToChartData(buckets: EndpointActivityBucketDAO[]): TimeSeriesChartDataItemDAO[] {
+  private transformEndpointActivityToChartData(
+    buckets: EndpointActivityBucketDAO[],
+  ): TimeSeriesChartDataItemDAO[] {
     const groupedByDate = new Map<string, TimeSeriesChartDataItemDAO>();
 
     buckets.forEach(({ endpoint, date, count }) => {
@@ -57,7 +68,9 @@ export class MetricsControllerImpl implements IMetricsController {
     return Array.from(groupedByDate.values());
   }
 
-  private transformEndpointActivityToTypeChartData(buckets: EndpointActivityBucketDAO[]): ChartDataItemDAO[] {
+  private transformEndpointActivityToTypeChartData(
+    buckets: EndpointActivityBucketDAO[],
+  ): ChartDataItemDAO[] {
     const groupedByType = new Map<string, number>();
 
     buckets.forEach(({ type, count }) => {
@@ -72,7 +85,9 @@ export class MetricsControllerImpl implements IMetricsController {
     return Array.from(groupedByType.entries()).map(([label, value]) => ({ label, value }));
   }
 
-  private transformEndpointActivityToCategoryChartData(buckets: EndpointActivityBucketDAO[]): ChartDataItemDAO[] {
+  private transformEndpointActivityToCategoryChartData(
+    buckets: EndpointActivityBucketDAO[],
+  ): ChartDataItemDAO[] {
     const groupedByCategory = new Map<string, number>();
 
     buckets.forEach(({ type, count }) => {