vasabase-js 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,357 @@
+export declare function createClient(url: string, key: string, options?: {
+    projectRef?: string;
+}): VasabaseClient;
+export declare class PostgrestError extends Error {
+    code?: number;
+    details?: string;
+    constructor(message: string, code?: number, details?: string);
+}
+export declare class AuthError extends Error {
+    code?: number;
+    details?: string;
+    constructor(message: string, code?: number, details?: string);
+}
+export declare class FunctionsError extends Error {
+    code?: number;
+    constructor(message: string, code?: number);
+}
+export interface User {
+    id: string;
+    email: string;
+    user_metadata?: Record<string, any>;
+}
+export interface Session {
+    access_token: string;
+    refresh_token?: string;
+    expires_in: number;
+    user: User;
+}
+export interface Factor {
+    id: string;
+    friendly_name?: string;
+    factor_type: 'totp' | 'webauthn';
+    status: 'verified' | 'unverified';
+    created_at: string;
+    updated_at: string;
+}
+export type AuthChangeEventType = 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED' | 'PASSWORD_RECOVERY';
+export interface PostgresCDCConfig {
+    event: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+    schema?: string;
+    filter?: string;
+}
+export interface RealtimePayload {
+    event: string;
+    schema: string;
+    table: string;
+    new: Record<string, any>;
+    old: Record<string, any>;
+}
+export declare class VasabaseClient {
+    auth: AuthClient;
+    rest: PostgrestClient;
+    storage: StorageClient;
+    realtime: RealtimeClient;
+    functions: FunctionsClient;
+    private url;
+    private key;
+    private projectRef;
+    constructor(url: string, key: string, options?: {
+        projectRef?: string;
+    });
+    from(table: string): PostgrestQueryBuilder;
+}
+declare class PostgrestClient {
+    private url;
+    private key;
+    private projectRef;
+    private getAuthHeaders;
+    constructor(url: string, key: string, projectRef: string, getAuthHeaders: () => Record<string, string>);
+    from(table: string): PostgrestQueryBuilder;
+}
+declare class PostgrestQueryBuilder {
+    private url;
+    private key;
+    private projectRef;
+    private getAuthHeaders;
+    private table;
+    private method;
+    private query;
+    private body;
+    private headers;
+    private _notPrefix;
+    constructor(url: string, key: string, projectRef: string, getAuthHeaders: () => Record<string, string>, table: string, method?: string, query?: Record<string, string>, body?: any, headers?: Record<string, string>, notPrefix?: string);
+    private clone;
+    select(columns?: string): PostgrestQueryBuilder;
+    insert(data: any | any[]): PostgrestQueryBuilder;
+    upsert(data: any | any[], onConflict?: string): PostgrestQueryBuilder;
+    update(data: any): PostgrestQueryBuilder;
+    delete(): PostgrestQueryBuilder;
+    eq(column: string, value: any): PostgrestQueryBuilder;
+    neq(column: string, value: any): PostgrestQueryBuilder;
+    gt(column: string, value: any): PostgrestQueryBuilder;
+    gte(column: string, value: any): PostgrestQueryBuilder;
+    lt(column: string, value: any): PostgrestQueryBuilder;
+    lte(column: string, value: any): PostgrestQueryBuilder;
+    like(column: string, pattern: string): PostgrestQueryBuilder;
+    ilike(column: string, pattern: string): PostgrestQueryBuilder;
+    is_(column: string, value: boolean | null): PostgrestQueryBuilder;
+    isNull(column: string): PostgrestQueryBuilder;
+    in_(column: string, values: any[]): PostgrestQueryBuilder;
+    contains(column: string, value: any): PostgrestQueryBuilder;
+    containedBy(column: string, value: any): PostgrestQueryBuilder;
+    match(column: string, query: Record<string, any>): PostgrestQueryBuilder;
+    imatch(column: string, query: Record<string, any>): PostgrestQueryBuilder;
+    or(filter: string): PostgrestQueryBuilder;
+    and(filter: string): PostgrestQueryBuilder;
+    not_(): PostgrestQueryBuilder;
+    order(column: string, ascending?: boolean): PostgrestQueryBuilder;
+    limit(n: number): PostgrestQueryBuilder;
+    offset(n: number): PostgrestQueryBuilder;
+    range(from: number, to: number): PostgrestQueryBuilder;
+    single(): PostgrestQueryBuilder;
+    maybeSingle(): PostgrestQueryBuilder;
+    then<T>(onFulfilled: (value: any) => T, onRejected?: (reason: any) => any): Promise<T>;
+    catch<T>(onRejected: (reason: any) => T): Promise<any>;
+    execute(): Promise<{
+        data: any;
+        error: PostgrestError | null;
+    }>;
+}
+declare class AuthClient {
+    private url;
+    private key;
+    private projectRef;
+    currentSession: Session | null;
+    currentUser: User | null;
+    private listeners;
+    constructor(url: string, key: string, projectRef: string);
+    onAuthStateChange(cb: (event: AuthChangeEventType, session: Session | null) => void): () => void;
+    private emit;
+    private getHeaders;
+    initialize(): Promise<void>;
+    private persist;
+    signUp(body: {
+        email: string;
+        password: string;
+    }): Promise<{
+        data: Session | null;
+        error: AuthError | null;
+    }>;
+    signInWithPassword(body: {
+        email: string;
+        password: string;
+    }): Promise<{
+        data: Session | null;
+        error: AuthError | null;
+    }>;
+    signInWithOAuth(options: {
+        provider: string;
+        redirectTo?: string;
+        codeChallenge?: string;
+    }): string;
+    signInWithOtp(body: {
+        email?: string;
+        phone?: string;
+    }): Promise<{
+        error: AuthError | null;
+    }>;
+    signInWithIdToken(body: {
+        provider: string;
+        idToken: string;
+    }): Promise<{
+        data: Session | null;
+        error: AuthError | null;
+    }>;
+    signInAnonymously(): Promise<{
+        data: Session | null;
+        error: AuthError | null;
+    }>;
+    reauthenticate(body: {
+        email: string;
+        password: string;
+    }): Promise<{
+        data: Session | null;
+        error: AuthError | null;
+    }>;
+    signOut(): Promise<{
+        error: AuthError | null;
+    }>;
+    setAuth(token: string): void;
+    setSession(session: Session): void;
+    refreshSession(): Promise<{
+        data: Session | null;
+        error: AuthError | null;
+    }>;
+    updateUser(attributes: Record<string, any>, options?: {
+        emailRedirectTo?: string;
+    }): Promise<{
+        data: User | null;
+        error: AuthError | null;
+    }>;
+    resetPasswordForEmail(email: string, options?: {
+        redirectTo?: string;
+    }): Promise<{
+        error: AuthError | null;
+    }>;
+    enroll(body: {
+        friendlyName?: string;
+    }): Promise<{
+        data: Factor | null;
+        error: AuthError | null;
+    }>;
+    verifyFactor(body: {
+        factorId: string;
+        code: string;
+        challengeId?: string;
+    }): Promise<{
+        data: any;
+        error: AuthError | null;
+    }>;
+    createChallenge(body: {
+        factorId: string;
+    }): Promise<{
+        data: any;
+        error: AuthError | null;
+    }>;
+    verifyChallenge(body: {
+        challengeId: string;
+        code: string;
+    }): Promise<{
+        data: any;
+        error: AuthError | null;
+    }>;
+    unenroll(body: {
+        factorId: string;
+    }): Promise<{
+        error: AuthError | null;
+    }>;
+    listFactors(): Promise<{
+        data: Factor[] | null;
+        error: AuthError | null;
+    }>;
+}
+declare class StorageClient {
+    private url;
+    private key;
+    private projectRef;
+    private getAuthHeaders;
+    constructor(url: string, key: string, projectRef: string, getAuthHeaders: () => Record<string, string>);
+    from(bucketId: string): StorageFileApi;
+    createBucket(id: string, options?: {
+        public?: boolean;
+        file_size_limit?: number;
+        allowed_mime_types?: string[];
+    }): Promise<{
+        data: any;
+        error: PostgrestError | null;
+    }>;
+    deleteBucket(id: string): Promise<{
+        data: any;
+        error: PostgrestError | null;
+    }>;
+    listBuckets(): Promise<{
+        data: any[] | null;
+        error: PostgrestError | null;
+    }>;
+}
+declare class StorageFileApi {
+    private url;
+    private key;
+    private projectRef;
+    private getAuthHeaders;
+    private bucketId;
+    constructor(url: string, key: string, projectRef: string, getAuthHeaders: () => Record<string, string>, bucketId: string);
+    private getHeaders;
+    upload(path: string, file: File | Blob): Promise<{
+        data: any;
+        error: PostgrestError | null;
+    }>;
+    download(path: string): Promise<{
+        data: Blob | null;
+        error: PostgrestError | null;
+    }>;
+    remove(paths: string[]): Promise<{
+        error: PostgrestError | null;
+    }>;
+    move(fromPath: string, toPath: string): Promise<{
+        error: PostgrestError | null;
+    }>;
+    copy(fromPath: string, toPath: string): Promise<{
+        error: PostgrestError | null;
+    }>;
+    createSignedUrl(path: string, expiresIn?: number): Promise<{
+        data: string | null;
+        error: PostgrestError | null;
+    }>;
+    getPublicUrl(path: string, download?: boolean): string;
+}
+declare class RealtimeClient {
+    private url;
+    private key;
+    private projectRef;
+    private ws;
+    private channels;
+    private reconnectTimer;
+    private connected;
+    constructor(url: string, key: string, projectRef: string);
+    connect(): void;
+    disconnect(): void;
+    on(table: string): {
+        subscribe: (cb: (payload: RealtimePayload) => void) => RealtimeSubscription;
+    };
+    channel(table: string, filter?: PostgresCDCConfig): RealtimeChannel;
+    send(payload: any): void;
+    get isConnected(): boolean;
+    removeChannel(name: string): void;
+}
+declare class RealtimeChannel {
+    private client;
+    private name;
+    private table;
+    private filter?;
+    private _subscribed;
+    private cdcCallbacks;
+    private presenceCallbacks;
+    private broadcastCallbacks;
+    private presenceState;
+    constructor(client: RealtimeClient, name: string, table: string, filter?: PostgresCDCConfig);
+    get subscribed(): boolean;
+    subscribe(): RealtimeChannel;
+    resubscribe(): void;
+    unsubscribe(): void;
+    on(event: 'INSERT' | 'UPDATE' | 'DELETE' | '*', cb: (payload: RealtimePayload) => void): RealtimeSubscription;
+    onPresence(cb: (payload: any) => void): () => void;
+    onBroadcast(eventOrCb: string | ((payload: any) => void), cb?: (payload: any) => void): () => void;
+    broadcast(event: string, payload?: any): void;
+    track(userState: Record<string, any>): void;
+    get stream(): {
+        on: (event: string, cb: (payload: any) => void) => () => void;
+    };
+    handleMessage(msg: any): void;
+}
+declare class RealtimeSubscription {
+    private client;
+    private table;
+    private event;
+    private callback;
+    private _active;
+    constructor(client: RealtimeClient, table: string, event: string, callback: (payload: RealtimePayload) => void);
+    _setActive(active: boolean): void;
+    subscribe(): void;
+    unsubscribe(): void;
+}
+declare class FunctionsClient {
+    private url;
+    private key;
+    private projectRef;
+    private getAuthHeaders;
+    constructor(url: string, key: string, projectRef: string, getAuthHeaders: () => Record<string, string>);
+    invoke(functionName: string, options?: {
+        body?: any;
+    }): Promise<{
+        data: any;
+        error: FunctionsError | null;
+    }>;
+}
+export {};