zet-api 1.0.0

package/dist/auth/types.d.ts

@@ -0,0 +1,277 @@
+import { z } from 'zod';
+export type LoginCredentials = z.infer<typeof LoginCredentialsSchema>;
+export declare const LoginCredentialsSchema: z.ZodEffects<z.ZodObject<{
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    revokeOtherTokens: z.ZodOptional<z.ZodBoolean>;
+    fcmToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    username?: string | undefined;
+    password?: string | undefined;
+    revokeOtherTokens?: boolean | undefined;
+    fcmToken?: string | undefined;
+    refreshToken?: string | undefined;
+    accessToken?: string | undefined;
+}, {
+    username?: string | undefined;
+    password?: string | undefined;
+    revokeOtherTokens?: boolean | undefined;
+    fcmToken?: string | undefined;
+    refreshToken?: string | undefined;
+    accessToken?: string | undefined;
+}>, {
+    username?: string | undefined;
+    password?: string | undefined;
+    revokeOtherTokens?: boolean | undefined;
+    fcmToken?: string | undefined;
+    refreshToken?: string | undefined;
+    accessToken?: string | undefined;
+}, {
+    username?: string | undefined;
+    password?: string | undefined;
+    revokeOtherTokens?: boolean | undefined;
+    fcmToken?: string | undefined;
+    refreshToken?: string | undefined;
+    accessToken?: string | undefined;
+}>;
+export type RegisterCredentials = z.infer<typeof RegisterCredentialsSchema>;
+export declare const RegisterCredentialsSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    password: string;
+    email: string;
+    confirmPassword: string;
+}, {
+    password: string;
+    email: string;
+    confirmPassword: string;
+}>;
+export type AuthTokens = z.infer<typeof AuthTokensSchema>;
+export type AuthTokensLogin = AuthTokens & {
+    expiresIn: number;
+    viaTokenRefresh: boolean;
+    viaAccessToken: boolean;
+};
+export declare const AuthTokensSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refreshToken: string;
+    accessToken: string;
+}, {
+    refreshToken: string;
+    accessToken: string;
+}>;
+export type RefreshTokenRequest = z.infer<typeof RefreshTokenRequestSchema>;
+export declare const RefreshTokenRequestSchema: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refreshToken: string;
+}, {
+    refreshToken: string;
+}>;
+export type Account = z.infer<typeof AccountSchema>;
+export declare const AccountSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    uid: z.ZodString;
+    email: z.ZodString;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    ePurseAmount: z.ZodNumber;
+    clientId: z.ZodNullable<z.ZodNumber>;
+    language: z.ZodNumber;
+    isFullProfileActivationInProgress: z.ZodBoolean;
+    messages: z.ZodArray<z.ZodUnknown, "many">;
+    processes: z.ZodNullable<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    id: number;
+    uid: string;
+    firstName: string;
+    lastName: string;
+    ePurseAmount: number;
+    clientId: number | null;
+    language: number;
+    isFullProfileActivationInProgress: boolean;
+    messages: unknown[];
+    processes?: unknown;
+}, {
+    email: string;
+    id: number;
+    uid: string;
+    firstName: string;
+    lastName: string;
+    ePurseAmount: number;
+    clientId: number | null;
+    language: number;
+    isFullProfileActivationInProgress: boolean;
+    messages: unknown[];
+    processes?: unknown;
+}>;
+export type StopIncomingTrip = z.infer<typeof StopIncomingTripSchema>;
+export declare const StopIncomingTripSchema: z.ZodObject<{
+    tripId: z.ZodString;
+    routeShortName: z.ZodString;
+    headsign: z.ZodString;
+    expectedArrivalDateTime: z.ZodString;
+    hasLiveTracking: z.ZodBoolean;
+    daysFromToday: z.ZodNumber;
+    shapeId: z.ZodString;
+    vehicles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        isForDisabledPeople: z.ZodNullable<z.ZodBoolean>;
+        vehicleTypeId: z.ZodNullable<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodObject<{
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            latitude: number;
+            longitude: number;
+        }, {
+            latitude: number;
+            longitude: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }, {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tripId: string;
+    routeShortName: string;
+    headsign: string;
+    expectedArrivalDateTime: string;
+    hasLiveTracking: boolean;
+    daysFromToday: number;
+    shapeId: string;
+    vehicles: {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }[];
+}, {
+    tripId: string;
+    routeShortName: string;
+    headsign: string;
+    expectedArrivalDateTime: string;
+    hasLiveTracking: boolean;
+    daysFromToday: number;
+    shapeId: string;
+    vehicles: {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }[];
+}>;
+export type StopIncomingTripWithDates = Omit<StopIncomingTrip, 'expectedArrivalDateTime'> & {
+    expectedArrivalDateTime: Date;
+};
+export type GetStopIncomingTripsInput = z.infer<typeof GetStopIncomingTripsInputSchema>;
+export declare const GetStopIncomingTripsInputSchema: z.ZodObject<{
+    stopId: z.ZodString;
+    isMapView: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    stopId: string;
+    isMapView: boolean;
+}, {
+    stopId: string;
+    isMapView?: boolean | undefined;
+}>;
+export declare const StopIncomingTripsResponseSchema: z.ZodArray<z.ZodObject<{
+    tripId: z.ZodString;
+    routeShortName: z.ZodString;
+    headsign: z.ZodString;
+    expectedArrivalDateTime: z.ZodString;
+    hasLiveTracking: z.ZodBoolean;
+    daysFromToday: z.ZodNumber;
+    shapeId: z.ZodString;
+    vehicles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        isForDisabledPeople: z.ZodNullable<z.ZodBoolean>;
+        vehicleTypeId: z.ZodNullable<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodObject<{
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            latitude: number;
+            longitude: number;
+        }, {
+            latitude: number;
+            longitude: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }, {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tripId: string;
+    routeShortName: string;
+    headsign: string;
+    expectedArrivalDateTime: string;
+    hasLiveTracking: boolean;
+    daysFromToday: number;
+    shapeId: string;
+    vehicles: {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }[];
+}, {
+    tripId: string;
+    routeShortName: string;
+    headsign: string;
+    expectedArrivalDateTime: string;
+    hasLiveTracking: boolean;
+    daysFromToday: number;
+    shapeId: string;
+    vehicles: {
+        id: string;
+        isForDisabledPeople: boolean | null;
+        vehicleTypeId: number | null;
+        position?: {
+            latitude: number;
+            longitude: number;
+        } | undefined;
+    }[];
+}>, "many">;

package/dist/auth/types.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopIncomingTripsResponseSchema = exports.GetStopIncomingTripsInputSchema = exports.StopIncomingTripSchema = exports.AccountSchema = exports.RefreshTokenRequestSchema = exports.AuthTokensSchema = exports.RegisterCredentialsSchema = exports.LoginCredentialsSchema = void 0;
+const zod_1 = require("zod");
+exports.LoginCredentialsSchema = zod_1.z.object({
+    username: zod_1.z.string().email().optional(),
+    password: zod_1.z.string().optional(),
+    revokeOtherTokens: zod_1.z.boolean().optional(),
+    fcmToken: zod_1.z.string().optional(),
+    refreshToken: zod_1.z.string().optional(),
+    accessToken: zod_1.z.string().optional(),
+}).refine((data) => {
+    return (data.accessToken && data.refreshToken) || data.refreshToken || (data.username && data.password);
+}, {
+    message: 'Either (accessToken + refreshToken), refreshToken alone, or both username and password must be provided',
+});
+exports.RegisterCredentialsSchema = zod_1.z.object({
+    email: zod_1.z.string().email(),
+    password: zod_1.z.string(),
+    confirmPassword: zod_1.z.string(),
+});
+exports.AuthTokensSchema = zod_1.z.object({
+    accessToken: zod_1.z.string(),
+    refreshToken: zod_1.z.string(),
+});
+exports.RefreshTokenRequestSchema = zod_1.z.object({
+    refreshToken: zod_1.z.string(),
+});
+exports.AccountSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    uid: zod_1.z.string(),
+    email: zod_1.z.string().email(),
+    firstName: zod_1.z.string(),
+    lastName: zod_1.z.string(),
+    ePurseAmount: zod_1.z.number(),
+    clientId: zod_1.z.number().nullable(),
+    language: zod_1.z.number(),
+    isFullProfileActivationInProgress: zod_1.z.boolean(),
+    messages: zod_1.z.array(zod_1.z.unknown()),
+    processes: zod_1.z.unknown().nullable(),
+});
+exports.StopIncomingTripSchema = zod_1.z.object({
+    tripId: zod_1.z.string(),
+    routeShortName: zod_1.z.string(),
+    headsign: zod_1.z.string(),
+    expectedArrivalDateTime: zod_1.z.string(),
+    hasLiveTracking: zod_1.z.boolean(),
+    daysFromToday: zod_1.z.number(),
+    shapeId: zod_1.z.string(),
+    vehicles: zod_1.z.array(zod_1.z.object({
+        id: zod_1.z.string(),
+        isForDisabledPeople: zod_1.z.boolean().nullable(),
+        vehicleTypeId: zod_1.z.number().nullable(),
+        position: zod_1.z.object({
+            latitude: zod_1.z.number(),
+            longitude: zod_1.z.number(),
+        }).optional(),
+    })),
+});
+exports.GetStopIncomingTripsInputSchema = zod_1.z.object({
+    stopId: zod_1.z.string(),
+    isMapView: zod_1.z.boolean().optional().default(false),
+});
+exports.StopIncomingTripsResponseSchema = zod_1.z.array(exports.StopIncomingTripSchema);

package/dist/core/auth-manager.d.ts

@@ -0,0 +1,54 @@
+import { LoginCredentials, AuthTokens, Account } from './auth-types';
+/**
+ * ZetAuthManager handles authentication with the ZET API
+ * Manages login, token refresh, and account information
+ */
+export declare class ZetAuthManager {
+    private accessToken;
+    private refreshToken;
+    private tokenExpiresAt;
+    /**
+     * Check if currently authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Check if access token is expired or about to expire (within 1 minute)
+     */
+    isAccessTokenExpired(): boolean;
+    /**
+     * Get current access token, refreshing if needed
+     */
+    getAccessToken(): Promise<string | null>;
+    /**
+     * Login with username and password
+     */
+    login(credentials: LoginCredentials): Promise<AuthTokens>;
+    /**
+     * Refresh access token using refresh token
+     */
+    refreshAccessToken(): Promise<AuthTokens>;
+    /**
+     * Get account information (requires authentication)
+     */
+    getAccount(): Promise<Account>;
+    /**
+     * Logout and clear stored tokens
+     */
+    logout(): void;
+    /**
+     * Set tokens and calculate expiration
+     */
+    private setTokens;
+    /**
+     * Clear all stored tokens
+     */
+    private clearTokens;
+    /**
+     * Manually set tokens (for restoring session)
+     */
+    setTokensManually(tokens: AuthTokens): void;
+    /**
+     * Get current tokens (for saving session)
+     */
+    getTokens(): AuthTokens | null;
+}

package/dist/core/auth-manager.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZetAuthManager = void 0;
+const auth_types_1 = require("./auth-types");
+const utils_1 = require("./utils");
+const axios_1 = __importDefault(require("axios"));
+const config_1 = __importDefault(require("./config"));
+/**
+ * ZetAuthManager handles authentication with the ZET API
+ * Manages login, token refresh, and account information
+ */
+class ZetAuthManager {
+    accessToken = null;
+    refreshToken = null;
+    tokenExpiresAt = null;
+    /**
+     * Check if currently authenticated
+     */
+    isAuthenticated() {
+        return !!this.accessToken && !!this.refreshToken;
+    }
+    /**
+     * Check if access token is expired or about to expire (within 1 minute)
+     */
+    isAccessTokenExpired() {
+        if (!this.tokenExpiresAt)
+            return true;
+        return Date.now() >= this.tokenExpiresAt - 60000; // 1 minute buffer
+    }
+    /**
+     * Get current access token, refreshing if needed
+     */
+    async getAccessToken() {
+        if (!this.isAuthenticated()) {
+            throw new Error('Not authenticated. Please login first.');
+        }
+        if (this.isAccessTokenExpired() && this.refreshToken) {
+            await this.refreshAccessToken();
+        }
+        return this.accessToken;
+    }
+    /**
+     * Login with username and password
+     */
+    async login(credentials) {
+        const validated = auth_types_1.LoginCredentialsSchema.parse(credentials);
+        const response = await axios_1.default.post(`${config_1.default.authServiceUrl}/login`, validated).catch((err) => err.response);
+        if (!response || response.status !== 200) {
+            throw new Error(`Login failed: ${response?.statusText || 'Unknown error'}`);
+        }
+        const parsed = auth_types_1.AuthTokensSchema.safeParse(response.data);
+        if (!parsed.success) {
+            throw new Error(`Failed to parse login response: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        }
+        this.setTokens(parsed.data);
+        return parsed.data;
+    }
+    /**
+     * Refresh access token using refresh token
+     */
+    async refreshAccessToken() {
+        if (!this.refreshToken) {
+            throw new Error('No refresh token available. Please login first.');
+        }
+        const validated = auth_types_1.RefreshTokenRequestSchema.parse({ refreshToken: this.refreshToken });
+        const response = await axios_1.default.post(`${config_1.default.authServiceUrl}/refreshTokens`, validated).catch((err) => err.response);
+        if (!response || response.status !== 200) {
+            // If refresh fails, clear tokens and require re-login
+            this.clearTokens();
+            throw new Error(`Token refresh failed: ${response?.statusText || 'Unknown error'}. Please login again.`);
+        }
+        const parsed = auth_types_1.AuthTokensSchema.safeParse(response.data);
+        if (!parsed.success) {
+            throw new Error(`Failed to parse refresh response: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        }
+        this.setTokens(parsed.data);
+        return parsed.data;
+    }
+    /**
+     * Get account information (requires authentication)
+     */
+    async getAccount() {
+        const token = await this.getAccessToken();
+        if (!token) {
+            throw new Error('Not authenticated. Please login first.');
+        }
+        const response = await axios_1.default.get(config_1.default.accountServiceUrl, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        }).catch((err) => err.response);
+        if (!response || response.status !== 200) {
+            throw new Error(`Failed to get account: ${response?.statusText || 'Unknown error'}`);
+        }
+        const parsed = auth_types_1.AccountSchema.safeParse(response.data);
+        if (!parsed.success) {
+            throw new Error(`Failed to parse account data: ${(0, utils_1.parseZodError)(parsed.error).join(', ')}.`);
+        }
+        return parsed.data;
+    }
+    /**
+     * Logout and clear stored tokens
+     */
+    logout() {
+        this.clearTokens();
+    }
+    /**
+     * Set tokens and calculate expiration
+     */
+    setTokens(tokens) {
+        this.accessToken = tokens.accessToken;
+        this.refreshToken = tokens.refreshToken;
+        // Decode JWT to get expiration (simple base64 decode, no verification)
+        try {
+            const parts = tokens.accessToken.split('.');
+            if (parts.length === 3 && parts[1]) {
+                const payload = JSON.parse(atob(parts[1]));
+                this.tokenExpiresAt = payload.exp * 1000; // Convert to milliseconds
+            }
+            else {
+                // If decode fails, assume 15 minutes
+                this.tokenExpiresAt = Date.now() + 900000;
+            }
+        }
+        catch (error) {
+            // If decode fails, assume 15 minutes
+            this.tokenExpiresAt = Date.now() + 900000;
+        }
+    }
+    /**
+     * Clear all stored tokens
+     */
+    clearTokens() {
+        this.accessToken = null;
+        this.refreshToken = null;
+        this.tokenExpiresAt = null;
+    }
+    /**
+     * Manually set tokens (for restoring session)
+     */
+    setTokensManually(tokens) {
+        this.setTokens(tokens);
+    }
+    /**
+     * Get current tokens (for saving session)
+     */
+    getTokens() {
+        if (!this.accessToken || !this.refreshToken)
+            return null;
+        return {
+            accessToken: this.accessToken,
+            refreshToken: this.refreshToken,
+        };
+    }
+}
+exports.ZetAuthManager = ZetAuthManager;