flashq 0.1.0

package/dist/client/connection.d.ts

@@ -0,0 +1,103 @@
+import { EventEmitter } from 'events';
+import type { ClientOptions } from '../types';
+/** Maximum job data size in bytes (1MB) */
+export declare const MAX_JOB_DATA_SIZE: number;
+/** Maximum batch size allowed by the server */
+export declare const MAX_BATCH_SIZE = 1000;
+/**
+ * Validate queue name to prevent injection attacks
+ * @throws Error if queue name is invalid
+ */
+export declare function validateQueueName(queue: string): void;
+/**
+ * Validate job data size
+ * @throws Error if data exceeds max size
+ */
+export declare function validateJobDataSize(data: unknown): void;
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'closed';
+/**
+ * Base connection class for FlashQ.
+ * Handles TCP/HTTP connection, binary protocol, request multiplexing, and auto-reconnect.
+ */
+export declare class FlashQConnection extends EventEmitter {
+    protected _options: Required<ClientOptions>;
+    private socket;
+    private connectionState;
+    private authenticated;
+    private pendingRequests;
+    private responseQueue;
+    private buffer;
+    private binaryBuffer;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private manualClose;
+    constructor(options?: ClientOptions);
+    /** Get client options (read-only) */
+    get options(): Required<ClientOptions>;
+    /**
+     * Connect to FlashQ server.
+     * Automatically called on first command if not connected.
+     *
+     * @example
+     * ```typescript
+     * const client = new FlashQ();
+     * await client.connect();
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Attempt to reconnect with exponential backoff
+     */
+    private scheduleReconnect;
+    private setupSocketHandlers;
+    private processBuffer;
+    private processBinaryBuffer;
+    private handleResponse;
+    /**
+     * Close the connection to the server.
+     *
+     * @example
+     * ```typescript
+     * await client.close();
+     * ```
+     */
+    close(): Promise<void>;
+    /**
+     * Check if connected to the server.
+     *
+     * @returns true if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get current connection state.
+     *
+     * @returns Connection state
+     */
+    getConnectionState(): ConnectionState;
+    /**
+     * Ping the server to check connection health.
+     *
+     * @returns true if server responds
+     */
+    ping(): Promise<boolean>;
+    /**
+     * Authenticate with the server.
+     *
+     * @param token - Authentication token
+     */
+    auth(token: string): Promise<void>;
+    /**
+     * Send a command to the server.
+     * Auto-connects if not connected.
+     *
+     * @param command - Command object
+     * @param customTimeout - Optional custom timeout
+     * @returns Response from server
+     */
+    send<T>(command: Record<string, unknown>, customTimeout?: number): Promise<T>;
+    private sendTcp;
+    private sendHttp;
+    private httpRequest;
+}
+export {};
+//# sourceMappingURL=connection.d.ts.map

package/dist/client/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../src/client/connection.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,UAAU,CAAC;AAI3D,2CAA2C;AAC3C,eAAO,MAAM,iBAAiB,QAAc,CAAC;AAE7C,+CAA+C;AAC/C,eAAO,MAAM,cAAc,OAAO,CAAC;AAWnC;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CASrD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAOvD;AAUD,KAAK,eAAe,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,GAAG,QAAQ,CAAC;AAI/F;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC5C,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,aAAa,CAGb;IACR,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,YAAY,CAA2B;IAG/C,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,aAAkB;IAkBvC,qCAAqC;IACrC,IAAI,OAAO,IAAI,QAAQ,CAAC,aAAa,CAAC,CAErC;IAED;;;;;;;;;OASG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAuE9B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqCzB,OAAO,CAAC,mBAAmB;IA8B3B,OAAO,CAAC,aAAa;IAerB,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,cAAc;IAwBtB;;;;;;;OAOG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B5B;;;;OAIG;IACH,WAAW,IAAI,OAAO;IAItB;;;;OAIG;IACH,kBAAkB,IAAI,eAAe;IAIrC;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAS9B;;;;OAIG;IACG,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxC;;;;;;;OAOG;IACG,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;YAoCrE,OAAO;YAiCP,QAAQ;YAQR,WAAW;CAkI1B"}

package/dist/client/connection.js

@@ -0,0 +1,570 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashQConnection = exports.MAX_BATCH_SIZE = exports.MAX_JOB_DATA_SIZE = void 0;
+exports.validateQueueName = validateQueueName;
+exports.validateJobDataSize = validateJobDataSize;
+/**
+ * Connection management for FlashQ client
+ * Production-ready with auto-reconnect, validation, and proper error handling
+ */
+const net = __importStar(require("net"));
+const events_1 = require("events");
+const msgpack_1 = require("@msgpack/msgpack");
+// ============== Constants ==============
+/** Maximum job data size in bytes (1MB) */
+exports.MAX_JOB_DATA_SIZE = 1024 * 1024;
+/** Maximum batch size allowed by the server */
+exports.MAX_BATCH_SIZE = 1000;
+/** Valid queue name pattern */
+const QUEUE_NAME_REGEX = /^[a-zA-Z0-9_.-]{1,256}$/;
+/** Ultra-fast request ID generator (no crypto overhead) */
+let requestIdCounter = 0;
+const generateReqId = () => `r${++requestIdCounter}`;
+// ============== Validation ==============
+/**
+ * Validate queue name to prevent injection attacks
+ * @throws Error if queue name is invalid
+ */
+function validateQueueName(queue) {
+    if (!queue || typeof queue !== 'string') {
+        throw new Error('Queue name is required');
+    }
+    if (!QUEUE_NAME_REGEX.test(queue)) {
+        throw new Error(`Invalid queue name: "${queue}". Must match pattern: alphanumeric, underscore, hyphen, dot (1-256 chars)`);
+    }
+}
+/**
+ * Validate job data size
+ * @throws Error if data exceeds max size
+ */
+function validateJobDataSize(data) {
+    const size = JSON.stringify(data).length;
+    if (size > exports.MAX_JOB_DATA_SIZE) {
+        throw new Error(`Job data size (${size} bytes) exceeds maximum allowed (${exports.MAX_JOB_DATA_SIZE} bytes)`);
+    }
+}
+// ============== Connection Class ==============
+/**
+ * Base connection class for FlashQ.
+ * Handles TCP/HTTP connection, binary protocol, request multiplexing, and auto-reconnect.
+ */
+class FlashQConnection extends events_1.EventEmitter {
+    _options;
+    socket = null;
+    connectionState = 'disconnected';
+    authenticated = false;
+    pendingRequests = new Map();
+    responseQueue = [];
+    buffer = '';
+    binaryBuffer = Buffer.alloc(0);
+    // Reconnect state
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    manualClose = false;
+    constructor(options = {}) {
+        super();
+        this._options = {
+            host: options.host ?? 'localhost',
+            port: options.port ?? 6789,
+            httpPort: options.httpPort ?? 6790,
+            socketPath: options.socketPath ?? '',
+            token: options.token ?? '',
+            timeout: options.timeout ?? 5000,
+            useHttp: options.useHttp ?? false,
+            useBinary: options.useBinary ?? false,
+            autoReconnect: options.autoReconnect ?? true,
+            maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
+            reconnectDelay: options.reconnectDelay ?? 1000,
+            maxReconnectDelay: options.maxReconnectDelay ?? 30000,
+        };
+    }
+    /** Get client options (read-only) */
+    get options() {
+        return this._options;
+    }
+    /**
+     * Connect to FlashQ server.
+     * Automatically called on first command if not connected.
+     *
+     * @example
+     * ```typescript
+     * const client = new FlashQ();
+     * await client.connect();
+     * ```
+     */
+    async connect() {
+        if (this._options.useHttp) {
+            this.connectionState = 'connected';
+            return;
+        }
+        if (this.connectionState === 'connected') {
+            return;
+        }
+        if (this.connectionState === 'connecting') {
+            // Wait for existing connection attempt
+            return new Promise((resolve, reject) => {
+                const onConnect = () => {
+                    this.removeListener('error', onError);
+                    resolve();
+                };
+                const onError = (err) => {
+                    this.removeListener('connect', onConnect);
+                    reject(err);
+                };
+                this.once('connect', onConnect);
+                this.once('error', onError);
+            });
+        }
+        this.connectionState = 'connecting';
+        this.manualClose = false;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.connectionState = 'disconnected';
+                reject(new Error('Connection timeout'));
+            }, this._options.timeout);
+            const connectionOptions = this._options.socketPath
+                ? { path: this._options.socketPath }
+                : { host: this._options.host, port: this._options.port };
+            this.socket = net.createConnection(connectionOptions, async () => {
+                clearTimeout(timeout);
+                this.connectionState = 'connected';
+                this.reconnectAttempts = 0;
+                this.setupSocketHandlers();
+                if (this._options.token) {
+                    try {
+                        await this.auth(this._options.token);
+                        this.authenticated = true;
+                    }
+                    catch (err) {
+                        this.socket?.destroy();
+                        this.connectionState = 'disconnected';
+                        reject(err);
+                        return;
+                    }
+                }
+                this.emit('connect');
+                resolve();
+            });
+            this.socket.on('error', (err) => {
+                clearTimeout(timeout);
+                if (this.connectionState === 'connecting') {
+                    this.connectionState = 'disconnected';
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Attempt to reconnect with exponential backoff
+     */
+    scheduleReconnect() {
+        if (this.manualClose || !this._options.autoReconnect) {
+            return;
+        }
+        if (this._options.maxReconnectAttempts > 0 &&
+            this.reconnectAttempts >= this._options.maxReconnectAttempts) {
+            this.emit('reconnect_failed', new Error('Max reconnection attempts reached'));
+            return;
+        }
+        this.connectionState = 'reconnecting';
+        this.reconnectAttempts++;
+        // Exponential backoff with jitter
+        const baseDelay = Math.min(this._options.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this._options.maxReconnectDelay);
+        const jitter = Math.random() * 0.3 * baseDelay;
+        const delay = baseDelay + jitter;
+        this.emit('reconnecting', { attempt: this.reconnectAttempts, delay });
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                this.connectionState = 'disconnected';
+                await this.connect();
+                this.emit('reconnected');
+            }
+            catch {
+                this.scheduleReconnect();
+            }
+        }, delay);
+    }
+    setupSocketHandlers() {
+        if (!this.socket)
+            return;
+        this.socket.on('data', (data) => {
+            if (this._options.useBinary) {
+                this.binaryBuffer = Buffer.concat([this.binaryBuffer, data]);
+                this.processBinaryBuffer();
+            }
+            else {
+                this.buffer += data.toString();
+                this.processBuffer();
+            }
+        });
+        this.socket.on('close', () => {
+            const wasConnected = this.connectionState === 'connected';
+            this.connectionState = 'disconnected';
+            this.authenticated = false;
+            this.emit('disconnect');
+            // Auto-reconnect if enabled and not manually closed
+            if (wasConnected && !this.manualClose && this._options.autoReconnect) {
+                this.scheduleReconnect();
+            }
+        });
+        this.socket.on('error', (err) => {
+            this.emit('error', err);
+        });
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const response = JSON.parse(line);
+                this.handleResponse(response);
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    processBinaryBuffer() {
+        while (this.binaryBuffer.length >= 4) {
+            const len = this.binaryBuffer.readUInt32BE(0);
+            if (this.binaryBuffer.length < 4 + len)
+                break;
+            const frameData = this.binaryBuffer.subarray(4, 4 + len);
+            this.binaryBuffer = this.binaryBuffer.subarray(4 + len);
+            try {
+                const response = (0, msgpack_1.decode)(frameData);
+                this.handleResponse(response);
+            }
+            catch {
+                // Ignore decode errors
+            }
+        }
+    }
+    handleResponse(response) {
+        if (response.reqId) {
+            const pending = this.pendingRequests.get(response.reqId);
+            if (pending) {
+                this.pendingRequests.delete(response.reqId);
+                clearTimeout(pending.timer);
+                if (response.ok === false && response.error) {
+                    pending.reject(new Error(response.error));
+                }
+                else {
+                    pending.resolve(response);
+                }
+            }
+        }
+        else {
+            const pending = this.responseQueue.shift();
+            if (pending) {
+                if (response.ok === false && response.error) {
+                    pending.reject(new Error(response.error));
+                }
+                else {
+                    pending.resolve(response);
+                }
+            }
+        }
+    }
+    /**
+     * Close the connection to the server.
+     *
+     * @example
+     * ```typescript
+     * await client.close();
+     * ```
+     */
+    async close() {
+        this.manualClose = true;
+        this.connectionState = 'closed';
+        // Cancel any pending reconnect
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Connection closed'));
+        }
+        this.pendingRequests.clear();
+        for (const pending of this.responseQueue) {
+            pending.reject(new Error('Connection closed'));
+        }
+        this.responseQueue.length = 0;
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    /**
+     * Check if connected to the server.
+     *
+     * @returns true if connected
+     */
+    isConnected() {
+        return this.connectionState === 'connected';
+    }
+    /**
+     * Get current connection state.
+     *
+     * @returns Connection state
+     */
+    getConnectionState() {
+        return this.connectionState;
+    }
+    /**
+     * Ping the server to check connection health.
+     *
+     * @returns true if server responds
+     */
+    async ping() {
+        try {
+            const response = await this.send({ cmd: 'PING' });
+            return response.ok || response.pong === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Authenticate with the server.
+     *
+     * @param token - Authentication token
+     */
+    async auth(token) {
+        const response = await this.send({
+            cmd: 'AUTH',
+            token,
+        });
+        if (!response.ok) {
+            throw new Error('Authentication failed');
+        }
+        this._options.token = token;
+        this.authenticated = true;
+    }
+    /**
+     * Send a command to the server.
+     * Auto-connects if not connected.
+     *
+     * @param command - Command object
+     * @param customTimeout - Optional custom timeout
+     * @returns Response from server
+     */
+    async send(command, customTimeout) {
+        // Wait for reconnection if in progress
+        if (this.connectionState === 'reconnecting') {
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    this.removeListener('reconnected', onReconnect);
+                    this.removeListener('reconnect_failed', onFailed);
+                    reject(new Error('Reconnection timeout'));
+                }, this._options.timeout);
+                const onReconnect = () => {
+                    clearTimeout(timeout);
+                    this.removeListener('reconnect_failed', onFailed);
+                    resolve();
+                };
+                const onFailed = (err) => {
+                    clearTimeout(timeout);
+                    this.removeListener('reconnected', onReconnect);
+                    reject(err);
+                };
+                this.once('reconnected', onReconnect);
+                this.once('reconnect_failed', onFailed);
+            });
+        }
+        if (this.connectionState !== 'connected') {
+            await this.connect();
+        }
+        if (this._options.useHttp) {
+            return this.sendHttp(command, customTimeout);
+        }
+        return this.sendTcp(command, customTimeout);
+    }
+    async sendTcp(command, customTimeout) {
+        if (!this.socket || this.connectionState !== 'connected') {
+            throw new Error('Not connected');
+        }
+        return new Promise((resolve, reject) => {
+            const reqId = generateReqId();
+            const timeoutMs = customTimeout ?? this._options.timeout;
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(reqId);
+                reject(new Error('Request timeout'));
+            }, timeoutMs);
+            this.pendingRequests.set(reqId, {
+                resolve: (value) => resolve(value),
+                reject,
+                timer,
+            });
+            if (this._options.useBinary) {
+                const payload = { ...command, reqId };
+                const encoded = (0, msgpack_1.encode)(payload);
+                const frame = Buffer.alloc(4 + encoded.length);
+                frame.writeUInt32BE(encoded.length, 0);
+                frame.set(encoded, 4);
+                this.socket.write(frame);
+            }
+            else {
+                this.socket.write(JSON.stringify({ ...command, reqId }) + '\n');
+            }
+        });
+    }
+    async sendHttp(command, customTimeout) {
+        const { cmd, ...params } = command;
+        const baseUrl = `http://${this._options.host}:${this._options.httpPort}`;
+        const timeout = customTimeout ?? this._options.timeout;
+        const response = await this.httpRequest(baseUrl, cmd, params, timeout);
+        return response;
+    }
+    async httpRequest(baseUrl, cmd, params, timeout) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this._options.token) {
+            headers['Authorization'] = `Bearer ${this._options.token}`;
+        }
+        // URL-encode queue names to prevent injection
+        const encodeQueue = (queue) => encodeURIComponent(String(queue));
+        let url;
+        let method;
+        let body;
+        switch (cmd) {
+            case 'PUSH':
+                url = `${baseUrl}/queues/${encodeQueue(params.queue)}/jobs`;
+                method = 'POST';
+                body = JSON.stringify({
+                    data: params.data,
+                    priority: params.priority,
+                    delay: params.delay,
+                    ttl: params.ttl,
+                    timeout: params.timeout,
+                    max_attempts: params.max_attempts,
+                    backoff: params.backoff,
+                    unique_key: params.unique_key,
+                    depends_on: params.depends_on,
+                    tags: params.tags,
+                    lifo: params.lifo,
+                    remove_on_complete: params.remove_on_complete,
+                    remove_on_fail: params.remove_on_fail,
+                    stall_timeout: params.stall_timeout,
+                    debounce_id: params.debounce_id,
+                    debounce_ttl: params.debounce_ttl,
+                    job_id: params.job_id,
+                    keep_completed_age: params.keep_completed_age,
+                    keep_completed_count: params.keep_completed_count,
+                });
+                break;
+            case 'PULL':
+                url = `${baseUrl}/queues/${encodeQueue(params.queue)}/jobs?count=1`;
+                method = 'GET';
+                break;
+            case 'PULLB':
+                url = `${baseUrl}/queues/${encodeQueue(params.queue)}/jobs?count=${params.count}`;
+                method = 'GET';
+                break;
+            case 'ACK':
+                url = `${baseUrl}/jobs/${params.id}/ack`;
+                method = 'POST';
+                body = JSON.stringify({ result: params.result });
+                break;
+            case 'FAIL':
+                url = `${baseUrl}/jobs/${params.id}/fail`;
+                method = 'POST';
+                body = JSON.stringify({ error: params.error });
+                break;
+            case 'STATS':
+                url = `${baseUrl}/stats`;
+                method = 'GET';
+                break;
+            case 'METRICS':
+                url = `${baseUrl}/metrics`;
+                method = 'GET';
+                break;
+            case 'LISTQUEUES':
+                url = `${baseUrl}/queues`;
+                method = 'GET';
+                break;
+            default:
+                throw new Error(`HTTP not supported for command: ${cmd}`);
+        }
+        // Create abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const res = await fetch(url, { method, headers, body, signal: controller.signal });
+            const json = (await res.json());
+            if (!json.ok) {
+                throw new Error(json.error ?? 'Unknown error');
+            }
+            const data = json.data;
+            if (cmd === 'PUSH' && data && typeof data === 'object') {
+                return { ok: true, id: data.id };
+            }
+            if ((cmd === 'PULL' || cmd === 'PULLB') && Array.isArray(data)) {
+                if (data.length === 0) {
+                    return { ok: true, job: null };
+                }
+                return cmd === 'PULL'
+                    ? { ok: true, job: data[0] }
+                    : { ok: true, jobs: data };
+            }
+            if (cmd === 'STATS' && data && typeof data === 'object') {
+                return { ok: true, ...data };
+            }
+            if (cmd === 'METRICS' && data && typeof data === 'object') {
+                return { ok: true, ...data };
+            }
+            if (cmd === 'LISTQUEUES' && Array.isArray(data)) {
+                return { ok: true, queues: data };
+            }
+            return json;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error('HTTP request timeout');
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+exports.FlashQConnection = FlashQConnection;
+//# sourceMappingURL=connection.js.map