@linabase/js 0.2.0 → 0.2.2

package/dist/index.d.cts

@@ -0,0 +1,442 @@
+type RequestFn$3 = (path: string, options?: RequestInit) => Promise<Response>;
+interface PostgrestError {
+    message: string;
+    code?: string;
+    details?: string;
+    hint?: string;
+}
+interface QueryResult<T = any> {
+    data: T[] | null;
+    error: PostgrestError | null;
+    count: number | null;
+}
+interface SingleQueryResult<T = any> {
+    data: T | null;
+    error: PostgrestError | null;
+    count: number | null;
+}
+interface CsvQueryResult {
+    data: string | null;
+    error: PostgrestError | null;
+    count: number | null;
+}
+declare class DatabaseClient {
+    private request;
+    private table;
+    private params;
+    private method;
+    private body;
+    private preferHeaders;
+    private _single;
+    private _maybeSingle;
+    private _throwOnError;
+    private _csv;
+    private _abortSignal;
+    private _schema;
+    constructor(request: RequestFn$3, table: string);
+    /** Select columns. Supports nested joins: "*, comments(*)" and aliases: "full_name:name" */
+    select(columns?: string, options?: {
+        count?: "exact" | "estimated" | "planned";
+        head?: boolean;
+    }): this;
+    insert(data: Record<string, any> | Record<string, any>[]): this;
+    /** Upsert: insert or update on conflict. Uses merge-duplicates by default. */
+    upsert(data: Record<string, any> | Record<string, any>[], options?: {
+        ignoreDuplicates?: boolean;
+        onConflict?: string;
+    }): this;
+    update(data: Record<string, any>): this;
+    delete(): this;
+    eq(column: string, value: any): this;
+    neq(column: string, value: any): this;
+    gt(column: string, value: any): this;
+    gte(column: string, value: any): this;
+    lt(column: string, value: any): this;
+    lte(column: string, value: any): this;
+    like(column: string, pattern: string): this;
+    ilike(column: string, pattern: string): this;
+    /** Regex match (~) when called with (column, pattern). Object-based multi-column filter when called with ({ col: val }). */
+    match(columnOrFilter: string | Record<string, any>, pattern?: string): this;
+    /** Case-insensitive regex match (~*) */
+    imatch(column: string, pattern: string): this;
+    in(column: string, values: any[]): this;
+    /** Contains (@>) - array or JSONB containment */
+    contains(column: string, value: any): this;
+    /** Contained by (<@) */
+    containedBy(column: string, value: any): this;
+    /** Overlap (&&) - ranges or arrays */
+    overlaps(column: string, value: any): this;
+    is(column: string, value: "null" | "true" | "false" | null | boolean): this;
+    /** IS DISTINCT FROM */
+    isDistinct(column: string, value: any): this;
+    /** Negate a filter: not.eq, not.in, not.is, etc. */
+    not(column: string, operator: string, value: any): this;
+    /** OR filter: or("age.gt.20,name.eq.John") */
+    or(filters: string): this;
+    /** to_tsquery */
+    textSearch(column: string, query: string, options?: {
+        type?: "plain" | "phrase" | "websearch";
+    }): this;
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    /** Request exact, estimated, or planned count via Prefer header */
+    count(type?: "exact" | "estimated" | "planned"): this;
+    /** Return a single object instead of an array. Errors if 0 or >1 rows. */
+    single(): this;
+    /** Return a single object or null. Errors only if >1 rows. */
+    maybeSingle(): this;
+    /** Range-based pagination: range(0, 9) fetches the first 10 rows. */
+    range(from: number, to: number): this;
+    /** Throw an error instead of returning it in the result object. */
+    throwOnError(): this;
+    /** Request CSV format. Returns raw CSV text in data instead of parsed objects. */
+    csv(): this;
+    /** Pass an AbortSignal for request cancellation. */
+    abortSignal(signal: AbortSignal): this;
+    /** Switch schema. Sets Accept-Profile (GET) or Content-Profile (POST/PATCH/DELETE). */
+    schema(schemaName: string): this;
+    private reset;
+    execute(): Promise<QueryResult | SingleQueryResult | CsvQueryResult>;
+    /**
+     * Makes DatabaseClient thenable (await-able). Resolves to
+     * `{ data, error, count }` where data is permissively typed so
+     * callers can access properties without generated database types.
+     */
+    then<T = any, U = never>(onfulfilled?: ((value: any) => T | PromiseLike<T>) | null, onrejected?: ((reason: any) => U | PromiseLike<U>) | null): Promise<T | U>;
+}
+declare class RpcClient {
+    private request;
+    constructor(request: RequestFn$3);
+    /** Call a Postgres function: rpc("my_function", { arg1: "value" }, { count: "exact" }) */
+    call(fn: string, args?: Record<string, any>, options?: {
+        count?: "exact" | "estimated" | "planned";
+        throwOnError?: boolean;
+    }): Promise<QueryResult>;
+}
+
+type RequestFn$2 = (path: string, options?: RequestInit) => Promise<Response>;
+declare class StorageClient {
+    private request;
+    private baseUrl;
+    constructor(request: RequestFn$2, baseUrl?: string);
+    from(bucket: string): BucketClient;
+    listBuckets(): Promise<{
+        data: any[];
+        error: any;
+    }>;
+    createBucket(name: string, options?: {
+        public?: boolean;
+    }): Promise<{
+        data: any;
+        error: any;
+    }>;
+}
+declare class BucketClient {
+    private request;
+    private bucket;
+    private baseUrl;
+    constructor(request: RequestFn$2, bucket: string, baseUrl?: string);
+    upload(path: string, file: Blob | File | ArrayBuffer, options?: {
+        contentType?: string;
+        upsert?: boolean;
+        headers?: Record<string, string>;
+    }): Promise<{
+        data: any;
+        error: any;
+    }>;
+    download(path: string): Promise<{
+        data: Blob | null;
+        error: any;
+    }>;
+    list(prefix?: string): Promise<{
+        data: any[];
+        error: any;
+    }>;
+    remove(pathOrPaths: string | string[]): Promise<{
+        data: any;
+        error: any;
+    }>;
+    getPublicUrl(path: string, options?: {
+        transform?: {
+            width?: number;
+            height?: number;
+            quality?: number;
+            format?: string;
+        };
+    }): {
+        data: {
+            publicUrl: string;
+        };
+    };
+    createSignedUrl(path: string, expiresIn: number): Promise<{
+        data: {
+            signedUrl: string;
+        } | null;
+        error: any;
+    }>;
+    createSignedUrls(paths: string[], expiresIn: number): Promise<{
+        data: Array<{
+            path: string;
+            signedUrl: string;
+        }> | null;
+        error: any;
+    }>;
+    createSignedUploadUrl(path: string): Promise<{
+        data: {
+            signedUrl: string;
+            token: string;
+            path: string;
+        } | null;
+        error: any;
+    }>;
+    move(fromPath: string, toPath: string): Promise<{
+        error: any;
+    }>;
+    copy(fromPath: string, toPath: string): Promise<{
+        error: any;
+    }>;
+}
+
+type RequestFn$1 = (path: string, options?: RequestInit) => Promise<Response>;
+type OAuthProvider = "google" | "github" | "apple" | "microsoft" | "linkedin" | "slack" | "gitlab" | "bitbucket" | "discord" | "facebook" | "twitter" | "reddit" | "twitch" | "tiktok" | "spotify" | "telegram" | "roblox";
+interface AuthSession {
+    access_token: string;
+    refresh_token: string;
+    token_type: string;
+    expires_in: number;
+    expires_at: number;
+    user: AuthUser;
+}
+interface AuthUser {
+    id: string;
+    email: string | null;
+    email_confirmed_at: string | null;
+    role: string;
+    raw_user_meta_data: Record<string, unknown>;
+    raw_app_meta_data: Record<string, unknown>;
+    /** Alias for raw_user_meta_data (Supabase compatibility) */
+    user_metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+declare class AuthClient {
+    private request;
+    private listeners;
+    private currentSession;
+    /**
+     * Callback that the parent LinabaseClient can set to update the Authorization
+     * header when the user signs in/out or a token is refreshed.
+     */
+    onSessionChange: ((session: AuthSession | null) => void) | null;
+    constructor(request: RequestFn$1);
+    /**
+     * Set (or clear) the current session. Use this to restore a persisted
+     * session on app launch (e.g., from AsyncStorage / SecureStore).
+     * Emits INITIAL_SESSION to onAuthStateChange listeners when called externally.
+     * Internal callers (signIn, signUp, etc.) pass _internal=true to skip the emit.
+     */
+    setSession(session: AuthSession | null, _internal?: boolean): void;
+    signUp(params: {
+        email: string;
+        password: string;
+        data?: Record<string, unknown>;
+    }): Promise<{
+        data: AuthSession | null;
+        error: any;
+    }>;
+    signIn(params: {
+        email: string;
+        password: string;
+    }): Promise<{
+        data: AuthSession | null;
+        error: any;
+    }>;
+    /** Supabase-compatible alias for signIn */
+    signInWithPassword(params: {
+        email: string;
+        password: string;
+    }): Promise<{
+        data: AuthSession | null;
+        error: any;
+    }>;
+    signInWithIdToken(params: {
+        provider: OAuthProvider;
+        token: string;
+        nonce?: string;
+    }): Promise<{
+        data: AuthSession | null;
+        error: any;
+    }>;
+    signInWithOAuth(params: {
+        provider: OAuthProvider;
+        redirectTo?: string;
+    }): {
+        url: string;
+    };
+    signOut(): Promise<{
+        error: any;
+    }>;
+    getSession(): Promise<{
+        data: {
+            session: AuthSession | null;
+        };
+        error: any;
+    }>;
+    getUser(): Promise<{
+        data: {
+            user: AuthUser | null;
+        };
+        error: any;
+    }>;
+    refreshSession(): Promise<{
+        data: AuthSession | null;
+        error: any;
+    }>;
+    resetPasswordForEmail(email: string, _options?: {
+        redirectTo?: string;
+    }): Promise<{
+        error: any;
+    }>;
+    updatePassword(newPassword: string): Promise<{
+        error: any;
+    }>;
+    updateUser(attributes: {
+        email?: string;
+        password?: string;
+        data?: Record<string, any>;
+    }): Promise<{
+        data: {
+            user: AuthUser | null;
+        };
+        error: any;
+    }>;
+    signInWithOtp(params: {
+        email: string;
+        options?: {
+            emailRedirectTo?: string;
+        };
+    }): Promise<{
+        data: any;
+        error: any;
+    }>;
+    verifyOtp(params: {
+        email?: string;
+        phone?: string;
+        token: string;
+        type?: "email" | "sms" | "magiclink" | "signup" | "recovery";
+    }): Promise<{
+        data: any;
+        error: any;
+    }>;
+    get admin(): {
+        listUsers(params?: {
+            page?: number;
+            per_page?: number;
+        }): Promise<{
+            data: any;
+            error: any;
+        }>;
+        createUser(params: {
+            email: string;
+            password?: string;
+            user_metadata?: Record<string, any>;
+            email_confirm?: boolean;
+        }): Promise<{
+            data: any;
+            error: any;
+        }>;
+        getUserById(id: string): Promise<{
+            data: any;
+            error: any;
+        }>;
+        updateUserById(id: string, attributes: Record<string, any>): Promise<{
+            data: any;
+            error: any;
+        }>;
+        deleteUser(id: string): Promise<{
+            error: any;
+        }>;
+    };
+    get mfa(): {
+        enroll(params: {
+            factorType: "totp";
+            friendlyName?: string;
+        }): Promise<{
+            data: any;
+            error: any;
+        }>;
+        challenge(params: {
+            factorId: string;
+        }): Promise<{
+            data: any;
+            error: any;
+        }>;
+        verify(params: {
+            factorId: string;
+            challengeId: string;
+            code: string;
+        }): Promise<{
+            data: any;
+            error: any;
+        }>;
+        unenroll(params: {
+            factorId: string;
+        }): Promise<{
+            error: any;
+        }>;
+        listFactors(): Promise<{
+            data: any;
+            error: any;
+        }>;
+    };
+    onAuthStateChange(callback: (event: string, session: AuthSession | null) => void): {
+        unsubscribe: () => void;
+    };
+    private emit;
+    private parseAuthResponse;
+}
+
+type RequestFn = (path: string, options?: RequestInit) => Promise<Response>;
+interface FunctionInvokeOptions {
+    body?: Record<string, any>;
+    method?: "GET" | "POST";
+    headers?: Record<string, string>;
+}
+declare class FunctionsClient {
+    private request;
+    constructor(request: RequestFn);
+    invoke<T = any>(name: string, options?: FunctionInvokeOptions): Promise<{
+        data: T | null;
+        error: any;
+    }>;
+}
+
+interface LinabaseConfig {
+    url: string;
+    anonKey?: string;
+    serviceRoleKey?: string;
+}
+interface LinabaseClient {
+    from: (table: string) => DatabaseClient;
+    schema: (schemaName: string) => {
+        from: (table: string) => DatabaseClient;
+    };
+    rpc: (fn: string, args?: Record<string, any>) => ReturnType<RpcClient["call"]>;
+    storage: StorageClient;
+    auth: AuthClient;
+    functions: FunctionsClient;
+    /** Realtime channel (stub; not yet supported). Returns a chainable no-op. */
+    channel: (name: string) => any;
+    /** Remove a realtime channel (stub; not yet supported). */
+    removeChannel: (channel: any) => void;
+    generateTypes: () => Promise<string>;
+    /** Returns a new client that targets the given branch via X-Branch header. */
+    branch: (slug: string) => LinabaseClient;
+}
+declare function createClient(config: LinabaseConfig): LinabaseClient;
+
+export { AuthClient, type AuthSession, type AuthUser, BucketClient, type CsvQueryResult, DatabaseClient, type FunctionInvokeOptions, FunctionsClient, type LinabaseClient, type LinabaseConfig, type OAuthProvider, type PostgrestError, type QueryResult, RpcClient, type SingleQueryResult, StorageClient, createClient };

package/dist/index.d.ts

@@ -236,9 +236,10 @@ declare class AuthClient {
     /**
      * Set (or clear) the current session. Use this to restore a persisted
      * session on app launch (e.g., from AsyncStorage / SecureStore).
-     * Emits INITIAL_SESSION to onAuthStateChange listeners.
+     * Emits INITIAL_SESSION to onAuthStateChange listeners when called externally.
+     * Internal callers (signIn, signUp, etc.) pass _internal=true to skip the emit.
      */
-    setSession(session: AuthSession | null): void;
+    setSession(session: AuthSession | null, _internal?: boolean): void;
     signUp(params: {
         email: string;
         password: string;

package/dist/index.js

@@ -159,7 +159,12 @@ var DatabaseClient = class {
   order(column, options) {
     const dir = options?.ascending === false ? "desc" : "asc";
     const nulls = options?.nullsFirst === true ? ".nullsfirst" : options?.nullsFirst === false ? ".nullslast" : "";
-    this.params.set("order", `${column}.${dir}${nulls}`);
+    const existing = this.params.get("order");
+    if (existing) {
+      this.params.set("order", `${existing},${column}.${dir}${nulls}`);
+    } else {
+      this.params.set("order", `${column}.${dir}${nulls}`);
+    }
     return this;
   }
   limit(count) {
@@ -594,12 +599,13 @@ var AuthClient = class {
   /**
    * Set (or clear) the current session. Use this to restore a persisted
    * session on app launch (e.g., from AsyncStorage / SecureStore).
-   * Emits INITIAL_SESSION to onAuthStateChange listeners.
+   * Emits INITIAL_SESSION to onAuthStateChange listeners when called externally.
+   * Internal callers (signIn, signUp, etc.) pass _internal=true to skip the emit.
    */
-  setSession(session) {
+  setSession(session, _internal) {
     this.currentSession = session;
     if (this.onSessionChange) this.onSessionChange(session);
-    this.emit("INITIAL_SESSION", session);
+    if (!_internal) this.emit("INITIAL_SESSION", session);
   }
   // ─── Email/Password ────────────────────────────────────────
   async signUp(params) {
@@ -611,7 +617,7 @@ var AuthClient = class {
       const data = await res.json();
       if (!res.ok) return { data: null, error: data };
       const session = this.parseAuthResponse(data);
-      this.setSession(session);
+      this.setSession(session, true);
       this.emit("SIGNED_IN", session);
       return { data: session, error: null };
     } catch (err) {
@@ -627,7 +633,7 @@ var AuthClient = class {
       const data = await res.json();
       if (!res.ok) return { data: null, error: data };
       const session = this.parseAuthResponse(data);
-      this.setSession(session);
+      this.setSession(session, true);
       this.emit("SIGNED_IN", session);
       return { data: session, error: null };
     } catch (err) {
@@ -652,7 +658,7 @@ var AuthClient = class {
       const data = await res.json();
       if (!res.ok) return { data: null, error: data };
       const session = this.parseAuthResponse(data);
-      this.setSession(session);
+      this.setSession(session, true);
       this.emit("SIGNED_IN", session);
       return { data: session, error: null };
     } catch (err) {
@@ -673,7 +679,7 @@ var AuthClient = class {
   async signOut() {
     try {
       await this.request("/auth/v1/logout", { method: "POST" });
-      this.setSession(null);
+      this.setSession(null, true);
       this.emit("SIGNED_OUT", null);
       return { error: null };
     } catch (err) {
@@ -713,12 +719,12 @@ var AuthClient = class {
       });
       const data = await res.json();
       if (!res.ok) {
-        this.setSession(null);
+        this.setSession(null, true);
         this.emit("SIGNED_OUT", null);
         return { data: null, error: data };
       }
       const session = this.parseAuthResponse(data);
-      this.setSession(session);
+      this.setSession(session, true);
       this.emit("TOKEN_REFRESHED", session);
       return { data: session, error: null };
     } catch (err) {

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@linabase/js",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "JavaScript/TypeScript client SDK for Linabase (database, storage, auth)",
   "license": "MIT",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     }
   },