@luxdb/sdk 1.3.0 → 1.4.2

package/dist/types/project.d.ts

@@ -0,0 +1,121 @@
+import { LuxAuthClient, type LuxAuthOptions } from './auth';
+import type { LuxResult } from './types';
+export interface LuxProjectOptions {
+    url: string;
+    key: string;
+    fetch?: typeof fetch;
+    auth?: Omit<LuxAuthOptions, 'httpUrl' | 'apiKey' | 'fetch'>;
+}
+export interface LuxTableColumn {
+    name: string;
+    type: 'STR' | 'INT' | 'FLOAT' | 'BOOL' | 'TIMESTAMP' | 'UUID';
+    primaryKey?: boolean;
+    unique?: boolean;
+    notNull?: boolean;
+    references?: string;
+    onDelete?: string;
+}
+export interface LuxVectorSearchOptions {
+    vector: number[];
+    k?: number;
+    filter?: string;
+    filter_value?: string;
+}
+type QueryValue = string | number | boolean | null;
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'is';
+interface QueryFilter {
+    column: string;
+    operator: FilterOperator;
+    value: QueryValue;
+}
+interface QueryOrder {
+    column: string;
+    ascending: boolean;
+}
+export declare class LuxProjectClient {
+    readonly url: string;
+    readonly key: string;
+    readonly auth: LuxAuthClient;
+    private fetchImpl;
+    constructor(options: LuxProjectOptions);
+    table<T extends Record<string, unknown> = Record<string, unknown>>(name: string): LuxProjectTable<T>;
+    ping(): Promise<LuxResult<unknown>>;
+    createTable(name: string, columns: Array<string | LuxTableColumn>): Promise<LuxResult<unknown>>;
+    exec(command: string | string[]): Promise<LuxResult<unknown>>;
+    vectorSet(key: string, vector: number[], metadata?: Record<string, unknown>): Promise<LuxResult<unknown>>;
+    vectorSearch(options: LuxVectorSearchOptions): Promise<LuxResult<unknown>>;
+    tsAdd(key: string, value: number, options?: {
+        timestamp?: number | '*';
+        labels?: Record<string, string>;
+        retention?: number;
+    }): Promise<LuxResult<unknown>>;
+    tsRange(key: string, options?: {
+        from?: number | '-';
+        to?: number | '+';
+        count?: number;
+    }): Promise<LuxResult<unknown>>;
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<LuxResult<T>>;
+}
+export declare class LuxProjectTable<T extends Record<string, unknown>> {
+    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>;
+    delete(): LuxProjectMutationBuilder<unknown>;
+    count(): Promise<LuxResult<number>>;
+}
+declare abstract class LuxProjectThenable<TResult> implements PromiseLike<LuxResult<TResult>> {
+    then<TFulfilled = LuxResult<TResult>, TRejected = never>(onfulfilled?: ((value: LuxResult<TResult>) => TFulfilled | PromiseLike<TFulfilled>) | null, onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<TFulfilled | TRejected>;
+    catch<TRejected = never>(onrejected?: ((reason: unknown) => TRejected | PromiseLike<TRejected>) | null): Promise<LuxResult<TResult> | TRejected>;
+    finally(onfinally?: (() => void) | null): Promise<LuxResult<TResult>>;
+    abstract execute(): Promise<LuxResult<TResult>>;
+}
+declare abstract class LuxProjectFilterBuilder<TResult, TSelf> extends LuxProjectThenable<TResult> {
+    protected client: LuxProjectClient;
+    protected tableName: string;
+    protected filters: QueryFilter[];
+    protected orderBy?: QueryOrder;
+    protected limitCount?: number;
+    protected offsetCount?: number;
+    protected constructor(client: LuxProjectClient, tableName: string);
+    eq(column: string, value: QueryValue): TSelf;
+    neq(column: string, value: QueryValue): TSelf;
+    gt(column: string, value: QueryValue): TSelf;
+    gte(column: string, value: QueryValue): TSelf;
+    lt(column: string, value: QueryValue): TSelf;
+    lte(column: string, value: QueryValue): TSelf;
+    is(column: string, 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>> {
+    private columns;
+    private expectSingle;
+    constructor(client: LuxProjectClient, tableName: string, columns: string);
+    order(column: string, options?: {
+        ascending?: boolean;
+    }): this;
+    limit(count: number): this;
+    range(from: number, to: number): this;
+    single(): LuxProjectSelectBuilder<T, T>;
+    execute(): Promise<LuxResult<TResult>>;
+}
+export declare class LuxProjectInsertBuilder<TResult> extends LuxProjectThenable<TResult> {
+    private client;
+    private tableName;
+    private rowOrRows;
+    constructor(client: LuxProjectClient, tableName: string, rowOrRows: Record<string, QueryValue> | Array<Record<string, QueryValue>>);
+    execute(): Promise<LuxResult<TResult>>;
+}
+export declare class LuxProjectMutationBuilder<TResult> extends LuxProjectFilterBuilder<TResult, LuxProjectMutationBuilder<TResult>> {
+    private method;
+    private body?;
+    constructor(client: LuxProjectClient, tableName: string, method: 'PATCH' | 'DELETE', body?: Record<string, QueryValue> | undefined);
+    execute(): Promise<LuxResult<TResult>>;
+}
+export declare function createProjectClient(options: LuxProjectOptions): LuxProjectClient;
+export declare function createClient(url: string, key: string, options?: Omit<LuxProjectOptions, 'url' | 'key'>): LuxProjectClient;
+export {};

package/dist/types/ssr.d.ts

@@ -0,0 +1,22 @@
+import { type LuxProjectOptions } from './project';
+export interface LuxCookieOptions {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'lax' | 'strict' | 'none';
+    secure?: boolean;
+}
+export interface LuxCookieMethods {
+    get(name: string): string | null | undefined | Promise<string | null | undefined>;
+    set?(name: string, value: string, options?: LuxCookieOptions): void | Promise<void>;
+    remove?(name: string, options?: LuxCookieOptions): void | Promise<void>;
+}
+export interface LuxServerClientOptions extends Omit<LuxProjectOptions, 'url' | 'key' | 'auth'> {
+    auth?: Omit<NonNullable<LuxProjectOptions['auth']>, 'storage'> & {
+        cookieOptions?: LuxCookieOptions;
+    };
+    cookies: LuxCookieMethods;
+}
+export declare function createServerClient(url: string, key: string, options: LuxServerClientOptions): import("./project").LuxProjectClient;

package/dist/{table.d.ts → types/table.d.ts}

@@ -60,7 +60,16 @@ export declare class TableQueryBuilder<T extends TableRow = TableRow> {
     select(columns?: string): this;
     single(): this;
     where(field: string, op: TableWhereOp, value: TableWhereValue): this;
+    eq(field: string, value: TableWhereValue): this;
+    neq(field: string, value: TableWhereValue): this;
+    gt(field: string, value: TableWhereValue): this;
+    gte(field: string, value: TableWhereValue): this;
+    lt(field: string, value: TableWhereValue): this;
+    lte(field: string, value: TableWhereValue): this;
     orderBy(field: string, dir?: 'asc' | 'desc'): this;
+    order(field: string, options?: {
+        ascending?: boolean;
+    }): this;
     limit(n: number): this;
     offset(n: number): this;
     join(table: string, alias: string, onLeft: string, onRight: string): this;
@@ -73,11 +82,11 @@ export declare class TableQueryBuilder<T extends TableRow = TableRow> {
     }): 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>>;
     update(id: number | string, data: Record<string, unknown>): Promise<LuxResult<number>>;
-    updateWhere(data: Record<string, unknown>): Promise<LuxResult<number>>;
+    update(data: Record<string, unknown>): Promise<LuxResult<number>>;
     delete(...ids: Array<number | string>): Promise<LuxResult<number>>;
-    deleteWhere(): Promise<LuxResult<number>>;
     subscribe(): TableSubscription<T>;
 }
 export {};

package/package.json

@@ -1,12 +1,46 @@
 {
     "name": "@luxdb/sdk",
-    "version": "1.3.0",
-    "description": "Lux SDK - ioredis extended with vector search, time series, and realtime key subscriptions",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
+    "version": "1.4.2",
+    "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",
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/esm/index.js",
+            "require": "./dist/cjs/index.js",
+            "default": "./dist/esm/index.js"
+        },
+        "./project": {
+            "types": "./dist/types/project.d.ts",
+            "import": "./dist/esm/project.js",
+            "require": "./dist/cjs/project.js",
+            "default": "./dist/esm/project.js"
+        },
+        "./auth": {
+            "types": "./dist/types/auth.d.ts",
+            "import": "./dist/esm/auth.js",
+            "require": "./dist/cjs/auth.js",
+            "default": "./dist/esm/auth.js"
+        },
+        "./browser": {
+            "types": "./dist/types/browser.d.ts",
+            "import": "./dist/esm/browser.js",
+            "require": "./dist/cjs/browser.js",
+            "default": "./dist/esm/browser.js"
+        },
+        "./ssr": {
+            "types": "./dist/types/ssr.d.ts",
+            "import": "./dist/esm/ssr.js",
+            "require": "./dist/cjs/ssr.js",
+            "default": "./dist/esm/ssr.js"
+        }
+    },
     "files": ["dist"],
     "scripts": {
-        "build": "tsc",
+        "build": "bun scripts/build.ts",
+        "test": "bun test tests",
         "prepublishOnly": "bun run build"
     },
     "dependencies": {
@@ -25,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"]
 }