feat(be): route endpoint

Author: krystxf

apps/backend/src/app.module.ts

@@ -14,6 +14,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 { RouteModule } from "src/modules/route/route.module";
 import { StatusModule } from "src/modules/status/status.module";
 import { StopModule } from "src/modules/stop/stop.module";
 
@@ -27,6 +28,7 @@ import { StopModule } from "src/modules/stop/stop.module";
         LoggerModule,
         StatusModule,
         GtfsModule,
+        RouteModule,
         ConfigModule.forRoot(configModuleConfig),
         ScheduleModule.forRoot(),
         CacheModule.registerAsync(cacheModuleConfig),

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

@@ -8,11 +8,19 @@ export class GtfsController implements OnModuleInit {
     constructor(private readonly gtfsService: GtfsService) {}
 
     async onModuleInit(): Promise<void> {
-        await this.gtfsService.syncGtfsData();
+        try {
+            this.gtfsService.syncGtfsData();
+        } catch (error) {
+            console.error(error);
+        }
     }
 
     @Cron(CronExpression.EVERY_7_HOURS)
     async cronSyncStops(): Promise<void> {
-        await this.gtfsService.syncGtfsData();
+        try {
+            await this.gtfsService.syncGtfsData();
+        } catch (error) {
+            console.error(error);
+        }
     }
 }

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

@@ -0,0 +1,38 @@
+import { CacheInterceptor } from "@nestjs/cache-manager";
+import {
+    Controller,
+    Get,
+    HttpException,
+    HttpStatus,
+    Param,
+    UseInterceptors,
+    Version,
+} from "@nestjs/common";
+import { ApiParam, ApiTags } from "@nestjs/swagger";
+
+import { EndpointVersion } from "src/enums/endpoint-version";
+import { RouteService } from "src/modules/route/route.service";
+
+@ApiTags("route")
+@Controller("route")
+@UseInterceptors(CacheInterceptor)
+export class RouteController {
+    constructor(private readonly routeService: RouteService) {}
+
+    @Get(":id")
+    @Version([EndpointVersion.v1])
+    @ApiParam({
+        name: "id",
+        description: "Route ID",
+        required: true,
+        example: "L991",
+        type: "string",
+    })
+    async getRoute(@Param("id") id: unknown) {
+        if (typeof id !== "string") {
+            throw new HttpException("Missing route ID", HttpStatus.BAD_REQUEST);
+        }
+
+        return this.routeService.getRoute(id);
+    }
+}

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

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

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

@@ -0,0 +1,65 @@
+import { Injectable } from "@nestjs/common";
+import { group, unique } from "radash";
+
+import { platformSelect } from "src/modules/platform/platform.service";
+import { PrismaService } from "src/modules/prisma/prisma.service";
+
+const gtfsRouteSelect = {
+    id: true,
+    shortName: true,
+    longName: true,
+    isNight: true,
+    color: true,
+    url: true,
+    type: true,
+};
+
+const gtfsRouteStopSelect = {
+    directionId: true,
+    stopId: true,
+    stopSequence: true,
+};
+
+@Injectable()
+export class RouteService {
+    constructor(private prisma: PrismaService) {}
+
+    async getRoute(id: string) {
+        const route = await this.prisma.gtfsRoute.findFirst({
+            select: gtfsRouteSelect,
+            where: {
+                id,
+            },
+        });
+
+        const routeStops = await this.prisma.gtfsRouteStop.findMany({
+            select: gtfsRouteStopSelect,
+            where: {
+                routeId: id,
+            },
+            orderBy: {
+                stopSequence: "asc",
+            },
+        });
+
+        const stops = await this.prisma.platform.findMany({
+            select: platformSelect,
+            where: {
+                id: {
+                    in: unique(routeStops.map((item) => item.stopId)),
+                },
+            },
+        });
+
+        return {
+            ...route,
+            directions: group(
+                routeStops.map((routeStop) => ({
+                    ...routeStop,
+                    stop: stops.find((stop) => stop.id === routeStop.stopId),
+                })),
+                (item) => item.directionId,
+            ),
+        };
+    }
+}