@tmlmobilidade/external 20260604.1643.5 → 20260604.2236.3

package/dist/clients/ml/auth.js

@@ -1,6 +1,7 @@
 /* * */
 import { Logger } from '@tmlmobilidade/logger';
 import { asyncSingletonProxy } from '@tmlmobilidade/utils';
+import { curlFetcher } from './curl-fetcher.js';
 /* * */
 export class MLAuthClient {
     //
@@ -52,20 +53,17 @@ export class MLAuthClient {
         // and handle the response, extracting the access token or throwing an error if the request fails.
         const requestBody = new URLSearchParams({
             grant_type: 'password',
-            password: process.env.ML_AUTH_PASSWORD,
-            username: process.env.ML_AUTH_USERNAME,
+            password: process.env.ML_PASSWORD,
+            username: process.env.ML_USERNAME,
         }).toString();
-        const response = await fetch(process.env.ML_AUTH_URL, {
+        const data = await curlFetcher(process.env.ML_AUTH_URL, {
             body: requestBody,
             headers: {
+                'Authorization': `Basic ${Buffer.from(`${process.env.ML_CLIENT_ID}:${process.env.ML_CLIENT_SECRET}`).toString('base64')}`,
                 'Content-Type': 'application/x-www-form-urlencoded',
             },
             method: 'POST',
         });
-        if (!response.ok) {
-            throw new Error(`[MLAuthClient] Token request failed (${response.status}): ${response.statusText}`);
-        }
-        const data = await response.json();
         //
         // With the response data, set the token and calculate the expiration time
         // based on the current time and the expires_in value from the response.

package/dist/clients/ml/curl-fetcher.d.ts

@@ -0,0 +1,5 @@
+export declare function curlFetcher<T>(url: string, options?: {
+    body?: unknown;
+    headers?: Record<string, string>;
+    method?: string;
+}): Promise<T>;

package/dist/clients/ml/curl-fetcher.js

@@ -0,0 +1,37 @@
+// ! THIS IS A TEMPORARY FIX FOR THE ML API CERTIFICATE ISSUE
+import { exec } from 'child_process';
+export async function curlFetcher(url, options) {
+    const method = options?.method ?? 'GET';
+    const headers = options?.headers ?? {};
+    const curlArgs = [
+        'curl',
+        '-sSLf',
+        '-X', method,
+        ...Object.entries(headers).map(([key, value]) => `-H "${key}: ${value}"`),
+    ];
+    if (options?.body !== undefined) {
+        const bodyStr = typeof options.body === 'string' ? options.body : JSON.stringify(options.body);
+        curlArgs.push('--data-raw', `"${bodyStr}"`);
+    }
+    curlArgs.push(`"${url}"`);
+    const curlCommand = curlArgs.join(' ');
+    return await new Promise((resolve, reject) => {
+        exec(curlCommand, (error, stdout, stderr) => {
+            if (error) {
+                console.error(`curl error: ${error.message}`);
+                reject(new Error(`curl error: ${error.message}`));
+                return;
+            }
+            if (stderr) {
+                console.error(`curl stderr: ${stderr}`);
+            }
+            try {
+                const data = JSON.parse(stdout);
+                resolve(data);
+            }
+            catch (parseError) {
+                reject(new Error(`Failed to parse curl response: ${parseError.message}`));
+            }
+        });
+    });
+}

package/dist/clients/ml/index.d.ts

@@ -1,4 +1,4 @@
-import { ServiceAlertResponse } from '@tmlmobilidade/types';
+import { type GtfsRtFeedMessage, ServiceAlertResponse } from '@tmlmobilidade/types';
 import { BaseResponse, EstadoLinha, InfoEstacao, TempoEspera } from './types.js';
 export declare const MlClient: Readonly<{
     /**
@@ -45,4 +45,10 @@ export declare const MlClient: Readonly<{
      * @returns An array of TempoEspera objects, one for each station.
      */
     tempoEsperaTodasEstacoes: () => Promise<BaseResponse<TempoEspera[]>>;
+    /**
+     * Fetches waiting time estimates for a line and transforms them into a GTFS-RT TripUpdates feed.
+     * @param linha Line identifier as string.
+     * @returns A GtfsRtFeedMessage containing TripUpdates.
+     */
+    tripUpdates: () => Promise<GtfsRtFeedMessage>;
 }>;

package/dist/clients/ml/index.js

@@ -1,5 +1,7 @@
 /* * */
 import { mlAuthClient } from './auth.js';
+import { curlFetcher } from './curl-fetcher.js';
+import { DESTINATION_MAP } from './types.js';
 /* * */
 const BASE_URL = process.env.ML_API_URL;
 const ALERTS_URL = process.env.ML_ALERTS_URL;
@@ -8,15 +10,11 @@ async function fetcher(endpoint) {
         throw new Error('Missing ML_API_URL environment variable.');
     }
     const apiToken = await mlAuthClient.getToken();
-    const response = await fetch(`${BASE_URL}${endpoint}`, {
+    return await curlFetcher(`${BASE_URL}${endpoint}`, {
         headers: {
             Authorization: `Bearer ${apiToken}`,
         },
     });
-    if (!response.ok) {
-        throw new Error(`Request failed (${response.status}): ${response.statusText}`);
-    }
-    return response;
 }
 /* * */
 const endpoints = {
@@ -36,16 +34,14 @@ export const MlClient = Object.freeze({
      * @returns EstadoLinha object with the current status of the line.
      */
     estadoLinha: async (linha) => {
-        const response = await fetcher(endpoints.estadoLinha(linha));
-        return await response.json();
+        return await fetcher(endpoints.estadoLinha(linha));
     },
     /**
      * Gets the status of all Metro Lisboa lines.
      * @returns An array of EstadoLinha objects, each representing the status of a line.
      */
     estadoLinhaTodas: async () => {
-        const response = await fetcher(endpoints.estadoLinhaTodas);
-        return await response.json();
+        return await fetcher(endpoints.estadoLinhaTodas);
     },
     /**
      * Gets information about a specific Metro Lisboa station.
@@ -53,24 +49,21 @@ export const MlClient = Object.freeze({
      * @returns InfoEstacao object with details about the station.
      */
     infoEstacao: async (estacao) => {
-        const response = await fetcher(endpoints.infoEstacao(estacao));
-        return await response.json();
+        return await fetcher(endpoints.infoEstacao(estacao));
     },
     /**
      * Gets information about all Metro Lisboa stations.
      * @returns An array of InfoEstacao objects, one for each station.
      */
     infoEstacaoTodas: async () => {
-        const response = await fetcher(endpoints.infoEstacaoTodas);
-        return await response.json();
+        return await fetcher(endpoints.infoEstacaoTodas);
     },
     /**
      * Retrieves current Metro Lisboa service alerts.
      * @returns A ServiceAlertResponse containing the active service alerts in GTFS-realtime format.
      */
     serviceAlerts: async () => {
-        const response = await fetcher(endpoints.serviceAlerts);
-        return await response.json();
+        return await fetcher(endpoints.serviceAlerts);
     },
     /**
      * Gets the current waiting time estimates for a specific station.
@@ -78,8 +71,7 @@ export const MlClient = Object.freeze({
      * @returns TempoEspera object with estimated waiting times for the station.
      */
     tempoEsperaEstacao: async (estacao) => {
-        const response = await fetcher(endpoints.tempoEsperaEstacao(estacao));
-        return await response.json();
+        return await fetcher(endpoints.tempoEsperaEstacao(estacao));
     },
     /**
      * Gets the current waiting time estimates for a specific line.
@@ -87,15 +79,80 @@ export const MlClient = Object.freeze({
      * @returns An array of TempoEspera objects, one for each station in the line.
      */
     tempoEsperaLinha: async (linha) => {
-        const response = await fetcher(endpoints.tempoEsperaLinha(linha));
-        return await response.json();
+        return await fetcher(endpoints.tempoEsperaLinha(linha));
     },
     /**
      * Gets the current waiting time estimates for all stations.
      * @returns An array of TempoEspera objects, one for each station.
      */
     tempoEsperaTodasEstacoes: async () => {
-        const response = await fetcher(endpoints.tempoEsperaTodasEstacoes);
-        return await response.json();
+        return await fetcher(endpoints.tempoEsperaTodasEstacoes);
+    },
+    /**
+     * Fetches waiting time estimates for a line and transforms them into a GTFS-RT TripUpdates feed.
+     * @param linha Line identifier as string.
+     * @returns A GtfsRtFeedMessage containing TripUpdates.
+     */
+    tripUpdates: async () => {
+        const now = Date.now();
+        const lines = ['Amarela', 'Azul', 'Verde', 'Vermelha'];
+        const entities = [];
+        for (const line of lines) {
+            const data = await fetcher(endpoints.tempoEsperaLinha(line));
+            const trainStops = new Map();
+            for (const [index, item] of data.resposta.entries()) {
+                const trains = [
+                    { comboio: item.comboio, tempo: item.tempoChegada1 },
+                    { comboio: item.comboio2, tempo: item.tempoChegada2 },
+                    { comboio: item.comboio3, tempo: item.tempoChegada3 },
+                ];
+                for (const train of trains) {
+                    if (!train.comboio || train.tempo === '--')
+                        continue;
+                    const arrivalSeconds = Number.parseInt(train.tempo, 10);
+                    if (!trainStops.has(train.comboio)) {
+                        trainStops.set(train.comboio, { destination: item.destino, stops: [] });
+                    }
+                    trainStops.get(train.comboio).stops.push({
+                        arrival_seconds: arrivalSeconds,
+                        stop_id: item.stop_id,
+                        stop_sequence: index,
+                    });
+                }
+            }
+            entities.push(...Array.from(trainStops.entries()).map(([key, value]) => {
+                const sortedStops = value.stops.sort((a, b) => a.stop_sequence - b.stop_sequence);
+                return {
+                    id: `${line}_${key}_${DESTINATION_MAP[value.destination].code}`,
+                    trip_update: {
+                        stop_time_update: sortedStops.map(stop => ({
+                            arrival: {
+                                time: now + stop.arrival_seconds * 1000,
+                            },
+                            stop_id: stop.stop_id,
+                            stop_sequence: stop.stop_sequence,
+                        })),
+                        timestamp: now,
+                        trip: {
+                            line_id: line,
+                            line_short_name: `${line}_${DESTINATION_MAP[value.destination].code}`,
+                            trip_headsign: DESTINATION_MAP[value.destination].name,
+                            trip_id: `${line}_${key}_${value.destination}`,
+                        },
+                        vehicle: {
+                            id: key,
+                        },
+                    },
+                };
+            }));
+        }
+        return {
+            entity: entities,
+            header: {
+                gtfs_realtime_version: '2.0',
+                incrementality: 'FULL_DATASET',
+                timestamp: now,
+            },
+        };
     },
 });

package/dist/clients/ml/types.d.ts

@@ -15,6 +15,23 @@ export interface TempoEspera {
     nomeEstacao: string;
     tempoEspera: string;
 }
+/**
+ * Raw response item from GET /tempoEspera/Linha/{linha}.
+ * Each entry represents a stop/platform with up to 3 upcoming trains.
+ */
+export interface TempoEsperaRawItem {
+    cais: string;
+    comboio: string;
+    comboio2: string;
+    comboio3: string;
+    destino: string;
+    hora: string;
+    sairServico: string;
+    stop_id: string;
+    tempoChegada1: string;
+    tempoChegada2: string;
+    tempoChegada3: string;
+}
 /**
  * @see GET /infoEstacao/todos
  * @see GET /infoEstacao/{estacao}
@@ -36,3 +53,101 @@ export interface EstadoLinha {
     estado: string;
     linha: string;
 }
+export declare const DESTINATION_MAP: {
+    readonly 33: {
+        readonly code: "RB";
+        readonly name: "Reboleira";
+    };
+    readonly 34: {
+        readonly code: "AS";
+        readonly name: "Amadora Este";
+    };
+    readonly 35: {
+        readonly code: "PO";
+        readonly name: "Pontinha";
+    };
+    readonly 36: {
+        readonly code: "CM";
+        readonly name: "Colégio Militar/Luz";
+    };
+    readonly 37: {
+        readonly code: "LA";
+        readonly name: "Laranjeiras";
+    };
+    readonly 38: {
+        readonly code: "SS";
+        readonly name: "São Sebastião";
+    };
+    readonly 39: {
+        readonly code: "AV";
+        readonly name: "Avenida";
+    };
+    readonly 40: {
+        readonly code: "BC";
+        readonly name: "Baixa-Chiado";
+    };
+    readonly 41: {
+        readonly code: "TP";
+        readonly name: "Terreiro do Paço";
+    };
+    readonly 42: {
+        readonly code: "SP";
+        readonly name: "Santa Apolónia";
+    };
+    readonly 43: {
+        readonly code: "OD";
+        readonly name: "Odivelas";
+    };
+    readonly 44: {
+        readonly code: "LU";
+        readonly name: "Lumiar";
+    };
+    readonly 45: {
+        readonly code: "CG";
+        readonly name: "Campo Grande";
+    };
+    readonly 46: {
+        readonly code: "CP";
+        readonly name: "Campo Pequeno";
+    };
+    readonly 48: {
+        readonly code: "RA";
+        readonly name: "Rato";
+    };
+    readonly 50: {
+        readonly code: "TE";
+        readonly name: "Telheiras";
+    };
+    readonly 51: {
+        readonly code: "AL";
+        readonly name: "Alvalade";
+    };
+    readonly 52: {
+        readonly code: "AM";
+        readonly name: "Alameda";
+    };
+    readonly 53: {
+        readonly code: "MM";
+        readonly name: "Martim Moniz";
+    };
+    readonly 54: {
+        readonly code: "CS";
+        readonly name: "Cais do Sodré";
+    };
+    readonly 56: {
+        readonly code: "BV";
+        readonly name: "Bela Vista";
+    };
+    readonly 57: {
+        readonly code: "CH";
+        readonly name: "Chelas";
+    };
+    readonly 59: {
+        readonly code: "MO";
+        readonly name: "Moscavide";
+    };
+    readonly 60: {
+        readonly code: "AP";
+        readonly name: "Aeroporto";
+    };
+};

package/dist/clients/ml/types.js

@@ -1,2 +1,99 @@
 /* * */
-export {};
+export const DESTINATION_MAP = {
+    33: {
+        code: 'RB',
+        name: 'Reboleira',
+    },
+    34: {
+        code: 'AS',
+        name: 'Amadora Este',
+    },
+    35: {
+        code: 'PO',
+        name: 'Pontinha',
+    },
+    36: {
+        code: 'CM',
+        name: 'Colégio Militar/Luz',
+    },
+    37: {
+        code: 'LA',
+        name: 'Laranjeiras',
+    },
+    38: {
+        code: 'SS',
+        name: 'São Sebastião',
+    },
+    39: {
+        code: 'AV',
+        name: 'Avenida',
+    },
+    40: {
+        code: 'BC',
+        name: 'Baixa-Chiado',
+    },
+    41: {
+        code: 'TP',
+        name: 'Terreiro do Paço',
+    },
+    42: {
+        code: 'SP',
+        name: 'Santa Apolónia',
+    },
+    43: {
+        code: 'OD',
+        name: 'Odivelas',
+    },
+    44: {
+        code: 'LU',
+        name: 'Lumiar',
+    },
+    45: {
+        code: 'CG',
+        name: 'Campo Grande',
+    },
+    46: {
+        code: 'CP',
+        name: 'Campo Pequeno',
+    },
+    48: {
+        code: 'RA',
+        name: 'Rato',
+    },
+    50: {
+        code: 'TE',
+        name: 'Telheiras',
+    },
+    51: {
+        code: 'AL',
+        name: 'Alvalade',
+    },
+    52: {
+        code: 'AM',
+        name: 'Alameda',
+    },
+    53: {
+        code: 'MM',
+        name: 'Martim Moniz',
+    },
+    54: {
+        code: 'CS',
+        name: 'Cais do Sodré',
+    },
+    56: {
+        code: 'BV',
+        name: 'Bela Vista',
+    },
+    57: {
+        code: 'CH',
+        name: 'Chelas',
+    },
+    59: {
+        code: 'MO',
+        name: 'Moscavide',
+    },
+    60: {
+        code: 'AP',
+        name: 'Aeroporto',
+    },
+};

package/dist/index.d.ts

@@ -40,6 +40,7 @@ export declare const externalClients: Readonly<{
         tempoEsperaEstacao: (estacao: string) => Promise<import("./clients/ml/types.js").BaseResponse<import("./clients/ml/types.js").TempoEspera>>;
         tempoEsperaLinha: (linha: string) => Promise<import("./clients/ml/types.js").BaseResponse<import("./clients/ml/types.js").TempoEspera[]>>;
         tempoEsperaTodasEstacoes: () => Promise<import("./clients/ml/types.js").BaseResponse<import("./clients/ml/types.js").TempoEspera[]>>;
+        tripUpdates: () => Promise<import("@tmlmobilidade/types").GtfsRtFeedMessage>;
     }>;
     mobi: Readonly<{
         tripUpdates: () => Promise<import("@tmlmobilidade/types").GtfsRtFeedMessage>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tmlmobilidade/external",
-	"version": "20260604.1643.5",
+	"version": "20260604.2236.3",
 	"author": {
 		"email": "iso@tmlmobilidade.pt",
 		"name": "TML-ISO"