@luxdb/sdk 1.1.0 → 1.2.1

package/dist/index.d.ts

@@ -1,17 +1,9 @@
-import Redis, { RedisOptions } from 'ioredis';
+import Redis, { type RedisOptions } from 'ioredis';
 export interface VSearchResult {
     key: string;
     similarity: number;
     metadata?: Record<string, unknown>;
 }
-export interface VSearchOptions {
-    k: number;
-    filter?: {
-        key: string;
-        value: string;
-    };
-    meta?: boolean;
-}
 export interface TSSample {
     timestamp: number;
     value: number;
@@ -36,8 +28,66 @@ export interface KSubEvent {
     key: string;
     operation: string;
 }
+export interface TableRow {
+    id: number;
+    [field: string]: unknown;
+}
+declare class TableQueryBuilder {
+    private client;
+    private name;
+    private conditions;
+    private orderField?;
+    private orderDir?;
+    private limitCount?;
+    private joinTable?;
+    constructor(client: Lux, name: string);
+    where(field: string, op: '=' | '!=' | '>' | '<' | '>=' | '<=', value: string | number | boolean): this;
+    orderBy(field: string, dir?: 'asc' | 'desc'): this;
+    limit(n: number): this;
+    join(table: string): this;
+    run(): Promise<TableRow[]>;
+    insert(data: Record<string, unknown>): Promise<number>;
+    update(id: number, data: Record<string, unknown>): Promise<string>;
+    delete(...ids: number[]): Promise<number>;
+}
+declare class VectorNamespace {
+    private client;
+    constructor(client: Lux);
+    set(key: string, vector: number[], metadata?: Record<string, unknown>): Promise<string>;
+    get(key: string): Promise<{
+        dims: number;
+        vector: number[];
+        metadata?: Record<string, unknown>;
+    } | null>;
+    search(query: number[], options: {
+        topK: number;
+        filter?: {
+            key: string;
+            value: string;
+        };
+        meta?: boolean;
+    }): Promise<VSearchResult[]>;
+    count(): Promise<number>;
+}
+declare class TimeSeriesNamespace {
+    private client;
+    constructor(client: Lux);
+    add(key: string, value: number, options?: {
+        timestamp?: number | '*';
+        retention?: number;
+        labels?: Record<string, string>;
+    }): Promise<number>;
+    get(key: string): Promise<TSSample | null>;
+    range(key: string, from: number | '-', to: number | '+', options?: TSRangeOptions): Promise<TSSample[]>;
+    mrange(from: number | '-', to: number | '+', filter: string, options?: TSRangeOptions): Promise<TSMRangeResult[]>;
+    info(key: string): Promise<Record<string, unknown>>;
+}
 export declare class Lux extends Redis {
+    vectors: VectorNamespace;
+    timeseries: TimeSeriesNamespace;
     constructor(options?: RedisOptions | string);
+    table(name: string): TableQueryBuilder;
+    _tquery(args: string[]): Promise<TableRow[]>;
     vset(key: string, vector: number[], options?: {
         metadata?: Record<string, unknown>;
         ex?: number;
@@ -48,7 +98,14 @@ export declare class Lux extends Redis {
         vector: number[];
         metadata?: Record<string, unknown>;
     } | null>;
-    vsearch(query: number[], options: VSearchOptions): Promise<VSearchResult[]>;
+    vsearch(query: number[], options: {
+        k: number;
+        filter?: {
+            key: string;
+            value: string;
+        };
+        meta?: boolean;
+    }): Promise<VSearchResult[]>;
     vcard(): Promise<number>;
     tsadd(key: string, timestamp: number | '*', value: number, options?: TSAddOptions): Promise<number>;
     tsmadd(...entries: [string, number | '*', number][]): Promise<string>;

package/dist/index.js

@@ -5,10 +5,140 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lux = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
+class TableQueryBuilder {
+    constructor(client, name) {
+        this.conditions = [];
+        this.client = client;
+        this.name = name;
+    }
+    where(field, op, value) {
+        const v = typeof value === 'string' ? `'${value}'` : String(value);
+        this.conditions.push(`${field} ${op} ${v}`);
+        return this;
+    }
+    orderBy(field, dir = 'asc') {
+        this.orderField = field;
+        this.orderDir = dir.toUpperCase();
+        return this;
+    }
+    limit(n) {
+        this.limitCount = n;
+        return this;
+    }
+    join(table) {
+        this.joinTable = table;
+        return this;
+    }
+    async run() {
+        const args = [this.name];
+        if (this.conditions.length) {
+            args.push('WHERE', this.conditions.join(' AND '));
+        }
+        if (this.orderField) {
+            args.push('ORDER', 'BY', this.orderField, this.orderDir || 'ASC');
+        }
+        if (this.limitCount != null) {
+            args.push('LIMIT', String(this.limitCount));
+        }
+        if (this.joinTable) {
+            args.push('JOIN', this.joinTable);
+        }
+        return this.client._tquery(args);
+    }
+    async insert(data) {
+        const args = [this.name];
+        for (const [k, v] of Object.entries(data)) {
+            args.push(k, String(v));
+        }
+        const result = await this.client.call('TINSERT', ...args);
+        return parseInt(result, 10) || 0;
+    }
+    async update(id, data) {
+        const args = [this.name, id];
+        for (const [k, v] of Object.entries(data)) {
+            args.push(k, String(v));
+        }
+        return this.client.call('TUPDATE', ...args);
+    }
+    async delete(...ids) {
+        return this.client.call('TDEL', this.name, ...ids);
+    }
+}
+class VectorNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    async set(key, vector, metadata) {
+        const args = [key, vector.length, ...vector];
+        if (metadata) {
+            args.push('META', JSON.stringify(metadata));
+        }
+        return this.client.call('VSET', ...args);
+    }
+    async get(key) {
+        return this.client.vget(key);
+    }
+    async search(query, options) {
+        return this.client.vsearch(query, { k: options.topK, filter: options.filter, meta: options.meta ?? true });
+    }
+    async count() {
+        return this.client.vcard();
+    }
+}
+class TimeSeriesNamespace {
+    constructor(client) {
+        this.client = client;
+    }
+    async add(key, value, options) {
+        return this.client.tsadd(key, options?.timestamp ?? '*', value, { retention: options?.retention, labels: options?.labels });
+    }
+    async get(key) {
+        return this.client.tsget(key);
+    }
+    async range(key, from, to, options) {
+        return this.client.tsrange(key, from, to, options);
+    }
+    async mrange(from, to, filter, options) {
+        return this.client.tsmrange(from, to, filter, options);
+    }
+    async info(key) {
+        return this.client.tsinfo(key);
+    }
+}
 class Lux extends ioredis_1.default {
     constructor(options) {
+        if (typeof options === 'string') {
+            if (options.startsWith('rediss://') || options.startsWith('luxs://')) {
+                throw new Error('TLS is not yet supported');
+            }
+            options = options.replace(/^lux:\/\//, 'redis://');
+        }
         super(options);
+        this.vectors = new VectorNamespace(this);
+        this.timeseries = new TimeSeriesNamespace(this);
     }
+    table(name) {
+        return new TableQueryBuilder(this, name);
+    }
+    async _tquery(args) {
+        const result = await this.call('TQUERY', ...args);
+        if (!result || !Array.isArray(result))
+            return [];
+        const rows = [];
+        for (const item of result) {
+            if (Array.isArray(item) && item.length >= 1) {
+                const row = { id: parseInt(item[0], 10) };
+                for (let i = 1; i < item.length - 1; i += 2) {
+                    const key = String(item[i]);
+                    const val = item[i + 1];
+                    row[key] = val;
+                }
+                rows.push(row);
+            }
+        }
+        return rows;
+    }
+    // Vector methods (keep for backward compat)
     async vset(key, vector, options) {
         const args = [key, vector.length, ...vector];
         if (options?.metadata) {
@@ -23,7 +153,7 @@ class Lux extends ioredis_1.default {
         return this.call('VSET', ...args);
     }
     async vget(key) {
-        const result = (await this.call('VGET', key));
+        const result = await this.call('VGET', key);
         if (!result || !Array.isArray(result))
             return null;
         const dims = parseInt(result[0], 10);
@@ -49,16 +179,13 @@ class Lux extends ioredis_1.default {
         if (options.meta) {
             args.push('META');
         }
-        const result = (await this.call('VSEARCH', ...args));
+        const result = await this.call('VSEARCH', ...args);
         if (!result || !Array.isArray(result))
             return [];
         const results = [];
         for (const item of result) {
             if (Array.isArray(item)) {
-                const entry = {
-                    key: item[0],
-                    similarity: parseFloat(item[1]),
-                };
+                const entry = { key: item[0], similarity: parseFloat(item[1]) };
                 if (options.meta && item[2]) {
                     try {
                         entry.metadata = JSON.parse(item[2]);
@@ -75,6 +202,7 @@ class Lux extends ioredis_1.default {
     async vcard() {
         return this.call('VCARD');
     }
+    // Time series methods (keep for backward compat)
     async tsadd(key, timestamp, value, options) {
         const args = [key, timestamp === '*' ? '*' : timestamp, value];
         if (options?.retention != null) {
@@ -96,7 +224,7 @@ class Lux extends ioredis_1.default {
         return this.call('TSMADD', ...args);
     }
     async tsget(key) {
-        const result = (await this.call('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]) };
@@ -106,13 +234,10 @@ class Lux extends ioredis_1.default {
         if (options?.aggregation) {
             args.push('AGGREGATION', options.aggregation.type, options.aggregation.bucketSize);
         }
-        const result = (await this.call('TSRANGE', ...args));
+        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]),
-        }));
+        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];
@@ -120,16 +245,15 @@ class Lux extends ioredis_1.default {
             args.push('AGGREGATION', options.aggregation.type, options.aggregation.bucketSize);
         }
         args.push('FILTER', filter);
-        const result = (await this.call('TSMRANGE', ...args));
+        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) {
+                    if (Array.isArray(pair) && pair.length >= 2)
                         labels[pair[0]] = pair[1];
-                    }
                 }
             }
             const samples = Array.isArray(series[2])
@@ -139,7 +263,7 @@ class Lux extends ioredis_1.default {
         });
     }
     async tsinfo(key) {
-        const result = (await this.call('TSINFO', key));
+        const result = await this.call('TSINFO', key);
         if (!result || !Array.isArray(result))
             return {};
         const info = {};
@@ -160,10 +284,10 @@ class Lux extends ioredis_1.default {
         }
         return info;
     }
+    // Realtime key subscriptions
     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);
@@ -191,9 +315,7 @@ class Lux extends ioredis_1.default {
         sub.call('KSUB', ...patterns);
         return {
             connection: sub,
-            unsubscribe() {
-                sub.disconnect();
-            },
+            unsubscribe() { sub.disconnect(); },
         };
     }
 }

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@luxdb/sdk",
-    "version": "1.1.0",
+    "version": "1.2.1",
     "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"],
     "scripts": {
         "build": "tsc",
-        "prepublishOnly": "npm run build"
+        "prepublishOnly": "bun run build"
     },
     "dependencies": {
         "ioredis": "^5.0.0"