@luxdb/sdk 1.3.0 → 1.4.2

package/dist/esm/index.js

@@ -0,0 +1,270 @@
+import Redis from 'ioredis';
+import { LuxAuthClient } from './auth.js';
+import { createProjectClient, LuxProjectClient } from './project.js';
+import { TimeSeriesNamespace, VectorNamespace } from './namespaces.js';
+import { LuxRealtimeManager } from './realtime.js';
+import { TableQueryBuilder } from './table.js';
+export { createProjectClient, LuxProjectClient, };
+export { createBrowserClient } from './browser.js';
+export { createServerClient } from './ssr.js';
+export { TableQueryBuilder, TableSubscription } from './table.js';
+function createAuthNamespace(redis, options) {
+    const client = new LuxAuthClient(options);
+    const redisAuth = ((...args) => {
+        return redis.call('AUTH', ...args);
+    });
+    return new Proxy(redisAuth, {
+        get(target, prop, receiver) {
+            if (prop in client) {
+                const value = client[prop];
+                return typeof value === 'function' ? value.bind(client) : value;
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+        set(_target, prop, value) {
+            client[prop] = value;
+            return true;
+        },
+    });
+}
+export class Lux extends Redis {
+    constructor(options) {
+        let authOptions = {};
+        if (typeof options === 'string') {
+            options = options.replace(/^luxs:\/\//, 'rediss://').replace(/^lux:\/\//, 'redis://');
+        }
+        else if (options) {
+            const { httpUrl, apiKey, authToken, fetch: fetchImpl, ...redisOptions } = options;
+            authOptions = { httpUrl, apiKey, authToken, fetch: fetchImpl };
+            options = redisOptions;
+        }
+        super(options);
+        this.vectors = new VectorNamespace(this);
+        this.timeseries = new TimeSeriesNamespace(this);
+        this.auth = createAuthNamespace(this, authOptions);
+        this.authApi = this.auth;
+    }
+    table(name, options) {
+        return new TableQueryBuilder(this, name, options);
+    }
+    async _subscribePattern(pattern, handler) {
+        if (!this.realtimeManager) {
+            this.realtimeManager = new LuxRealtimeManager(this);
+        }
+        return this.realtimeManager.subscribe(pattern, handler);
+    }
+    async _tselect(args) {
+        const result = await this.call('TSELECT', ...args);
+        if (!result || !Array.isArray(result))
+            return [];
+        const rows = [];
+        for (const item of result) {
+            if (Array.isArray(item)) {
+                const row = {};
+                for (let i = 0; i < item.length - 1; i += 2) {
+                    const key = String(item[i]);
+                    const val = item[i + 1];
+                    row[key] = val;
+                }
+                if (row.id != null) {
+                    const parsed = Number(row.id);
+                    if (!Number.isNaN(parsed) && Number.isFinite(parsed)) {
+                        row.id = parsed;
+                    }
+                }
+                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) {
+            args.push('META', JSON.stringify(options.metadata));
+        }
+        if (options?.ex) {
+            args.push('EX', options.ex);
+        }
+        else if (options?.px) {
+            args.push('PX', options.px);
+        }
+        return this.call('VSET', ...args);
+    }
+    async vget(key) {
+        const result = await this.call('VGET', key);
+        if (!result || !Array.isArray(result))
+            return null;
+        const dims = parseInt(result[0], 10);
+        const vector = [];
+        for (let i = 1; i <= dims; i++) {
+            vector.push(parseFloat(result[i]));
+        }
+        const metaRaw = result[dims + 1];
+        let metadata;
+        if (metaRaw) {
+            try {
+                metadata = JSON.parse(metaRaw);
+            }
+            catch { }
+        }
+        return { dims, vector, metadata };
+    }
+    async vsearch(query, options) {
+        const args = [query.length, ...query, 'K', options.k];
+        if (options.filter) {
+            args.push('FILTER', options.filter.key, options.filter.value);
+        }
+        if (options.meta) {
+            args.push('META');
+        }
+        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]) };
+                if (options.meta && item[2]) {
+                    try {
+                        entry.metadata = JSON.parse(item[2]);
+                    }
+                    catch {
+                        entry.metadata = { _raw: item[2] };
+                    }
+                }
+                results.push(entry);
+            }
+        }
+        return results;
+    }
+    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) {
+            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;
+    }
+    // Realtime key subscriptions
+    ksub(patterns, handler) {
+        const sub = this.duplicate();
+        sub.on('error', () => { });
+        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(); },
+        };
+    }
+}
+export function createClient(optionsOrUrl, key, projectOptions) {
+    if (typeof optionsOrUrl === 'string' && typeof key === 'string') {
+        return createProjectClient({ ...(projectOptions ?? {}), url: optionsOrUrl, key });
+    }
+    return new Lux(optionsOrUrl);
+}
+export function createAuthClient(options) {
+    return new LuxAuthClient(options);
+}
+export default Lux;

package/dist/esm/namespaces.js

@@ -0,0 +1,41 @@
+export 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();
+    }
+}
+export 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);
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/project.js

@@ -0,0 +1,303 @@
+import { LuxAuthClient } from './auth.js';
+import { err, ok, toLuxError } from './utils.js';
+export class LuxProjectClient {
+    constructor(options) {
+        this.url = options.url.replace(/\/+$/, '');
+        this.key = options.key;
+        this.fetchImpl = resolveFetch(options.fetch);
+        this.auth = new LuxAuthClient({
+            ...options.auth,
+            httpUrl: this.url,
+            apiKey: this.key,
+            fetch: this.fetchImpl,
+        });
+    }
+    table(name) {
+        return new LuxProjectTable(this, name);
+    }
+    async ping() {
+        return this.request('GET', '/ping');
+    }
+    async createTable(name, columns) {
+        return this.request('POST', '/tables', { name, columns });
+    }
+    async exec(command) {
+        return this.request('POST', '/exec', { command });
+    }
+    async vectorSet(key, vector, metadata) {
+        return this.request('POST', `/vectors/${encodeURIComponent(key)}`, { vector, metadata });
+    }
+    async vectorSearch(options) {
+        return this.request('POST', '/vectors/search', {
+            vector: options.vector,
+            k: options.k ?? 10,
+            filter: options.filter,
+            filter_value: options.filter_value,
+        });
+    }
+    async tsAdd(key, value, options) {
+        return this.request('POST', `/ts/${encodeURIComponent(key)}`, {
+            timestamp: options?.timestamp ?? '*',
+            value,
+            labels: options?.labels,
+            retention: options?.retention,
+        });
+    }
+    async tsRange(key, options) {
+        const params = new URLSearchParams();
+        if (options?.from != null)
+            params.set('from', String(options.from));
+        if (options?.to != null)
+            params.set('to', String(options.to));
+        if (options?.count != null)
+            params.set('count', String(options.count));
+        const query = params.toString();
+        return this.request('GET', `/ts/${encodeURIComponent(key)}${query ? `?${query}` : ''}`);
+    }
+    async request(method, path, body) {
+        try {
+            const accessToken = await this.auth.getAccessToken();
+            const headers = {
+                Accept: 'application/json',
+                apikey: this.key,
+                Authorization: `Bearer ${accessToken ?? this.key}`,
+            };
+            const init = { method, headers };
+            if (body !== undefined) {
+                headers['Content-Type'] = 'application/json';
+                init.body = JSON.stringify(body);
+            }
+            const response = await this.fetchImpl(`${this.url}${path}`, init);
+            const text = await response.text();
+            const payload = text ? JSON.parse(text) : {};
+            if (!response.ok) {
+                return err('LUX_PROJECT_REQUEST_ERROR', payload?.error || `Lux request failed with HTTP ${response.status}`, { status: response.status, payload });
+            }
+            return ok(payload);
+        }
+        catch (error) {
+            return err('LUX_PROJECT_REQUEST_ERROR', 'Lux request failed', toLuxError(error));
+        }
+    }
+}
+export class LuxProjectTable {
+    constructor(client, name) {
+        this.client = client;
+        this.name = name;
+    }
+    select(columns = '*') {
+        return new LuxProjectSelectBuilder(this.client, this.name, columns);
+    }
+    insert(rowOrRows) {
+        return new LuxProjectInsertBuilder(this.client, this.name, rowOrRows);
+    }
+    update(patch) {
+        return new LuxProjectMutationBuilder(this.client, this.name, 'PATCH', patch);
+    }
+    delete() {
+        return new LuxProjectMutationBuilder(this.client, this.name, 'DELETE');
+    }
+    async count() {
+        const result = await this.client.request('GET', `/tables/${encodeURIComponent(this.name)}/count`);
+        if (result.error)
+            return result;
+        return ok(unwrapResult(result.data) ?? 0);
+    }
+}
+class LuxProjectThenable {
+    then(onfulfilled, onrejected) {
+        return this.execute().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.execute().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.execute().finally(onfinally ?? undefined);
+    }
+}
+class LuxProjectFilterBuilder extends LuxProjectThenable {
+    constructor(client, tableName) {
+        super();
+        this.client = client;
+        this.tableName = tableName;
+        this.filters = [];
+    }
+    eq(column, value) {
+        return this.addFilter(column, 'eq', value);
+    }
+    neq(column, value) {
+        return this.addFilter(column, 'neq', value);
+    }
+    gt(column, value) {
+        return this.addFilter(column, 'gt', value);
+    }
+    gte(column, value) {
+        return this.addFilter(column, 'gte', value);
+    }
+    lt(column, value) {
+        return this.addFilter(column, 'lt', value);
+    }
+    lte(column, value) {
+        return this.addFilter(column, 'lte', value);
+    }
+    is(column, value) {
+        return this.addFilter(column, 'is', value);
+    }
+    addFilter(column, operator, value) {
+        this.filters.push({ column, operator, value });
+        return this;
+    }
+    filteredQueryParams() {
+        const params = new URLSearchParams();
+        if (this.filters.length)
+            params.set('where', filtersToWhere(this.filters));
+        if (this.orderBy) {
+            params.set('order', `${this.orderBy.column} ${this.orderBy.ascending ? 'ASC' : 'DESC'}`);
+        }
+        if (this.limitCount != null)
+            params.set('limit', String(this.limitCount));
+        if (this.offsetCount != null)
+            params.set('offset', String(this.offsetCount));
+        return params;
+    }
+}
+export class LuxProjectSelectBuilder extends LuxProjectFilterBuilder {
+    constructor(client, tableName, columns) {
+        super(client, tableName);
+        this.columns = columns;
+        this.expectSingle = false;
+    }
+    order(column, options = {}) {
+        this.orderBy = { column, ascending: options.ascending ?? true };
+        return this;
+    }
+    limit(count) {
+        this.limitCount = count;
+        return this;
+    }
+    range(from, to) {
+        this.offsetCount = from;
+        this.limitCount = Math.max(0, to - from + 1);
+        return this;
+    }
+    single() {
+        this.expectSingle = true;
+        if (this.limitCount == null)
+            this.limitCount = 1;
+        return this;
+    }
+    async execute() {
+        const params = this.filteredQueryParams();
+        if (this.columns && this.columns !== '*')
+            params.set('select', this.columns);
+        const query = params.toString();
+        const result = await this.client.request('GET', `/tables/${encodeURIComponent(this.tableName)}${query ? `?${query}` : ''}`);
+        if (result.error)
+            return result;
+        const rows = unwrapRows(result.data);
+        if (!this.expectSingle) {
+            return ok(rows);
+        }
+        if (rows.length === 0) {
+            return err('NOT_FOUND', `No rows found in table '${this.tableName}'`);
+        }
+        return ok(rows[0]);
+    }
+}
+export class LuxProjectInsertBuilder extends LuxProjectThenable {
+    constructor(client, tableName, rowOrRows) {
+        super();
+        this.client = client;
+        this.tableName = tableName;
+        this.rowOrRows = rowOrRows;
+    }
+    async execute() {
+        if (!Array.isArray(this.rowOrRows)) {
+            return this.client.request('POST', `/tables/${encodeURIComponent(this.tableName)}`, this.rowOrRows);
+        }
+        const results = [];
+        for (const row of this.rowOrRows) {
+            const result = await this.client.request('POST', `/tables/${encodeURIComponent(this.tableName)}`, row);
+            if (result.error)
+                return result;
+            results.push(result.data);
+        }
+        return ok(results);
+    }
+}
+export class LuxProjectMutationBuilder extends LuxProjectFilterBuilder {
+    constructor(client, tableName, method, body) {
+        super(client, tableName);
+        this.method = method;
+        this.body = body;
+    }
+    async execute() {
+        if (this.filters.length === 0) {
+            return err('MISSING_FILTER', `${this.method === 'PATCH' ? 'update' : 'delete'}() requires at least one filter`);
+        }
+        const params = this.filteredQueryParams();
+        const query = params.toString();
+        return this.client.request(this.method, `/tables/${encodeURIComponent(this.tableName)}${query ? `?${query}` : ''}`, this.body);
+    }
+}
+function unwrapRows(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    if (payload && typeof payload === 'object' && Array.isArray(payload.result)) {
+        return payload.result;
+    }
+    return [];
+}
+function unwrapResult(payload) {
+    if (payload && typeof payload === 'object' && 'result' in payload) {
+        return payload.result;
+    }
+    return payload;
+}
+function normalizeWhere(where) {
+    return where.trim().replace(/\s*(>=|<=|!=|=|>|<)\s*/g, ' $1 ');
+}
+function filtersToWhere(filters) {
+    return filters.map((filter) => {
+        const op = filterOperatorToWhere(filter.operator);
+        return normalizeWhere(`${filter.column} ${op} ${formatWhereValue(filter.value)}`);
+    }).join(' AND ');
+}
+function filterOperatorToWhere(operator) {
+    switch (operator) {
+        case 'eq':
+        case 'is':
+            return '=';
+        case 'neq':
+            return '!=';
+        case 'gt':
+            return '>';
+        case 'gte':
+            return '>=';
+        case 'lt':
+            return '<';
+        case 'lte':
+            return '<=';
+    }
+}
+function formatWhereValue(value) {
+    if (value === null)
+        return '';
+    return String(value);
+}
+export function createProjectClient(options) {
+    return new LuxProjectClient(options);
+}
+export function createClient(url, key, options = {}) {
+    return new LuxProjectClient({ ...options, url, key });
+}
+function resolveFetch(fetchImpl) {
+    const candidate = fetchImpl ?? globalThis.fetch;
+    if (!candidate) {
+        throw new Error('Lux project client requires a fetch implementation');
+    }
+    if (typeof globalThis !== 'undefined' && candidate === globalThis.fetch) {
+        return candidate.bind(globalThis);
+    }
+    return candidate;
+}

package/dist/esm/realtime.js

@@ -0,0 +1,84 @@
+export class LuxRealtimeManager {
+    constructor(client) {
+        this.connection = null;
+        this.initPromise = null;
+        this.nextHandlerId = 1;
+        this.handlersByPattern = new Map();
+        this.client = client;
+    }
+    async ensureConnection() {
+        if (this.connection)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            const sub = this.client.duplicate();
+            sub.on('error', () => { });
+            const dispatch = (event) => {
+                const handlers = this.handlersByPattern.get(event.pattern);
+                if (!handlers)
+                    return;
+                for (const handler of handlers.values()) {
+                    handler(event);
+                }
+            };
+            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') {
+                        dispatch({ 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) {
+                            dispatch({ pattern: match[1], key: match[2], operation: match[3] });
+                            return true;
+                        }
+                    }
+                    return origEmit(event, ...args);
+                };
+            }
+            this.connection = sub;
+        })();
+        try {
+            await this.initPromise;
+        }
+        finally {
+            this.initPromise = null;
+        }
+    }
+    async subscribe(pattern, handler) {
+        await this.ensureConnection();
+        const id = this.nextHandlerId++;
+        let handlers = this.handlersByPattern.get(pattern);
+        const firstForPattern = !handlers;
+        if (!handlers) {
+            handlers = new Map();
+            this.handlersByPattern.set(pattern, handlers);
+        }
+        handlers.set(id, handler);
+        if (firstForPattern && this.connection) {
+            await this.connection.call('KSUB', pattern);
+        }
+        return () => {
+            const map = this.handlersByPattern.get(pattern);
+            if (!map)
+                return;
+            map.delete(id);
+            if (map.size === 0) {
+                this.handlersByPattern.delete(pattern);
+                if (this.connection) {
+                    this.connection.call('KUNSUB', pattern).catch(() => { });
+                }
+            }
+        };
+    }
+}