@luxdb/sdk 1.2.1 → 1.4.1

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/cjs/table.js

@@ -0,0 +1,396 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableQueryBuilder = exports.TableSubscription = void 0;
+const utils_1 = require("./utils");
+class TableSubscription {
+    constructor(client, table, selectArgsBuilder, initError = null) {
+        this.handlers = {
+            change: [],
+            insert: [],
+            update: [],
+            delete: [],
+            error: [],
+        };
+        this.knownRows = new Map();
+        this.unsubscribeFn = null;
+        this.client = client;
+        this.table = table;
+        this.selectArgsBuilder = selectArgsBuilder;
+        this.initError = initError;
+        void this.start();
+    }
+    on(event, handler) {
+        this.handlers[event].push(handler);
+        return this;
+    }
+    async unsubscribe() {
+        if (this.unsubscribeFn) {
+            this.unsubscribeFn();
+            this.unsubscribeFn = null;
+        }
+    }
+    emitError(error) {
+        for (const handler of this.handlers.error) {
+            handler({ type: 'error', table: this.table, error });
+        }
+    }
+    emitChange(event) {
+        for (const handler of this.handlers.change)
+            handler(event);
+        for (const handler of this.handlers[event.type])
+            handler(event);
+    }
+    extractPkFromKey(key) {
+        const prefix = `_t:${this.table}:row:`;
+        if (!key.startsWith(prefix))
+            return null;
+        return key.slice(prefix.length);
+    }
+    async fetchMatches(extra) {
+        const args = this.selectArgsBuilder(extra);
+        const rows = await this.client._tselect(args);
+        return rows;
+    }
+    async start() {
+        if (this.initError) {
+            this.emitError(this.initError);
+            return;
+        }
+        try {
+            const initial = await this.fetchMatches();
+            for (const row of initial) {
+                if (row.id == null)
+                    continue;
+                this.knownRows.set(String(row.id), row);
+            }
+            const pattern = `_t:${this.table}:row:*`;
+            this.unsubscribeFn = await this.client._subscribePattern(pattern, (raw) => {
+                void this.handleRawChange(raw);
+            });
+        }
+        catch (error) {
+            this.emitError((0, utils_1.toLuxError)(error, 'LUX_SUBSCRIBE_INIT_ERROR'));
+        }
+    }
+    async handleRawChange(raw) {
+        const pk = this.extractPkFromKey(raw.key);
+        if (!pk)
+            return;
+        try {
+            const previous = this.knownRows.get(pk) ?? null;
+            const rows = await this.fetchMatches([{ field: 'id', op: '=', value: pk }]);
+            const next = rows[0] ?? null;
+            if (!previous && !next)
+                return;
+            if (!previous && next) {
+                this.knownRows.set(pk, next);
+                this.emitChange({
+                    type: 'insert',
+                    table: this.table,
+                    pk,
+                    operation: raw.operation,
+                    new: next,
+                    old: null,
+                    raw,
+                });
+                return;
+            }
+            if (previous && !next) {
+                this.knownRows.delete(pk);
+                this.emitChange({
+                    type: 'delete',
+                    table: this.table,
+                    pk,
+                    operation: raw.operation,
+                    new: null,
+                    old: previous,
+                    raw,
+                });
+                return;
+            }
+            if (!previous || !next)
+                return;
+            this.knownRows.set(pk, next);
+            const changed = Object.keys(next).filter((key) => previous[key] !== next[key]);
+            this.emitChange({
+                type: 'update',
+                table: this.table,
+                pk,
+                operation: raw.operation,
+                new: next,
+                old: previous,
+                changed,
+                raw,
+            });
+        }
+        catch (error) {
+            this.emitError((0, utils_1.toLuxError)(error, 'LUX_SUBSCRIBE_EVENT_ERROR'));
+        }
+    }
+}
+exports.TableSubscription = TableSubscription;
+class TableQueryBuilder {
+    constructor(client, name, options) {
+        this.conditions = [];
+        this.selectClause = '*';
+        this.expectSingle = false;
+        this.client = client;
+        this.name = name;
+        this.schema = options?.schema;
+    }
+    validateRow(row) {
+        if (!this.schema)
+            return row;
+        if (this.schema.safeParse) {
+            const parsed = this.schema.safeParse(row);
+            if (!parsed.success) {
+                throw new Error('row failed schema validation');
+            }
+            return parsed.data;
+        }
+        if (this.schema.parse) {
+            return this.schema.parse(row);
+        }
+        return row;
+    }
+    buildSelectArgs(extra) {
+        const args = [this.selectClause, 'FROM', this.name];
+        const allConditions = extra ? [...this.conditions, ...extra] : this.conditions;
+        if (this.joinClause) {
+            args.push('JOIN', this.joinClause.table, this.joinClause.alias, 'ON', this.joinClause.onLeft, '=', this.joinClause.onRight);
+        }
+        if (allConditions.length) {
+            args.push('WHERE');
+            for (let i = 0; i < allConditions.length; i++) {
+                const cond = allConditions[i];
+                args.push(cond.field, cond.op, String(cond.value));
+                if (i < allConditions.length - 1) {
+                    args.push('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.offsetCount != null) {
+            args.push('OFFSET', String(this.offsetCount));
+        }
+        return args;
+    }
+    select(columns = '*') {
+        this.selectClause = columns;
+        return this;
+    }
+    single() {
+        this.expectSingle = true;
+        if (this.limitCount == null) {
+            this.limitCount = 1;
+        }
+        return this;
+    }
+    where(field, op, value) {
+        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;
+    }
+    offset(n) {
+        this.offsetCount = n;
+        return this;
+    }
+    join(table, alias, onLeft, onRight) {
+        this.joinClause = { table, alias, onLeft, onRight };
+        return this;
+    }
+    similar(field, vector, options) {
+        this.similarityClause = {
+            field,
+            vector,
+            k: options.k,
+            filter: options.filter,
+        };
+        return this;
+    }
+    parseSimilarityPk(result, field) {
+        const metadata = result.metadata;
+        if (metadata && typeof metadata === 'object') {
+            for (const key of ['id', 'pk', 'row_id']) {
+                const value = metadata[key];
+                if (value != null)
+                    return String(value);
+            }
+        }
+        const expectedPrefix = `${this.name}:${field}:`;
+        if (result.key.startsWith(expectedPrefix)) {
+            return result.key.slice(expectedPrefix.length);
+        }
+        const segments = result.key.split(':');
+        if (segments.length > 0) {
+            return segments[segments.length - 1] || null;
+        }
+        return null;
+    }
+    async run() {
+        try {
+            let rows = [];
+            if (this.similarityClause) {
+                if (this.joinClause) {
+                    return (0, utils_1.err)('SIMILAR_JOIN_UNSUPPORTED', 'similar(...) cannot be combined with join(...) yet');
+                }
+                const similarResults = await this.client.vsearch(this.similarityClause.vector, {
+                    k: this.similarityClause.k,
+                    filter: this.similarityClause.filter,
+                    meta: true,
+                });
+                for (const match of similarResults) {
+                    const pk = this.parseSimilarityPk(match, this.similarityClause.field);
+                    if (!pk)
+                        continue;
+                    const args = this.buildSelectArgs([{ field: 'id', op: '=', value: pk }]);
+                    const one = await this.client._tselect(args);
+                    if (one.length === 0)
+                        continue;
+                    rows.push({ ...one[0], _similarity: match.similarity });
+                }
+                if (this.offsetCount != null || this.limitCount != null) {
+                    const start = this.offsetCount ?? 0;
+                    const end = this.limitCount != null ? start + this.limitCount : undefined;
+                    rows = rows.slice(start, end);
+                }
+            }
+            else {
+                rows = await this.client._tselect(this.buildSelectArgs());
+            }
+            const validated = rows.map((row) => this.validateRow(row));
+            if (this.expectSingle) {
+                if (validated.length === 0) {
+                    return (0, utils_1.err)('NOT_FOUND', `No rows found in table '${this.name}'`);
+                }
+                return (0, utils_1.ok)(validated[0]);
+            }
+            return (0, utils_1.ok)(validated);
+        }
+        catch (error) {
+            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) {
+                this.validateRow(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 (0, utils_1.ok)(parseInt(result, 10) || 0);
+        }
+        catch (error) {
+            return (0, utils_1.err)('TINSERT_ERROR', `Failed to insert into '${this.name}'`, (0, utils_1.toLuxError)(error));
+        }
+    }
+    async update(idOrData, data) {
+        try {
+            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');
+            }
+            const args = [this.name, 'SET'];
+            for (const [k, v] of Object.entries(patch)) {
+                args.push(k, String(v));
+            }
+            args.push('WHERE');
+            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);
+            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 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));
+                deleted += Number(result) || 0;
+            }
+            return (0, utils_1.ok)(deleted);
+        }
+        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), {
+                code: 'SIMILAR_SUBSCRIBE_UNSUPPORTED',
+                message: 'subscribe() is not supported on similar(...) queries yet',
+            });
+        }
+        return new TableSubscription(this.client, this.name, (extra) => this.buildSelectArgs(extra));
+    }
+}
+exports.TableQueryBuilder = TableQueryBuilder;

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ok = ok;
+exports.err = err;
+exports.toLuxError = toLuxError;
+function ok(data) {
+    return { data, error: null };
+}
+function err(code, message, details) {
+    return { data: null, error: { code, message, details } };
+}
+function toLuxError(error, fallbackCode = 'LUX_SDK_ERROR') {
+    if (typeof error === 'object' && error && 'message' in error) {
+        return { code: fallbackCode, message: String(error.message), details: error };
+    }
+    return { code: fallbackCode, message: String(error) };
+}