Merge pull request #43 from krystxf/fix/be-swagger-mark-endpoints-as-…

…deprecated

refactor(be): mark old endpoints as deprecated in swagger

apps/backend/src/enums/endpoint-version.ts

@@ -1,3 +1,4 @@
 export enum EndpointVersion {
     v1 = "1",
+    v2 = "2",
 }

apps/backend/src/modules/departure/departure.service.ts → apps/backend/src/modules/departure/departure-v1.service.ts

@@ -8,7 +8,7 @@ import { PrismaService } from "src/modules/prisma/prisma.service";
 import { getDelayInSeconds } from "src/utils/delay";
 
 @Injectable()
-export class DepartureService {
+export class DepartureServiceV1 {
     constructor(
         private prisma: PrismaService,
         private golemioService: GolemioService,
@@ -53,15 +53,18 @@ export class DepartureService {
         const searchParams = new URLSearchParams(
             allPlatformIds
                 .map((id) => ["ids", id])
-                .concat([
-                    ["skip", "canceled"],
-                    ["mode", "departures"],
-                    ["order", "real"],
-                ]),
+                .concat(
+                    Object.entries({
+                        skip: "canceled",
+                        mode: "departures",
+                        order: "real",
+                        minutesAfter: String(24 * 60),
+                    }),
+                ),
         );
 
         const res = await this.golemioService.getGolemioData(
-            `/v2/pid/departureboards?minutesAfter=600&${searchParams.toString()}`,
+            `/v2/pid/departureboards?${searchParams}`,
         );
 
         if (!res.ok) {

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

@@ -0,0 +1,97 @@
+import { Injectable } from "@nestjs/common";
+import { unique } from "radash";
+
+import { departureBoardsSchema } from "src/modules/departure/schema/departure-boards.schema";
+import type { DepartureSchema } from "src/modules/departure/schema/departure.schema";
+import { GolemioService } from "src/modules/golemio/golemio.service";
+import { PrismaService } from "src/modules/prisma/prisma.service";
+import { getDelayInSeconds } from "src/utils/delay";
+
+@Injectable()
+export class DepartureServiceV2 {
+    constructor(
+        private prisma: PrismaService,
+        private golemioService: GolemioService,
+    ) {}
+
+    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,
+        );
+
+        if (allPlatformIds.length === 0) {
+            return [];
+        }
+
+        const searchParams = new URLSearchParams(
+            allPlatformIds
+                .map((id) => ["ids", id])
+                .concat(
+                    Object.entries({
+                        skip: "canceled",
+                        mode: "departures",
+                        order: "real",
+                        minutesBefore: String(5),
+                        minutesAfter: String(10 * 60),
+                    }),
+                ),
+        );
+
+        const res = await this.golemioService.getGolemioData(
+            `/v2/pid/departureboards&${searchParams.toString()}`,
+        );
+
+        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;
+    }
+}

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

@@ -9,13 +9,14 @@ import {
     Version,
     VERSION_NEUTRAL,
 } from "@nestjs/common";
-import { ApiTags } from "@nestjs/swagger";
+import { ApiOperation, 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 { ApiDescription, ApiQueries } from "src/decorators/swagger.decorator";
 import { EndpointVersion } from "src/enums/endpoint-version";
-import { DepartureService } from "src/modules/departure/departure.service";
+import { DepartureServiceV1 } from "src/modules/departure/departure-v1.service";
+import { DepartureServiceV2 } from "src/modules/departure/departure-v2.service";
 import {
     departureSchema,
     type DepartureSchema,
@@ -30,10 +31,13 @@ import { toArray } from "src/utils/array.utils";
 @UseInterceptors(CacheInterceptor, LogInterceptor)
 @CacheTTL(4 * 1000)
 export class DepartureController {
-    constructor(private readonly departureService: DepartureService) {}
+    constructor(
+        private readonly departureServiceV1: DepartureServiceV1,
+        private readonly departureServiceV2: DepartureServiceV2,
+    ) {}
 
     @Get()
-    @Version([VERSION_NEUTRAL, EndpointVersion.v1])
+    @Version([VERSION_NEUTRAL])
     @ApiQueries([
         metroOnlyQuery,
         {
@@ -53,6 +57,12 @@ export class DepartureController {
             required: false,
         },
     ])
+    @ApiOperation({
+        deprecated: true,
+    })
+    @ApiDescription({
+        deprecated: true,
+    })
     async getDepartures(@Query() query): Promise<DepartureSchema[]> {
         const schema = z.object({
             metroOnly: metroOnlySchema,
@@ -75,7 +85,59 @@ export class DepartureController {
             );
         }
 
-        const departures = await this.departureService.getDepartures({
+        const departures = await this.departureServiceV1.getDepartures({
+            stopIds: parsedQuery.stop,
+            platformIds: parsedQuery.platform,
+            metroOnly: parsedQuery.metroOnly,
+        });
+
+        return departureSchema.array().parse(departures);
+    }
+
+    @Get()
+    @Version([EndpointVersion.v1])
+    @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 getDeparturesV1(@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.departureServiceV1.getDepartures({
             stopIds: parsedQuery.stop,
             platformIds: parsedQuery.platform,
             metroOnly: parsedQuery.metroOnly,
@@ -86,6 +148,9 @@ export class DepartureController {
 
     @Get("/platform")
     @Version([VERSION_NEUTRAL, EndpointVersion.v1])
+    @ApiDescription({
+        deprecated: true,
+    })
     async getDeparturesByPlatform(@Query("id") id): Promise<DepartureSchema[]> {
         const platformSchema = z
             .string()
@@ -101,12 +166,64 @@ export class DepartureController {
             );
         }
 
-        const departures = await this.departureService.getDepartures({
+        const departures = await this.departureServiceV1.getDepartures({
             stopIds: [],
             platformIds: parsed.data,
             metroOnly: false,
         });
 
         return departureSchema.array().parse(departures);
     }
+
+    @Get()
+    @Version([EndpointVersion.v2])
+    @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 getDeparturesV2(@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.departureServiceV2.getDepartures({
+            stopIds: parsedQuery.stop,
+            platformIds: parsedQuery.platform,
+            metroOnly: parsedQuery.metroOnly,
+        });
+
+        return departureSchema.array().parse(departures);
+    }
 }

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

@@ -1,12 +1,13 @@
 import { Module } from "@nestjs/common";
 
+import { DepartureServiceV1 } from "src/modules/departure/departure-v1.service";
+import { DepartureServiceV2 } from "src/modules/departure/departure-v2.service";
 import { DepartureController } from "src/modules/departure/departure.controller";
-import { DepartureService } from "src/modules/departure/departure.service";
 import { GolemioService } from "src/modules/golemio/golemio.service";
 
 @Module({
     controllers: [DepartureController],
-    providers: [DepartureService, GolemioService],
+    providers: [DepartureServiceV1, DepartureServiceV2, GolemioService],
     imports: [],
 })
 export class DepartureModule {}