@linabase/js 0.1.1 → 0.2.1

package/dist/index.d.cts

@@ -0,0 +1,441 @@
+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.
+     */
+    setSession(session: AuthSession | null): 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

@@ -1,23 +1,23 @@
-type RequestFn$2 = (path: string, options?: RequestInit) => Promise<Response>;
+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: {
-        message: string;
-    } | null;
+    error: PostgrestError | null;
     count: number | null;
 }
 interface SingleQueryResult<T = any> {
     data: T | null;
-    error: {
-        message: string;
-    } | null;
+    error: PostgrestError | null;
     count: number | null;
 }
 interface CsvQueryResult {
     data: string | null;
-    error: {
-        message: string;
-    } | null;
+    error: PostgrestError | null;
     count: number | null;
 }
 declare class DatabaseClient {
@@ -33,13 +33,17 @@ declare class DatabaseClient {
     private _csv;
     private _abortSignal;
     private _schema;
-    constructor(request: RequestFn$2, table: string);
+    constructor(request: RequestFn$3, table: string);
     /** Select columns. Supports nested joins: "*, comments(*)" and aliases: "full_name:name" */
-    select(columns?: string): this;
+    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;
@@ -51,8 +55,8 @@ declare class DatabaseClient {
     lte(column: string, value: any): this;
     like(column: string, pattern: string): this;
     ilike(column: string, pattern: string): this;
-    /** Regex match (~) */
-    match(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;
@@ -62,7 +66,7 @@ declare class DatabaseClient {
     containedBy(column: string, value: any): this;
     /** Overlap (&&) - ranges or arrays */
     overlaps(column: string, value: any): this;
-    is(column: string, value: "null" | "true" | "false"): 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. */
@@ -97,11 +101,16 @@ declare class DatabaseClient {
     schema(schemaName: string): this;
     private reset;
     execute(): Promise<QueryResult | SingleQueryResult | CsvQueryResult>;
-    then(resolve: (value: QueryResult | SingleQueryResult | CsvQueryResult) => void, reject?: (reason: any) => void): Promise<void>;
+    /**
+     * 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$2);
+    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";
@@ -109,11 +118,11 @@ declare class RpcClient {
     }): Promise<QueryResult>;
 }
 
-type RequestFn$1 = (path: string, options?: RequestInit) => Promise<Response>;
+type RequestFn$2 = (path: string, options?: RequestInit) => Promise<Response>;
 declare class StorageClient {
     private request;
     private baseUrl;
-    constructor(request: RequestFn$1, baseUrl?: string);
+    constructor(request: RequestFn$2, baseUrl?: string);
     from(bucket: string): BucketClient;
     listBuckets(): Promise<{
         data: any[];
@@ -130,9 +139,11 @@ declare class BucketClient {
     private request;
     private bucket;
     private baseUrl;
-    constructor(request: RequestFn$1, bucket: string, baseUrl?: string);
+    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;
@@ -141,11 +152,12 @@ declare class BucketClient {
         data: Blob | null;
         error: any;
     }>;
-    list(): Promise<{
+    list(prefix?: string): Promise<{
         data: any[];
         error: any;
     }>;
-    remove(path: string): Promise<{
+    remove(pathOrPaths: string | string[]): Promise<{
+        data: any;
         error: any;
     }>;
     getPublicUrl(path: string, options?: {
@@ -189,7 +201,7 @@ declare class BucketClient {
     }>;
 }
 
-type RequestFn = (path: string, options?: RequestInit) => Promise<Response>;
+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;
@@ -206,6 +218,8 @@ interface AuthUser {
     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;
 }
@@ -218,8 +232,13 @@ declare class AuthClient {
      * header when the user signs in/out or a token is refreshed.
      */
     onSessionChange: ((session: AuthSession | null) => void) | null;
-    constructor(request: RequestFn);
-    private setSession;
+    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.
+     */
+    setSession(session: AuthSession | null): void;
     signUp(params: {
         email: string;
         password: string;
@@ -243,6 +262,14 @@ declare class AuthClient {
         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;
@@ -372,6 +399,21 @@ declare class AuthClient {
     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;
@@ -385,8 +427,15 @@ interface LinabaseClient {
     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, BucketClient, type CsvQueryResult, DatabaseClient, type LinabaseClient, type LinabaseConfig, type OAuthProvider, type QueryResult, RpcClient, type SingleQueryResult, StorageClient, createClient };
+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 };