@svarabase/js 1.0.0

package/src/db/filterBuilder.ts

@@ -0,0 +1,302 @@
+export type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd' | 'not';
+
+export interface QueryState {
+  table: string;
+  selectCols: string;
+  filters: Array<{ key: string; value: string }>;
+  orderByStr: string | null;
+  limitVal: number | null;
+  offsetVal: number | null;
+  countMode: 'exact' | null;
+  isHead: boolean;
+  isSingle: boolean;
+  isMaybeSingle: boolean;
+  method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+  body?: unknown;
+  isUpsert: boolean;
+  onConflict?: string;
+}
+
+export type PostgrestSingleResponse<T> = {
+  data: T | null;
+  error: { message: string; code: string; details: string; hint: string } | null;
+  count: number | null;
+  status: number;
+  statusText: string;
+};
+
+export type PostgrestResponse<T> = {
+  data: T[] | null;
+  error: { message: string; code: string; details: string; hint: string } | null;
+  count: number | null;
+  status: number;
+  statusText: string;
+};
+
+export class FilterBuilder<T = unknown> {
+  protected state: QueryState;
+  protected url: string;
+  protected key: string;
+  protected getAuthHeader: () => string;
+
+  constructor(
+    url: string,
+    key: string,
+    getAuthHeader: () => string,
+    table: string,
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE' = 'GET',
+    body?: unknown,
+    isUpsert = false,
+    onConflict?: string
+  ) {
+    this.url = url;
+    this.key = key;
+    this.getAuthHeader = getAuthHeader;
+    this.state = {
+      table,
+      selectCols: '*',
+      filters: [],
+      orderByStr: null,
+      limitVal: null,
+      offsetVal: null,
+      countMode: null,
+      isHead: false,
+      isSingle: false,
+      isMaybeSingle: false,
+      method,
+      body,
+      isUpsert,
+      onConflict,
+    };
+  }
+
+  select(cols: string, options?: { count?: 'exact'; head?: boolean }): this {
+    this.state.selectCols = cols || '*';
+    if (options?.count) this.state.countMode = options.count;
+    if (options?.head) this.state.isHead = true;
+    return this;
+  }
+
+  eq(column: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `eq.${value}` });
+    return this;
+  }
+
+  neq(column: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `neq.${value}` });
+    return this;
+  }
+
+  gt(column: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `gt.${value}` });
+    return this;
+  }
+
+  gte(column: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `gte.${value}` });
+    return this;
+  }
+
+  lt(column: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `lt.${value}` });
+    return this;
+  }
+
+  lte(column: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `lte.${value}` });
+    return this;
+  }
+
+  like(column: string, pattern: string): this {
+    this.state.filters.push({ key: column, value: `like.${pattern}` });
+    return this;
+  }
+
+  ilike(column: string, pattern: string): this {
+    this.state.filters.push({ key: column, value: `ilike.${pattern}` });
+    return this;
+  }
+
+  is(column: string, value: boolean | null): this {
+    this.state.filters.push({ key: column, value: `is.${value}` });
+    return this;
+  }
+
+  in(column: string, values: unknown[]): this {
+    this.state.filters.push({ key: column, value: `in.(${values.join(',')})` });
+    return this;
+  }
+
+  contains(column: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `cs.${JSON.stringify(value)}` });
+    return this;
+  }
+
+  not(column: string, operator: string, value: unknown): this {
+    this.state.filters.push({ key: column, value: `not.${operator}.${value}` });
+    return this;
+  }
+
+  or(filters: string, options?: { foreignTable?: string }): this {
+    const key = options?.foreignTable ? `${options.foreignTable}.or` : 'or';
+    this.state.filters.push({ key, value: `(${filters})` });
+    return this;
+  }
+
+  order(column: string, options?: { ascending?: boolean; nullsFirst?: boolean }): this {
+    const dir = options?.ascending === false ? 'desc' : 'asc';
+    const nulls = options?.nullsFirst ? '.nullsfirst' : '';
+    this.state.orderByStr = (this.state.orderByStr ? this.state.orderByStr + ',' : '') + `${column}.${dir}${nulls}`;
+    return this;
+  }
+
+  limit(count: number): this {
+    this.state.limitVal = count;
+    return this;
+  }
+
+  range(from: number, to: number): this {
+    this.state.offsetVal = from;
+    this.state.limitVal = to - from + 1;
+    return this;
+  }
+
+  single(): PromiseLike<PostgrestSingleResponse<T>> {
+    this.state.isSingle = true;
+    return this as unknown as PromiseLike<PostgrestSingleResponse<T>>;
+  }
+
+  maybeSingle(): PromiseLike<PostgrestSingleResponse<T | null>> {
+    this.state.isMaybeSingle = true;
+    return this as unknown as PromiseLike<PostgrestSingleResponse<T | null>>;
+  }
+
+  then<R>(
+    onfulfilled?: ((value: PostgrestResponse<T> | PostgrestSingleResponse<T>) => R) | null,
+    onrejected?: ((reason: unknown) => R) | null
+  ): Promise<R> {
+    return this._execute().then(onfulfilled as never, onrejected as never);
+  }
+
+  catch<R>(onrejected?: ((reason: unknown) => R) | null): Promise<R | PostgrestResponse<T> | PostgrestSingleResponse<T>> {
+    return this._execute().catch(onrejected as never);
+  }
+
+  protected buildUrl(): string {
+    const params = new URLSearchParams();
+
+    if (this.state.method === 'GET' || this.state.method === 'DELETE') {
+      if (this.state.selectCols && this.state.selectCols !== '*') {
+        params.set('select', this.state.selectCols);
+      } else if (this.state.selectCols) {
+        params.set('select', this.state.selectCols);
+      }
+      for (const { key, value } of this.state.filters) {
+        params.set(key, value);
+      }
+      if (this.state.orderByStr) params.set('order', this.state.orderByStr);
+      if (this.state.limitVal != null) params.set('limit', String(this.state.limitVal));
+      if (this.state.offsetVal != null) params.set('offset', String(this.state.offsetVal));
+    } else {
+      // For POST/PATCH, filters go as query params too
+      for (const { key, value } of this.state.filters) {
+        params.set(key, value);
+      }
+      if (this.state.isUpsert && this.state.onConflict) {
+        params.set('on_conflict', this.state.onConflict);
+      }
+    }
+
+    const qs = params.toString();
+    return `${this.url}/rest/v1/${this.state.table}${qs ? '?' + qs : ''}`;
+  }
+
+  protected buildHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      apikey: this.key,
+      Authorization: this.getAuthHeader(),
+    };
+
+    const prefer: string[] = [];
+    if (this.state.countMode) prefer.push(`count=${this.state.countMode}`);
+    if (this.state.isUpsert) prefer.push('resolution=merge-duplicates');
+    if (prefer.length > 0) headers['Prefer'] = prefer.join(',');
+
+    if (this.state.isHead) headers['method'] = 'HEAD';
+
+    return headers;
+  }
+
+  protected async _execute(): Promise<PostgrestResponse<T> | PostgrestSingleResponse<T>> {
+    const url = this.buildUrl();
+    const headers = this.buildHeaders();
+
+    const init: RequestInit = {
+      method: this.state.method,
+      headers,
+    };
+
+    if (this.state.body !== undefined && (this.state.method === 'POST' || this.state.method === 'PATCH')) {
+      init.body = JSON.stringify(this.state.body);
+    }
+
+    // Use HEAD for count-only
+    if (this.state.isHead) {
+      init.method = 'HEAD';
+    }
+
+    const res = await fetch(url, init);
+    const contentRange = res.headers.get('Content-Range');
+    const count = contentRange ? parseInt(contentRange.split('/')[1]) : null;
+
+    if (this.state.isHead) {
+      return { data: null as never, error: null, count, status: res.status, statusText: res.statusText };
+    }
+
+    if (!res.ok) {
+      const errData = await res.json().catch(() => ({})) as Record<string, unknown>;
+      return {
+        data: null as never,
+        error: {
+          message: (errData.message ?? errData.error_description ?? 'Query failed') as string,
+          code: String(res.status),
+          details: (errData.details ?? '') as string,
+          hint: (errData.hint ?? '') as string,
+        },
+        count: null,
+        status: res.status,
+        statusText: res.statusText,
+      };
+    }
+
+    const raw = await res.json() as T[];
+
+    if (this.state.isSingle) {
+      if (!raw || (Array.isArray(raw) && raw.length === 0)) {
+        return {
+          data: null as never,
+          error: { message: 'JSON object requested, multiple (or no) rows returned', code: 'PGRST116', details: '', hint: '' },
+          count,
+          status: 406,
+          statusText: 'Not Acceptable',
+        };
+      }
+      const single = Array.isArray(raw) ? raw[0] : raw;
+      return { data: single as T, error: null, count, status: res.status, statusText: res.statusText };
+    }
+
+    if (this.state.isMaybeSingle) {
+      const single = Array.isArray(raw) ? (raw[0] ?? null) : raw;
+      return { data: single as T, error: null, count, status: res.status, statusText: res.statusText };
+    }
+
+    return {
+      data: (Array.isArray(raw) ? raw : [raw]) as T[],
+      error: null,
+      count,
+      status: res.status,
+      statusText: res.statusText,
+    };
+  }
+}

package/src/db/index.ts

@@ -0,0 +1,86 @@
+import { FilterBuilder } from './filterBuilder';
+
+export class SvarabaseQueryBuilder {
+  private url: string;
+  private key: string;
+  private getAuthHeader: () => string;
+
+  constructor(url: string, key: string, getAuthHeader: () => string) {
+    this.url = url;
+    this.key = key;
+    this.getAuthHeader = getAuthHeader;
+  }
+
+  from<T = Record<string, unknown>>(table: string) {
+    return new TableQuery<T>(this.url, this.key, this.getAuthHeader, table);
+  }
+
+  async rpc<T = unknown>(
+    functionName: string,
+    params: Record<string, unknown> = {},
+    options?: { count?: 'exact'; head?: boolean }
+  ): Promise<{ data: T | null; error: Error | null; count?: number | null }> {
+    try {
+      const res = await fetch(`${this.url}/rest/v1/rpc/${functionName}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          apikey: this.key,
+          Authorization: this.getAuthHeader(),
+          ...(options?.count ? { Prefer: `count=${options.count}` } : {}),
+        },
+        body: JSON.stringify(params),
+      });
+
+      const contentRange = res.headers.get('Content-Range');
+      const count = contentRange ? parseInt(contentRange.split('/')[1]) : null;
+
+      if (!res.ok) {
+        const errData = await res.json().catch(() => ({})) as Record<string, unknown>;
+        return { data: null, error: new Error((errData.message ?? 'RPC failed') as string), count };
+      }
+
+      const data = await res.json() as T;
+      return { data, error: null, count };
+    } catch (e: unknown) {
+      return { data: null, error: e as Error };
+    }
+  }
+}
+
+export class TableQuery<T> {
+  private url: string;
+  private key: string;
+  private getAuthHeader: () => string;
+  private table: string;
+
+  constructor(url: string, key: string, getAuthHeader: () => string, table: string) {
+    this.url = url;
+    this.key = key;
+    this.getAuthHeader = getAuthHeader;
+    this.table = table;
+  }
+
+  select(cols = '*', options?: { count?: 'exact'; head?: boolean }): FilterBuilder<T> {
+    const fb = new FilterBuilder<T>(this.url, this.key, this.getAuthHeader, this.table, 'GET');
+    return fb.select(cols, options);
+  }
+
+  insert(values: Partial<T> | Partial<T>[], options?: { count?: 'exact' }): FilterBuilder<T> {
+    return new FilterBuilder<T>(this.url, this.key, this.getAuthHeader, this.table, 'POST', values);
+  }
+
+  upsert(values: Partial<T> | Partial<T>[], options?: { onConflict?: string; count?: 'exact' }): FilterBuilder<T> {
+    return new FilterBuilder<T>(this.url, this.key, this.getAuthHeader, this.table, 'POST', values, true, options?.onConflict);
+  }
+
+  update(values: Partial<T>, options?: { count?: 'exact' }): FilterBuilder<T> {
+    return new FilterBuilder<T>(this.url, this.key, this.getAuthHeader, this.table, 'PATCH', values);
+  }
+
+  delete(options?: { count?: 'exact' }): FilterBuilder<T> {
+    return new FilterBuilder<T>(this.url, this.key, this.getAuthHeader, this.table, 'DELETE');
+  }
+}
+
+export { FilterBuilder };

package/src/index.ts

@@ -0,0 +1,22 @@
+export { SvarabaseClient } from './client';
+export { SvarabaseAuthClient } from './auth';
+export { SvarabaseQueryBuilder } from './db';
+export { SvarabaseStorageClient } from './storage';
+export { SvarabaseRealtimeClient } from './realtime';
+export type { SvarabaseClientOptions } from './client';
+export type { Session, UserData, AuthChangeEvent, AuthListener } from './auth/session';
+export type { PostgrestResponse, PostgrestSingleResponse } from './db/filterBuilder';
+
+import { SvarabaseClient } from './client';
+import type { SvarabaseClientOptions } from './client';
+
+// Drop-in replacement for @supabase/supabase-js createClient
+export function createClient(
+  supabaseUrl: string,
+  supabaseKey: string,
+  options?: SvarabaseClientOptions
+): SvarabaseClient {
+  return new SvarabaseClient(supabaseUrl, supabaseKey, options);
+}
+
+export default createClient;

package/src/realtime/index.ts

@@ -0,0 +1,38 @@
+// Realtime stub - Yesvara uses Socket.IO instead of Supabase Realtime
+// This stub provides API compatibility without actual websocket functionality
+
+export type RealtimeChannelStatus = 'SUBSCRIBED' | 'CLOSED' | 'CHANNEL_ERROR' | 'TIMED_OUT';
+
+export class RealtimeChannel {
+  private channelId: string;
+
+  constructor(channelId: string) {
+    this.channelId = channelId;
+  }
+
+  on(
+    _type: 'postgres_changes' | 'broadcast' | 'presence',
+    _filter: Record<string, unknown>,
+    _callback: (payload: unknown) => void
+  ): this {
+    return this;
+  }
+
+  subscribe(_callback?: (status: RealtimeChannelStatus) => void): this {
+    return this;
+  }
+
+  unsubscribe(): Promise<'ok' | 'error' | 'timed out'> {
+    return Promise.resolve('ok');
+  }
+}
+
+export class SvarabaseRealtimeClient {
+  channel(channelId: string): RealtimeChannel {
+    return new RealtimeChannel(channelId);
+  }
+
+  removeChannel(_channel: RealtimeChannel): void {}
+
+  removeAllChannels(): void {}
+}

package/src/storage/index.ts

@@ -0,0 +1,174 @@
+export interface StorageUploadOptions {
+  cacheControl?: string;
+  contentType?: string;
+  upsert?: boolean;
+}
+
+export interface FileObject {
+  name: string;
+  id: string;
+  updated_at: string;
+  created_at: string;
+  last_accessed_at: string;
+  metadata: Record<string, unknown>;
+}
+
+export class SvarabaseStorageClient {
+  private url: string;
+  private key: string;
+  private getAuthHeader: () => string;
+
+  constructor(url: string, key: string, getAuthHeader: () => string) {
+    this.url = `${url}/storage/v1`;
+    this.key = key;
+    this.getAuthHeader = getAuthHeader;
+  }
+
+  from(bucketId: string): StorageBucketApi {
+    return new StorageBucketApi(this.url, this.key, this.getAuthHeader, bucketId);
+  }
+
+  async listBuckets(): Promise<{ data: unknown[] | null; error: Error | null }> {
+    try {
+      const res = await this._fetch('/bucket');
+      const data = await res.json();
+      return { data, error: null };
+    } catch (e: unknown) { return { data: null, error: e as Error }; }
+  }
+
+  async createBucket(id: string, options?: { public?: boolean; fileSizeLimit?: number; allowedMimeTypes?: string[] }): Promise<{ data: unknown; error: Error | null }> {
+    try {
+      const res = await this._fetch('/bucket', {
+        method: 'POST',
+        body: JSON.stringify({ id, name: id, public: options?.public ?? false, file_size_limit: options?.fileSizeLimit, allowed_mime_types: options?.allowedMimeTypes }),
+      });
+      const data = await res.json();
+      if (!res.ok) return { data: null, error: new Error((data as Record<string, string>).message) };
+      return { data, error: null };
+    } catch (e: unknown) { return { data: null, error: e as Error }; }
+  }
+
+  private _fetch(path: string, init: RequestInit = {}): Promise<Response> {
+    return fetch(`${this.url}${path}`, {
+      ...init,
+      headers: {
+        'Content-Type': 'application/json',
+        apikey: this.key,
+        Authorization: this.getAuthHeader(),
+        ...(init.headers as Record<string, string> ?? {}),
+      },
+    });
+  }
+}
+
+class StorageBucketApi {
+  private url: string;
+  private key: string;
+  private getAuthHeader: () => string;
+  private bucketId: string;
+
+  constructor(url: string, key: string, getAuthHeader: () => string, bucketId: string) {
+    this.url = url;
+    this.key = key;
+    this.getAuthHeader = getAuthHeader;
+    this.bucketId = bucketId;
+  }
+
+  private get baseUrl() { return `${this.url}/object/${this.bucketId}`; }
+
+  async upload(
+    path: string,
+    fileBody: File | Blob | Buffer | ArrayBuffer | ReadableStream | string,
+    options?: StorageUploadOptions
+  ): Promise<{ data: { path: string } | null; error: Error | null }> {
+    try {
+      const headers: Record<string, string> = {
+        apikey: this.key,
+        Authorization: this.getAuthHeader(),
+      };
+
+      if (options?.contentType) headers['content-type'] = options.contentType;
+      if (options?.cacheControl) headers['cache-control'] = options.cacheControl;
+      if (options?.upsert) headers['x-upsert'] = 'true';
+
+      const res = await fetch(`${this.baseUrl}/${path}`, {
+        method: 'POST',
+        headers,
+        body: fileBody as BodyInit,
+      });
+
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({})) as Record<string, string>;
+        return { data: null, error: new Error(data.message ?? 'Upload failed') };
+      }
+
+      return { data: { path }, error: null };
+    } catch (e: unknown) { return { data: null, error: e as Error }; }
+  }
+
+  getPublicUrl(path: string): { data: { publicUrl: string } } {
+    const publicUrl = `${this.url}/object/public/${this.bucketId}/${path}`;
+    return { data: { publicUrl } };
+  }
+
+  async createSignedUrl(
+    path: string,
+    expiresIn: number,
+    options?: { download?: boolean | string }
+  ): Promise<{ data: { signedUrl: string } | null; error: Error | null }> {
+    try {
+      const res = await fetch(`${this.url}/object/sign/${this.bucketId}/${path}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          apikey: this.key,
+          Authorization: this.getAuthHeader(),
+        },
+        body: JSON.stringify({ expiresIn }),
+      });
+
+      const data = await res.json() as Record<string, string>;
+      if (!res.ok) return { data: null, error: new Error(data.message ?? 'Signing failed') };
+
+      return { data: { signedUrl: data.signedURL ?? data.signedUrl }, error: null };
+    } catch (e: unknown) { return { data: null, error: e as Error }; }
+  }
+
+  async remove(paths: string[]): Promise<{ data: FileObject[] | null; error: Error | null }> {
+    try {
+      const res = await fetch(`${this.url}/object/${this.bucketId}`, {
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
+          apikey: this.key,
+          Authorization: this.getAuthHeader(),
+        },
+        body: JSON.stringify({ prefixes: paths }),
+      });
+
+      const data = await res.json() as FileObject[] | Record<string, string>;
+      if (!res.ok) return { data: null, error: new Error((data as Record<string, string>).message) };
+      return { data: data as FileObject[], error: null };
+    } catch (e: unknown) { return { data: null, error: e as Error }; }
+  }
+
+  async list(
+    prefix?: string,
+    options?: { limit?: number; offset?: number; search?: string }
+  ): Promise<{ data: FileObject[] | null; error: Error | null }> {
+    try {
+      const res = await fetch(`${this.url}/object/list/${this.bucketId}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          apikey: this.key,
+          Authorization: this.getAuthHeader(),
+        },
+        body: JSON.stringify({ prefix: prefix ?? '', limit: options?.limit ?? 100, offset: options?.offset, search: options?.search }),
+      });
+
+      const data = await res.json();
+      return { data: data as FileObject[], error: null };
+    } catch (e: unknown) { return { data: null, error: e as Error }; }
+  }
+}