@luxdb/sdk 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -12,6 +12,30 @@ export interface VSearchOptions {
     };
     meta?: boolean;
 }
+export interface TSSample {
+    timestamp: number;
+    value: number;
+}
+export interface TSAddOptions {
+    retention?: number;
+    labels?: Record<string, string>;
+}
+export interface TSRangeOptions {
+    aggregation?: {
+        type: 'avg' | 'sum' | 'min' | 'max' | 'count' | 'first' | 'last' | 'range' | 'std.p' | 'std.s' | 'var.p' | 'var.s';
+        bucketSize: number;
+    };
+}
+export interface TSMRangeResult {
+    key: string;
+    labels: Record<string, string>;
+    samples: TSSample[];
+}
+export interface KSubEvent {
+    pattern: string;
+    key: string;
+    operation: string;
+}
 export declare class Lux extends Redis {
     constructor(options?: RedisOptions | string);
     vset(key: string, vector: number[], options?: {
@@ -26,5 +50,15 @@ export declare class Lux extends Redis {
     } | null>;
     vsearch(query: number[], options: VSearchOptions): Promise<VSearchResult[]>;
     vcard(): Promise<number>;
+    tsadd(key: string, timestamp: number | '*', value: number, options?: TSAddOptions): Promise<number>;
+    tsmadd(...entries: [string, number | '*', number][]): Promise<string>;
+    tsget(key: string): Promise<TSSample | null>;
+    tsrange(key: string, from: number | '-', to: number | '+', options?: TSRangeOptions): Promise<TSSample[]>;
+    tsmrange(from: number | '-', to: number | '+', filter: string, options?: TSRangeOptions): Promise<TSMRangeResult[]>;
+    tsinfo(key: string): Promise<Record<string, unknown>>;
+    ksub(patterns: string[], handler: (event: KSubEvent) => void): {
+        unsubscribe: () => void;
+        connection: Redis;
+    };
 }
 export default Lux;

package/dist/index.js

@@ -75,6 +75,127 @@ class Lux extends ioredis_1.default {
     async vcard() {
         return this.call('VCARD');
     }
+    async tsadd(key, timestamp, value, options) {
+        const args = [key, timestamp === '*' ? '*' : timestamp, value];
+        if (options?.retention != null) {
+            args.push('RETENTION', options.retention);
+        }
+        if (options?.labels) {
+            args.push('LABELS');
+            for (const [k, v] of Object.entries(options.labels)) {
+                args.push(k, v);
+            }
+        }
+        return this.call('TSADD', ...args);
+    }
+    async tsmadd(...entries) {
+        const args = [];
+        for (const [key, ts, val] of entries) {
+            args.push(key, ts === '*' ? '*' : ts, val);
+        }
+        return this.call('TSMADD', ...args);
+    }
+    async tsget(key) {
+        const result = (await this.call('TSGET', key));
+        if (!result || !Array.isArray(result) || result.length < 2)
+            return null;
+        return { timestamp: parseInt(result[0], 10), value: parseFloat(result[1]) };
+    }
+    async tsrange(key, from, to, options) {
+        const args = [key, from === '-' ? '-' : from, to === '+' ? '+' : to];
+        if (options?.aggregation) {
+            args.push('AGGREGATION', options.aggregation.type, options.aggregation.bucketSize);
+        }
+        const result = (await this.call('TSRANGE', ...args));
+        if (!result || !Array.isArray(result))
+            return [];
+        return result.map((pair) => ({
+            timestamp: parseInt(pair[0], 10),
+            value: parseFloat(pair[1]),
+        }));
+    }
+    async tsmrange(from, to, filter, options) {
+        const args = [from === '-' ? '-' : from, to === '+' ? '+' : to];
+        if (options?.aggregation) {
+            args.push('AGGREGATION', options.aggregation.type, options.aggregation.bucketSize);
+        }
+        args.push('FILTER', filter);
+        const result = (await this.call('TSMRANGE', ...args));
+        if (!result || !Array.isArray(result))
+            return [];
+        return result.map((series) => {
+            const labels = {};
+            if (Array.isArray(series[1])) {
+                for (const pair of series[1]) {
+                    if (Array.isArray(pair) && pair.length >= 2) {
+                        labels[pair[0]] = pair[1];
+                    }
+                }
+            }
+            const samples = Array.isArray(series[2])
+                ? series[2].map((s) => ({ timestamp: parseInt(s[0], 10), value: parseFloat(s[1]) }))
+                : [];
+            return { key: series[0], labels, samples };
+        });
+    }
+    async tsinfo(key) {
+        const result = (await this.call('TSINFO', key));
+        if (!result || !Array.isArray(result))
+            return {};
+        const info = {};
+        for (let i = 0; i < result.length - 1; i += 2) {
+            const k = result[i];
+            const v = result[i + 1];
+            if (k === 'labels' && Array.isArray(v)) {
+                const labels = {};
+                for (const pair of v) {
+                    if (Array.isArray(pair) && pair.length >= 2)
+                        labels[pair[0]] = pair[1];
+                }
+                info[k] = labels;
+            }
+            else {
+                info[k] = v;
+            }
+        }
+        return info;
+    }
+    ksub(patterns, handler) {
+        const sub = this.duplicate();
+        sub.on('error', () => { });
+        const origReturnReply = sub.returnReply?.bind(sub);
+        const dataHandler = sub._dataHandler || sub.dataHandler;
+        if (dataHandler && dataHandler.returnReply) {
+            const origReturn = dataHandler.returnReply.bind(dataHandler);
+            dataHandler.returnReply = (reply) => {
+                if (Array.isArray(reply) && reply.length === 4 && reply[0] === 'kmessage') {
+                    handler({ pattern: reply[1], key: reply[2], operation: reply[3] });
+                    return;
+                }
+                return origReturn(reply);
+            };
+        }
+        else {
+            const origEmit = sub.emit.bind(sub);
+            sub.emit = (event, ...args) => {
+                if (event === 'error' && args[0]?.message?.includes('Command queue state error')) {
+                    const match = args[0].message.match(/Last reply: kmessage,([^,]+),([^,]+),(.+)/);
+                    if (match) {
+                        handler({ pattern: match[1], key: match[2], operation: match[3] });
+                        return true;
+                    }
+                }
+                return origEmit(event, ...args);
+            };
+        }
+        sub.call('KSUB', ...patterns);
+        return {
+            connection: sub,
+            unsubscribe() {
+                sub.disconnect();
+            },
+        };
+    }
 }
 exports.Lux = Lux;
 exports.default = Lux;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@luxdb/sdk",
-    "version": "1.0.0",
-    "description": "Lux SDK - ioredis extended with native vector search",
+    "version": "1.1.0",
+    "description": "Lux SDK - ioredis extended with vector search, time series, and realtime key subscriptions",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "files": ["dist"],
@@ -13,6 +13,7 @@
         "ioredis": "^5.0.0"
     },
     "devDependencies": {
+        "@types/node": "^25.5.0",
         "typescript": "^5.9.0"
     },
     "peerDependencies": {
@@ -24,5 +25,5 @@
         "url": "https://github.com/lux-db/lux",
         "directory": "sdk"
     },
-    "keywords": ["lux", "redis", "vector", "search", "database", "ioredis", "similarity"]
+    "keywords": ["lux", "redis", "vector", "search", "database", "ioredis", "similarity", "timeseries", "realtime", "subscriptions"]
 }