aurabase-js 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,392 @@
+interface AuraBaseClientOptions {
+    url: string;
+    anonKey: string;
+    headers?: Record<string, string>;
+}
+interface AuthSession {
+    access_token: string;
+    token_type: string;
+    user: User;
+}
+interface User {
+    id: number;
+    email: string;
+    username?: string;
+    role_id?: number;
+    created_at?: string;
+}
+interface AuthError {
+    error: string;
+    detail?: string | Array<{
+        msg: string;
+    }>;
+}
+interface PostgrestResponse<T> {
+    data: T | T[] | null;
+    error: AuraBaseError | null;
+    status: number;
+    statusText: string;
+}
+interface AuraBaseError {
+    message: string;
+    code?: string;
+    details?: string;
+}
+interface AuthStateChangeEvent {
+    SIGNED_IN: 'SIGNED_IN';
+    SIGNED_OUT: 'SIGNED_OUT';
+    TOKEN_REFRESHED: 'TOKEN_REFRESHED';
+    USER_UPDATED: 'USER_UPDATED';
+}
+type AuthChangeEvent = AuthStateChangeEvent[keyof AuthStateChangeEvent];
+interface Subscription {
+    unsubscribe: () => void;
+}
+interface SignInWithPasswordCredentials {
+    email: string;
+    password: string;
+}
+interface SignUpCredentials {
+    email: string;
+    password: string;
+    username?: string;
+}
+interface UpdateUserAttributes {
+    email?: string;
+    password?: string;
+    username?: string;
+}
+
+declare class QueryBuilder<T> {
+    private url;
+    private anonKey;
+    private accessToken;
+    private tableName;
+    private queryParams;
+    private headers;
+    private isSingle;
+    constructor(url: string, anonKey: string, accessToken: string | null, tableName: string, headers?: Record<string, string>);
+    /**
+     * Select columns
+     * @example
+     * .select('id, name, email')
+     * .select('*')
+     */
+    select(columns?: string): this;
+    /**
+     * Filter by column equality
+     * @example
+     * .eq('id', 1)
+     * .eq('status', 'active')
+     */
+    eq(column: string, value: unknown): this;
+    /**
+     * Filter by column inequality
+     */
+    neq(column: string, value: unknown): this;
+    /**
+     * Filter by greater than
+     */
+    gt(column: string, value: unknown): this;
+    /**
+     * Filter by greater than or equal
+     */
+    gte(column: string, value: unknown): this;
+    /**
+     * Filter by less than
+     */
+    lt(column: string, value: unknown): this;
+    /**
+     * Filter by less than or equal
+     */
+    lte(column: string, value: unknown): this;
+    /**
+     * Filter by like pattern
+     */
+    like(column: string, pattern: string): this;
+    /**
+     * Filter by case-insensitive like pattern
+     */
+    ilike(column: string, pattern: string): this;
+    /**
+     * Filter by array contains
+     */
+    contains(column: string, value: unknown[]): this;
+    /**
+     * Filter by value in array
+     */
+    in(column: string, values: unknown[]): this;
+    /**
+     * Filter for null values
+     */
+    isNull(column: string): this;
+    /**
+     * Filter for non-null values
+     */
+    isNotNull(column: string): this;
+    /**
+     * Order results
+     * @example
+     * .order('created_at', { ascending: false })
+     */
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): this;
+    /**
+     * Limit results
+     */
+    limit(count: number): this;
+    /**
+     * Offset results
+     */
+    offset(count: number): this;
+    /**
+     * Range of results (offset + limit)
+     */
+    range(from: number, to: number): this;
+    /**
+     * Return single result
+     */
+    single(): this;
+    /**
+     * Return single result or null
+     */
+    maybeSingle(): this;
+    private getHeaders;
+    private request;
+    /**
+     * Execute SELECT query
+     */
+    then<TResult = T[]>(resolve: (value: PostgrestResponse<TResult>) => void | PromiseLike<void>, reject?: (reason: unknown) => void | PromiseLike<void>): Promise<void>;
+    /**
+     * Insert row(s)
+     */
+    insert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>>;
+    /**
+     * Update row(s)
+     */
+    update(data: Partial<T>): Promise<PostgrestResponse<T>>;
+    /**
+     * Upsert row(s)
+     */
+    upsert(row: Partial<T> | Partial<T>[]): Promise<PostgrestResponse<T>>;
+    /**
+     * Delete row(s)
+     */
+    delete(): Promise<PostgrestResponse<T>>;
+}
+
+declare class AuthClient {
+    private url;
+    private anonKey;
+    private listeners;
+    private currentSession;
+    private storageKey;
+    constructor(url: string, anonKey: string);
+    private loadSession;
+    private saveSession;
+    private getHeaders;
+    private emitEvent;
+    /**
+     * Sign in with email and password
+     */
+    signInWithPassword(credentials: SignInWithPasswordCredentials): Promise<{
+        data: {
+            user: User;
+            session: AuthSession;
+        } | null;
+        error: AuthError | null;
+    }>;
+    /**
+     * Sign up with email and password
+     */
+    signUp(credentials: SignUpCredentials): Promise<{
+        data: {
+            user: User;
+        } | null;
+        error: AuthError | null;
+    }>;
+    /**
+     * Sign out
+     */
+    signOut(): Promise<{
+        error: AuthError | null;
+    }>;
+    /**
+     * Get current session
+     */
+    getSession(): {
+        data: {
+            session: AuthSession | null;
+        };
+    };
+    /**
+     * Get current user
+     */
+    getUser(): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: AuthError | null;
+    }>;
+    /**
+     * Update user
+     */
+    updateUser(attributes: UpdateUserAttributes): Promise<{
+        data: {
+            user: User;
+        } | null;
+        error: AuthError | null;
+    }>;
+    /**
+     * Request password reset
+     */
+    resetPasswordForEmail(email: string): Promise<{
+        error: AuthError | null;
+    }>;
+    /**
+     * Subscribe to auth state changes
+     */
+    onAuthStateChange(callback: (event: AuthChangeEvent, session: AuthSession | null) => void): {
+        data: {
+            subscription: Subscription;
+        };
+    };
+}
+
+declare class AuraBaseClient {
+    private url;
+    private anonKey;
+    private accessToken;
+    private customHeaders;
+    auth: AuthClient;
+    constructor(options: AuraBaseClientOptions);
+    /**
+     * Set access token for authenticated requests
+     */
+    setAccessToken(token: string | null): void;
+    /**
+     * Get the current access token
+     */
+    getAccessToken(): string | null;
+    /**
+     * Query a table
+     * @example
+     * const { data, error } = await client.from('todos').select('*')
+     */
+    from<T = unknown>(tableName: string): QueryBuilder<T>;
+    /**
+     * Execute raw SQL (RPC function call)
+     * @example
+     * const { data, error } = await client.rpc('my_function', { arg1: 'value' })
+     */
+    rpc<T = unknown>(functionName: string, params?: Record<string, unknown>): Promise<{
+        data: T | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * Get storage client (if available)
+     */
+    get storage(): {
+        from: (bucket: string) => StorageBucket;
+    };
+}
+/**
+ * Storage bucket operations
+ */
+declare class StorageBucket {
+    private url;
+    private anonKey;
+    private bucket;
+    private accessToken;
+    constructor(url: string, anonKey: string, bucket: string, accessToken: string | null);
+    private getHeaders;
+    /**
+     * Upload a file
+     */
+    upload(path: string, file: File | Blob, options?: {
+        contentType?: string;
+        upsert?: boolean;
+    }): Promise<{
+        data: {
+            path: string;
+        } | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * Download a file
+     */
+    download(path: string): Promise<{
+        data: Blob | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * Get public URL for a file
+     */
+    getPublicUrl(path: string): string;
+    /**
+     * Delete a file
+     */
+    remove(paths: string[]): Promise<{
+        error: {
+            message: string;
+        } | null;
+    }>;
+    /**
+     * List files in a bucket
+     */
+    list(prefix?: string): Promise<{
+        data: Array<{
+            name: string;
+            id: string;
+            created_at: string;
+        }> | null;
+        error: {
+            message: string;
+        } | null;
+    }>;
+}
+
+/**
+ * Create an AuraBase client
+ * @param options - Client options containing url and anonKey
+ * @returns AuraBaseClient instance
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from 'aurabase-js'
+ *
+ * const aurabase = createClient({
+ *   url: 'http://localhost:8000',
+ *   anonKey: 'your-anon-key'
+ * })
+ *
+ * // Query data
+ * const { data, error } = await aurabase
+ *   .from('todos')
+ *   .select('*')
+ *   .order('created_at', { ascending: false })
+ *   .limit(10)
+ *
+ * // Insert data
+ * const { data: newTodo, error: insertError } = await aurabase
+ *   .from('todos')
+ *   .insert({ title: 'My todo', completed: false })
+ *
+ * // Auth
+ * const { data, error } = await aurabase.auth.signInWithPassword({
+ *   email: 'user@example.com',
+ *   password: 'password'
+ * })
+ * ```
+ */
+declare function createClient(options: AuraBaseClientOptions): AuraBaseClient;
+
+export { AuraBaseClient, type AuraBaseClientOptions, type AuraBaseError, type AuthChangeEvent, type AuthError, type AuthSession, type PostgrestResponse, type SignInWithPasswordCredentials, type SignUpCredentials, type Subscription, type UpdateUserAttributes, type User, createClient, createClient as default };