@vulog/aima-booking 1.1.87 → 1.1.89

package/dist/index.d.mts

@@ -104,6 +104,47 @@ type SATBookingRequest = BaseBookingRequest & {
     trip: any | null;
     warning: string | null;
 };
+type GeoInfo = {
+    name: string;
+    coordinates: {
+        latitude: number;
+        longitude: number;
+    };
+    geoProperties: {
+        [key: string]: any;
+    };
+};
+type Service = {
+    id: string;
+    models: {
+        id: number;
+        vehicles: string[];
+    }[];
+};
+type ServiceInfo = {
+    services: Service[];
+};
+type Days = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
+type DayOpeningHours = {
+    id: number;
+    closed: boolean;
+    openAt: string;
+    closeAt: string;
+};
+type Timetable = Record<Days, DayOpeningHours[]>;
+type OpeningHours = {
+    alwaysOpen: boolean;
+    timetable: Timetable;
+};
+type Station = Partial<GeoInfo> & Partial<ServiceInfo> & {
+    id: string;
+    zoneId: string;
+    poiId: string;
+    modificationDate: string;
+    fleetId: string;
+    openingHours?: OpeningHours;
+    [key: string]: any;
+};
 
 declare const BookingRequestStatusSchema: z.ZodEnum<["ALERT", "UPCOMING", "ONGOING", "COMPLETED", "CANCELLED", "PENDING_APPROVAL"]>;
 type BookingRequestStatus = z.infer<typeof BookingRequestStatusSchema>;
@@ -146,49 +187,12 @@ declare const getBookingRequestById: (client: Client, id: string) => Promise<Boo
 declare const getBookingRequestByTrip: (client: Client, tripId: string) => Promise<BookingRequest>;
 declare const getSubscriptionBookingRequestById: (client: Client, id: string) => Promise<BookingRequest>;
 
-declare const IncludeSchema: z.ZodEnum<["INFO", "OPEN_HOUR", "SERVICES"]>;
-type Include = z.infer<typeof IncludeSchema>;
-type Days = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
-type DayOpeningHours = {
-    id: number;
-    closed: boolean;
-    openAt: string;
-    closeAt: string;
-};
-type Timetable = Record<Days, DayOpeningHours[]>;
-type OpeningHours = {
-    alwaysOpen: boolean;
-    timetable: Timetable;
-};
-type GeoInfo = {
-    name: string;
-    coordinates: {
-        latitude: number;
-        longitude: number;
-    };
-    geoProperties: {
-        [key: string]: any;
-    };
-};
-type Service = {
-    id: string;
-    models: {
-        id: number;
-        vehicles: string[];
-    }[];
-};
-type ServiceInfo = {
-    services: Service[];
-};
-type Station = Partial<GeoInfo> & Partial<ServiceInfo> & {
-    id: string;
-    zoneId: string;
-    poiId: string;
-    modificationDate: string;
-    fleetId: string;
-    openingHours?: OpeningHours;
-    [key: string]: any;
-};
+declare const IncludeSchema$1: z.ZodEnum<["INFO", "OPEN_HOUR", "SERVICES"]>;
+type Include = z.infer<typeof IncludeSchema$1>;
 declare const getStations: (client: Client, includes?: Include[]) => Promise<Station[]>;
 
-export { type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type DayOpeningHours, type Days, type Include, type OpeningHours, type SATBookingRequestStatus, type ServiceType, type Station, type Timetable, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };
+declare const IncludeSchema: z.ZodEnum<["INFO", "SERVICES"]>;
+type IncludeStation = z.infer<typeof IncludeSchema>;
+declare const getStationById: (client: Client, id: string, includes?: IncludeStation[]) => Promise<Station | null>;
+
+export { type BaseBookingRequest, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };

package/dist/index.d.ts

@@ -104,6 +104,47 @@ type SATBookingRequest = BaseBookingRequest & {
     trip: any | null;
     warning: string | null;
 };
+type GeoInfo = {
+    name: string;
+    coordinates: {
+        latitude: number;
+        longitude: number;
+    };
+    geoProperties: {
+        [key: string]: any;
+    };
+};
+type Service = {
+    id: string;
+    models: {
+        id: number;
+        vehicles: string[];
+    }[];
+};
+type ServiceInfo = {
+    services: Service[];
+};
+type Days = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
+type DayOpeningHours = {
+    id: number;
+    closed: boolean;
+    openAt: string;
+    closeAt: string;
+};
+type Timetable = Record<Days, DayOpeningHours[]>;
+type OpeningHours = {
+    alwaysOpen: boolean;
+    timetable: Timetable;
+};
+type Station = Partial<GeoInfo> & Partial<ServiceInfo> & {
+    id: string;
+    zoneId: string;
+    poiId: string;
+    modificationDate: string;
+    fleetId: string;
+    openingHours?: OpeningHours;
+    [key: string]: any;
+};
 
 declare const BookingRequestStatusSchema: z.ZodEnum<["ALERT", "UPCOMING", "ONGOING", "COMPLETED", "CANCELLED", "PENDING_APPROVAL"]>;
 type BookingRequestStatus = z.infer<typeof BookingRequestStatusSchema>;
@@ -146,49 +187,12 @@ declare const getBookingRequestById: (client: Client, id: string) => Promise<Boo
 declare const getBookingRequestByTrip: (client: Client, tripId: string) => Promise<BookingRequest>;
 declare const getSubscriptionBookingRequestById: (client: Client, id: string) => Promise<BookingRequest>;
 
-declare const IncludeSchema: z.ZodEnum<["INFO", "OPEN_HOUR", "SERVICES"]>;
-type Include = z.infer<typeof IncludeSchema>;
-type Days = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
-type DayOpeningHours = {
-    id: number;
-    closed: boolean;
-    openAt: string;
-    closeAt: string;
-};
-type Timetable = Record<Days, DayOpeningHours[]>;
-type OpeningHours = {
-    alwaysOpen: boolean;
-    timetable: Timetable;
-};
-type GeoInfo = {
-    name: string;
-    coordinates: {
-        latitude: number;
-        longitude: number;
-    };
-    geoProperties: {
-        [key: string]: any;
-    };
-};
-type Service = {
-    id: string;
-    models: {
-        id: number;
-        vehicles: string[];
-    }[];
-};
-type ServiceInfo = {
-    services: Service[];
-};
-type Station = Partial<GeoInfo> & Partial<ServiceInfo> & {
-    id: string;
-    zoneId: string;
-    poiId: string;
-    modificationDate: string;
-    fleetId: string;
-    openingHours?: OpeningHours;
-    [key: string]: any;
-};
+declare const IncludeSchema$1: z.ZodEnum<["INFO", "OPEN_HOUR", "SERVICES"]>;
+type Include = z.infer<typeof IncludeSchema$1>;
 declare const getStations: (client: Client, includes?: Include[]) => Promise<Station[]>;
 
-export { type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type DayOpeningHours, type Days, type Include, type OpeningHours, type SATBookingRequestStatus, type ServiceType, type Station, type Timetable, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };
+declare const IncludeSchema: z.ZodEnum<["INFO", "SERVICES"]>;
+type IncludeStation = z.infer<typeof IncludeSchema>;
+declare const getStationById: (client: Client, id: string, includes?: IncludeStation[]) => Promise<Station | null>;
+
+export { type BaseBookingRequest, type BookingRequest, type BookingRequestFilters, type BookingRequestStatus, type CustomPrice, type DayOpeningHours, type Days, type GeoInfo, type Include, type IncludeStation, type OpeningHours, type PaymentReceipts, type SATBookingRequest, type SATBookingRequestStatus, type Service, type ServiceInfo, type ServiceType, type Station, type Timetable, getBookingRequestById, getBookingRequestByTrip, getBookingRequests, getSATBookingRequests, getScheduleBookingRequests, getStationById, getStations, getSubscriptionBookingRequestById, getSubscriptionBookingRequests };

package/dist/index.js

@@ -25,6 +25,7 @@ __export(index_exports, {
   getBookingRequests: () => getBookingRequests,
   getSATBookingRequests: () => getSATBookingRequests,
   getScheduleBookingRequests: () => getScheduleBookingRequests,
+  getStationById: () => getStationById,
   getStations: () => getStations,
   getSubscriptionBookingRequestById: () => getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests: () => getSubscriptionBookingRequests
@@ -304,6 +305,110 @@ var getStations = async (client, includes = []) => {
   }
   return stations;
 };
+
+// src/getStation.ts
+var import_zod5 = require("zod");
+var IncludeSchema2 = import_zod5.z.enum(["INFO", "SERVICES"]);
+var IncludesSchema2 = import_zod5.z.array(IncludeSchema2);
+var getStationById = async (client, id, includes = []) => {
+  const resultIncludes = IncludesSchema2.safeParse(includes);
+  if (!resultIncludes.success) {
+    throw new TypeError("Invalid includes", {
+      cause: resultIncludes.error.issues
+    });
+  }
+  const station = await client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/${id}`).then(({ data, status }) => {
+    if (status === 200) {
+      return Object.keys(data).reduce((acc, key) => {
+        if (key === "stationTimetableDTO") {
+          if (data.stationTimetableDTO?.stationId) {
+            acc.openingHours = {
+              alwaysOpen: data.stationTimetableDTO.alwaysOpen,
+              timetable: Object.keys(data.stationTimetableDTO.timetable).reduce(
+                (timetable, val) => {
+                  timetable[val] = data.stationTimetableDTO.timetable[val].map(
+                    (day) => ({
+                      id: day.id,
+                      closed: day.closed,
+                      openAt: day.openAt,
+                      closeAt: day.closeAt
+                    })
+                  );
+                  return timetable;
+                },
+                {}
+              )
+            };
+          }
+          return acc;
+        }
+        acc[key] = data[key];
+        return acc;
+      }, {});
+    }
+    if (status === 400) {
+      return null;
+    }
+    return null;
+  }).catch((error) => {
+    if (error.formattedError?.status === 400) {
+      return null;
+    }
+    throw error;
+  });
+  if (station && includes.includes("INFO")) {
+    const poi = await client.get(
+      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+      {
+        headers: { accept: "application/vnd.geo+json" }
+      }
+    ).then(
+      ({ data }) => data.features.reduce(
+        (max, current) => {
+          if (current.properties.Version > max.version) {
+            const {
+              geometry: {
+                coordinates: [longitude, latitude]
+              },
+              properties
+            } = current;
+            return {
+              version: current.properties.Version,
+              name: properties.name,
+              coordinates: { latitude, longitude },
+              geoProperties: properties
+            };
+          }
+          return max;
+        },
+        { version: -1 }
+      )
+    );
+    if (station.poiId && poi) {
+      poi.version = void 0;
+      Object.assign(station, poi);
+      station.name = station.geoProperties?.name;
+    }
+  }
+  if (station && includes.includes("SERVICES")) {
+    const services = await client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/details?showTimetable=false`).then(
+      ({ data }) => data.stations.reduce((acc, service) => {
+        if (!acc[service.station.id]) {
+          acc[service.station.id] = { services: [] };
+        }
+        acc[service.station.id].services.push({
+          id: service.serviceId,
+          models: service.station.models
+        });
+        return acc;
+      }, {})
+    );
+    if (services[station.id]) {
+      Object.assign(station, services[station.id]);
+    }
+  }
+  return station;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getBookingRequestById,
@@ -311,6 +416,7 @@ var getStations = async (client, includes = []) => {
   getBookingRequests,
   getSATBookingRequests,
   getScheduleBookingRequests,
+  getStationById,
   getStations,
   getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests

package/dist/index.mjs

@@ -271,12 +271,117 @@ var getStations = async (client, includes = []) => {
   }
   return stations;
 };
+
+// src/getStation.ts
+import { z as z5 } from "zod";
+var IncludeSchema2 = z5.enum(["INFO", "SERVICES"]);
+var IncludesSchema2 = z5.array(IncludeSchema2);
+var getStationById = async (client, id, includes = []) => {
+  const resultIncludes = IncludesSchema2.safeParse(includes);
+  if (!resultIncludes.success) {
+    throw new TypeError("Invalid includes", {
+      cause: resultIncludes.error.issues
+    });
+  }
+  const station = await client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/${id}`).then(({ data, status }) => {
+    if (status === 200) {
+      return Object.keys(data).reduce((acc, key) => {
+        if (key === "stationTimetableDTO") {
+          if (data.stationTimetableDTO?.stationId) {
+            acc.openingHours = {
+              alwaysOpen: data.stationTimetableDTO.alwaysOpen,
+              timetable: Object.keys(data.stationTimetableDTO.timetable).reduce(
+                (timetable, val) => {
+                  timetable[val] = data.stationTimetableDTO.timetable[val].map(
+                    (day) => ({
+                      id: day.id,
+                      closed: day.closed,
+                      openAt: day.openAt,
+                      closeAt: day.closeAt
+                    })
+                  );
+                  return timetable;
+                },
+                {}
+              )
+            };
+          }
+          return acc;
+        }
+        acc[key] = data[key];
+        return acc;
+      }, {});
+    }
+    if (status === 400) {
+      return null;
+    }
+    return null;
+  }).catch((error) => {
+    if (error.formattedError?.status === 400) {
+      return null;
+    }
+    throw error;
+  });
+  if (station && includes.includes("INFO")) {
+    const poi = await client.get(
+      `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+      {
+        headers: { accept: "application/vnd.geo+json" }
+      }
+    ).then(
+      ({ data }) => data.features.reduce(
+        (max, current) => {
+          if (current.properties.Version > max.version) {
+            const {
+              geometry: {
+                coordinates: [longitude, latitude]
+              },
+              properties
+            } = current;
+            return {
+              version: current.properties.Version,
+              name: properties.name,
+              coordinates: { latitude, longitude },
+              geoProperties: properties
+            };
+          }
+          return max;
+        },
+        { version: -1 }
+      )
+    );
+    if (station.poiId && poi) {
+      poi.version = void 0;
+      Object.assign(station, poi);
+      station.name = station.geoProperties?.name;
+    }
+  }
+  if (station && includes.includes("SERVICES")) {
+    const services = await client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/details?showTimetable=false`).then(
+      ({ data }) => data.stations.reduce((acc, service) => {
+        if (!acc[service.station.id]) {
+          acc[service.station.id] = { services: [] };
+        }
+        acc[service.station.id].services.push({
+          id: service.serviceId,
+          models: service.station.models
+        });
+        return acc;
+      }, {})
+    );
+    if (services[station.id]) {
+      Object.assign(station, services[station.id]);
+    }
+  }
+  return station;
+};
 export {
   getBookingRequestById,
   getBookingRequestByTrip,
   getBookingRequests,
   getSATBookingRequests,
   getScheduleBookingRequests,
+  getStationById,
   getStations,
   getSubscriptionBookingRequestById,
   getSubscriptionBookingRequests

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-booking",
-    "version": "1.1.87",
+    "version": "1.1.89",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.1.87",
-        "@vulog/aima-core": "1.1.87"
+        "@vulog/aima-client": "1.1.89",
+        "@vulog/aima-core": "1.1.89"
     },
     "peerDependencies": {
         "es-toolkit": "^1.39.9",

package/src/getStation.test.ts

@@ -0,0 +1,411 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getStationById } from './getStation';
+import { features } from 'process';
+import { DayOpeningHours, Service, Station } from './types';
+
+const FLEET_ID = 'FLEET_ID';
+const STATION_ID: string = 'd7d70752-8cf5-4352-a420-33170785976e';
+const POI_ID = '9967b01d3a46469896888b458904669e'
+const STATION = {
+    id: STATION_ID,
+    zoneId: 'f40b8255b4b24e7cb7e5f28553e79c7e',
+    taxZoneId: null,
+    poiId: POI_ID,
+    modificationDate: '2024-09-23T07:19:12Z',
+    fleetId: FLEET_ID,
+    openTime: '00:00:00',
+    closeTime: '23:59:00',
+    stationTimetableDTO: {
+        stationId: STATION_ID,
+        fleetId: FLEET_ID,
+        alwaysOpen: false,
+        timetable: {
+            MONDAY: [
+                {
+                    id: 10863,
+                    openAt: '00:00',
+                    closeAt: '23:59',
+                    closed: false,
+                    weekDay: 'MONDAY',
+                }
+            ],
+            TUESDAY: [
+                {
+                    id: 10866,
+                    openAt: '00:00',
+                    closeAt: '23:59',
+                    closed: false,
+                    weekDay: 'TUESDAY',
+                }
+            ],
+            WEDNESDAY: [
+                {
+                    id: 10869,
+                    openAt: '00:00',
+                    closeAt: '23:59',
+                    closed: false,
+                    weekDay: 'WEDNESDAY',
+                }
+            ],
+            THURSDAY: [
+                {
+                    id: 10872,
+                    openAt: '00:00',
+                    closeAt: '23:59',
+                    closed: false,
+                    weekDay: 'THURSDAY',
+                }
+            ],
+            FRIDAY: [
+                {
+                    id: 10875,
+                    openAt: '00:00',
+                    closeAt: '23:59',
+                    closed: false,
+                    weekDay: 'FRIDAY',
+                }
+            ],
+            SATURDAY: [
+                {
+                    id: 10878,
+                    openAt: '00:00',
+                    closeAt: '23:59',
+                    closed: false,
+                    weekDay: 'SATURDAY',
+                }
+            ],
+            SUNDAY: [
+                {
+                    id: 10881,
+                    openAt: '00:00',
+                    closeAt: '23:59',
+                    closed: false,
+                    weekDay: 'SUNDAY',
+                }
+            ]
+        },
+    },
+    description: null,
+    maxAvailableSpots: 0,
+};
+const POI = {
+    type: 'Feature',
+    properties: {
+        name: 'Vulog HQ',
+        Version: 12,
+        type: 'scheduled_booking_station',
+        description: '',
+        address: 'av Simone Veil',
+        postal_code: '06000',
+        city: 'Nice',
+        capacity: 0
+    },
+    geometry: {
+        type: 'Point',
+        coordinates: [
+            -7.852491,
+            42.282294
+        ]
+    }
+};
+const STATION_MODELS = {
+    station: {
+        id: STATION.id,
+        models: [
+            { id: 1950, vehicles: [ '52d8c237-03a8-4b2d-bc66-f52a5d5c5119' ] },
+            { id: 1981, vehicles: [ 'c20bc631-9943-444d-b025-b5cf78b68084' ] },
+        ],
+        openTime: STATION.openTime,
+        closeTime: STATION.closeTime,
+        maxAvailableSpots: 0
+    },
+    serviceId: '55160733-334d-40fb-b80f-bad7080f90de',
+    stationTimetableDTO: {
+        stationId: null,
+        fleetId: null,
+        alwaysOpen: false,
+        timetable: null
+    }
+};
+
+const expectStationTimeTableDay = (value: DayOpeningHours[] | undefined, expected: DayOpeningHours[]) => {
+    expect(value).not.toBeNull();
+    expect(value).not.toBeUndefined();
+    expect(value?.length).toEqual(expected.length);
+    if (value) {
+        expect(value[0]?.id).toEqual(expected[0].id);
+        expect(value[0].closed).toEqual(expected[0].closed);
+        expect(value[0].openAt).toEqual(expected[0].openAt);
+        expect(value[0].closeAt).toEqual(expected[0].closeAt);
+    }
+}
+
+const expectStation = (value: Station | null, expected: Station) => {
+    
+        expect(value).not.toBeNull();
+        expect(value).not.toBeUndefined();        
+        expect(value?.id).toEqual(expected.id);
+        expect(value?.zoneId).toEqual(expected.zoneId);
+        expect(value?.poiId).toEqual(expected.poiId);
+        expect(value?.modificationDate).toEqual(expected.modificationDate);
+        expect(value?.fleetId).toEqual(expected.fleetId);
+        expect(value?.openingHours).not.toBeNull();
+        expect(value?.openingHours?.alwaysOpen).toEqual(expected.stationTimetableDTO.alwaysOpen);
+        expect(value?.openingHours?.timetable).not.toBeNull();
+        expect(value?.openingHours?.timetable?.MONDAY).not.toBeNull();
+        expect(value?.openingHours?.timetable?.MONDAY.length).toEqual(expected.stationTimetableDTO.timetable.MONDAY.length);
+        expect(value?.openingHours?.timetable?.MONDAY[0].id).toEqual(expected.stationTimetableDTO.timetable.MONDAY[0].id);
+        expect(value?.openingHours?.timetable?.MONDAY[0].closed).toEqual(expected.stationTimetableDTO.timetable.MONDAY[0].closed);
+        expect(value?.openingHours?.timetable?.MONDAY[0].openAt).toEqual(expected.stationTimetableDTO.timetable.MONDAY[0].openAt);
+        expect(value?.openingHours?.timetable?.MONDAY[0].closeAt).toEqual(expected.stationTimetableDTO.timetable.MONDAY[0].closeAt);
+        expectStationTimeTableDay(value?.openingHours?.timetable?.TUESDAY, expected.stationTimetableDTO.timetable.TUESDAY);
+        expectStationTimeTableDay(value?.openingHours?.timetable?.WEDNESDAY, expected.stationTimetableDTO.timetable.WEDNESDAY);
+        expectStationTimeTableDay(value?.openingHours?.timetable?.THURSDAY, expected.stationTimetableDTO.timetable.THURSDAY);
+        expectStationTimeTableDay(value?.openingHours?.timetable?.FRIDAY, expected.stationTimetableDTO.timetable.FRIDAY);
+        expectStationTimeTableDay(value?.openingHours?.timetable?.SATURDAY, expected.stationTimetableDTO.timetable.SATURDAY);
+        expectStationTimeTableDay(value?.openingHours?.timetable?.SUNDAY, expected.stationTimetableDTO.timetable.SUNDAY);
+}
+const expectStationInfo = (value: Station | null, expectedPoi: any) => {    
+    expect(value?.name).toEqual(expectedPoi.properties.name);
+    expect(value?.coordinates?.latitude).toEqual(expectedPoi.geometry.coordinates[1]);
+    expect(value?.coordinates?.longitude).toEqual(expectedPoi.geometry.coordinates[0]);
+    expect(value?.geoProperties?.Version).toEqual(expectedPoi.properties.Version);
+    expect(value?.geoProperties?.type).toEqual(expectedPoi.properties.type);
+    expect(value?.geoProperties?.description).toEqual(expectedPoi.properties.description);
+    expect(value?.geoProperties?.address).toEqual(expectedPoi.properties.address);
+    expect(value?.geoProperties?.postal_code).toEqual(expectedPoi.properties.postal_code);
+    expect(value?.geoProperties?.city).toEqual(expectedPoi.properties.city);
+}
+const expectStationServices = (value: Service[] | undefined, expectedStationModels: any) => {
+    expect(value).not.toBeUndefined();
+    expect(value?.length).toEqual(1);// 1 service for station ?
+    if (value) {
+        expect(value[0].id).toEqual(expectedStationModels.serviceId);
+        expect(value[0].models.length).toEqual(expectedStationModels.station.models.length);
+        expect(value[0].models[0].id).toEqual(expectedStationModels.station.models[0].id);
+        expect(value[0].models[0].vehicles.length).toEqual(expectedStationModels.station.models[0].vehicles.length);
+        expect(value[0].models[0].vehicles[0]).toEqual(expectedStationModels.station.models[0].vehicles[0]);
+    }        
+}
+
+describe('getStationById', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+        vi.useFakeTimers({ now: new Date('2025-01-12T13:35:50.123Z') });
+
+        getMock.mockImplementation((url: string): Promise<any> => {
+            if (url === `/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`) {
+                return Promise.resolve({
+                    data: STATION,
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+               });
+            }
+            if (url.startsWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/`)) {
+                return Promise.resolve({
+                    data: {
+                        status: 'BAD_REQUEST',
+                        errorCode: 'BAD_REQUEST',
+                        message: 'The provided input is not valid',
+                        detail: null,
+                        transactionId: '8c97dc753afc43098933a73bee34c327'
+                    },
+                    status: 400,
+                    statusText: 'BAD REQUEST',
+                    headers: {},
+                    config: {}
+               });
+            }
+            if (url === `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}` ) {
+                return Promise.resolve({
+                    data: {
+                        type: 'FeatureCollection',
+                        features: [
+                            {
+                                type: 'Feature',
+                                properties: {
+                                    name: 'Vulog Silo',
+                                    Version: 1,
+                                    type: 'scheduled_booking_station',
+                                    description: '',
+                                    address: '42 av Simone Veil',
+                                    postal_code: '06200',
+                                    city: 'NICE',
+                                    capacity: 0
+                                },
+                                geometry: {
+                                    type: 'Point',
+                                    coordinates: [
+                                        -7.85794,
+                                        42.28325
+                                    ]
+                                }
+                            },                            
+                            // more than 2 ... but it's OK for this test
+                            POI,
+                        ]
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+               });
+            }
+            if (url.startsWith(`/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/`)) {
+                return Promise.resolve({
+                    data: {
+                        type: 'FeatureCollection',
+                        features: []
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+               });
+            }
+            if (url.startsWith(`/boapi/proxy/user/fleets/${FLEET_ID}/stations/details`)) {
+                return Promise.resolve({
+                    data: {
+                        stations:[
+                            {
+                                station: {
+                                    id: '404b6ea4-2004-421c-9304-84796b018975',
+                                    models: [],
+                                    openTime: '00:00:00',
+                                    closeTime: '23:59:00',
+                                    maxAvailableSpots: 0
+                                },
+                                serviceId: '66a91a3a-12dc-40bc-8750-440f0ea14fee',
+                                stationTimetableDTO: {
+                                    stationId: null,
+                                    fleetId: null,
+                                    alwaysOpen: false,
+                                    timetable: null
+                                }
+                            },
+                            STATION_MODELS,                        
+                            {
+                                station: {
+                                    id: '95095a04-afb7-49e7-b039-5da9750c8911',
+                                    models: [],
+                                    openTime: '07:00:00',
+                                    closeTime: '19:00:00',
+                                    maxAvailableSpots: 0
+                                },
+                                serviceId: '5f53f2ab-5af0-4ef5-8138-6a5b7698397d',
+                                stationTimetableDTO: {
+                                    stationId: null,
+                                    fleetId: null,
+                                    alwaysOpen: false,
+                                    timetable: null
+                                }
+                            },
+                        ],
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+               });
+
+            }
+
+            // Pour les autres URLs, rejetez la promesse
+            return Promise.reject(new Error('404 Not Found'));
+        });
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    test('Fake includes', async () => {
+        const rejects = expect(() => getStationById(client, STATION_ID, ['FAKE'] as any)).rejects;
+        await rejects.toThrowError('Invalid includes');
+        await rejects.toSatisfy((error: any) => {
+            expect(error).toHaveProperty('cause');
+            expect(error.cause).toHaveLength(1);
+            expect(error.cause[0]).toHaveProperty('code');
+            expect(error.cause[0].code).toBe('invalid_enum_value');
+            return true;
+        });
+    });
+
+    test('station not found', async () => {
+        const station = await getStationById(client, 'FAKE_ID');
+        expect(getMock).toBeCalled();
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/FAKE_ID`);
+        expect(station).toBeNull();
+    });
+
+    test('all OK', async () => {
+        const station: Station | null = await getStationById(client, STATION_ID, []);
+        expectStation(station, STATION);
+        expect(station?.name).toBeUndefined();
+        expect(station?.coordinates?.latitude).toBeUndefined();
+        expect(station?.coordinates?.longitude).toBeUndefined();
+        expect(station?.geoProperties?.Version).toBeUndefined();
+        expect(station?.geoProperties?.type).toBeUndefined();
+        expect(station?.geoProperties?.description).toBeUndefined();
+        expect(station?.geoProperties?.address).toBeUndefined();
+        expect(station?.geoProperties?.postal_code).toBeUndefined();
+        expect(station?.geoProperties?.city).toBeUndefined();
+        expect(station?.services).toBeUndefined();
+    });
+
+    test('all OK with INFO', async () => {
+        const station: Station | null = await getStationById(client, STATION_ID, ['INFO']);
+        expect(getMock).toBeCalledTimes(2);
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`);
+        expect(getMock).toBeCalledWith(
+            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}`,
+            { headers: { accept: 'application/vnd.geo+json' } }
+        );
+        expectStation(station, STATION);
+        expectStationInfo(station, POI);
+        expect(station?.services).toBeUndefined();
+    });
+
+    test('all OK with SERVICES', async () => {
+        const station: Station | null = await getStationById(client, STATION_ID, ['SERVICES']);
+        expect(getMock).toBeCalledTimes(2);
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`);
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/${FLEET_ID}/stations/details?showTimetable=false`);
+        expectStation(station, STATION);
+        expect(station?.name).toBeUndefined();
+        expect(station?.coordinates?.latitude).toBeUndefined();
+        expect(station?.coordinates?.longitude).toBeUndefined();
+        expect(station?.geoProperties?.Version).toBeUndefined();
+        expect(station?.geoProperties?.type).toBeUndefined();
+        expect(station?.geoProperties?.description).toBeUndefined();
+        expect(station?.geoProperties?.address).toBeUndefined();
+        expect(station?.geoProperties?.postal_code).toBeUndefined();
+        expect(station?.geoProperties?.city).toBeUndefined();
+        expectStationServices(station?.services, STATION_MODELS);
+    });
+
+    test('all OK with INFO SERVICE', async () => {
+        const station: Station | null = await getStationById(client, STATION_ID, ['INFO', 'SERVICES']);
+        expect(getMock).toBeCalledTimes(3);
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/scheduledBooking/fleets/${FLEET_ID}/stations/${STATION_ID}`);
+        expect(getMock).toBeCalledWith(
+            `/boapi/proxy/geoloc/fleets/${FLEET_ID}/poi/${POI_ID}`,
+            { headers: { accept: 'application/vnd.geo+json' } }
+        );
+        expect(getMock).toBeCalledWith(`/boapi/proxy/user/fleets/${FLEET_ID}/stations/details?showTimetable=false`);
+        expectStation(station, STATION);
+        expectStationInfo(station, POI);
+        expectStationServices(station?.services, STATION_MODELS);
+    });
+});

package/src/getStation.ts

@@ -0,0 +1,128 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Days, ServiceInfo, Station, Timetable } from './types';
+
+const IncludeSchema = z.enum(['INFO', 'SERVICES']);
+const IncludesSchema = z.array(IncludeSchema);
+export type IncludeStation = z.infer<typeof IncludeSchema>;
+
+export const getStationById = async (
+    client: Client,
+    id: string,
+    includes: IncludeStation[] = []
+): Promise<Station | null> => {
+    const resultIncludes = IncludesSchema.safeParse(includes);
+    if (!resultIncludes.success) {
+        throw new TypeError('Invalid includes', {
+            cause: resultIncludes.error.issues,
+        });
+    }
+
+    const station: Station | null = await client
+        .get<any>(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/${id}`)
+        .then(({ data, status }) => {
+            if (status === 200) {
+                return Object.keys(data).reduce<{ [key: string]: any }>((acc, key) => {
+                    if (key === 'stationTimetableDTO') {
+                        if (data.stationTimetableDTO?.stationId) {
+                            acc.openingHours = {
+                                alwaysOpen: data.stationTimetableDTO.alwaysOpen,
+                                timetable: Object.keys(data.stationTimetableDTO.timetable).reduce<Timetable>(
+                                    (timetable, val) => {
+                                        // eslint-disable-next-line no-param-reassign
+                                        timetable[val as Days] = data.stationTimetableDTO.timetable[val].map(
+                                            (day: any) => ({
+                                                id: day.id,
+                                                closed: day.closed,
+                                                openAt: day.openAt,
+                                                closeAt: day.closeAt,
+                                            })
+                                        );
+                                        return timetable;
+                                    },
+                                    {} as Timetable
+                                ),
+                            };
+                        }
+                        return acc;
+                    }
+                    acc[key] = data[key];
+                    return acc;
+                }, {}) as Station;
+            }
+            if (status === 400) {
+                return null;
+            }
+            return null;
+        })
+        .catch((error) => {
+            if (error.formattedError?.status === 400) {
+                return null;
+            }
+            throw error;
+        });
+
+    if (station && includes.includes('INFO')) {
+        const poi = await client
+            .get<{ features: any[] }>(
+                `/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/poi/${station.poiId}`,
+                {
+                    headers: { accept: 'application/vnd.geo+json' },
+                }
+            )
+            .then(({ data }) =>
+                data.features.reduce(
+                    (max, current) => {
+                        if (current.properties.Version > max.version) {
+                            const {
+                                geometry: {
+                                    coordinates: [longitude, latitude],
+                                },
+                                properties,
+                            } = current;
+                            return {
+                                version: current.properties.Version,
+                                name: properties.name,
+                                coordinates: { latitude, longitude },
+                                geoProperties: properties,
+                            };
+                        }
+                        return max;
+                    },
+                    { version: -1 }
+                )
+            );
+
+        if (station.poiId && poi) {
+            poi.version = undefined;
+            Object.assign(station, poi);
+            station.name = station.geoProperties?.name;
+        }
+    }
+
+    if (station && includes.includes('SERVICES')) {
+        const services = await client
+            .get<{
+                stations: any[];
+            }>(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/details?showTimetable=false`)
+            .then(({ data }) =>
+                data.stations.reduce<{ [key: string]: ServiceInfo }>((acc, service) => {
+                    if (!acc[service.station.id]) {
+                        acc[service.station.id] = { services: [] };
+                    }
+                    acc[service.station.id].services.push({
+                        id: service.serviceId,
+                        models: service.station.models,
+                    });
+                    return acc;
+                }, {})
+            );
+
+        if (services[station.id]) {
+            Object.assign(station, services[station.id]);
+        }
+    }
+
+    return station;
+};

package/src/getStations.ts

@@ -1,63 +1,12 @@
 import { Client } from '@vulog/aima-client';
 import { z } from 'zod';
 
+import { Days, GeoInfo, ServiceInfo, Station, Timetable } from './types';
+
 const IncludeSchema = z.enum(['INFO', 'OPEN_HOUR', 'SERVICES']);
 const IncludesSchema = z.array(IncludeSchema);
 export type Include = z.infer<typeof IncludeSchema>;
 
-export type Days = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
-
-export type DayOpeningHours = {
-    id: number;
-    closed: boolean;
-    openAt: string;
-    closeAt: string;
-};
-
-export type Timetable = Record<Days, DayOpeningHours[]>;
-
-export type OpeningHours = {
-    alwaysOpen: boolean;
-    timetable: Timetable;
-};
-
-type GeoInfo = {
-    name: string;
-    coordinates: {
-        latitude: number;
-        longitude: number;
-    };
-    geoProperties: { [key: string]: any };
-};
-
-type Service = {
-    id: string;
-    models: {
-        id: number;
-        vehicles: string[];
-    }[];
-};
-
-type ServiceInfo = {
-    services: Service[];
-};
-
-export type Station = Partial<GeoInfo> &
-    Partial<ServiceInfo> & {
-        id: string;
-        zoneId: string;
-        poiId: string;
-        modificationDate: string;
-        fleetId: string;
-        openingHours?: OpeningHours;
-        // description: {
-        //     fleetId: null;
-        //     stationId: null;
-        //     infos: [];
-        // };
-        [key: string]: any;
-    };
-
 export const getStations = async (client: Client, includes: Include[] = []): Promise<Station[]> => {
     const resultIncludes = IncludesSchema.safeParse(includes);
     if (!resultIncludes.success) {

package/src/index.ts

@@ -1,8 +1,10 @@
 export { getBookingRequests, getScheduleBookingRequests, getSubscriptionBookingRequests } from './getBookingRequests';
 export { getSATBookingRequests } from './getSATBookingRequests';
 export { getBookingRequestById, getBookingRequestByTrip, getSubscriptionBookingRequestById } from './getBookingRequest';
-export type { BookingRequest } from './types';
+export * from './types';
 export type { BookingRequestStatus, ServiceType, BookingRequestFilters } from './getBookingRequests';
 export type { SATBookingRequestStatus } from './getSATBookingRequests';
 export { getStations } from './getStations';
-export type { Station, Include, Days, DayOpeningHours, Timetable, OpeningHours } from './getStations';
+export type { Include } from './getStations';
+export { getStationById } from './getStation';
+export type { IncludeStation } from './getStation';

package/src/types.ts

@@ -103,3 +103,57 @@ export type SATBookingRequest = BaseBookingRequest & {
     trip: any | null;
     warning: string | null;
 };
+
+// Station types
+export type GeoInfo = {
+    name: string;
+    coordinates: {
+        latitude: number;
+        longitude: number;
+    };
+    geoProperties: { [key: string]: any };
+};
+
+export type Service = {
+    id: string;
+    models: {
+        id: number;
+        vehicles: string[];
+    }[];
+};
+
+export type ServiceInfo = {
+    services: Service[];
+};
+
+export type Days = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
+
+export type DayOpeningHours = {
+    id: number;
+    closed: boolean;
+    openAt: string;
+    closeAt: string;
+};
+
+export type Timetable = Record<Days, DayOpeningHours[]>;
+
+export type OpeningHours = {
+    alwaysOpen: boolean;
+    timetable: Timetable;
+};
+
+export type Station = Partial<GeoInfo> &
+    Partial<ServiceInfo> & {
+        id: string;
+        zoneId: string;
+        poiId: string;
+        modificationDate: string;
+        fleetId: string;
+        openingHours?: OpeningHours;
+        // description: {
+        //     fleetId: null;
+        //     stationId: null;
+        //     infos: [];
+        // };
+        [key: string]: any;
+    };