@linabase/js 0.1.1 → 0.2.0

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 };

package/dist/index.js

@@ -19,9 +19,11 @@ var DatabaseClient = class {
   }
   // ─── Query Methods ──────────────────────────────────────
   /** Select columns. Supports nested joins: "*, comments(*)" and aliases: "full_name:name" */
-  select(columns) {
+  select(columns, options) {
     this.method = "GET";
     if (columns) this.params.set("select", columns);
+    if (options?.count) this.preferHeaders.push(`count=${options.count}`);
+    if (options?.head) this.method = "GET";
     return this;
   }
   insert(data) {
@@ -38,6 +40,9 @@ var DatabaseClient = class {
     this.preferHeaders.push(
       options?.ignoreDuplicates ? "resolution=ignore-duplicates" : "resolution=merge-duplicates"
     );
+    if (options?.onConflict) {
+      this.params.set("on_conflict", options.onConflict);
+    }
     return this;
   }
   update(data) {
@@ -84,9 +89,15 @@ var DatabaseClient = class {
     this.params.set(column, `ilike.${pattern}`);
     return this;
   }
-  /** Regex match (~) */
-  match(column, pattern) {
-    this.params.set(column, `match.${pattern}`);
+  /** Regex match (~) when called with (column, pattern). Object-based multi-column filter when called with ({ col: val }). */
+  match(columnOrFilter, pattern) {
+    if (typeof columnOrFilter === "object") {
+      for (const [key, value] of Object.entries(columnOrFilter)) {
+        this.eq(key, value);
+      }
+    } else if (pattern !== void 0) {
+      this.params.set(columnOrFilter, `match.${pattern}`);
+    }
     return this;
   }
   /** Case-insensitive regex match (~*) */
@@ -116,7 +127,8 @@ var DatabaseClient = class {
   }
   // ─── Null/Boolean ───────────────────────────────────────
   is(column, value) {
-    this.params.set(column, `is.${value}`);
+    const v = value === null ? "null" : String(value);
+    this.params.set(column, `is.${v}`);
     return this;
   }
   /** IS DISTINCT FROM */
@@ -308,8 +320,13 @@ var DatabaseClient = class {
       this.reset();
     }
   }
-  then(resolve, reject) {
-    return this.execute().then(resolve, reject);
+  /**
+   * 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(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
   }
 };
 var RpcClient = class {
@@ -423,7 +440,7 @@ var BucketClient = class {
         `/storage/${this.bucket}/${path}`
       );
       if (!res.ok) {
-        const err = await res.json().catch(() => ({}));
+        const err = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
         return { data: null, error: err };
       }
       const blob = await res.blob();
@@ -432,30 +449,37 @@ var BucketClient = class {
       return { data: null, error: { message: err.message } };
     }
   }
-  async list() {
+  async list(prefix) {
     try {
-      const res = await this.request(
-        `/api/storage/objects?bucketName=${this.bucket}`
-      );
+      let url = `/api/storage/objects?bucketName=${this.bucket}`;
+      if (prefix) url += `&prefix=${encodeURIComponent(prefix)}`;
+      const res = await this.request(url);
       const data = await res.json();
       return { data: data.objects || [], error: null };
     } catch (err) {
       return { data: [], error: { message: err.message } };
     }
   }
-  async remove(path) {
+  async remove(pathOrPaths) {
+    const paths = Array.isArray(pathOrPaths) ? pathOrPaths : [pathOrPaths];
     try {
-      const res = await this.request(
-        `/storage/${this.bucket}/${path}`,
-        { method: "DELETE" }
+      const results = await Promise.all(
+        paths.map(async (p) => {
+          const res = await this.request(
+            `/storage/${this.bucket}/${p}`,
+            { method: "DELETE" }
+          );
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
+            return { error: data };
+          }
+          return { error: null };
+        })
       );
-      if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        return { error: data };
-      }
-      return { error: null };
+      const firstError = results.find((r) => r.error);
+      return { data: firstError ? null : paths, error: firstError?.error ?? null };
     } catch (err) {
-      return { error: { message: err.message } };
+      return { data: null, error: { message: err.message } };
     }
   }
   getPublicUrl(path, options) {
@@ -529,7 +553,7 @@ var BucketClient = class {
         body: JSON.stringify({ from: fromPath, to: toPath })
       });
       if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
+        const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
         return { error: data };
       }
       return { error: null };
@@ -544,7 +568,7 @@ var BucketClient = class {
         body: JSON.stringify({ from: fromPath, to: toPath })
       });
       if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
+        const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
         return { error: data };
       }
       return { error: null };
@@ -567,9 +591,15 @@ var AuthClient = class {
   constructor(request) {
     this.request = request;
   }
+  /**
+   * 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) {
     this.currentSession = session;
     if (this.onSessionChange) this.onSessionChange(session);
+    this.emit("INITIAL_SESSION", session);
   }
   // ─── Email/Password ────────────────────────────────────────
   async signUp(params) {
@@ -608,6 +638,27 @@ var AuthClient = class {
   async signInWithPassword(params) {
     return this.signIn(params);
   }
+  // ─── ID Token (Mobile OAuth) ────────────────────────────────
+  async signInWithIdToken(params) {
+    try {
+      const res = await this.request("/auth/v1/token?grant_type=id_token", {
+        method: "POST",
+        body: JSON.stringify({
+          provider: params.provider,
+          id_token: params.token,
+          nonce: params.nonce
+        })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      const session = this.parseAuthResponse(data);
+      this.setSession(session);
+      this.emit("SIGNED_IN", session);
+      return { data: session, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
   // ─── OAuth ─────────────────────────────────────────────────
   signInWithOAuth(params) {
     const queryParams = new URLSearchParams({ provider: params.provider });
@@ -804,7 +855,7 @@ var AuthClient = class {
             method: "DELETE"
           });
           if (!res.ok) {
-            const data = await res.json().catch(() => ({}));
+            const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
             return { error: data };
           }
           return { error: null };
@@ -862,7 +913,7 @@ var AuthClient = class {
             method: "DELETE"
           });
           if (!res.ok) {
-            const data = await res.json().catch(() => ({}));
+            const data = await res.json().catch(() => ({ message: `Request failed (${res.status})` }));
             return { error: data };
           }
           return { error: null };
@@ -897,17 +948,53 @@ var AuthClient = class {
     }
   }
   parseAuthResponse(data) {
+    const user = data.user || {};
     return {
       access_token: data.session?.access_token || data.access_token,
       refresh_token: data.session?.refresh_token || data.refresh_token,
       token_type: data.session?.token_type || data.token_type || "bearer",
       expires_in: data.session?.expires_in || data.expires_in || 3600,
       expires_at: data.session?.expires_at || data.expires_at || Math.floor(Date.now() / 1e3) + 3600,
-      user: data.user || {}
+      user: {
+        ...user,
+        // Supabase-compatible alias
+        user_metadata: user.raw_user_meta_data || user.user_metadata || {}
+      }
     };
   }
 };
 
+// src/functions.ts
+var FunctionsClient = class {
+  request;
+  constructor(request) {
+    this.request = request;
+  }
+  async invoke(name, options) {
+    try {
+      const method = options?.method || "POST";
+      const init = { method, headers: options?.headers };
+      if (options?.body && method !== "GET") {
+        init.body = JSON.stringify(options.body);
+      }
+      let path = `/functions/v1/${name}`;
+      if (options?.body && method === "GET") {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(options.body)) {
+          if (v !== void 0 && v !== null) params.set(k, String(v));
+        }
+        path += `?${params}`;
+      }
+      const res = await this.request(path, init);
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+};
+
 // src/client.ts
 function createClient(config) {
   const baseUrl = config.url.replace(/\/$/, "");
@@ -931,36 +1018,67 @@ function createClient(config) {
       headers: mergedHeaders
     });
   }
-  const rpcClient = new RpcClient(request);
   const authClient = new AuthClient(request);
   authClient.onSessionChange = (session) => {
     accessToken = session?.access_token || null;
   };
-  return {
-    from: (table) => new DatabaseClient(request, table),
-    schema: (schemaName) => ({
-      from: (table) => {
-        const client = new DatabaseClient(request, table);
-        client._schema = schemaName;
-        return client;
+  function buildClient(reqFn, branchSlug) {
+    const rc = new RpcClient(reqFn);
+    const ac = new AuthClient(reqFn);
+    ac.onSessionChange = (session) => {
+      accessToken = session?.access_token || null;
+    };
+    return {
+      from: (table) => new DatabaseClient(reqFn, table),
+      schema: (schemaName) => ({
+        from: (table) => {
+          const client = new DatabaseClient(reqFn, table);
+          client._schema = schemaName;
+          return client;
+        }
+      }),
+      rpc: (fn, args) => rc.call(fn, args),
+      storage: new StorageClient(reqFn, baseUrl),
+      auth: branchSlug ? authClient : ac,
+      functions: new FunctionsClient(reqFn),
+      /** Realtime channel (stub; not yet supported). Returns a chainable no-op. */
+      channel: (_name) => {
+        const noop = { on: () => noop, subscribe: () => noop, unsubscribe: () => {
+        } };
+        return noop;
+      },
+      /** Remove a realtime channel (stub; not yet supported). */
+      removeChannel: (_channel) => {
+      },
+      generateTypes: async () => {
+        const restUrl = baseUrl.replace(/:3100/, ":3107");
+        const headers = { Authorization: `Bearer ${apiKey}` };
+        if (branchSlug) headers["X-Branch"] = branchSlug;
+        const res = await fetch(`${restUrl}/rest/v1/types`, { headers });
+        return res.text();
+      },
+      branch: (slug) => {
+        if (branchSlug) throw new Error("Cannot nest branch() calls");
+        function branchRequest(path, options = {}) {
+          return reqFn(path, {
+            ...options,
+            headers: {
+              ...options.headers,
+              "X-Branch": slug
+            }
+          });
+        }
+        return buildClient(branchRequest, slug);
       }
-    }),
-    rpc: (fn, args) => rpcClient.call(fn, args),
-    storage: new StorageClient(request, baseUrl),
-    auth: authClient,
-    generateTypes: async () => {
-      const restUrl = baseUrl.replace(/:3100/, ":3107");
-      const res = await fetch(`${restUrl}/rest/v1/types`, {
-        headers: { Authorization: `Bearer ${apiKey}` }
-      });
-      return res.text();
-    }
-  };
+    };
+  }
+  return buildClient(request);
 }
 export {
   AuthClient,
   BucketClient,
   DatabaseClient,
+  FunctionsClient,
   RpcClient,
   StorageClient,
   createClient

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linabase/js",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "JavaScript/TypeScript client SDK for Linabase (database, storage, auth)",
   "license": "MIT",
   "type": "module",
@@ -47,6 +47,7 @@
     "@linabase/db": "workspace:*",
     "@linabase/rest-api": "workspace:*",
     "@types/pg": "^8.11.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "pg": "^8.13.0",
     "tsup": "^8.3.0",
     "typescript": "^5.7.0",