@luxdb/sdk 1.4.1 → 1.4.3

package/dist/esm/table.js

@@ -56,9 +56,10 @@ export class TableSubscription {
         try {
             const initial = await this.fetchMatches();
             for (const row of initial) {
-                if (row.id == null)
+                const id = row.id;
+                if (id == null)
                     continue;
-                this.knownRows.set(String(row.id), row);
+                this.knownRows.set(String(id), row);
             }
             const pattern = `_t:${this.table}:row:*`;
             this.unsubscribeFn = await this.client._subscribePattern(pattern, (raw) => {
@@ -108,7 +109,9 @@ export class TableSubscription {
             if (!previous || !next)
                 return;
             this.knownRows.set(pk, next);
-            const changed = Object.keys(next).filter((key) => previous[key] !== next[key]);
+            const previousRow = previous;
+            const nextRow = next;
+            const changed = Object.keys(nextRow).filter((key) => previousRow[key] !== nextRow[key]);
             this.emitChange({
                 type: 'update',
                 table: this.table,
@@ -128,6 +131,8 @@ export class TableSubscription {
 export class TableQueryBuilder {
     constructor(client, name, options) {
         this.conditions = [];
+        this.groupFields = [];
+        this.havingConditions = [];
         this.selectClause = '*';
         this.expectSingle = false;
         this.client = client;
@@ -153,7 +158,7 @@ export class TableQueryBuilder {
         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);
+            args.push(...(this.joinClause.type === 'LEFT' ? ['LEFT', 'JOIN'] : ['JOIN']), this.joinClause.table, this.joinClause.alias, 'ON', this.joinClause.onLeft, '=', this.joinClause.onRight);
         }
         if (allConditions.length) {
             args.push('WHERE');
@@ -165,6 +170,25 @@ export class TableQueryBuilder {
                 }
             }
         }
+        if (this.groupFields.length) {
+            args.push('GROUP', 'BY', ...this.groupFields);
+        }
+        if (this.havingConditions.length) {
+            args.push('HAVING');
+            for (let i = 0; i < this.havingConditions.length; i++) {
+                const cond = this.havingConditions[i];
+                args.push(cond.field, cond.op, String(cond.value));
+                if (i < this.havingConditions.length - 1) {
+                    args.push('AND');
+                }
+            }
+        }
+        if (this.similarityClause) {
+            args.push('NEAR', this.similarityClause.field, `[${this.similarityClause.vector.join(',')}]`, 'K', String(this.similarityClause.k));
+            if (this.similarityClause.threshold != null) {
+                args.push('THRESHOLD', String(this.similarityClause.threshold));
+            }
+        }
         if (this.orderField) {
             args.push('ORDER', 'BY', this.orderField, this.orderDir || 'ASC');
         }
@@ -226,68 +250,41 @@ export class TableQueryBuilder {
         return this;
     }
     join(table, alias, onLeft, onRight) {
-        this.joinClause = { table, alias, onLeft, onRight };
+        this.joinClause = { type: 'INNER', table, alias, onLeft, onRight };
+        return this;
+    }
+    leftJoin(table, alias, onLeft, onRight) {
+        this.joinClause = { type: 'LEFT', table, alias, onLeft, onRight };
+        return this;
+    }
+    group(fields) {
+        this.groupFields = Array.isArray(fields)
+            ? fields
+            : fields.split(',').map((field) => field.trim()).filter(Boolean);
+        return this;
+    }
+    groupBy(fields) {
+        return this.group(fields);
+    }
+    having(field, op, value) {
+        this.havingConditions.push({ field, op, value });
         return this;
     }
-    similar(field, vector, options) {
+    near(field, vector, options = {}) {
         this.similarityClause = {
             field,
             vector,
-            k: options.k,
-            filter: options.filter,
+            k: options.k ?? 10,
+            threshold: options.threshold,
         };
         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;
+    similar(field, vector, options = {}) {
+        return this.near(field, vector, options);
     }
     async run() {
         try {
-            let rows = [];
-            if (this.similarityClause) {
-                if (this.joinClause) {
-                    return 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 rows = await this.client._tselect(this.buildSelectArgs());
             const validated = rows.map((row) => this.validateRow(row));
             if (this.expectSingle) {
                 if (validated.length === 0) {
@@ -380,12 +377,6 @@ export class TableQueryBuilder {
         }
     }
     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));
     }
 }

package/dist/types/auth.d.ts

@@ -11,6 +11,90 @@ export interface LuxAuthUser {
     user_metadata?: Record<string, unknown>;
     app_metadata?: Record<string, unknown>;
 }
+export type LuxUser = LuxAuthUser;
+export interface LuxAuthUserRow {
+    id: string;
+    email?: string;
+    phone?: string;
+    encrypted_password?: string;
+    email_confirmed_at?: number | null;
+    phone_confirmed_at?: number | null;
+    raw_user_meta_data?: string;
+    raw_app_meta_data?: string;
+    created_at?: number | null;
+    updated_at?: number | null;
+    last_sign_in_at?: number | null;
+    banned_until?: number | null;
+    deleted_at?: number | null;
+}
+export interface LuxAuthIdentityRow {
+    id: string;
+    user_id: string;
+    provider: string;
+    provider_id: string;
+    identity_data?: string;
+    created_at?: number | null;
+    updated_at?: number | null;
+}
+export interface LuxAuthSessionRow {
+    id: string;
+    user_id: string;
+    refresh_token_hash: string;
+    refresh_token_family?: string;
+    user_agent?: string;
+    ip?: string;
+    expires_at?: number | null;
+    revoked_at?: number | null;
+    created_at?: number | null;
+    updated_at?: number | null;
+}
+export interface LuxAuthKeyRow {
+    id: string;
+    name?: string;
+    kind: 'publishable' | 'secret' | string;
+    prefix: string;
+    key_hash: string;
+    scopes?: string;
+    created_at?: number | null;
+    revoked_at?: number | null;
+    last_used_at?: number | null;
+}
+export interface LuxAuthSigningKeyRow {
+    id: string;
+    kid: string;
+    algorithm: string;
+    public_jwk?: string;
+    private_key_encrypted?: string;
+    active: boolean;
+    created_at?: number | null;
+    rotated_at?: number | null;
+}
+export interface LuxAuthGrantRow {
+    id: string;
+    user_id: string;
+    capability: string;
+    created_at?: number | null;
+    revoked_at?: number | null;
+}
+export interface LuxAuthProviderRow {
+    provider: LuxOAuthProvider | string;
+    enabled: boolean;
+    client_id?: string;
+    client_secret?: string;
+    redirect_uri?: string;
+    scopes?: string;
+    created_at?: number | null;
+    updated_at?: number | null;
+}
+export interface LuxAuthTables {
+    'auth.users': LuxAuthUserRow;
+    'auth.identities': LuxAuthIdentityRow;
+    'auth.sessions': LuxAuthSessionRow;
+    'auth.keys': LuxAuthKeyRow;
+    'auth.signing_keys': LuxAuthSigningKeyRow;
+    'auth.grants': LuxAuthGrantRow;
+    'auth.providers': LuxAuthProviderRow;
+}
 export interface LuxAuthSession {
     access_token: string;
     token_type: 'bearer';

package/dist/types/index.d.ts

@@ -3,15 +3,15 @@ import { LuxAuthClient, type LuxAuthOptions } from './auth';
 import { createProjectClient, LuxProjectClient, type LuxProjectOptions } from './project';
 import { TimeSeriesNamespace, VectorNamespace } from './namespaces';
 import { TableQueryBuilder, type TableQueryBuilderOptions } from './table';
-import type { KSubEvent, TableRow, TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult } from './types';
-export type { LuxAuthKey, LuxAuthChangeEvent, LuxAuthOptions, LuxAuthSession, LuxAuthStateChangeCallback, LuxAuthStorage, LuxAuthSubscription, LuxAuthUser, LuxOAuthProvider, LuxOAuthUrl, LuxSignInWithOAuthOptions, LuxCreateApiKeyOptions, LuxSignInOptions, LuxSignUpOptions, } from './auth';
+import type { KSubEvent, LuxTypedRow, TableRow, TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult } from './types';
+export type { LuxAuthKey, LuxAuthGrantRow, LuxAuthIdentityRow, LuxAuthChangeEvent, LuxAuthOptions, LuxAuthKeyRow, LuxAuthProviderRow, LuxAuthSession, LuxAuthSessionRow, LuxAuthSigningKeyRow, LuxAuthStateChangeCallback, LuxAuthStorage, LuxAuthSubscription, LuxAuthTables, LuxAuthUserRow, LuxAuthUser, LuxUser, LuxOAuthProvider, LuxOAuthUrl, LuxSignInWithOAuthOptions, LuxCreateApiKeyOptions, LuxSignInOptions, LuxSignUpOptions, } from './auth';
 export { createProjectClient, LuxProjectClient, };
 export { createBrowserClient } from './browser';
 export type { LuxBrowserClientOptions } from './browser';
 export { createServerClient } from './ssr';
 export type { LuxCookieMethods, LuxCookieOptions, LuxServerClientOptions } from './ssr';
-export type { LuxProjectOptions, LuxTableColumn, LuxVectorSearchOptions, } from './project';
-export type { KSubEvent, LuxError, LuxResult, TableChangeEvent, TableChangeType, TableErrorEvent, TableRow, TableSchema, TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult, } from './types';
+export type { LuxProjectLiveEvent, LuxProjectLiveEventType, LuxProjectOptions, LuxTableColumn, LuxVectorSearchOptions, } from './project';
+export type { KSubEvent, LuxAggregateRow, LuxAggregateValue, LuxError, LuxInferRow, LuxNearRow, LuxResult, LuxSimilarity, LuxTypedRow, TableChangeEvent, TableChangeType, TableErrorEvent, TableRow, TableSchema, TSAddOptions, TSMRangeResult, TSRangeOptions, TSSample, VSearchResult, } from './types';
 export { TableQueryBuilder, TableSubscription } from './table';
 export type { TableQueryBuilderOptions } from './table';
 export type LuxClientOptions = RedisOptions & LuxAuthOptions;
@@ -23,7 +23,7 @@ export declare class Lux extends Redis {
     authApi: LuxAuthClient;
     private realtimeManager?;
     constructor(options?: LuxClientOptions | RedisOptions | string);
-    table<T extends TableRow = TableRow>(name: string, options?: TableQueryBuilderOptions<T>): TableQueryBuilder<T>;
+    table<T extends object | readonly object[] = TableRow>(name: string, options?: TableQueryBuilderOptions<LuxTypedRow<T>>): TableQueryBuilder<LuxTypedRow<T>>;
     _subscribePattern(pattern: string, handler: (event: KSubEvent) => void): Promise<() => void>;
     _tselect(args: string[]): Promise<TableRow[]>;
     vset(key: string, vector: number[], options?: {

package/dist/types/project.d.ts

@@ -1,14 +1,15 @@
 import { LuxAuthClient, type LuxAuthOptions } from './auth';
-import type { LuxResult } from './types';
+import type { LuxResult, LuxTypedRow } from './types';
 export interface LuxProjectOptions {
     url: string;
     key: string;
     fetch?: typeof fetch;
+    websocket?: typeof WebSocket;
     auth?: Omit<LuxAuthOptions, 'httpUrl' | 'apiKey' | 'fetch'>;
 }
 export interface LuxTableColumn {
     name: string;
-    type: 'STR' | 'INT' | 'FLOAT' | 'BOOL' | 'TIMESTAMP' | 'UUID';
+    type: 'STR' | 'INT' | 'FLOAT' | 'BOOL' | 'TIMESTAMP' | 'UUID' | `VECTOR(${number})`;
     primaryKey?: boolean;
     unique?: boolean;
     notNull?: boolean;
@@ -21,8 +22,10 @@ export interface LuxVectorSearchOptions {
     filter?: string;
     filter_value?: string;
 }
-type QueryValue = string | number | boolean | null;
+type QueryValue = string | number | boolean | number[] | null;
 type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'is';
+type ProjectRowInput<T extends object> = Partial<T> & Record<string, QueryValue>;
+type ProjectSelectSingle<TResult> = TResult extends readonly (infer Row)[] ? Row : TResult;
 interface QueryFilter {
     column: string;
     operator: FilterOperator;
@@ -32,13 +35,51 @@ interface QueryOrder {
     column: string;
     ascending: boolean;
 }
+interface QueryJoin {
+    type: 'inner' | 'left';
+    table: string;
+    alias: string;
+    onLeft: string;
+    onRight: string;
+}
+interface QueryHaving {
+    column: string;
+    operator: FilterOperator;
+    value: QueryValue;
+}
+interface QueryNear {
+    field: string;
+    vector: number[];
+    k: number;
+    threshold?: number;
+}
+export type LuxProjectLiveEventType = 'snapshot' | 'insert' | 'update' | 'delete' | 'error';
+export interface LuxProjectLiveEvent<T extends object = Record<string, unknown>> {
+    type: LuxProjectLiveEventType;
+    table: string;
+    pk?: string;
+    new: T | null;
+    old: T | null;
+    rows?: T[];
+    changed?: string[];
+    raw?: unknown;
+    error?: {
+        code?: string;
+        message?: string;
+    };
+}
+type LiveEventHandler<T extends object> = (event: LuxProjectLiveEvent<T>) => void;
 export declare class LuxProjectClient {
     readonly url: string;
     readonly key: string;
     readonly auth: LuxAuthClient;
     private fetchImpl;
+    private WebSocketImpl?;
+    private liveSocket;
+    private liveSubscriptions;
+    private livePending;
     constructor(options: LuxProjectOptions);
-    table<T extends Record<string, unknown> = Record<string, unknown>>(name: string): LuxProjectTable<T>;
+    table<T extends object | readonly object[] = Record<string, unknown>>(name: string): LuxProjectTable<LuxTypedRow<T>>;
     ping(): Promise<LuxResult<unknown>>;
     createTable(name: string, columns: Array<string | LuxTableColumn>): Promise<LuxResult<unknown>>;
     exec(command: string | string[]): Promise<LuxResult<unknown>>;
@@ -55,15 +96,33 @@ export declare class LuxProjectClient {
         count?: number;
     }): Promise<LuxResult<unknown>>;
     request<T = unknown>(method: string, path: string, body?: unknown): Promise<LuxResult<T>>;
+    _subscribeLive(spec: Record<string, unknown>, handler: (event: unknown) => void, error: (error: {
+        code?: string;
+        message?: string;
+    }) => void): Promise<() => void>;
+    private ensureLiveSocket;
+    private sendLive;
 }
-export declare class LuxProjectTable<T extends Record<string, unknown>> {
+export declare class LuxProjectTable<T extends object> {
     private client;
     private name;
     constructor(client: LuxProjectClient, name: string);
-    select(columns?: string): LuxProjectSelectBuilder<T, T[]>;
-    insert(row: Partial<T> & Record<string, QueryValue>): LuxProjectInsertBuilder<unknown>;
-    insert(rows: Array<Partial<T> & Record<string, QueryValue>>): LuxProjectInsertBuilder<unknown[]>;
-    update(patch: Partial<T> & Record<string, QueryValue>): LuxProjectMutationBuilder<unknown>;
+    select<TResult extends object = T>(columns?: string): LuxProjectSelectBuilder<T, TResult[]>;
+    eq(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    neq(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    gt(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    gte(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    lt(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    lte(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    near(column: string, vector: number[], options?: {
+        k?: number;
+        threshold?: number;
+    }): LuxProjectSelectBuilder<T, T[]>;
+    is(column: string, value: QueryValue): LuxProjectSelectBuilder<T, T[]>;
+    live(): LuxProjectLiveSubscription<T>;
+    insert(row: ProjectRowInput<T>): LuxProjectInsertBuilder<unknown>;
+    insert(rows: Array<ProjectRowInput<T>>): LuxProjectInsertBuilder<unknown[]>;
+    update(patch: ProjectRowInput<T>): LuxProjectMutationBuilder<unknown>;
     delete(): LuxProjectMutationBuilder<unknown>;
     count(): Promise<LuxResult<number>>;
 }
@@ -78,6 +137,10 @@ declare abstract class LuxProjectFilterBuilder<TResult, TSelf> extends LuxProjec
     protected tableName: string;
     protected filters: QueryFilter[];
     protected orderBy?: QueryOrder;
+    protected joins: QueryJoin[];
+    protected groupColumns: string[];
+    protected havingFilters: QueryHaving[];
+    protected nearQuery?: QueryNear;
     protected limitCount?: number;
     protected offsetCount?: number;
     protected constructor(client: LuxProjectClient, tableName: string);
@@ -88,20 +151,48 @@ declare abstract class LuxProjectFilterBuilder<TResult, TSelf> extends LuxProjec
     lt(column: string, value: QueryValue): TSelf;
     lte(column: string, value: QueryValue): TSelf;
     is(column: string, value: QueryValue): TSelf;
+    join(table: string, alias: string, onLeft: string, onRight: string): TSelf;
+    leftJoin(table: string, alias: string, onLeft: string, onRight: string): TSelf;
+    group(columns: string | string[]): TSelf;
+    having(column: string, operator: FilterOperator, value: QueryValue): TSelf;
     protected addFilter(column: string, operator: FilterOperator, value: QueryValue): TSelf;
     protected filteredQueryParams(): URLSearchParams;
 }
-export declare class LuxProjectSelectBuilder<T extends Record<string, unknown>, TResult> extends LuxProjectFilterBuilder<TResult, LuxProjectSelectBuilder<T, TResult>> {
+export declare class LuxProjectSelectBuilder<T extends object, TResult> extends LuxProjectFilterBuilder<TResult, LuxProjectSelectBuilder<T, TResult>> {
     private columns;
     private expectSingle;
     constructor(client: LuxProjectClient, tableName: string, columns: string);
     order(column: string, options?: {
         ascending?: boolean;
     }): this;
+    near(column: string, vector: number[], options?: {
+        k?: number;
+        threshold?: number;
+    }): this;
     limit(count: number): this;
     range(from: number, to: number): this;
-    single(): LuxProjectSelectBuilder<T, T>;
+    single(): LuxProjectSelectBuilder<T, ProjectSelectSingle<TResult>>;
     execute(): Promise<LuxResult<TResult>>;
+    live(): LuxProjectLiveSubscription<LuxTypedRow<TResult>>;
+}
+export declare class LuxProjectLiveSubscription<T extends object> {
+    private client;
+    private table;
+    private columns;
+    private filters;
+    private nearQuery?;
+    private orderBy?;
+    private limitCount?;
+    private offsetCount?;
+    private handlers;
+    private unsubscribeFn;
+    constructor(client: LuxProjectClient, table: string, columns: string, filters: QueryFilter[], nearQuery?: QueryNear | undefined, orderBy?: QueryOrder | undefined, limitCount?: number | undefined, offsetCount?: number | undefined);
+    on(type: LuxProjectLiveEventType | 'change', handler: LiveEventHandler<T>): this;
+    unsubscribe(): Promise<void>;
+    private start;
+    private spec;
+    private handleEvent;
+    private emit;
 }
 export declare class LuxProjectInsertBuilder<TResult> extends LuxProjectThenable<TResult> {
     private client;

package/dist/types/table.d.ts

@@ -1,4 +1,4 @@
-import type { KSubEvent, LuxError, LuxResult, TableChangeEvent, TableErrorEvent, TableRow, TableSchema, VSearchResult } from './types';
+import type { KSubEvent, LuxError, LuxResult, TableChangeEvent, TableErrorEvent, TableRow, TableSchema } from './types';
 type TableWhereOp = '=' | '!=' | '>' | '<' | '>=' | '<=';
 type TableWhereValue = string | number | boolean;
 interface TableWhereCondition {
@@ -10,19 +10,11 @@ interface TableClient {
     call(command: string, ...args: Array<string | number>): Promise<unknown>;
     _tselect(args: string[]): Promise<TableRow[]>;
     _subscribePattern(pattern: string, handler: (event: KSubEvent) => void): Promise<() => void>;
-    vsearch(query: number[], options: {
-        k: number;
-        filter?: {
-            key: string;
-            value: string;
-        };
-        meta?: boolean;
-    }): Promise<VSearchResult[]>;
 }
-export interface TableQueryBuilderOptions<T extends TableRow> {
+export interface TableQueryBuilderOptions<T extends object> {
     schema?: TableSchema<T>;
 }
-export declare class TableSubscription<T extends TableRow> {
+export declare class TableSubscription<T extends object> {
     private client;
     private table;
     private selectArgsBuilder;
@@ -41,7 +33,7 @@ export declare class TableSubscription<T extends TableRow> {
     private start;
     private handleRawChange;
 }
-export declare class TableQueryBuilder<T extends TableRow = TableRow> {
+export declare class TableQueryBuilder<T extends object = TableRow> {
     private client;
     private name;
     private conditions;
@@ -51,6 +43,8 @@ export declare class TableQueryBuilder<T extends TableRow = TableRow> {
     private offsetCount?;
     private joinClause?;
     private similarityClause?;
+    private groupFields;
+    private havingConditions;
     private selectClause;
     private expectSingle;
     private schema?;
@@ -73,14 +67,18 @@ export declare class TableQueryBuilder<T extends TableRow = TableRow> {
     limit(n: number): this;
     offset(n: number): this;
     join(table: string, alias: string, onLeft: string, onRight: string): this;
-    similar(field: string, vector: number[], options: {
-        k: number;
-        filter?: {
-            key: string;
-            value: string;
-        };
+    leftJoin(table: string, alias: string, onLeft: string, onRight: string): this;
+    group(fields: string | string[]): this;
+    groupBy(fields: string | string[]): this;
+    having(field: string, op: TableWhereOp, value: TableWhereValue): this;
+    near(field: string, vector: number[], options?: {
+        k?: number;
+        threshold?: number;
+    }): this;
+    similar(field: string, vector: number[], options?: {
+        k?: number;
+        threshold?: number;
     }): this;
-    private parseSimilarityPk;
     run(): Promise<LuxResult<T[] | T>>;
     then<TFulfilled = LuxResult<T[] | T>, TRejected = never>(onfulfilled?: ((value: LuxResult<T[] | T>) => TFulfilled | PromiseLike<TFulfilled>) | null, onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TFulfilled | TRejected>;
     insert(data: Record<string, unknown>): Promise<LuxResult<number>>;

package/dist/types/types.d.ts

@@ -31,6 +31,14 @@ export interface TableRow {
     id?: number | string;
     [field: string]: unknown;
 }
+export type LuxInferRow<T> = T extends readonly (infer Row)[] ? Row : T;
+export type LuxTypedRow<T> = LuxInferRow<T> extends object ? LuxInferRow<T> : TableRow;
+export type LuxAggregateValue = number | string;
+export type LuxAggregateRow<Aliases extends string = string> = Record<Aliases, LuxAggregateValue>;
+export interface LuxSimilarity {
+    _similarity: number | string;
+}
+export type LuxNearRow<T extends object = Record<string, unknown>> = T & LuxSimilarity;
 export interface LuxError {
     code: string;
     message: string;
@@ -52,7 +60,7 @@ export interface TableSchema<T> {
     safeParse?: (input: unknown) => SchemaSafeParse<T>;
 }
 export type TableChangeType = 'insert' | 'update' | 'delete' | 'change' | 'error';
-export interface TableChangeEvent<T extends TableRow> {
+export interface TableChangeEvent<T extends object = TableRow> {
     type: Exclude<TableChangeType, 'error'>;
     table: string;
     pk: string;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@luxdb/sdk",
-    "version": "1.4.1",
-    "description": "Lux SDK - ioredis extended with vector search, time series, and realtime key subscriptions",
+    "version": "1.4.3",
+    "description": "Official Lux TypeScript SDK for app data, auth, tables, vectors, realtime, and Redis-compatible direct access",
     "main": "./dist/cjs/index.js",
     "module": "./dist/esm/index.js",
     "types": "./dist/types/index.d.ts",
@@ -59,5 +59,5 @@
         "url": "https://github.com/lux-db/lux",
         "directory": "sdk"
     },
-    "keywords": ["lux", "redis", "vector", "search", "database", "ioredis", "similarity", "timeseries", "realtime", "subscriptions"]
+    "keywords": ["lux", "database", "application-database", "auth", "tables", "vectors", "realtime", "redis", "cache", "queues", "timeseries"]
 }