feat(be): extend departure endpoint

apps/backend/package.json

@@ -16,7 +16,7 @@
         "test:cov": "jest --coverage",
         "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
         "test:e2e": "jest --config ./e2e/jest-e2e.json",
-        "prisma:studio": "prisma studio",
+        "prisma:studio": "dotenv -e .env.local -- prisma studio",
         "prisma:generate": "prisma generate",
         "prisma:migrate:create": "dotenv -e .env.local -- prisma migrate dev",
         "prisma:migrate:deploy": "dotenv -e .env.local -- prisma migrate deploy",

apps/backend/src/app.module.ts

@@ -13,6 +13,7 @@ import { ImportModule } from "src/modules/import/import.module";
 import { LoggerModule } from "src/modules/logger/logger.module";
 import { PlatformModule } from "src/modules/platform/platform.module";
 import { PrismaModule } from "src/modules/prisma/prisma.module";
+import { StatusModule } from "src/modules/status/status.module";
 import { StopModule } from "src/modules/stop/stop.module";
 
 @Module({
@@ -23,6 +24,7 @@ import { StopModule } from "src/modules/stop/stop.module";
         StopModule,
         PrismaModule,
         LoggerModule,
+        StatusModule,
         ConfigModule.forRoot(configModuleConfig),
         ScheduleModule.forRoot(),
         CacheModule.registerAsync(cacheModuleConfig),

apps/backend/src/modules/departure/departure.controller.ts

@@ -10,12 +10,15 @@ import { ApiTags } from "@nestjs/swagger";
 import { z } from "zod";
 
 import { QUERY_IDS_COUNT_MAX } from "src/constants/constants";
+import { ApiQueries } from "src/decorators/swagger.decorator";
 import { DepartureService } from "src/modules/departure/departure.service";
 import {
     departureSchema,
     type DepartureSchema,
 } from "src/modules/departure/schema/departure.schema";
 import { LogInterceptor } from "src/modules/logger/log.interceptor";
+import { metroOnlySchema } from "src/schema/metro-only.schema";
+import { metroOnlyQuery } from "src/swagger/query.swagger";
 import { toArray } from "src/utils/array.utils";
 
 @ApiTags("departure")
@@ -24,6 +27,57 @@ import { toArray } from "src/utils/array.utils";
 export class DepartureController {
     constructor(private readonly departureService: DepartureService) {}
 
+    @Get()
+    @ApiQueries([
+        metroOnlyQuery,
+        {
+            name: "platform[]",
+            description: "Platform IDs",
+            type: String,
+            isArray: true,
+            allowEmptyValue: true,
+            required: false,
+        },
+        {
+            name: "stop[]",
+            description: "Stop IDs",
+            type: String,
+            isArray: true,
+            allowEmptyValue: true,
+            required: false,
+        },
+    ])
+    async getDepartures(@Query() query): Promise<DepartureSchema[]> {
+        const schema = z.object({
+            metroOnly: metroOnlySchema,
+            platform: z.string().array().optional().default([]),
+            stop: z.string().array().optional().default([]),
+        });
+        const parsed = schema.safeParse(query);
+        if (!parsed.success) {
+            throw new HttpException(
+                "Invalid query params",
+                HttpStatus.BAD_REQUEST,
+            );
+        }
+        const parsedQuery = parsed.data;
+
+        if (parsedQuery.platform.length + parsedQuery.stop.length === 0) {
+            throw new HttpException(
+                "At least one platform or stop ID must be provided",
+                HttpStatus.BAD_REQUEST,
+            );
+        }
+
+        const departures = await this.departureService.getDepartures({
+            stopIds: parsedQuery.stop,
+            platformIds: parsedQuery.platform,
+            metroOnly: parsedQuery.metroOnly,
+        });
+
+        return departureSchema.array().parse(departures);
+    }
+
     @Get("/platform")
     async getDeparturesByPlatform(@Query("id") id): Promise<DepartureSchema[]> {
         const platformSchema = z
@@ -40,9 +94,11 @@ export class DepartureController {
             );
         }
 
-        const departures = await this.departureService.getDeparturesByPlatform(
-            parsed.data,
-        );
+        const departures = await this.departureService.getDepartures({
+            stopIds: [],
+            platformIds: parsed.data,
+            metroOnly: false,
+        });
 
         return departureSchema.array().parse(departures);
     }

apps/backend/src/modules/departure/departure.service.ts

@@ -1,4 +1,5 @@
 import { HttpException, HttpStatus, Injectable } from "@nestjs/common";
+import { unique } from "radash";
 
 import { GOLEMIO_API } from "src/constants/golemio.const";
 import { departureBoardsSchema } from "src/modules/departure/schema/departure-boards.schema";
@@ -10,6 +11,84 @@ import { getDelayInSeconds } from "src/utils/delay";
 export class DepartureService {
     constructor(private prisma: PrismaService) {}
 
+    async getDepartures(args: {
+        stopIds: string[];
+        platformIds: string[];
+        metroOnly: boolean;
+    }): Promise<DepartureSchema[]> {
+        const dbPlatforms = (
+            await this.prisma.platform.findMany({
+                select: { id: true },
+                where: {
+                    id: { in: args.platformIds },
+                    ...(args.metroOnly ? { isMetro: true } : {}),
+                },
+            })
+        ).map((platform) => platform.id);
+        const stopPlatforms = (
+            await this.prisma.stop.findMany({
+                select: {
+                    platforms: {
+                        select: { id: true },
+                        where: { ...(args.metroOnly ? { isMetro: true } : {}) },
+                    },
+                },
+                where: { id: { in: args.stopIds } },
+            })
+        ).flatMap((stop) => stop.platforms.map((platform) => platform.id));
+        const allPlatformIds = unique([...dbPlatforms, ...stopPlatforms]).slice(
+            0,
+            100,
+        );
+
+        const searchParams = new URLSearchParams(
+            allPlatformIds
+                .map((id) => ["ids", id])
+                .concat([
+                    ["skip", "canceled"],
+                    ["mode", "departures"],
+                    ["order", "real"],
+                ]),
+        );
+
+        const url = new URL(
+            `${GOLEMIO_API}/v2/pid/departureboards?${searchParams.toString()}`,
+        );
+
+        const res = await fetch(url, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Access-Token": process.env.GOLEMIO_API_KEY ?? "",
+            },
+        });
+        if (!res.ok) {
+            throw new Error(
+                `Failed to fetch departure data: ${res.status} ${res.statusText}`,
+            );
+        }
+
+        const json = await res.json();
+        const parsed = departureBoardsSchema.safeParse(json);
+
+        if (!parsed.success) {
+            throw new Error(parsed.error.message);
+        }
+
+        const parsedDepartures = parsed.data.departures.map((departure) => {
+            return {
+                departure: departure.departure_timestamp,
+                delay: getDelayInSeconds(departure.delay),
+                headsign: departure.trip.headsign,
+                route: departure.route.short_name,
+                platformId: departure.stop.id,
+                platformCode: departure.stop.platform_code,
+            };
+        });
+
+        return parsedDepartures;
+    }
+
     async getDeparturesByPlatform(
         requestedIds: string[],
     ): Promise<DepartureSchema[]> {

apps/backend/src/modules/prisma/prisma.service.ts

@@ -19,4 +19,19 @@ export class PrismaService
     async onModuleDestroy() {
         await this.$disconnect();
     }
+
+    async getExtensions(): Promise<
+        {
+            oid: string | number;
+            extname: string;
+        }[]
+    > {
+        return await this.$queryRaw`SELECT * FROM pg_extension`;
+    }
+
+    async getExtensionNames(): Promise<string[]> {
+        const extensions = await this.getExtensions();
+
+        return extensions.map((ext) => ext.extname);
+    }
 }

apps/backend/src/modules/status/status.controller.ts

@@ -0,0 +1,85 @@
+import { Controller, Get } from "@nestjs/common";
+import { ApiResponse, ApiTags } from "@nestjs/swagger";
+
+import { ApiDescription } from "src/decorators/swagger.decorator";
+import { StatusService } from "src/modules/status/status.service";
+import {
+    StatusObject,
+    SystemStatus,
+    SystemStatusService,
+} from "src/modules/status/status.types";
+
+@ApiTags("status")
+@Controller("status")
+export class StatusController {
+    constructor(private readonly statusService: StatusService) {}
+
+    @Get()
+    @ApiDescription({
+        summary: "Backend status",
+    })
+    @ApiResponse({
+        status: 200,
+        isArray: true,
+        example: [
+            {
+                service: SystemStatusService.BACKEND,
+                status: SystemStatus.OK,
+            },
+            {
+                service: SystemStatusService.GEO_FUNCTIONS,
+                status: SystemStatus.OK,
+            },
+            {
+                service: SystemStatusService.DB_DATA,
+                status: SystemStatus.OK,
+            },
+        ],
+    })
+    async getBackendStatus(): Promise<StatusObject[]> {
+        return [
+            this.statusService.getBackendStatus(),
+            await this.statusService.getGeoFunctionsStatus(),
+            await this.statusService.getDbDataStatus(),
+        ];
+    }
+
+    @Get("/geo-functions")
+    @ApiDescription({ summary: "Geo functions status" })
+    @ApiResponse({
+        status: 200,
+        example: {
+            service: SystemStatusService.GEO_FUNCTIONS,
+            status: SystemStatus.OK,
+        },
+    })
+    async getPlatformsByDistance(): Promise<StatusObject> {
+        const geoFunctionsStatus =
+            await this.statusService.getGeoFunctionsStatus();
+
+        if (geoFunctionsStatus.status === "error") {
+            throw new Error("Geo functions status is not OK");
+        }
+
+        return geoFunctionsStatus;
+    }
+
+    @Get("/db-data")
+    @ApiDescription({ summary: "DB data status" })
+    @ApiResponse({
+        status: 200,
+        example: {
+            service: SystemStatusService.DB_DATA,
+            status: SystemStatus.OK,
+        },
+    })
+    async getDbDataStatus(): Promise<StatusObject> {
+        const dbStatus = await this.statusService.getDbDataStatus();
+
+        if (dbStatus.status === "error") {
+            throw new Error("DB data status is not OK");
+        }
+
+        return dbStatus;
+    }
+}

apps/backend/src/modules/status/status.module.ts

@@ -0,0 +1,11 @@
+import { Module } from "@nestjs/common";
+
+import { StatusController } from "src/modules/status/status.controller";
+import { StatusService } from "src/modules/status/status.service";
+
+@Module({
+    controllers: [StatusController],
+    providers: [StatusService],
+    imports: [],
+})
+export class StatusModule {}

apps/backend/src/modules/status/status.service.ts

@@ -0,0 +1,45 @@
+import { Injectable } from "@nestjs/common";
+
+import { PrismaService } from "src/modules/prisma/prisma.service";
+import {
+    StatusObject,
+    SystemStatus,
+    SystemStatusService,
+} from "src/modules/status/status.types";
+
+@Injectable()
+export class StatusService {
+    constructor(private prisma: PrismaService) {}
+
+    getBackendStatus(): StatusObject {
+        return {
+            service: SystemStatusService.BACKEND,
+            status: SystemStatus.OK,
+        };
+    }
+
+    async getGeoFunctionsStatus(): Promise<StatusObject> {
+        const extensionNames = await this.prisma.getExtensionNames();
+        const isOk =
+            extensionNames.includes("cube") &&
+            extensionNames.includes("earthdistance");
+
+        return {
+            service: SystemStatusService.GEO_FUNCTIONS,
+            status: isOk ? SystemStatus.OK : SystemStatus.ERROR,
+        };
+    }
+
+    async getDbDataStatus(): Promise<StatusObject> {
+        const stopCount = await this.prisma.stop.count();
+        const routeCount = await this.prisma.route.count();
+        const platformCount = await this.prisma.platform.count();
+
+        const isOk = stopCount > 0 && routeCount > 0 && platformCount > 0;
+
+        return {
+            service: SystemStatusService.DB_DATA,
+            status: isOk ? SystemStatus.OK : SystemStatus.ERROR,
+        };
+    }
+}

apps/backend/src/modules/status/status.types.ts

@@ -0,0 +1,15 @@
+export enum SystemStatusService {
+    BACKEND = "backend",
+    GEO_FUNCTIONS = "geo-functions",
+    DB_DATA = "db-data",
+}
+
+export enum SystemStatus {
+    OK = "ok",
+    ERROR = "error",
+}
+
+export type StatusObject = {
+    service: SystemStatusService;
+    status: SystemStatus;
+};