@linabase/js 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,392 @@
+type RequestFn$2 = (path: string, options?: RequestInit) => Promise<Response>;
+interface QueryResult<T = any> {
+    data: T[] | null;
+    error: {
+        message: string;
+    } | null;
+    count: number | null;
+}
+interface SingleQueryResult<T = any> {
+    data: T | null;
+    error: {
+        message: string;
+    } | null;
+    count: number | null;
+}
+interface CsvQueryResult {
+    data: string | null;
+    error: {
+        message: string;
+    } | 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$2, table: string);
+    /** Select columns. Supports nested joins: "*, comments(*)" and aliases: "full_name:name" */
+    select(columns?: string): 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;
+    }): 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 (~) */
+    match(column: string, 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"): 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>;
+    then(resolve: (value: QueryResult | SingleQueryResult | CsvQueryResult) => void, reject?: (reason: any) => void): Promise<void>;
+}
+declare class RpcClient {
+    private request;
+    constructor(request: RequestFn$2);
+    /** 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$1 = (path: string, options?: RequestInit) => Promise<Response>;
+declare class StorageClient {
+    private request;
+    private baseUrl;
+    constructor(request: RequestFn$1, 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$1, bucket: string, baseUrl?: string);
+    upload(path: string, file: Blob | File | ArrayBuffer, options?: {
+        contentType?: string;
+    }): Promise<{
+        data: any;
+        error: any;
+    }>;
+    download(path: string): Promise<{
+        data: Blob | null;
+        error: any;
+    }>;
+    list(): Promise<{
+        data: any[];
+        error: any;
+    }>;
+    remove(path: string): Promise<{
+        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 = (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>;
+    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);
+    private setSession;
+    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;
+    }>;
+    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;
+}
+
+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;
+    generateTypes: () => Promise<string>;
+}
+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 };

package/dist/index.js

@@ -0,0 +1,967 @@
+// src/database.ts
+var DatabaseClient = class {
+  request;
+  table;
+  params;
+  method = "GET";
+  body = null;
+  preferHeaders = [];
+  _single = false;
+  _maybeSingle = false;
+  _throwOnError = false;
+  _csv = false;
+  _abortSignal;
+  _schema;
+  constructor(request, table) {
+    this.request = request;
+    this.table = table;
+    this.params = new URLSearchParams();
+  }
+  // ─── Query Methods ──────────────────────────────────────
+  /** Select columns. Supports nested joins: "*, comments(*)" and aliases: "full_name:name" */
+  select(columns) {
+    this.method = "GET";
+    if (columns) this.params.set("select", columns);
+    return this;
+  }
+  insert(data) {
+    this.method = "POST";
+    this.body = data;
+    this.preferHeaders.push("return=representation");
+    return this;
+  }
+  /** Upsert: insert or update on conflict. Uses merge-duplicates by default. */
+  upsert(data, options) {
+    this.method = "POST";
+    this.body = data;
+    this.preferHeaders.push("return=representation");
+    this.preferHeaders.push(
+      options?.ignoreDuplicates ? "resolution=ignore-duplicates" : "resolution=merge-duplicates"
+    );
+    return this;
+  }
+  update(data) {
+    this.method = "PATCH";
+    this.body = data;
+    this.preferHeaders.push("return=representation");
+    return this;
+  }
+  delete() {
+    this.method = "DELETE";
+    return this;
+  }
+  // ─── Comparison Filters ─────────────────────────────────
+  eq(column, value) {
+    this.params.set(column, `eq.${value}`);
+    return this;
+  }
+  neq(column, value) {
+    this.params.set(column, `neq.${value}`);
+    return this;
+  }
+  gt(column, value) {
+    this.params.set(column, `gt.${value}`);
+    return this;
+  }
+  gte(column, value) {
+    this.params.set(column, `gte.${value}`);
+    return this;
+  }
+  lt(column, value) {
+    this.params.set(column, `lt.${value}`);
+    return this;
+  }
+  lte(column, value) {
+    this.params.set(column, `lte.${value}`);
+    return this;
+  }
+  // ─── Pattern Matching ───────────────────────────────────
+  like(column, pattern) {
+    this.params.set(column, `like.${pattern}`);
+    return this;
+  }
+  ilike(column, pattern) {
+    this.params.set(column, `ilike.${pattern}`);
+    return this;
+  }
+  /** Regex match (~) */
+  match(column, pattern) {
+    this.params.set(column, `match.${pattern}`);
+    return this;
+  }
+  /** Case-insensitive regex match (~*) */
+  imatch(column, pattern) {
+    this.params.set(column, `imatch.${pattern}`);
+    return this;
+  }
+  // ─── Array/Set Filters ──────────────────────────────────
+  in(column, values) {
+    this.params.set(column, `in.(${values.join(",")})`);
+    return this;
+  }
+  /** Contains (@>) - array or JSONB containment */
+  contains(column, value) {
+    this.params.set(column, `cs.${JSON.stringify(value)}`);
+    return this;
+  }
+  /** Contained by (<@) */
+  containedBy(column, value) {
+    this.params.set(column, `cd.${JSON.stringify(value)}`);
+    return this;
+  }
+  /** Overlap (&&) - ranges or arrays */
+  overlaps(column, value) {
+    this.params.set(column, `ov.${JSON.stringify(value)}`);
+    return this;
+  }
+  // ─── Null/Boolean ───────────────────────────────────────
+  is(column, value) {
+    this.params.set(column, `is.${value}`);
+    return this;
+  }
+  /** IS DISTINCT FROM */
+  isDistinct(column, value) {
+    this.params.set(column, `isdistinct.${value}`);
+    return this;
+  }
+  // ─── Negation ───────────────────────────────────────────
+  /** Negate a filter: not.eq, not.in, not.is, etc. */
+  not(column, operator, value) {
+    this.params.set(column, `not.${operator}.${value}`);
+    return this;
+  }
+  // ─── Logical ────────────────────────────────────────────
+  /** OR filter: or("age.gt.20,name.eq.John") */
+  or(filters) {
+    this.params.set("or", `(${filters})`);
+    return this;
+  }
+  // ─── Full-Text Search ───────────────────────────────────
+  /** to_tsquery */
+  textSearch(column, query, options) {
+    const op = options?.type === "plain" ? "plfts" : options?.type === "phrase" ? "phfts" : options?.type === "websearch" ? "wfts" : "fts";
+    this.params.set(column, `${op}.${query}`);
+    return this;
+  }
+  // ─── Ordering & Pagination ──────────────────────────────
+  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}`);
+    return this;
+  }
+  limit(count) {
+    this.params.set("limit", String(count));
+    return this;
+  }
+  offset(count) {
+    this.params.set("offset", String(count));
+    return this;
+  }
+  // ─── Count Options ──────────────────────────────────────
+  /** Request exact, estimated, or planned count via Prefer header */
+  count(type = "exact") {
+    this.preferHeaders.push(`count=${type}`);
+    return this;
+  }
+  // ─── Convenience Methods ───────────────────────────────
+  /** Return a single object instead of an array. Errors if 0 or >1 rows. */
+  single() {
+    this._single = true;
+    this._maybeSingle = false;
+    return this;
+  }
+  /** Return a single object or null. Errors only if >1 rows. */
+  maybeSingle() {
+    this._maybeSingle = true;
+    this._single = false;
+    return this;
+  }
+  /** Range-based pagination: range(0, 9) fetches the first 10 rows. */
+  range(from, to) {
+    this.params.set("limit", String(to - from + 1));
+    this.params.set("offset", String(from));
+    return this;
+  }
+  /** Throw an error instead of returning it in the result object. */
+  throwOnError() {
+    this._throwOnError = true;
+    return this;
+  }
+  /** Request CSV format. Returns raw CSV text in data instead of parsed objects. */
+  csv() {
+    this._csv = true;
+    return this;
+  }
+  /** Pass an AbortSignal for request cancellation. */
+  abortSignal(signal) {
+    this._abortSignal = signal;
+    return this;
+  }
+  /** Switch schema. Sets Accept-Profile (GET) or Content-Profile (POST/PATCH/DELETE). */
+  schema(schemaName) {
+    this._schema = schemaName;
+    return this;
+  }
+  // ─── Internal ──────────────────────────────────────────
+  reset() {
+    this.params = new URLSearchParams();
+    this.method = "GET";
+    this.body = null;
+    this.preferHeaders = [];
+    this._single = false;
+    this._maybeSingle = false;
+    this._throwOnError = false;
+    this._csv = false;
+    this._abortSignal = void 0;
+    this._schema = void 0;
+  }
+  // ─── Execution ──────────────────────────────────────────
+  async execute() {
+    const qs = this.params.toString();
+    const path = `/rest/v1/${this.table}${qs ? `?${qs}` : ""}`;
+    const isSingle = this._single;
+    const isMaybeSingle = this._maybeSingle;
+    const shouldThrow = this._throwOnError;
+    const isCsv = this._csv;
+    const abortSignal = this._abortSignal;
+    const schema = this._schema;
+    const headers = {};
+    if (this.preferHeaders.length) {
+      headers["Prefer"] = this.preferHeaders.join(", ");
+    }
+    if (isCsv) {
+      headers["Accept"] = "text/csv";
+    }
+    if (schema) {
+      if (this.method === "GET") {
+        headers["Accept-Profile"] = schema;
+      } else {
+        headers["Content-Profile"] = schema;
+      }
+    }
+    const makeError = (message) => {
+      const result = { data: null, error: { message }, count: null };
+      if (shouldThrow) throw new Error(message);
+      return result;
+    };
+    try {
+      const res = await this.request(path, {
+        method: this.method,
+        headers,
+        body: this.body ? JSON.stringify(this.body) : void 0,
+        signal: abortSignal
+      });
+      const countHeader = res.headers.get("X-Total-Count");
+      const totalCount = countHeader ? parseInt(countHeader) : null;
+      if (isCsv) {
+        if (!res.ok) {
+          const text = await res.text();
+          return makeError(text || res.statusText);
+        }
+        const csvText = await res.text();
+        return { data: csvText, error: null, count: totalCount };
+      }
+      const data = await res.json();
+      if (!res.ok) {
+        return makeError(data.error || res.statusText);
+      }
+      const rows = Array.isArray(data) ? data : [data];
+      if (isSingle) {
+        if (rows.length === 0) {
+          return makeError("No rows found");
+        }
+        if (rows.length > 1) {
+          return makeError("Multiple rows returned for single()");
+        }
+        const result = {
+          data: rows[0],
+          error: null,
+          count: totalCount
+        };
+        return result;
+      }
+      if (isMaybeSingle) {
+        if (rows.length > 1) {
+          return makeError("Multiple rows returned");
+        }
+        const result = {
+          data: rows.length === 1 ? rows[0] : null,
+          error: null,
+          count: totalCount ?? (rows.length === 0 ? 0 : 1)
+        };
+        return result;
+      }
+      return {
+        data: rows,
+        error: null,
+        count: totalCount
+      };
+    } catch (err) {
+      if (shouldThrow) throw err;
+      return {
+        data: null,
+        error: { message: err.message },
+        count: null
+      };
+    } finally {
+      this.reset();
+    }
+  }
+  then(resolve, reject) {
+    return this.execute().then(resolve, reject);
+  }
+};
+var RpcClient = class {
+  request;
+  constructor(request) {
+    this.request = request;
+  }
+  /** Call a Postgres function: rpc("my_function", { arg1: "value" }, { count: "exact" }) */
+  async call(fn, args, options) {
+    const headers = {};
+    const preferParts = [];
+    if (options?.count) {
+      preferParts.push(`count=${options.count}`);
+    }
+    if (preferParts.length) {
+      headers["Prefer"] = preferParts.join(", ");
+    }
+    try {
+      const res = await this.request(`/rest/v1/rpc/${fn}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(args || {})
+      });
+      const countHeader = res.headers.get("X-Total-Count");
+      const totalCount = countHeader ? parseInt(countHeader) : null;
+      const data = await res.json();
+      if (!res.ok) {
+        const message = data.error || res.statusText;
+        if (options?.throwOnError) throw new Error(message);
+        return { data: null, error: { message }, count: null };
+      }
+      return {
+        data: Array.isArray(data) ? data : [data],
+        error: null,
+        count: totalCount
+      };
+    } catch (err) {
+      if (options?.throwOnError) throw err;
+      return { data: null, error: { message: err.message }, count: null };
+    }
+  }
+};
+
+// src/storage.ts
+var StorageClient = class {
+  request;
+  baseUrl;
+  constructor(request, baseUrl) {
+    this.request = request;
+    this.baseUrl = baseUrl || "";
+  }
+  from(bucket) {
+    return new BucketClient(this.request, bucket, this.baseUrl);
+  }
+  async listBuckets() {
+    try {
+      const res = await this.request("/api/storage/buckets");
+      const data = await res.json();
+      return { data: data.buckets || [], error: null };
+    } catch (err) {
+      return { data: [], error: { message: err.message } };
+    }
+  }
+  async createBucket(name, options) {
+    try {
+      const res = await this.request("/api/storage/buckets", {
+        method: "POST",
+        body: JSON.stringify({ name, isPublic: options?.public })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data: data.bucket, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+};
+var BucketClient = class {
+  request;
+  bucket;
+  baseUrl;
+  constructor(request, bucket, baseUrl) {
+    this.request = request;
+    this.bucket = bucket;
+    this.baseUrl = baseUrl || "";
+  }
+  async upload(path, file, options) {
+    try {
+      const formData = new FormData();
+      const blob = file instanceof Blob ? file : new Blob([file], { type: options?.contentType });
+      formData.append("file", blob, path);
+      const res = await this.request(
+        `/storage/${this.bucket}/${path}`,
+        {
+          method: "POST",
+          body: formData,
+          headers: {}
+          // Let browser set Content-Type for FormData
+        }
+      );
+      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 } };
+    }
+  }
+  async download(path) {
+    try {
+      const res = await this.request(
+        `/storage/${this.bucket}/${path}`
+      );
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        return { data: null, error: err };
+      }
+      const blob = await res.blob();
+      return { data: blob, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async list() {
+    try {
+      const res = await this.request(
+        `/api/storage/objects?bucketName=${this.bucket}`
+      );
+      const data = await res.json();
+      return { data: data.objects || [], error: null };
+    } catch (err) {
+      return { data: [], error: { message: err.message } };
+    }
+  }
+  async remove(path) {
+    try {
+      const res = await this.request(
+        `/storage/${this.bucket}/${path}`,
+        { method: "DELETE" }
+      );
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        return { error: data };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+  getPublicUrl(path, options) {
+    let url;
+    if (options?.transform) {
+      const params = new URLSearchParams();
+      if (options.transform.width)
+        params.set("width", String(options.transform.width));
+      if (options.transform.height)
+        params.set("height", String(options.transform.height));
+      if (options.transform.quality)
+        params.set("quality", String(options.transform.quality));
+      if (options.transform.format)
+        params.set("format", options.transform.format);
+      url = `${this.baseUrl}/storage/transform/${this.bucket}/${path}?${params}`;
+    } else {
+      url = `${this.baseUrl}/public/${this.bucket}/${path}`;
+    }
+    return { data: { publicUrl: url } };
+  }
+  async createSignedUrl(path, expiresIn) {
+    try {
+      const res = await this.request(
+        `/storage/presign/download/${this.bucket}/${path}?expiresIn=${expiresIn}`
+      );
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return { data: { signedUrl: data.url || data.signedUrl }, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async createSignedUrls(paths, expiresIn) {
+    const results = await Promise.all(
+      paths.map(async (p) => {
+        const { data, error } = await this.createSignedUrl(p, expiresIn);
+        return { path: p, signedUrl: data?.signedUrl || "", error };
+      })
+    );
+    const hasError = results.find((r) => r.error);
+    if (hasError) return { data: null, error: hasError.error };
+    return {
+      data: results.map((r) => ({ path: r.path, signedUrl: r.signedUrl })),
+      error: null
+    };
+  }
+  async createSignedUploadUrl(path) {
+    try {
+      const res = await this.request(`/storage/presign/upload`, {
+        method: "POST",
+        body: JSON.stringify({ bucket: this.bucket, path })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      return {
+        data: {
+          signedUrl: data.url || data.signedUrl,
+          token: data.token || "",
+          path
+        },
+        error: null
+      };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  async move(fromPath, toPath) {
+    try {
+      const res = await this.request(`/storage/${this.bucket}/move`, {
+        method: "POST",
+        body: JSON.stringify({ from: fromPath, to: toPath })
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        return { error: data };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+  async copy(fromPath, toPath) {
+    try {
+      const res = await this.request(`/storage/${this.bucket}/copy`, {
+        method: "POST",
+        body: JSON.stringify({ from: fromPath, to: toPath })
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        return { error: data };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+};
+
+// src/auth.ts
+var AuthClient = class {
+  request;
+  listeners = [];
+  currentSession = null;
+  /**
+   * Callback that the parent LinabaseClient can set to update the Authorization
+   * header when the user signs in/out or a token is refreshed.
+   */
+  onSessionChange = null;
+  constructor(request) {
+    this.request = request;
+  }
+  setSession(session) {
+    this.currentSession = session;
+    if (this.onSessionChange) this.onSessionChange(session);
+  }
+  // ─── Email/Password ────────────────────────────────────────
+  async signUp(params) {
+    try {
+      const res = await this.request("/auth/v1/signup", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      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 } };
+    }
+  }
+  async signIn(params) {
+    try {
+      const res = await this.request("/auth/v1/token?grant_type=password", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      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 } };
+    }
+  }
+  /** Supabase-compatible alias for signIn */
+  async signInWithPassword(params) {
+    return this.signIn(params);
+  }
+  // ─── OAuth ─────────────────────────────────────────────────
+  signInWithOAuth(params) {
+    const queryParams = new URLSearchParams({ provider: params.provider });
+    if (params.redirectTo) queryParams.set("redirect_to", params.redirectTo);
+    const url = `/auth/v1/authorize?${queryParams}`;
+    if (typeof window !== "undefined") {
+      window.location.href = url;
+    }
+    return { url };
+  }
+  // ─── Session Management ────────────────────────────────────
+  async signOut() {
+    try {
+      await this.request("/auth/v1/logout", { method: "POST" });
+      this.setSession(null);
+      this.emit("SIGNED_OUT", null);
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+  async getSession() {
+    if (this.currentSession) {
+      const now = Math.floor(Date.now() / 1e3);
+      if (this.currentSession.expires_at <= now) {
+        const refreshed = await this.refreshSession();
+        if (refreshed.error) return { data: { session: null }, error: refreshed.error };
+        return { data: { session: this.currentSession }, error: null };
+      }
+      return { data: { session: this.currentSession }, error: null };
+    }
+    return { data: { session: null }, error: null };
+  }
+  async getUser() {
+    try {
+      const res = await this.request("/auth/v1/user");
+      const data = await res.json();
+      if (!res.ok) return { data: { user: null }, error: data };
+      return { data: { user: data }, error: null };
+    } catch (err) {
+      return { data: { user: null }, error: { message: err.message } };
+    }
+  }
+  async refreshSession() {
+    if (!this.currentSession?.refresh_token) {
+      return { data: null, error: { message: "No refresh token available" } };
+    }
+    try {
+      const res = await this.request("/auth/v1/token?grant_type=refresh_token", {
+        method: "POST",
+        body: JSON.stringify({ refresh_token: this.currentSession.refresh_token })
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        this.setSession(null);
+        this.emit("SIGNED_OUT", null);
+        return { data: null, error: data };
+      }
+      const session = this.parseAuthResponse(data);
+      this.setSession(session);
+      this.emit("TOKEN_REFRESHED", session);
+      return { data: session, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  // ─── Password Reset ────────────────────────────────────────
+  async resetPasswordForEmail(email, _options) {
+    try {
+      const res = await this.request("/auth/v1/recover", {
+        method: "POST",
+        body: JSON.stringify({ email })
+      });
+      if (!res.ok) {
+        const data = await res.json();
+        return { error: data };
+      }
+      return { error: null };
+    } catch (err) {
+      return { error: { message: err.message } };
+    }
+  }
+  async updatePassword(newPassword) {
+    return this.updateUser({ password: newPassword }).then((r) => ({ error: r.error }));
+  }
+  // ─── User Update ───────────────────────────────────────────
+  async updateUser(attributes) {
+    try {
+      const res = await this.request("/auth/v1/user", {
+        method: "PUT",
+        body: JSON.stringify({
+          email: attributes.email,
+          password: attributes.password,
+          user_metadata: attributes.data
+        })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: { user: null }, error: data };
+      return { data: { user: data }, error: null };
+    } catch (err) {
+      return { data: { user: null }, error: { message: err.message } };
+    }
+  }
+  // ─── Magic Link / OTP ──────────────────────────────────────
+  async signInWithOtp(params) {
+    try {
+      const res = await this.request("/auth/v1/magiclink", {
+        method: "POST",
+        body: JSON.stringify({
+          email: params.email,
+          redirect_to: params.options?.emailRedirectTo
+        })
+      });
+      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 } };
+    }
+  }
+  async verifyOtp(params) {
+    try {
+      const res = await this.request("/auth/v1/verify", {
+        method: "POST",
+        body: JSON.stringify({
+          type: params.type || "email",
+          token: params.token
+        })
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: data };
+      this.emit("SIGNED_IN", data);
+      return { data, error: null };
+    } catch (err) {
+      return { data: null, error: { message: err.message } };
+    }
+  }
+  // ─── Admin ─────────────────────────────────────────────────
+  get admin() {
+    const request = this.request;
+    return {
+      async listUsers(params) {
+        try {
+          const qs = new URLSearchParams();
+          if (params?.page) qs.set("page", String(params.page));
+          if (params?.per_page) qs.set("per_page", String(params.per_page));
+          const res = await request(`/auth/v1/admin/users?${qs}`);
+          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 } };
+        }
+      },
+      async createUser(params) {
+        try {
+          const res = await request("/auth/v1/admin/users", {
+            method: "POST",
+            body: JSON.stringify(params)
+          });
+          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 } };
+        }
+      },
+      async getUserById(id) {
+        try {
+          const res = await request(`/auth/v1/admin/users/${id}`);
+          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 } };
+        }
+      },
+      async updateUserById(id, attributes) {
+        try {
+          const res = await request(`/auth/v1/admin/users/${id}`, {
+            method: "PUT",
+            body: JSON.stringify(attributes)
+          });
+          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 } };
+        }
+      },
+      async deleteUser(id) {
+        try {
+          const res = await request(`/auth/v1/admin/users/${id}`, {
+            method: "DELETE"
+          });
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({}));
+            return { error: data };
+          }
+          return { error: null };
+        } catch (err) {
+          return { error: { message: err.message } };
+        }
+      }
+    };
+  }
+  // ─── MFA / TOTP ────────────────────────────────────────────
+  get mfa() {
+    const request = this.request;
+    return {
+      async enroll(params) {
+        try {
+          const res = await request("/auth/v1/factors", {
+            method: "POST",
+            body: JSON.stringify({ factor_type: params.factorType, friendly_name: params.friendlyName })
+          });
+          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 } };
+        }
+      },
+      async challenge(params) {
+        try {
+          const res = await request(`/auth/v1/factors/${params.factorId}/challenge`, {
+            method: "POST"
+          });
+          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 } };
+        }
+      },
+      async verify(params) {
+        try {
+          const res = await request(`/auth/v1/factors/${params.factorId}/verify`, {
+            method: "POST",
+            body: JSON.stringify({ challenge_id: params.challengeId, code: params.code })
+          });
+          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 } };
+        }
+      },
+      async unenroll(params) {
+        try {
+          const res = await request(`/auth/v1/factors/${params.factorId}`, {
+            method: "DELETE"
+          });
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({}));
+            return { error: data };
+          }
+          return { error: null };
+        } catch (err) {
+          return { error: { message: err.message } };
+        }
+      },
+      async listFactors() {
+        try {
+          const res = await request("/auth/v1/factors");
+          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 } };
+        }
+      }
+    };
+  }
+  // ─── Auth State Listener ───────────────────────────────────
+  onAuthStateChange(callback) {
+    this.listeners.push(callback);
+    return {
+      unsubscribe: () => {
+        this.listeners = this.listeners.filter((l) => l !== callback);
+      }
+    };
+  }
+  emit(event, session) {
+    for (const listener of this.listeners) {
+      listener(event, session);
+    }
+  }
+  parseAuthResponse(data) {
+    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 || {}
+    };
+  }
+};
+
+// src/client.ts
+function createClient(config) {
+  const baseUrl = config.url.replace(/\/$/, "");
+  const apiKey = config.serviceRoleKey || config.anonKey || "";
+  let accessToken = null;
+  async function request(path, options = {}) {
+    const url = `${baseUrl}${path}`;
+    const mergedHeaders = {
+      "Content-Type": "application/json",
+      // Always send the API key for project identification
+      apikey: apiKey,
+      // Use access token if signed in; otherwise use the API key
+      Authorization: `Bearer ${accessToken || apiKey}`,
+      ...options.headers
+    };
+    if (!options.body) {
+      delete mergedHeaders["Content-Type"];
+    }
+    return fetch(url, {
+      ...options,
+      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;
+      }
+    }),
+    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();
+    }
+  };
+}
+export {
+  AuthClient,
+  BucketClient,
+  DatabaseClient,
+  RpcClient,
+  StorageClient,
+  createClient
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@linabase/js",
+  "version": "0.1.0",
+  "description": "JavaScript/TypeScript client SDK for Linabase (database, storage, auth)",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "linabase",
+    "supabase",
+    "database",
+    "storage",
+    "auth",
+    "baas",
+    "sdk",
+    "postgres",
+    "rls"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/linabase/linabase",
+    "directory": "packages/sdk-js"
+  },
+  "homepage": "https://linabase.com",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/"
+  },
+  "devDependencies": {
+    "@linabase/db": "workspace:*",
+    "@linabase/rest-api": "workspace:*",
+    "@types/pg": "^8.11.0",
+    "pg": "^8.13.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.2.1"
+  }
+}