velora-node-sdk 1.0.0

package/dist/types/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./errors"), exports);

package/dist/ws/MessageQueue.d.ts

@@ -0,0 +1,8 @@
+export declare class MessageQueue {
+    private queue;
+    enqueue(message: Record<string, unknown>): void;
+    flush(): Record<string, unknown>[];
+    clear(): void;
+    size(): number;
+    isEmpty(): boolean;
+}

package/dist/ws/MessageQueue.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueue = void 0;
+class MessageQueue {
+    constructor() {
+        this.queue = [];
+    }
+    enqueue(message) {
+        this.queue.push(message);
+    }
+    flush() {
+        const messages = [...this.queue];
+        this.queue = [];
+        return messages;
+    }
+    clear() {
+        this.queue = [];
+    }
+    size() {
+        return this.queue.length;
+    }
+    isEmpty() {
+        return this.queue.length === 0;
+    }
+}
+exports.MessageQueue = MessageQueue;

package/dist/ws/ReconnectManager.d.ts

@@ -0,0 +1,13 @@
+export declare class ReconnectManager {
+    private readonly initialBackoffMs;
+    private readonly maxBackoffMs;
+    private attemptCount;
+    private timeoutId;
+    constructor(initialBackoffMs?: number, maxBackoffMs?: number);
+    getNextBackoffMs(): number;
+    nextAttempt(): void;
+    resetBackoff(): void;
+    scheduleReconnect(callback: () => void): void;
+    cancel(): void;
+    getAttemptCount(): number;
+}

package/dist/ws/ReconnectManager.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectManager = void 0;
+class ReconnectManager {
+    constructor(initialBackoffMs = 1000, maxBackoffMs = 60000) {
+        this.attemptCount = 0;
+        this.timeoutId = null;
+        this.initialBackoffMs = initialBackoffMs;
+        this.maxBackoffMs = maxBackoffMs;
+    }
+    getNextBackoffMs() {
+        const exponentialBackoff = this.initialBackoffMs * Math.pow(2, this.attemptCount);
+        return Math.min(exponentialBackoff, this.maxBackoffMs);
+    }
+    nextAttempt() {
+        this.attemptCount += 1;
+    }
+    resetBackoff() {
+        this.attemptCount = 0;
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    scheduleReconnect(callback) {
+        const backoffMs = this.getNextBackoffMs();
+        this.timeoutId = setTimeout(() => {
+            this.nextAttempt();
+            callback();
+        }, backoffMs);
+    }
+    cancel() {
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    getAttemptCount() {
+        return this.attemptCount;
+    }
+}
+exports.ReconnectManager = ReconnectManager;

package/dist/ws/WebSocketClient.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'events';
+import { CredentialManager } from '../auth/CredentialManager';
+export declare class WebSocketClient extends EventEmitter {
+    private ws;
+    private baseUrl;
+    private credentialManager;
+    private reconnectManager;
+    private messageQueue;
+    private isIntentionallyClosed;
+    private isConnected;
+    private connectionAttempts;
+    constructor(baseUrl: string, credentialManager: CredentialManager, initialBackoffMs?: number, maxBackoffMs?: number);
+    connect(): Promise<void>;
+    disconnect(): void;
+    isWSConnected(): boolean;
+    send(message: Record<string, unknown>): void;
+    private handleOpen;
+    private handleMessage;
+    private handleClose;
+    private handleError;
+}

package/dist/ws/WebSocketClient.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+const events_1 = require("events");
+const errors_1 = require("../types/errors");
+const ReconnectManager_1 = require("./ReconnectManager");
+const MessageQueue_1 = require("./MessageQueue");
+class WebSocketClient extends events_1.EventEmitter {
+    constructor(baseUrl, credentialManager, initialBackoffMs = 1000, maxBackoffMs = 60000) {
+        super();
+        this.ws = null;
+        this.isIntentionallyClosed = false;
+        this.isConnected = false;
+        this.connectionAttempts = 0;
+        this.baseUrl = baseUrl;
+        this.credentialManager = credentialManager;
+        this.reconnectManager = new ReconnectManager_1.ReconnectManager(initialBackoffMs, maxBackoffMs);
+        this.messageQueue = new MessageQueue_1.MessageQueue();
+    }
+    async connect() {
+        if (this.ws !== null) {
+            return;
+        }
+        const token = this.credentialManager.getToken();
+        if (!token) {
+            throw new errors_1.AuthError('No valid token for WebSocket connection');
+        }
+        if (!this.credentialManager.hasPermission('read')) {
+            throw new errors_1.AuthError('Missing read permission for WebSocket');
+        }
+        this.isIntentionallyClosed = false;
+        this.connectionAttempts += 1;
+        try {
+            const url = `${this.baseUrl}/ws?access_token=${encodeURIComponent(token)}`;
+            this.emit('connecting');
+            this.ws = new WebSocket(url);
+            this.ws.addEventListener('open', () => this.handleOpen());
+            this.ws.addEventListener('message', (event) => this.handleMessage(event));
+            this.ws.addEventListener('close', () => this.handleClose());
+            this.ws.addEventListener('error', (error) => this.handleError(error));
+        }
+        catch (error) {
+            this.ws = null;
+            throw new errors_1.NetworkError(error instanceof Error ? error.message : 'WebSocket connection failed');
+        }
+    }
+    disconnect() {
+        this.isIntentionallyClosed = true;
+        this.reconnectManager.cancel();
+        if (this.ws) {
+            this.ws.removeEventListener('open', () => this.handleOpen());
+            this.ws.removeEventListener('message', (event) => this.handleMessage(event));
+            this.ws.removeEventListener('close', () => this.handleClose());
+            this.ws.removeEventListener('error', (error) => this.handleError(error));
+            if (this.ws.readyState === 1) {
+                this.ws.close();
+            }
+            this.ws = null;
+        }
+        this.isConnected = false;
+        this.messageQueue.clear();
+        this.emit('disconnected');
+    }
+    isWSConnected() {
+        return this.isConnected && this.ws !== null;
+    }
+    send(message) {
+        if (this.isConnected && this.ws) {
+            this.ws.send(JSON.stringify(message));
+        }
+        else {
+            this.messageQueue.enqueue(message);
+        }
+    }
+    handleOpen() {
+        this.isConnected = true;
+        this.reconnectManager.resetBackoff();
+        this.connectionAttempts = 0;
+        this.emit('connected');
+        const queuedMessages = this.messageQueue.flush();
+        for (const msg of queuedMessages) {
+            if (this.ws) {
+                this.ws.send(JSON.stringify(msg));
+            }
+        }
+    }
+    handleMessage(event) {
+        try {
+            const payload = JSON.parse(event.data);
+            this.emit('message', payload);
+            if (payload.event === 'track_changed') {
+                this.emit('track_changed', payload.data);
+            }
+            else if (payload.event === 'playback_state_changed') {
+                this.emit('playback_state_changed', payload.data);
+            }
+            else if (payload.event === 'connected') {
+                this.emit('event:connected');
+            }
+        }
+        catch (error) {
+            this.emit('error', new errors_1.NetworkError('Failed to parse WebSocket message'));
+        }
+    }
+    handleClose() {
+        this.isConnected = false;
+        if (!this.isIntentionallyClosed) {
+            this.reconnectManager.scheduleReconnect(() => {
+                void this.connect();
+            });
+        }
+        else {
+            this.emit('disconnected');
+        }
+    }
+    handleError(error) {
+        this.isConnected = false;
+        const wsError = new errors_1.NetworkError(error instanceof Error ? error.message : 'WebSocket error occurred');
+        this.emit('error', wsError);
+        if (!this.isIntentionallyClosed) {
+            this.reconnectManager.scheduleReconnect(() => {
+                void this.connect();
+            });
+        }
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/dist/ws/index.d.ts

@@ -0,0 +1,3 @@
+export { WebSocketClient } from './WebSocketClient';
+export { ReconnectManager } from './ReconnectManager';
+export { MessageQueue } from './MessageQueue';

package/dist/ws/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueue = exports.ReconnectManager = exports.WebSocketClient = void 0;
+var WebSocketClient_1 = require("./WebSocketClient");
+Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return WebSocketClient_1.WebSocketClient; } });
+var ReconnectManager_1 = require("./ReconnectManager");
+Object.defineProperty(exports, "ReconnectManager", { enumerable: true, get: function () { return ReconnectManager_1.ReconnectManager; } });
+var MessageQueue_1 = require("./MessageQueue");
+Object.defineProperty(exports, "MessageQueue", { enumerable: true, get: function () { return MessageQueue_1.MessageQueue; } });

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "velora-node-sdk",
+  "version": "1.0.0",
+  "author": "CrickDevs",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "Node.js SDK for Velora local API with registration, HTTP endpoints, and WebSocket support",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "commonjs",
+  "files": ["dist", "README.md"],
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "velora",
+    "sdk",
+    "api",
+    "local-api",
+    "nodejs"
+  ],
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  }
+}