@luxdb/sdk 1.3.0 → 1.4.2

package/dist/{index.js → cjs/index.js}

@@ -3,26 +3,59 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lux = exports.TableSubscription = exports.TableQueryBuilder = void 0;
+exports.Lux = exports.TableSubscription = exports.TableQueryBuilder = exports.createServerClient = exports.createBrowserClient = exports.LuxProjectClient = exports.createProjectClient = void 0;
 exports.createClient = createClient;
+exports.createAuthClient = createAuthClient;
 const ioredis_1 = __importDefault(require("ioredis"));
+const auth_1 = require("./auth");
+const project_1 = require("./project");
+Object.defineProperty(exports, "createProjectClient", { enumerable: true, get: function () { return project_1.createProjectClient; } });
+Object.defineProperty(exports, "LuxProjectClient", { enumerable: true, get: function () { return project_1.LuxProjectClient; } });
 const namespaces_1 = require("./namespaces");
 const realtime_1 = require("./realtime");
 const table_1 = require("./table");
+var browser_1 = require("./browser");
+Object.defineProperty(exports, "createBrowserClient", { enumerable: true, get: function () { return browser_1.createBrowserClient; } });
+var ssr_1 = require("./ssr");
+Object.defineProperty(exports, "createServerClient", { enumerable: true, get: function () { return ssr_1.createServerClient; } });
 var table_2 = require("./table");
 Object.defineProperty(exports, "TableQueryBuilder", { enumerable: true, get: function () { return table_2.TableQueryBuilder; } });
 Object.defineProperty(exports, "TableSubscription", { enumerable: true, get: function () { return table_2.TableSubscription; } });
+function createAuthNamespace(redis, options) {
+    const client = new auth_1.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;
+        },
+    });
+}
 class Lux extends ioredis_1.default {
     constructor(options) {
+        let authOptions = {};
         if (typeof options === 'string') {
-            if (options.startsWith('rediss://') || options.startsWith('luxs://')) {
-                throw new Error('TLS is not yet supported');
-            }
-            options = options.replace(/^lux:\/\//, 'redis://');
+            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 namespaces_1.VectorNamespace(this);
         this.timeseries = new namespaces_1.TimeSeriesNamespace(this);
+        this.auth = createAuthNamespace(this, authOptions);
+        this.authApi = this.auth;
     }
     table(name, options) {
         return new table_1.TableQueryBuilder(this, name, options);
@@ -239,7 +272,13 @@ class Lux extends ioredis_1.default {
     }
 }
 exports.Lux = Lux;
-function createClient(options) {
-    return new Lux(options);
+function createClient(optionsOrUrl, key, projectOptions) {
+    if (typeof optionsOrUrl === 'string' && typeof key === 'string') {
+        return (0, project_1.createProjectClient)({ ...(projectOptions ?? {}), url: optionsOrUrl, key });
+    }
+    return new Lux(optionsOrUrl);
+}
+function createAuthClient(options) {
+    return new auth_1.LuxAuthClient(options);
 }
 exports.default = Lux;

package/dist/cjs/package.json

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

package/dist/cjs/project.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LuxProjectMutationBuilder = exports.LuxProjectInsertBuilder = exports.LuxProjectSelectBuilder = exports.LuxProjectTable = exports.LuxProjectClient = void 0;
+exports.createProjectClient = createProjectClient;
+exports.createClient = createClient;
+const auth_1 = require("./auth");
+const utils_1 = require("./utils");
+class LuxProjectClient {
+    constructor(options) {
+        this.url = options.url.replace(/\/+$/, '');
+        this.key = options.key;
+        this.fetchImpl = resolveFetch(options.fetch);
+        this.auth = new auth_1.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 (0, utils_1.err)('LUX_PROJECT_REQUEST_ERROR', payload?.error || `Lux request failed with HTTP ${response.status}`, { status: response.status, payload });
+            }
+            return (0, utils_1.ok)(payload);
+        }
+        catch (error) {
+            return (0, utils_1.err)('LUX_PROJECT_REQUEST_ERROR', 'Lux request failed', (0, utils_1.toLuxError)(error));
+        }
+    }
+}
+exports.LuxProjectClient = LuxProjectClient;
+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 (0, utils_1.ok)(unwrapResult(result.data) ?? 0);
+    }
+}
+exports.LuxProjectTable = LuxProjectTable;
+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;
+    }
+}
+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 (0, utils_1.ok)(rows);
+        }
+        if (rows.length === 0) {
+            return (0, utils_1.err)('NOT_FOUND', `No rows found in table '${this.tableName}'`);
+        }
+        return (0, utils_1.ok)(rows[0]);
+    }
+}
+exports.LuxProjectSelectBuilder = LuxProjectSelectBuilder;
+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 (0, utils_1.ok)(results);
+    }
+}
+exports.LuxProjectInsertBuilder = LuxProjectInsertBuilder;
+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 (0, utils_1.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);
+    }
+}
+exports.LuxProjectMutationBuilder = LuxProjectMutationBuilder;
+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);
+}
+function createProjectClient(options) {
+    return new LuxProjectClient(options);
+}
+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/cjs/ssr.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerClient = createServerClient;
+const project_1 = require("./project");
+const DEFAULT_COOKIE = 'lux-auth-session';
+function createServerClient(url, key, options) {
+    const storageKey = options.auth?.storageKey ?? DEFAULT_COOKIE;
+    const cookieOptions = options.auth?.cookieOptions ?? {
+        path: '/',
+        sameSite: 'lax',
+    };
+    const { cookieOptions: _cookieOptions, ...authOptions } = options.auth ?? {};
+    return (0, project_1.createClient)(url, key, {
+        fetch: options.fetch,
+        auth: {
+            persistSession: true,
+            autoRefreshToken: false,
+            ...authOptions,
+            storageKey,
+            storage: cookieStorage(options.cookies, cookieOptions),
+        },
+    });
+}
+function cookieStorage(cookies, options) {
+    return {
+        async getItem(key) {
+            return await cookies.get(key) ?? null;
+        },
+        async setItem(key, value) {
+            if (!cookies.set)
+                return;
+            await cookies.set(key, value, options);
+        },
+        async removeItem(key) {
+            if (!cookies.remove)
+                return;
+            await cookies.remove(key, { ...options, maxAge: 0, expires: new Date(0) });
+        },
+    };
+}

package/dist/{table.js → cjs/table.js}

@@ -195,11 +195,32 @@ class TableQueryBuilder {
         this.conditions.push({ field, op, value });
         return this;
     }
+    eq(field, value) {
+        return this.where(field, '=', value);
+    }
+    neq(field, value) {
+        return this.where(field, '!=', value);
+    }
+    gt(field, value) {
+        return this.where(field, '>', value);
+    }
+    gte(field, value) {
+        return this.where(field, '>=', value);
+    }
+    lt(field, value) {
+        return this.where(field, '<', value);
+    }
+    lte(field, value) {
+        return this.where(field, '<=', value);
+    }
     orderBy(field, dir = 'asc') {
         this.orderField = field;
         this.orderDir = dir.toUpperCase();
         return this;
     }
+    order(field, options = {}) {
+        return this.orderBy(field, options.ascending === false ? 'desc' : 'asc');
+    }
     limit(n) {
         this.limitCount = n;
         return this;
@@ -284,6 +305,9 @@ class TableQueryBuilder {
             return (0, utils_1.err)('TSELECT_ERROR', `Failed to query table '${this.name}'`, (0, utils_1.toLuxError)(error));
         }
     }
+    then(onfulfilled, onrejected) {
+        return this.run().then(onfulfilled, onrejected);
+    }
     async insert(data) {
         try {
             if (this.schema) {
@@ -300,35 +324,28 @@ class TableQueryBuilder {
             return (0, utils_1.err)('TINSERT_ERROR', `Failed to insert into '${this.name}'`, (0, utils_1.toLuxError)(error));
         }
     }
-    async update(id, data) {
+    async update(idOrData, data) {
         try {
-            const args = [this.name, 'SET'];
-            for (const [k, v] of Object.entries(data)) {
-                args.push(k, String(v));
+            const hasExplicitId = data !== undefined;
+            const patch = hasExplicitId ? data : idOrData;
+            if (!hasExplicitId && this.conditions.length === 0) {
+                return (0, utils_1.err)('MISSING_WHERE', 'update requires at least one filter');
             }
-            args.push('WHERE', 'id', '=', String(id));
-            const result = await this.client.call('TUPDATE', ...args);
-            return (0, utils_1.ok)(Number(result) || 0);
-        }
-        catch (error) {
-            return (0, utils_1.err)('TUPDATE_ERROR', `Failed to update '${this.name}'`, (0, utils_1.toLuxError)(error));
-        }
-    }
-    async updateWhere(data) {
-        if (this.conditions.length === 0) {
-            return (0, utils_1.err)('MISSING_WHERE', 'updateWhere requires at least one where() condition');
-        }
-        try {
             const args = [this.name, 'SET'];
-            for (const [k, v] of Object.entries(data)) {
+            for (const [k, v] of Object.entries(patch)) {
                 args.push(k, String(v));
             }
             args.push('WHERE');
-            for (let i = 0; i < this.conditions.length; i++) {
-                const cond = this.conditions[i];
-                args.push(cond.field, cond.op, String(cond.value));
-                if (i < this.conditions.length - 1) {
-                    args.push('AND');
+            if (hasExplicitId) {
+                args.push('id', '=', String(idOrData));
+            }
+            else {
+                for (let i = 0; i < this.conditions.length; i++) {
+                    const cond = this.conditions[i];
+                    args.push(cond.field, cond.op, String(cond.value));
+                    if (i < this.conditions.length - 1) {
+                        args.push('AND');
+                    }
                 }
             }
             const result = await this.client.call('TUPDATE', ...args);
@@ -340,6 +357,21 @@ class TableQueryBuilder {
     }
     async delete(...ids) {
         try {
+            if (ids.length === 0) {
+                if (this.conditions.length === 0) {
+                    return (0, utils_1.err)('MISSING_WHERE', 'delete requires at least one filter');
+                }
+                const args = ['FROM', this.name, 'WHERE'];
+                for (let i = 0; i < this.conditions.length; i++) {
+                    const cond = this.conditions[i];
+                    args.push(cond.field, cond.op, String(cond.value));
+                    if (i < this.conditions.length - 1) {
+                        args.push('AND');
+                    }
+                }
+                const result = await this.client.call('TDELETE', ...args);
+                return (0, utils_1.ok)(Number(result) || 0);
+            }
             let deleted = 0;
             for (const id of ids) {
                 const result = await this.client.call('TDELETE', 'FROM', this.name, 'WHERE', 'id', '=', String(id));
@@ -351,26 +383,6 @@ class TableQueryBuilder {
             return (0, utils_1.err)('TDELETE_ERROR', `Failed to delete from '${this.name}'`, (0, utils_1.toLuxError)(error));
         }
     }
-    async deleteWhere() {
-        if (this.conditions.length === 0) {
-            return (0, utils_1.err)('MISSING_WHERE', 'deleteWhere requires at least one where() condition');
-        }
-        try {
-            const args = ['FROM', this.name, 'WHERE'];
-            for (let i = 0; i < this.conditions.length; i++) {
-                const cond = this.conditions[i];
-                args.push(cond.field, cond.op, String(cond.value));
-                if (i < this.conditions.length - 1) {
-                    args.push('AND');
-                }
-            }
-            const result = await this.client.call('TDELETE', ...args);
-            return (0, utils_1.ok)(Number(result) || 0);
-        }
-        catch (error) {
-            return (0, utils_1.err)('TDELETE_ERROR', `Failed to delete from '${this.name}'`, (0, utils_1.toLuxError)(error));
-        }
-    }
     subscribe() {
         if (this.similarityClause) {
             return new TableSubscription(this.client, this.name, (extra) => this.buildSelectArgs(extra), {