zet-api 1.0.0

package/dist/core/manager.d.ts

@@ -0,0 +1,39 @@
+import { Route, Stop, News, GetRoutesInput, GetRouteTripsInput, GetStopsInput, GetTripStopTimesInput, SearchRoutesInput, SearchStopsInput, GetLiveVehiclesInput, TripWithDates, TripStopTimeWithDates, NewsWithDates, Vehicle } from './parsers';
+import { GetStopIncomingTripsInput, StopIncomingTripWithDates, Account } from '../auth/types';
+import { ZetAuthManager } from '../auth/manager';
+import { RouteTypeEnum } from './constants';
+export declare class ZetManager {
+    private cachedRoutes;
+    private cachedStops;
+    private cachedNews;
+    private routesCachedAt;
+    private stopsCachedAt;
+    private newsCachedAt;
+    authManager: ZetAuthManager;
+    private timeoutMs;
+    private cacheTTL;
+    constructor(cacheTTL?: number, timeoutMs?: number);
+    getRoutes(): Promise<Route[]>;
+    getRoutesInternal(options: GetRoutesInput): Promise<Route[]>;
+    getRouteById(routeId: number): Promise<Route | null>;
+    searchRoutes(options: SearchRoutesInput): Promise<Route[]>;
+    getRouteTrips(options: GetRouteTripsInput): Promise<TripWithDates[]>;
+    getTripStopTimes(options: GetTripStopTimesInput): Promise<TripStopTimeWithDates[]>;
+    getLiveTripsForRoute(routeId: number, daysFromToday?: number): Promise<Map<string, TripStopTimeWithDates[]>>;
+    getActiveTripIds(routeId: number, daysFromToday?: number, tripsOverride?: TripWithDates[]): Promise<string[]>;
+    getAccountInfo(): Promise<Account>;
+    getStops(routeType?: RouteTypeEnum): Promise<Stop[]>;
+    getStopIncomingTrips(options: GetStopIncomingTripsInput): Promise<StopIncomingTripWithDates[]>;
+    getStopsInternal(options: GetStopsInput): Promise<Stop[]>;
+    getStopById(stopId: string, routeType?: RouteTypeEnum): Promise<Stop | null>;
+    searchStops(options: SearchStopsInput): Promise<Stop[]>;
+    private getNewsfeedInternal;
+    getNewsfeed(): Promise<NewsWithDates[]>;
+    getNewsByRoute(routeId: number): Promise<News[]>;
+    getLiveVehicles(options?: GetLiveVehiclesInput): Promise<Vehicle[]>;
+    getVehicleById(vehicleId: string): Promise<Vehicle | null>;
+    refreshCache(): Promise<void>;
+    clearCache(): void;
+    private fetchAndCacheRoutes;
+    private fetchAndCacheStops;
+}

package/dist/core/manager.js

@@ -0,0 +1,359 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZetManager = void 0;
+const parsers_1 = require("./parsers");
+const types_1 = require("../auth/types");
+const utils_1 = require("./utils");
+const manager_1 = require("../auth/manager");
+const config_1 = __importStar(require("./config"));
+const axios_1 = __importDefault(require("axios"));
+class ZetManager {
+    cachedRoutes = null;
+    cachedStops = null;
+    cachedNews = null;
+    routesCachedAt = null;
+    stopsCachedAt = null;
+    newsCachedAt = null;
+    authManager = new manager_1.ZetAuthManager();
+    timeoutMs = 10000;
+    cacheTTL = -1;
+    constructor(cacheTTL = -1, timeoutMs = 10000) {
+        if (cacheTTL < -1)
+            throw new Error('cacheTTL must be -1 (no expiry) or a non-negative number in milliseconds.');
+        if (timeoutMs <= 0)
+            throw new Error('timeoutMs must be a positive number in milliseconds.');
+        this.timeoutMs = timeoutMs;
+        this.cacheTTL = cacheTTL;
+    }
+    // Routes.
+    async getRoutes() {
+        const now = Date.now();
+        const needsRefresh = !this.cachedRoutes || (this.cacheTTL >= 0 && this.routesCachedAt && now - this.routesCachedAt > this.cacheTTL);
+        if (needsRefresh)
+            await this.fetchAndCacheRoutes();
+        if (!this.cachedRoutes)
+            throw new Error('Failed to fetch routes.');
+        return this.cachedRoutes;
+    }
+    async getRoutesInternal(options) {
+        let routes = await this.getRoutes();
+        if (options.routeId !== undefined)
+            routes = routes.filter((route) => route.id === options.routeId);
+        if (options.routeType !== undefined)
+            routes = routes.filter((route) => route.routeType === options.routeType);
+        return routes;
+    }
+    async getRouteById(routeId) {
+        const routes = await this.getRoutesInternal({ routeId });
+        return routes[0] || null;
+    }
+    async searchRoutes(options) {
+        const routes = await this.getRoutesInternal({ routeType: options.routeType });
+        const normalizedQuery = (0, utils_1.normalizeString)(options.query);
+        const filtered = routes.filter((route) => {
+            const normalizedName = (0, utils_1.normalizeString)(route.normalizedSearchName);
+            return normalizedName.includes(normalizedQuery) || route.shortName.toLowerCase().includes(options.query.toLowerCase());
+        });
+        return filtered.slice(0, options.limit || 10);
+    }
+    // Trips.
+    async getRouteTrips(options) {
+        const url = `${config_1.default.timetableServiceUrl}/routeTrips`;
+        const params = {
+            routeId: options.routeId.toString(),
+            daysFromToday: (options.daysFromToday || 0).toString(),
+        };
+        const response = await axios_1.default.get(url, { params, headers: config_1.headers, timeout: this.timeoutMs }).catch((err) => err.response);
+        if (!response || response.status !== 200)
+            throw new Error(`Failed to fetch route trips: ${response?.statusText || 'Unknown error'}`);
+        const parsed = parsers_1.RouteTripsResponseSchema.safeParse(response.data);
+        if (!parsed.success)
+            throw new Error(`Failed to parse route trips data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        return parsed.data.map((trip) => ({
+            ...trip,
+            departureDateTime: new Date(trip.departureDateTime),
+            arrivalDateTime: new Date(trip.arrivalDateTime),
+        }));
+    }
+    async getTripStopTimes(options) {
+        const url = `${config_1.default.timetableServiceUrl}/tripStopTimes`;
+        const params = {
+            tripId: options.tripId,
+            daysFromToday: (options.daysFromToday || 0).toString(),
+        };
+        const response = await axios_1.default.get(url, { params, headers: config_1.headers, timeout: this.timeoutMs }).catch((err) => err.response);
+        if (!response || response.status !== 200)
+            throw new Error(`Failed to fetch trip stop times: ${response?.statusText || 'Unknown error'}`);
+        const parsed = parsers_1.TripStopTimesResponseSchema.safeParse(response.data);
+        if (!parsed.success)
+            throw new Error(`Failed to parse trip stop times data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        return parsed.data.map((stopTime) => ({
+            ...stopTime,
+            expectedArrivalDateTime: new Date(stopTime.expectedArrivalDateTime),
+            trip: {
+                ...stopTime.trip,
+                departureDateTime: new Date(stopTime.trip.departureDateTime),
+                arrivalDateTime: new Date(stopTime.trip.arrivalDateTime),
+            },
+        }));
+    }
+    async getLiveTripsForRoute(routeId, daysFromToday = 0) {
+        const trips = await this.getRouteTrips({ routeId, daysFromToday });
+        const liveData = new Map();
+        const now = new Date();
+        const activeTrips = trips.filter((trip) => {
+            const isActive = trip.departureDateTime <= now && trip.arrivalDateTime >= now;
+            return isActive && trip.vehicles.some((v) => v.position);
+        });
+        const stopTimesPromises = activeTrips.map(async (trip) => {
+            try {
+                const stopTimes = await this.getTripStopTimes({ tripId: trip.id, daysFromToday });
+                return { tripId: trip.id, stopTimes };
+            }
+            catch (error) {
+                return { tripId: trip.id, stopTimes: [] };
+            }
+        });
+        const results = await Promise.all(stopTimesPromises);
+        for (const result of results) {
+            if (result.stopTimes.length > 0) {
+                liveData.set(result.tripId, result.stopTimes);
+            }
+        }
+        return liveData;
+    }
+    async getActiveTripIds(routeId, daysFromToday = 0, tripsOverride) {
+        const trips = tripsOverride || await this.getRouteTrips({ routeId, daysFromToday });
+        const now = new Date();
+        return trips
+            .filter((trip) => trip.departureDateTime <= now && trip.arrivalDateTime >= now && trip.vehicles.some((v) => v.position))
+            .map((trip) => trip.id);
+    }
+    // Account,
+    async getAccountInfo() {
+        if (!this.authManager.isAuthenticated())
+            throw new Error('Authentication required. Please login using getAuthManager().login() first.');
+        const token = await this.authManager.getAccessToken();
+        if (!token)
+            throw new Error('Failed to get access token. Please login again.');
+        const response = await axios_1.default.get(config_1.default.accountServiceUrl, {
+            headers: {
+                ...config_1.headers,
+                Authorization: `Bearer ${token}`,
+            },
+        }).catch((err) => err.response);
+        if (!response || response.status !== 200)
+            throw new Error(`Failed to fetch account info: ${response?.statusText || 'Unknown error'}`);
+        const parsed = types_1.AccountSchema.safeParse(response.data);
+        if (!parsed.success)
+            throw new Error(`Failed to parse account info data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        return parsed.data;
+    }
+    // Stops.
+    async getStops(routeType) {
+        const now = Date.now();
+        const needsRefresh = !this.cachedStops || (this.cacheTTL >= 0 && this.stopsCachedAt && now - this.stopsCachedAt > this.cacheTTL);
+        if (needsRefresh)
+            await this.fetchAndCacheStops();
+        if (!this.cachedStops)
+            throw new Error('Failed to fetch stops.');
+        if (routeType !== undefined)
+            return this.cachedStops.filter((stop) => stop.routeType === routeType);
+        return this.cachedStops;
+    }
+    async getStopIncomingTrips(options) {
+        if (!this.authManager.isAuthenticated())
+            throw new Error('Authentication required. Please login using getAuthManager().login() first.');
+        const token = await this.authManager.getAccessToken();
+        if (!token)
+            throw new Error('Failed to get access token. Please login again.');
+        const url = `${config_1.default.timetableServiceUrl}/stopIncomingTrips`;
+        const params = {
+            stopId: options.stopId,
+            isMapView: (options.isMapView || false).toString(),
+        };
+        const response = await axios_1.default.get(url, {
+            params, timeout: this.timeoutMs,
+            headers: {
+                ...config_1.headers,
+                Authorization: `Bearer ${token}`,
+            },
+        }).catch((err) => err.response);
+        if (!response || response.status !== 200)
+            throw new Error(`Failed to fetch stop incoming trips: ${response?.statusText || 'Unknown error'}`);
+        const parsed = types_1.StopIncomingTripsResponseSchema.safeParse(response.data);
+        if (!parsed.success)
+            throw new Error(`Failed to parse stop incoming trips data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        return parsed.data.map((trip) => ({
+            ...trip,
+            expectedArrivalDateTime: new Date(trip.expectedArrivalDateTime),
+        }));
+    }
+    async getStopsInternal(options) {
+        let stops = await this.getStops();
+        if (options.stopId)
+            stops = stops.filter((stop) => stop.id === options.stopId);
+        if (options.stopName) {
+            const normalizedName = (0, utils_1.normalizeString)(options.stopName);
+            stops = stops.filter((stop) => {
+                const normalizedStopName = (0, utils_1.normalizeString)(stop.normalizedSearchName);
+                return normalizedStopName.includes(normalizedName);
+            });
+        }
+        if (options.routeType !== undefined)
+            stops = stops.filter((stop) => stop.routeType === options.routeType);
+        return stops;
+    }
+    async getStopById(stopId, routeType) {
+        const stops = await this.getStopsInternal({ stopId, routeType });
+        return stops[0] || null;
+    }
+    async searchStops(options) {
+        const stops = await this.getStopsInternal({ routeType: options.routeType });
+        const normalizedQuery = (0, utils_1.normalizeString)(options.query);
+        const filtered = stops.filter((stop) => {
+            const normalizedName = (0, utils_1.normalizeString)(stop.normalizedSearchName);
+            return normalizedName.includes(normalizedQuery);
+        });
+        return filtered.slice(0, options.limit || 10);
+    }
+    // News.
+    async getNewsfeedInternal() {
+        const now = Date.now();
+        const needsRefresh = !this.cachedNews || (this.cacheTTL >= 0 && this.newsCachedAt && now - this.newsCachedAt > this.cacheTTL);
+        if (!needsRefresh && this.cachedNews)
+            return this.cachedNews;
+        const url = config_1.default.newsProxyServiceUrl;
+        const response = await axios_1.default.get(url, { headers: config_1.headers, timeout: this.timeoutMs }).catch((err) => err.response);
+        if (!response || response.status !== 200)
+            throw new Error(`Failed to fetch newsfeed: ${response?.statusText || 'Unknown error'}`);
+        const parsed = parsers_1.NewsfeedResponseSchema.safeParse(response.data);
+        if (!parsed.success)
+            throw new Error(`Failed to parse newsfeed data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        this.cachedNews = parsed.data;
+        this.newsCachedAt = now;
+        return parsed.data;
+    }
+    async getNewsfeed() {
+        const news = await this.getNewsfeedInternal();
+        return news.map((item) => ({
+            ...item,
+            datePublished: new Date(item.datePublished),
+            validFrom: new Date(item.validFrom),
+            validTo: new Date(item.validTo),
+        }));
+    }
+    async getNewsByRoute(routeId) {
+        const news = await this.getNewsfeedInternal();
+        return news.filter((item) => item.lines.includes(routeId));
+    }
+    // Vehicles.
+    async getLiveVehicles(options) {
+        const routes = options?.routeId ? [await this.getRouteById(options.routeId)].filter((r) => r !== null) : await this.getRoutes();
+        const vehicles = [];
+        for (const route of routes) {
+            try {
+                const trips = await this.getRouteTrips({ routeId: route.id, daysFromToday: 0 });
+                for (const trip of trips) {
+                    for (const vehicle of trip.vehicles) {
+                        if (options?.vehicleId && vehicle.id !== options.vehicleId)
+                            continue;
+                        if (vehicle.position) {
+                            vehicles.push(vehicle);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                continue;
+            }
+        }
+        return vehicles;
+    }
+    async getVehicleById(vehicleId) {
+        const vehicles = await this.getLiveVehicles({ vehicleId });
+        return vehicles[0] || null;
+    }
+    // Cache.
+    async refreshCache() {
+        this.cachedRoutes = null;
+        this.cachedStops = null;
+        this.cachedNews = null;
+        this.routesCachedAt = null;
+        this.stopsCachedAt = null;
+        this.newsCachedAt = null;
+        await Promise.all([
+            this.fetchAndCacheRoutes(),
+            this.fetchAndCacheStops(),
+            this.getNewsfeed(),
+        ]);
+    }
+    clearCache() {
+        this.cachedRoutes = null;
+        this.cachedStops = null;
+        this.cachedNews = null;
+        this.routesCachedAt = null;
+        this.stopsCachedAt = null;
+        this.newsCachedAt = null;
+    }
+    // Private.
+    async fetchAndCacheRoutes() {
+        const url = `${config_1.default.timetableServiceUrl}/routes`;
+        const response = await axios_1.default.get(url, { headers: config_1.headers, timeout: this.timeoutMs }).catch((err) => err.response);
+        if (!response || response.status !== 200)
+            throw new Error(`Failed to fetch routes: ${response?.statusText || 'Unknown error'}`);
+        const parsed = parsers_1.RoutesResponseSchema.safeParse(response.data);
+        if (!parsed.success)
+            throw new Error(`Failed to parse routes data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        this.cachedRoutes = parsed.data;
+        this.routesCachedAt = Date.now();
+    }
+    async fetchAndCacheStops() {
+        const url = `${config_1.default.timetableServiceUrl}/stops`;
+        const response = await axios_1.default.get(url, { headers: config_1.headers, timeout: this.timeoutMs }).catch((err) => err.response);
+        if (!response || response.status !== 200)
+            throw new Error(`Failed to fetch stops: ${response?.statusText || 'Unknown error'}`);
+        const parsed = parsers_1.StopsResponseSchema.safeParse(response.data);
+        if (!parsed.success)
+            throw new Error(`Failed to parse stops data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        this.cachedStops = parsed.data;
+        this.stopsCachedAt = Date.now();
+    }
+}
+exports.ZetManager = ZetManager;