skikrumb-api 1.4.0 → 2.0.0

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//Users/michael/.config/nvim/**)",
+      "Read(//Users/michael/.config/**)",
+      "Read(//Users/michael/Code/skikrumb-api/**)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/dist/index.d.ts

@@ -1,30 +1,46 @@
-import { apiKeys, Device, Gateways, QueryDevice, RateRequest, Rates } from './models';
+import { apiKeys, Device, Gateways, QueryDevice, RateRequest, Rates, ExternalUserRequest, ExternalUserResponse } from './models';
+declare class SkiKrumbRealtimeClient {
+    private websocket;
+    private sessionToken;
+    private supabaseToken?;
+    private url;
+    private userId;
+    private listeners;
+    private isConnecting;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    constructor(sessionToken: string, userId: string, url: string, supabaseToken?: string);
+    connect(): Promise<void>;
+    private connectToWebSocket;
+    private scheduleReconnect;
+    disconnect(): void;
+    ping(): void;
+    requestRefresh(): void;
+    on(event: string, callback: Function): void;
+    off(event: string, callback?: Function): void;
+    private emit;
+    isConnected(): boolean;
+}
 export declare const skiKrumb: (options?: {
-    apiKey: string;
-    supabaseToken: string;
-    requestedWith: string | undefined;
-    url: string | undefined;
+    apiKey?: string;
+    supabaseToken?: string | undefined;
+    requestedWith?: string | undefined;
+    url?: string | undefined;
 }) => {
-    createDevice: (deveui: string, serialNumber: string) => Promise<any>;
-    createDeviceDownlink: (userId: string, deveui: string, type?: string) => Promise<any>;
-    sendMobileLocation: (payload: any) => Promise<any>;
-    createPaymentIntent: (form: any) => Promise<any>;
-    createPrePurchaseIntent: (form: any) => Promise<any>;
-    getPaymentIntent: (clientSecret: string) => Promise<any>;
-    updateCustomerAddress: (customerId: string, email: string, shipping: object) => Promise<any>;
-    getTaxCalculation: (amount: number, reference: string, quantity: number, address: {
-        country: string;
-        postal_code: string;
-        state?: string;
-    }) => Promise<any>;
-    createSubscription: (customerId: string, priceId: string, cartId: string, productId: string, registrations: Array<string>) => Promise<any>;
-    updatePaymentIntent: (cartId: string, intentId: string) => Promise<any>;
-    updateSubscription: (subscriptionId: string, quantity: number, registrations: Array<string>) => Promise<any>;
-    cancelSubscription: (subscriptionId: string) => Promise<any>;
-    readApiKeys: () => Promise<apiKeys[]>;
-    readDataForDevices: (query: QueryDevice) => Promise<Device[]>;
-    readDeviceDailyDistance: (serialNumber: string, query: QueryDevice) => Promise<Device[]>;
-    readDeviceData: (serialNumber: string, query: QueryDevice) => Promise<Device>;
+    createDevice: (device: Device) => Promise<Device>;
+    readDevices: (devices: QueryDevice | string) => Promise<Device[]>;
+    readApiKeys: () => Promise<apiKeys>;
+    readDeviceDailyDistance: (deviceSerialNumber: string) => Promise<unknown>;
+    readDeviceData: (deviceSerialNumber: string, limit?: number) => Promise<unknown>;
     readGateways: () => Promise<Gateways>;
-    readShippingRates: (payload: RateRequest) => Promise<Rates[]>;
+    readShippingRates: (rateRequest: RateRequest) => Promise<Rates>;
+    sendMobileLocation: (payload: {
+        deviceId: string;
+        locations: any[];
+    }) => Promise<unknown>;
+    authenticateExternalUser: (userData: ExternalUserRequest) => Promise<ExternalUserResponse>;
+    refreshSessionToken: (currentToken: string) => Promise<ExternalUserResponse>;
+    createRealtimeClient: (userId: string, sessionToken?: string, supabaseToken?: string) => SkiKrumbRealtimeClient;
 };
+export type { Device, Gateways, QueryDevice, RateRequest, Rates, apiKeys, ExternalUserRequest, ExternalUserResponse };

package/dist/index.js

@@ -1,227 +1,381 @@
 import ky from 'ky';
+class SkiKrumbRealtimeClient {
+    constructor(sessionToken, userId, url, supabaseToken) {
+        this.websocket = null;
+        this.listeners = {};
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;
+        this.sessionToken = sessionToken;
+        this.supabaseToken = supabaseToken;
+        this.userId = userId;
+        this.url = url.replace(/\/+$/, ''); // Remove trailing slashes
+    }
+    async connect() {
+        if (this.isConnecting) {
+            return Promise.resolve();
+        }
+        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            return Promise.resolve();
+        }
+        // Additional guard: check if we're already connecting or connected
+        if (this.websocket && (this.websocket.readyState === WebSocket.CONNECTING || this.websocket.readyState === WebSocket.OPEN)) {
+            return Promise.resolve();
+        }
+        // Clean up any stale websocket before creating new one
+        if (this.websocket && this.websocket.readyState >= WebSocket.CLOSING) {
+            this.disconnect();
+        }
+        this.isConnecting = true;
+        try {
+            await this.connectToWebSocket();
+        }
+        catch (error) {
+            this.isConnecting = false;
+            throw error;
+        }
+    }
+    connectToWebSocket() {
+        return new Promise((resolve, reject) => {
+            try {
+                const baseWsUrl = this.url.replace(/^https/, 'wss').replace(/^http/, 'ws') + '/realtime';
+                let wsUrl = `${baseWsUrl}?token=${encodeURIComponent(this.sessionToken)}`;
+                if (this.supabaseToken) {
+                    wsUrl += `&supabaseToken=${encodeURIComponent(this.supabaseToken)}`;
+                }
+                this.websocket = new WebSocket(wsUrl);
+                this.websocket.onopen = () => {
+                    // Authentication is handled automatically via query parameters
+                };
+                // Handle all WebSocket messages
+                this.websocket.onmessage = (event) => {
+                    var _a, _b, _c, _d, _e, _f;
+                    try {
+                        const message = JSON.parse(event.data);
+                        if (message.type === 'auth_success') {
+                            this.isConnecting = false;
+                            this.reconnectAttempts = 0;
+                            this.emit('connected', message);
+                            resolve();
+                        }
+                        else if (message.type === 'auth_error' || message.type === 'error') {
+                            console.error('❌ Authentication/Connection failed:', message.message || message.error);
+                            (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.close();
+                            reject(new Error(`Connection failed: ${message.message || message.error}`));
+                        }
+                        else if (message.type === 'session_replaced') {
+                            this.emit('session_replaced', message);
+                        }
+                        else if (message.type === 'subscription_updated') {
+                            this.emit('subscription_updated', message);
+                        }
+                        else if (message.type === 'profile_update') {
+                            this.emit('profile_update', message);
+                        }
+                        else if (message.type === 'device_data') {
+                            // Transform device data to match expected React Native format
+                            const deviceData = {
+                                ...message.data,
+                                device_id: ((_b = message.data.deveui) === null || _b === void 0 ? void 0 : _b.replace(/'/g, '')) || message.data.device_id,
+                                serial_number: ((_c = message.data.serial_number) === null || _c === void 0 ? void 0 : _c.replace(/'/g, '')) || message.data.serial_number,
+                                gps_fix: ((_d = message.data.gps_fix) === null || _d === void 0 ? void 0 : _d.replace(/'/g, '')) || message.data.gps_fix,
+                                gateway_id: ((_e = message.data.gateway_uuid) === null || _e === void 0 ? void 0 : _e.replace(/'/g, '')) || message.data.gateway_id,
+                                created_at: ((_f = message.data.recorded_at) === null || _f === void 0 ? void 0 : _f.replace(/'/g, '')) || message.data.created_at || message.timestamp,
+                                timestamp: message.timestamp
+                            };
+                            this.emit('device_data', deviceData);
+                        }
+                        else if (message.type === 'pong') {
+                            this.emit('pong', message);
+                        }
+                        else {
+                            // Handle any other message types
+                            if (message.type) {
+                                this.emit(message.type, message);
+                            }
+                            this.emit('message', message);
+                        }
+                    }
+                    catch (error) {
+                        console.error('❌ Error parsing realtime message:', error);
+                        this.emit('error', error);
+                    }
+                };
+                this.websocket.onerror = (error) => {
+                    console.error('❌ Realtime connection error:', error);
+                    this.isConnecting = false;
+                    this.emit('error', error);
+                    reject(error);
+                };
+                this.websocket.onclose = (event) => {
+                    this.websocket = null;
+                    this.isConnecting = false;
+                    // Don't auto-reconnect if it's a session replacement or normal close
+                    if (event.code === 4000) {
+                        this.emit('disconnected', { reason: 'Session replaced' });
+                    }
+                    else if (event.code === 1000) {
+                        this.emit('disconnected', { reason: 'Manual disconnect' });
+                    }
+                    else {
+                        // Only reconnect for unexpected disconnections
+                        this.emit('disconnected', {
+                            reason: event.reason || 'Connection closed',
+                        });
+                        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                            this.scheduleReconnect();
+                        }
+                        else {
+                            this.emit('max_reconnect_attempts_reached');
+                        }
+                    }
+                };
+            }
+            catch (error) {
+                this.isConnecting = false;
+                reject(error);
+            }
+        });
+    }
+    scheduleReconnect() {
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        setTimeout(() => {
+            this.connect().catch((error) => {
+                console.error('❌ Reconnect failed:', error);
+                if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+                    console.error('❌ Max reconnect attempts reached');
+                    this.emit('max_reconnect_attempts_reached');
+                }
+            });
+        }, delay);
+    }
+    disconnect() {
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        if (this.websocket) {
+            // Remove all listeners to prevent events during cleanup
+            this.websocket.onopen = null;
+            this.websocket.onmessage = null;
+            this.websocket.onerror = null;
+            this.websocket.onclose = null;
+            // Close the connection if it's still open
+            if (this.websocket.readyState === WebSocket.OPEN || this.websocket.readyState === WebSocket.CONNECTING) {
+                this.websocket.close(1000, 'Manual disconnect');
+            }
+            this.websocket = null;
+        }
+    }
+    ping() {
+        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            this.websocket.send(JSON.stringify({ type: 'ping', timestamp: new Date().toISOString() }));
+        }
+    }
+    requestRefresh() {
+        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            this.websocket.send(JSON.stringify({ type: 'request_refresh', timestamp: new Date().toISOString() }));
+        }
+    }
+    on(event, callback) {
+        if (!this.listeners[event]) {
+            this.listeners[event] = [];
+        }
+        this.listeners[event].push(callback);
+    }
+    off(event, callback) {
+        if (!this.listeners[event])
+            return;
+        if (callback) {
+            this.listeners[event] = this.listeners[event].filter((cb) => cb !== callback);
+        }
+        else {
+            this.listeners[event] = [];
+        }
+    }
+    emit(event, data) {
+        const callbacks = this.listeners[event] || [];
+        callbacks.forEach((callback) => {
+            try {
+                callback(data);
+            }
+            catch (error) {
+                console.error(`❌ Error in realtime event listener for '${event}':`, error);
+            }
+        });
+    }
+    isConnected() {
+        return (this.websocket !== null && this.websocket.readyState === WebSocket.OPEN);
+    }
+}
 export const skiKrumb = (options = {
     apiKey: '',
-    supabaseToken: '',
+    supabaseToken: undefined,
     requestedWith: 'skiKrumb Node & Client API Wrapper',
     url: 'https://api.skikrumb.ca',
 }) => {
-    const api = ky.extend({
-        hooks: {
-            beforeRequest: [
-                (request) => {
-                    request.headers.set('X-Requested-With', `${options.requestedWith}`);
-                    request.headers.set('Authorization', `Bearer ${options.apiKey}`);
-                    request.headers.set('Content-Type', `application/json`);
-                    if (options.supabaseToken) {
-                        request.headers.set('supabase-auth-token', options.supabaseToken);
-                    }
-                },
-            ],
+    const request = ky.create({
+        prefixUrl: options.url,
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${options.apiKey}`,
+            'x-client': options.requestedWith,
         },
     });
-    const createDevice = async (deveui, serialNumber) => {
-        if (!deveui || !serialNumber)
-            throw new Error('Must pass Lora MAC (deveui) and Serial Number');
-        return await api
-            .post(`${options.url}/devices`, {
-            headers: {
-                'content-type': 'application/json',
-            },
-            json: { deveui: deveui, serial_number: serialNumber },
-        })
+    // Device API endpoints
+    const createDevice = async (device) => {
+        const response = await request
+            .post('device', { json: device })
             .json();
+        return response;
     };
-    const createDeviceDownlink = async (userId, deveui, type = 'beep') => {
-        if (!userId || !deveui || !type)
-            throw new Error('Must pass userId, Lora MAC (deveui) and message type');
-        let message = 'DAgAC04zKE9EPTEwKQ0K';
-        switch (type) {
-            case 'help-off':
-                message = 'DBECAAAAAAAAAAAB';
-                break;
-        }
-        return await api
-            .post(`${options.url}/devices/downlink`, {
-            headers: {
-                'content-type': 'application/json',
-            },
-            json: {
-                device: deveui,
-                userId: userId,
-                data: {
-                    params: {
-                        data: message,
-                        port: 100,
-                    },
-                },
-            },
-        })
-            .json();
-    };
-    const sendMobileLocation = async (payload) => {
-        if (!payload)
-            throw new Error('Payload is required');
-        return await api
-            .post(`${options.url}/devices/location/mobile`, {
-            headers: {
-                'content-type': 'application/json',
-            },
-            json: payload,
-        })
-            .json();
-    };
-    const createPaymentIntent = async (form) => {
-        if (!form)
-            throw new Error('Form values not posted.');
-        return api
-            .post(`${options.url}/payments/purchase/intent`, {
-            body: form,
-        })
-            .json();
-    };
-    const getPaymentIntent = async (clientSecret) => {
-        if (!clientSecret)
-            throw new Error('Client secret is required');
-        return api.get(`${options.url}/payments/intent/${clientSecret}`).json();
-    };
-    const updatePaymentIntent = async (cartId, intentId) => {
-        if (!cartId || !intentId)
-            throw new Error('Cart Id and IntentId are required');
-        return api.patch(`${options.url}/payments/intent/${intentId}`, {
-            json: {
-                cartId: cartId,
+    const readDevices = async (devices) => {
+        try {
+            let response;
+            if (typeof devices === 'string') {
+                response = await request.get(`device/read/${devices}`).json();
             }
-        }).json();
-    };
-    const createPrePurchaseIntent = async (form) => {
-        if (!form)
-            throw new Error('Form values not posted.');
-        return api
-            .post(`${options.url}/payments/pre-purchase/intent`, {
-            body: form,
-        })
-            .json();
-    };
-    const updateCustomerAddress = async (customerId, email, shipping) => {
-        if (!customerId || !email || !shipping) {
-            throw new Error('Customer ID, email, and shipping details are required');
-        }
-        return api
-            .post(`${options.url}/customers/address`, {
-            json: { customerId, email, shipping },
-        })
-            .json();
-    };
-    const getTaxCalculation = async (amount, reference, quantity, address) => {
-        if (!amount || !reference || !quantity || !address) {
-            throw new Error('Amount, reference, quantity, and address are required');
-        }
-        return api
-            .post(`${options.url}/tax-calculation`, {
-            json: { amount, reference, quantity, address },
-        })
-            .json();
-    };
-    const createSubscription = async (customerId, priceId, cartId, productId, registrations) => {
-        if (!customerId || !priceId || !cartId || !productId || !registrations) {
-            throw new Error('Customer ID, price Id, cart ID, product ID, and registrations are required');
-        }
-        return api
-            .post(`${options.url}/payments/create-subscription`, {
-            json: {
-                customerId,
-                priceId,
-                cartId,
-                productId,
-                quantity: registrations.length,
-                registrations,
-            },
-        })
-            .json();
-    };
-    const updateSubscription = async (subscriptionId, quantity, registrations) => {
-        if (!subscriptionId) {
-            throw new Error('Subscription ID is required');
-        }
-        return api
-            .patch(`${options.url}/payments/update-subscription`, {
-            json: {
-                subscriptionId,
-                quantity,
-                registrations,
-            },
-        })
-            .json();
+            else {
+                response = await request
+                    .post('device/read', { json: devices })
+                    .json();
+            }
+            return response;
+        }
+        catch (error) {
+            console.error('❌ Read Devices Error:', error);
+            throw error;
+        }
     };
-    const cancelSubscription = async (subscriptionId) => {
-        if (!subscriptionId) {
-            throw new Error('Subscription ID is required');
+    const readDeviceData = async (deviceSerialNumber, limit) => {
+        try {
+            const queryParams = limit ? `?limit=${limit}` : '';
+            const response = await request
+                .get(`device/data/${deviceSerialNumber}${queryParams}`)
+                .json();
+            return response;
+        }
+        catch (error) {
+            console.error('❌ Read Device Data Error:', error);
+            throw error;
         }
-        return api
-            .delete(`${options.url}/payments/subscription/${subscriptionId}`)
-            .json();
     };
-    const readDeviceData = async (serialNumber, query) => {
-        if (!serialNumber)
-            throw new Error('Serial number is required');
-        return api
-            .get(`${options.url}/devices/data/${serialNumber}`, {
-            searchParams: new URLSearchParams({ ...query }),
-        })
-            .json();
+    const readDeviceDailyDistance = async (deviceSerialNumber) => {
+        try {
+            const response = await request
+                .get(`device/distance/${deviceSerialNumber}`)
+                .json();
+            return response;
+        }
+        catch (error) {
+            console.error('❌ Read Device Daily Distance Error:', error);
+            throw error;
+        }
     };
     const readGateways = async () => {
-        return api.get(`${options.url}/gateways`).json();
+        try {
+            const response = await request.get('gateways').json();
+            return response;
+        }
+        catch (error) {
+            console.error('❌ Read Gateways Error:', error);
+            throw error;
+        }
     };
-    const readDeviceDailyDistance = async (serialNumber, query) => {
-        if (!serialNumber)
-            throw new Error('Serial number is required');
-        return api
-            .get(`${options.url}/devices/${serialNumber}/distance`, {
-            searchParams: new URLSearchParams({ ...query }),
-        })
-            .json();
+    const readApiKeys = async () => {
+        try {
+            const response = await request.get('keys').json();
+            return response;
+        }
+        catch (error) {
+            console.error('❌ Read API Keys Error:', error);
+            throw error;
+        }
     };
-    const readDataForDevices = async (query) => {
-        if (!query.serial_numbers)
-            throw new Error('Serial number is required');
-        return api
-            .get(`${options.url}/devices/data`, {
-            searchParams: new URLSearchParams({ ...query }),
-        })
-            .json();
+    const readShippingRates = async (rateRequest) => {
+        try {
+            const response = await request
+                .post('shipping/rates', { json: rateRequest })
+                .json();
+            return response;
+        }
+        catch (error) {
+            console.error('❌ Read Shipping Rates Error:', error);
+            throw error;
+        }
     };
-    const readApiKeys = async () => {
-        return api.get(`${options.url}/keys`).json();
+    const sendMobileLocation = async (payload) => {
+        try {
+            const response = await request
+                .post('devices/location/mobile', { json: payload })
+                .json();
+            return response;
+        }
+        catch (error) {
+            console.error('❌ Send Mobile Location Error:', error);
+            throw error;
+        }
     };
-    const readShippingRates = async (payload) => {
-        return await api
-            .post(`${options.url}/payments/shipping-rates`, {
-            headers: {
-                'content-type': 'application/json',
-            },
-            json: payload,
-        })
-            .json();
+    const authenticateExternalUser = async (userData) => {
+        try {
+            const response = await request
+                .post('auth/external', { json: userData })
+                .json();
+            return response;
+        }
+        catch (error) {
+            console.error('❌ External User Authentication Error:', error);
+            throw error;
+        }
+    };
+    const refreshSessionToken = async (currentToken) => {
+        try {
+            // Create temporary request with current token
+            const refreshRequest = ky.create({
+                prefixUrl: options.url,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${currentToken}`,
+                    'x-client': options.requestedWith,
+                },
+            });
+            const response = await refreshRequest
+                .post('auth/external/refresh')
+                .json();
+            return {
+                success: response.success,
+                sessionToken: response.sessionToken,
+                accessibleSerials: response.accessibleSerials,
+                serialsCount: response.serialsCount,
+                timestamp: response.timestamp,
+            };
+        }
+        catch (error) {
+            console.error('❌ Token Refresh Error:', error);
+            throw error;
+        }
     };
     return {
         createDevice,
-        createDeviceDownlink,
-        sendMobileLocation,
-        createPaymentIntent,
-        createPrePurchaseIntent,
-        getPaymentIntent,
-        updateCustomerAddress,
-        getTaxCalculation,
-        createSubscription,
-        updatePaymentIntent,
-        updateSubscription,
-        cancelSubscription,
+        readDevices,
         readApiKeys,
-        readDataForDevices,
         readDeviceDailyDistance,
         readDeviceData,
         readGateways,
-        readShippingRates
+        readShippingRates,
+        sendMobileLocation,
+        authenticateExternalUser,
+        refreshSessionToken,
+        createRealtimeClient: (userId, sessionToken, supabaseToken) => {
+            if (!sessionToken && !options.apiKey) {
+                throw new Error('Session token or API key required for realtime client');
+            }
+            if (!userId) {
+                throw new Error('User ID is required for realtime client');
+            }
+            // Use provided session token or fall back to API key for backward compatibility
+            const token = sessionToken || options.apiKey;
+            return new SkiKrumbRealtimeClient(token, userId, options.url || 'https://api.skikrumb.ca', supabaseToken);
+        },
     };
 };

package/dist/models.d.ts

@@ -97,3 +97,20 @@ export interface RateRequest {
     email_addresses: string[];
     quantity: number;
 }
+export interface ExternalUserRequest {
+    externalUserId: string;
+    externalUserEmail?: string;
+    nickName?: string;
+    providerId?: string;
+    providerName?: string;
+}
+export interface ExternalUserResponse {
+    success: boolean;
+    accountId?: string;
+    sessionToken?: string;
+    isNewUser?: boolean;
+    error?: string;
+    accessibleSerials?: string[];
+    serialsCount?: number;
+    timestamp?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skikrumb-api",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "Wrapper for the skiKrumb API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,9 +13,10 @@
   "author": "",
   "license": "UNLICENSED",
   "devDependencies": {
-    "typescript": "^5.1.6",
+    "@types/node": "^18.19.125",
     "prettier": "^3.3.3",
-    "prettier-plugin-organize-attributes": "^1.0.0"
+    "prettier-plugin-organize-attributes": "^1.0.0",
+    "typescript": "^5.1.6"
   },
   "dependencies": {
     "ky": "^1.7.5"

package/tsconfig.json

@@ -7,8 +7,13 @@
     "strict": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
-    "moduleResolution":"Node"
+    "moduleResolution": "Node",
+    "rootDir": "./lib",
+    "types": ["node"]
   },
+  "include": [
+    "lib/**/*"
+  ],
   "exclude": [
     "node_modules",
     "dist",