corebase-js 0.1.0 → 0.2.0

package/README.md

@@ -1,69 +1,254 @@
 # CoreBase JS Client
 
-A JavaScript/TypeScript client for CoreBase.
+A robust JavaScript/TypeScript client for communicating with your CoreBase backend. This library provides a simple, Supabase-like interface for authentication and database operations.
 
 ## Installation
 
 ```bash
 npm install corebase-js
+
+# If using React/React Native hooks (Optioanal peer dependency)
+npm install --save-dev react @types/react
 ```
 
 ## Initialization
 
-Initialize the client with your project URL and API Key.
+Initialize the client with your CoreBase project URL and API Key.
 
-```javascript
+```typescript
 import { createClient } from 'corebase-js';
 
-const corebase = createClient('https://your-project-url.com', 'your-public-api-key');
+const CLIENT_URL = 'https://corebase.trivyaa.in'; // Your CoreBase API URL
+const API_KEY = 'pk_...'; // Your Project Public API Key
+
+const corebase = createClient(CLIENT_URL, API_KEY);
 ```
 
 ## Authentication
 
+Manage user sessions securely.
+
 ### Sign Up
 
-```javascript
+Register a new user in your project.
+
+```typescript
 const { data, error } = await corebase.auth.signUp({
   email: 'user@example.com',
-  password: 'password123',
+  password: 'securePassword123',
   name: 'John Doe'
 });
 
-if (error) {
-  console.error('Signup failed:', error.message);
-} else {
-  console.log('User created:', data.user);
-}
+if (error) console.error('Signup error:', error);
+else console.log('Welcome!', data.user);
 ```
 
 ### Sign In
 
-```javascript
+Log in an existing user. The session is automatically persisted (in localStorage for browsers).
+
+```typescript
 const { data, error } = await corebase.auth.signIn({
   email: 'user@example.com',
-  password: 'password123'
+  password: 'securePassword123'
 });
 
-if (error) {
-  console.error('Login failed:', error.message);
-} else {
-  console.log('Logged in user:', data.user);
-  console.log('Access token:', data.access_token);
-}
+if (error) console.error('Login error:', error);
+else console.log('Logged in:', data.user);
 ```
 
 ### Get Current User
 
-```javascript
+Retrieve the currently authenticated user's details.
+
+```typescript
 const { data, error } = await corebase.auth.getUser();
 
-if (data) {
-  console.log('Current user:', data.user);
-}
+if (data) console.log('Current user:', data.user);
 ```
 
 ### Sign Out
 
-```javascript
+Clear the current session.
+
+```typescript
 await corebase.auth.signOut();
 ```
+
+## specific Database Operations
+
+Perform CRUD operations on your tables using a fluent, chainable API.
+
+### Select Data (Read)
+
+**Get all rows:**
+
+```typescript
+const { data, error, count } = await corebase
+  .from('posts')
+  .select('*');
+```
+
+**Select specific columns:**
+
+```typescript
+const { data } = await corebase
+  .from('users')
+  .select('id, name, email');
+```
+
+**Filtering (Where clause):**
+
+```typescript
+const { data } = await corebase
+  .from('posts')
+  .select('*')
+  .eq('status', 'published')
+  .match({ author_id: 'user_123', category: 'tech' });
+```
+
+**Pagination & Sorting:**
+
+```typescript
+const { data, count } = await corebase
+  .from('posts')
+  .select('*')
+  .order('created_at', { ascending: false }) // Sort by newest
+  .limit(10)                                 // Take 10
+  .page(1);                                  // Page 1
+```
+
+**Get a Single Record:**
+
+```typescript
+const { data: user, error } = await corebase
+  .from('users')
+  .select('*')
+  .eq('id', 1)
+  .single();
+```
+
+### Insert Data (Create)
+
+Insert one or multiple rows.
+
+```typescript
+// Single insert
+const { data, error } = await corebase
+  .from('posts')
+  .insert({ 
+    title: 'My New Post', 
+    content: 'Hello World', 
+    user_id: 'user_123' 
+  });
+
+// Bulk insert
+const { data, error } = await corebase
+  .from('posts')
+  .insert([
+    { title: 'Post 1', user_id: 'user_123' },
+    { title: 'Post 2', user_id: 'user_123' }
+  ]);
+```
+
+### Update Data
+
+Update rows matching specific criteria.
+
+```typescript
+const { data, error } = await corebase
+  .from('posts')
+  .update({ status: 'archived' })
+  .eq('status', 'draft')
+  .match({ user_id: 'user_123' });
+```
+
+### Delete Data
+
+Delete rows matching specific criteria.
+
+```typescript
+const { data, error } = await corebase
+  .from('posts')
+  .delete()
+  .eq('id', 123);
+```
+
+## File Storage
+
+Upload files to your project buckets.
+
+### Upload File
+
+Upload a file directly from the browser (e.g., from an `<input type="file" />`).
+
+```typescript
+// Assuming you have an input element: <input type="file" id="fileInput" />
+const fileInput = document.getElementById('fileInput') as HTMLInputElement;
+const file = fileInput.files?.[0];
+
+if (file) {
+  const { data, error } = await corebase.storage.upload(file);
+
+  if (error) {
+    console.error('Upload failed:', error);
+  } else {
+    console.log('File uploaded successfully!');
+    console.log('File Key:', data.key);
+    console.log('Upload URL:', data.url);
+  }
+}
+```
+
+## Realtime Data (React / React Native)
+
+Subscribe to live data changes using the `useQuery` hook.
+
+```typescript
+import { useQuery } from 'corebase-js/react';
+
+// Define your query
+const query = {
+  from: 'posts',
+  select: ['id', 'title', 'likes'],
+  where: { 
+    status: 'published' 
+  }
+};
+
+const MyComponent = () => {
+  // Subscribe to realtime updates
+  const { data, loading, error } = useQuery(corebase, query);
+
+  if (loading) return <div>Loading...</div>;
+  if (error) return <div>Error: {error.message}</div>;
+
+  return (
+    <ul>
+      {data.map(post => (
+        <li key={post.id}>
+          {post.title} ({post.likes} likes)
+        </li>
+      ))}
+    </ul>
+  );
+};
+```
+
+## TypeScript Support
+
+This library is written in TypeScript and exports types for all responses.
+
+```typescript
+import { User, AuthSession, ClientResponse } from 'corebase-js';
+
+// You can also provide a generic type to .from() for typed results
+interface Post {
+  id: number;
+  title: string;
+  content: string;
+}
+
+const { data } = await corebase.from<Post>('posts').select('*');
+// data is typed as Post[] | null
+```

package/dist/auth.d.ts

@@ -1,12 +1,4 @@
-import { AuthSession, ClientConfig, User } from './types';
-export interface AuthResponse<T> {
-    data: T | null;
-    error: {
-        message: string;
-        code?: string;
-        details?: string;
-    } | null;
-}
+import { AuthSession, ClientConfig, ClientResponse, User } from './types';
 export declare class AuthClient {
     private config;
     private session;
@@ -14,19 +6,19 @@ export declare class AuthClient {
     constructor(config: ClientConfig);
     private get baseUrl();
     private get headers();
-    private request;
+    request<T>(path: string, options?: RequestInit): Promise<ClientResponse<T>>;
     signUp(credentials: {
         email: string;
         password: string;
         name?: string;
-    }): Promise<AuthResponse<{
+    }): Promise<ClientResponse<{
         user: User;
     }>>;
     signIn(credentials: {
         email: string;
         password: string;
-    }): Promise<AuthResponse<AuthSession>>;
-    getUser(): Promise<AuthResponse<{
+    }): Promise<ClientResponse<AuthSession>>;
+    getUser(): Promise<ClientResponse<{
         user: User;
     }>>;
     signOut(): Promise<{

package/dist/client.d.ts

@@ -1,8 +1,14 @@
 import { AuthClient } from './auth';
+import { QueryBuilder } from './query';
+import { StorageClient } from './storage';
+import { RealtimeClient } from './realtime';
 import { ClientConfig } from './types';
 export declare class CoreBaseClient {
     auth: AuthClient;
+    storage: StorageClient;
+    realtime: RealtimeClient;
     private config;
     constructor(config: ClientConfig);
+    from<T = any>(table: string): QueryBuilder<T>;
 }
 export declare function createClient(baseUrl: string, apiKey: string): CoreBaseClient;

package/dist/client.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoreBaseClient = void 0;
 exports.createClient = createClient;
 const auth_1 = require("./auth");
+const query_1 = require("./query");
+const storage_1 = require("./storage");
+const realtime_1 = require("./realtime");
 class CoreBaseClient {
     constructor(config) {
         if (!config.apiKey) {
@@ -13,6 +16,11 @@ class CoreBaseClient {
         }
         this.config = config;
         this.auth = new auth_1.AuthClient(config);
+        this.storage = new storage_1.StorageClient(this.auth);
+        this.realtime = new realtime_1.RealtimeClient(config, this.auth);
+    }
+    from(table) {
+        return new query_1.QueryBuilder((path, options) => this.auth.request(path, options), table);
     }
 }
 exports.CoreBaseClient = CoreBaseClient;

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export * from './types';
 export * from './client';
 export * from './auth';
+export * from './query';
+export * from './storage';
+export * from './realtime';

package/dist/index.js

@@ -17,3 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./client"), exports);
 __exportStar(require("./auth"), exports);
+__exportStar(require("./query"), exports);
+__exportStar(require("./storage"), exports);
+__exportStar(require("./realtime"), exports);

package/dist/query.d.ts

@@ -0,0 +1,42 @@
+import { ClientResponse } from './types';
+export type RequestHandler = <T>(path: string, options?: RequestInit) => Promise<ClientResponse<T>>;
+export declare class QueryBuilder<T = any> {
+    private request;
+    private tableName;
+    constructor(request: RequestHandler, tableName: string);
+    select(columns?: string): SelectBuilder<T>;
+    insert(values: Partial<T> | Partial<T>[]): Promise<ClientResponse<{
+        message: string;
+        count: number;
+    }>>;
+    update(values: Partial<T>): FilterBuilder<any>;
+    delete(): FilterBuilder<any>;
+}
+export declare class FilterBuilder<T> implements PromiseLike<ClientResponse<T>> {
+    protected request: RequestHandler;
+    protected tableName: string;
+    protected method: 'UPDATE' | 'DELETE' | 'SELECT';
+    protected body?: any | undefined;
+    protected columns?: string | undefined;
+    protected filters: Record<string, any>;
+    constructor(request: RequestHandler, tableName: string, method: 'UPDATE' | 'DELETE' | 'SELECT', body?: any | undefined, columns?: string | undefined);
+    eq(column: string, value: any): this;
+    match(query: Record<string, any>): this;
+    then<TResult1 = ClientResponse<T>, TResult2 = never>(onfulfilled?: ((value: ClientResponse<T>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    execute(): Promise<ClientResponse<T>>;
+}
+export declare class SelectBuilder<T> extends FilterBuilder<T> {
+    private _limit?;
+    private _page?;
+    private _sort?;
+    private _order?;
+    private _isSingle;
+    constructor(request: RequestHandler, tableName: string, columns: string);
+    limit(count: number): this;
+    page(page: number): this;
+    order(column: string, { ascending }?: {
+        ascending?: boolean;
+    }): this;
+    single(): this;
+    execute(): Promise<ClientResponse<T>>;
+}

package/dist/query.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectBuilder = exports.FilterBuilder = exports.QueryBuilder = void 0;
+class QueryBuilder {
+    constructor(request, tableName) {
+        this.request = request;
+        this.tableName = tableName;
+    }
+    select(columns = '*') {
+        return new SelectBuilder(this.request, this.tableName, columns);
+    }
+    insert(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/table_operation/insert/${encodeURIComponent(this.tableName)}`, {
+                method: 'POST',
+                body: JSON.stringify(values),
+            });
+        });
+    }
+    update(values) {
+        return new FilterBuilder(this.request, this.tableName, 'UPDATE', values);
+    }
+    delete() {
+        return new FilterBuilder(this.request, this.tableName, 'DELETE');
+    }
+}
+exports.QueryBuilder = QueryBuilder;
+class FilterBuilder {
+    constructor(request, tableName, method, body, columns) {
+        this.request = request;
+        this.tableName = tableName;
+        this.method = method;
+        this.body = body;
+        this.columns = columns;
+        this.filters = {};
+    }
+    eq(column, value) {
+        this.filters[column] = value;
+        return this;
+    }
+    match(query) {
+        Object.assign(this.filters, query);
+        return this;
+    }
+    then(onfulfilled, onrejected) {
+        return this.execute().then(onfulfilled, onrejected);
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.method === 'SELECT') {
+                throw new Error("Execute should be called on SelectBuilder");
+            }
+            const path = `/table_operation/${this.method.toLowerCase()}/${encodeURIComponent(this.tableName)}`;
+            let payload = {};
+            if (this.method === 'UPDATE') {
+                payload = {
+                    updates: this.body,
+                    where: this.filters
+                };
+                return this.request(path, { method: 'PUT', body: JSON.stringify(payload) });
+            }
+            else if (this.method === 'DELETE') {
+                payload = {
+                    where: this.filters
+                };
+                return this.request(path, { method: 'DELETE', body: JSON.stringify(payload) });
+            }
+            return { data: null, error: { message: 'Invalid method' } };
+        });
+    }
+}
+exports.FilterBuilder = FilterBuilder;
+class SelectBuilder extends FilterBuilder {
+    constructor(request, tableName, columns) {
+        super(request, tableName, 'SELECT', undefined, columns);
+        this._isSingle = false;
+    }
+    limit(count) {
+        this._limit = count;
+        return this;
+    }
+    page(page) {
+        this._page = page;
+        return this;
+    }
+    order(column, { ascending = true } = {}) {
+        this._sort = column;
+        this._order = ascending ? 'ASC' : 'DESC';
+        return this;
+    }
+    single() {
+        this._limit = 1;
+        this._isSingle = true;
+        return this;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const payload = {
+                columns: this.columns === '*' ? undefined : (_a = this.columns) === null || _a === void 0 ? void 0 : _a.split(',').map(s => s.trim()),
+                where: Object.keys(this.filters).length > 0 ? this.filters : undefined,
+                limit: this._limit,
+                page: this._page,
+                sort: this._sort,
+                order: this._order
+            };
+            const response = yield this.request(`/table_operation/select/${encodeURIComponent(this.tableName)}`, {
+                method: 'POST',
+                body: JSON.stringify(payload)
+            });
+            if (response.error)
+                return { data: null, error: response.error };
+            const resultData = (_b = response.data) === null || _b === void 0 ? void 0 : _b.data; // Array of items
+            const meta = (_c = response.data) === null || _c === void 0 ? void 0 : _c.meta;
+            let finalData = resultData;
+            if (this._isSingle) {
+                if (Array.isArray(resultData) && resultData.length > 0) {
+                    finalData = resultData[0];
+                }
+                else {
+                    finalData = null; // Or undefined? Supabase errors here usually.
+                }
+            }
+            return {
+                data: finalData,
+                error: null,
+                count: meta === null || meta === void 0 ? void 0 : meta.total
+            };
+        });
+    }
+}
+exports.SelectBuilder = SelectBuilder;

package/dist/react.d.ts

@@ -0,0 +1,21 @@
+import { CoreBaseClient } from './client';
+export interface UseQueryOptions {
+    enabled?: boolean;
+    onData?: (data: any) => void;
+    onError?: (error: any) => void;
+}
+export interface UseQueryResult<T> {
+    data: T | null;
+    loading: boolean;
+    error: any;
+}
+/**
+ * Hook to subscribe to realtime data queries.
+ * Compatible with React and React Native.
+ *
+ * @param client - The CoreBaseClient instance
+ * @param query - The query object definition
+ * @param options - Options for the hook
+ * @returns The current data, loading state, and error
+ */
+export declare function useQuery<T = any>(client: CoreBaseClient, query: any, options?: UseQueryOptions): UseQueryResult<T>;

package/dist/react.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQuery = useQuery;
+const react_1 = require("react");
+/**
+ * Hook to subscribe to realtime data queries.
+ * Compatible with React and React Native.
+ *
+ * @param client - The CoreBaseClient instance
+ * @param query - The query object definition
+ * @param options - Options for the hook
+ * @returns The current data, loading state, and error
+ */
+function useQuery(client, query, options = {}) {
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const { enabled = true, onData, onError } = options;
+    // Use stringified query to detect changes deeply
+    const queryJson = JSON.stringify(query);
+    (0, react_1.useEffect)(() => {
+        if (!enabled) {
+            setLoading(false);
+            return;
+        }
+        let subId;
+        const subscribe = () => {
+            setLoading(true);
+            setError(null);
+            try {
+                if (!client.realtime) {
+                    throw new Error("RealtimeClient is not initialized on the CoreBaseClient instance.");
+                }
+                subId = client.realtime.subscribe(query, (newData) => {
+                    setData(newData);
+                    setLoading(false);
+                    if (onData)
+                        onData(newData);
+                });
+            }
+            catch (err) {
+                console.error("CoreBase useQuery error:", err);
+                setError(err);
+                setLoading(false);
+                if (onError)
+                    onError(err);
+            }
+        };
+        subscribe();
+        return () => {
+            if (subId && client.realtime) {
+                client.realtime.unsubscribe(subId);
+            }
+        };
+    }, [client, queryJson, enabled]); // Re-run if client, query or enabled status changes
+    return { data, loading, error };
+}

package/dist/realtime.d.ts

@@ -0,0 +1,28 @@
+import { AuthClient } from './auth';
+import { ClientConfig } from './types';
+export interface RealtimeMessage {
+    type: 'subscribe' | 'unsubscribe' | 'data' | 'error';
+    id?: string;
+    query?: any;
+    data?: any;
+    error?: any;
+}
+export type RealtimeCallback = (data: any) => void;
+export declare class RealtimeClient {
+    private ws;
+    private subscriptions;
+    private reconnectTimer;
+    private config;
+    private auth;
+    private isConnected;
+    constructor(config: ClientConfig, auth: AuthClient);
+    private getUrl;
+    connect(): void;
+    disconnect(): void;
+    subscribe(query: any, callback: RealtimeCallback): string;
+    unsubscribe(id: string): void;
+    private send;
+    private handleMessage;
+    private resubscribeAll;
+    private scheduleReconnect;
+}

package/dist/realtime.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeClient = void 0;
+class RealtimeClient {
+    constructor(config, auth) {
+        this.ws = null;
+        this.subscriptions = new Map();
+        this.reconnectTimer = null;
+        this.isConnected = false;
+        this.config = config;
+        this.auth = auth;
+    }
+    getUrl() {
+        const baseUrl = this.config.baseUrl || 'http://localhost:3000';
+        return baseUrl.replace(/^http/, 'ws') + '/v1/realtime';
+    }
+    connect() {
+        var _a;
+        if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING))
+            return;
+        const url = this.getUrl();
+        const headers = {
+            'x-api-key': this.config.apiKey
+        };
+        const token = (_a = this.auth.getSession()) === null || _a === void 0 ? void 0 : _a.access_token;
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        try {
+            // Compatible with React Native (supports headers in 3rd arg) and standard browsers (ignores 3rd arg)
+            // @ts-ignore
+            this.ws = new WebSocket(url, [], { headers });
+        }
+        catch (e) {
+            this.ws = new WebSocket(url);
+        }
+        if (!this.ws)
+            return;
+        this.ws.onopen = () => {
+            this.isConnected = true;
+            this.resubscribeAll();
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                this.handleMessage(msg);
+            }
+            catch (e) {
+                console.error('CoreBase Realtime parse error', e);
+            }
+        };
+        this.ws.onclose = () => {
+            this.isConnected = false;
+            this.scheduleReconnect();
+        };
+        this.ws.onerror = (e) => {
+            console.error('CoreBase Realtime error', e);
+            // Do not close immediately on error, let onclose handle it? 
+            // Sometimes error precedes close.
+        };
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.isConnected = false;
+    }
+    subscribe(query, callback) {
+        const id = Math.random().toString(36).substring(7);
+        this.subscriptions.set(id, { query, callback });
+        if (this.isConnected) {
+            this.send({ type: 'subscribe', id, query });
+        }
+        else {
+            this.connect();
+        }
+        return id;
+    }
+    unsubscribe(id) {
+        if (this.subscriptions.has(id)) {
+            this.subscriptions.delete(id);
+            if (this.isConnected) {
+                this.send({ type: 'unsubscribe', id });
+            }
+        }
+    }
+    send(msg) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(msg));
+        }
+    }
+    handleMessage(msg) {
+        if (msg.type === 'data' && msg.id && msg.data) {
+            const sub = this.subscriptions.get(msg.id);
+            if (sub) {
+                sub.callback(msg.data);
+            }
+        }
+        else if (msg.type === 'error') {
+            console.error('CoreBase Realtime message error:', msg.error);
+        }
+    }
+    resubscribeAll() {
+        this.subscriptions.forEach((sub, id) => {
+            this.send({ type: 'subscribe', id, query: sub.query });
+        });
+    }
+    scheduleReconnect() {
+        if (!this.reconnectTimer) {
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnectTimer = null;
+                this.connect();
+            }, 3000);
+        }
+    }
+}
+exports.RealtimeClient = RealtimeClient;

package/dist/storage.d.ts

@@ -0,0 +1,19 @@
+import { AuthClient } from './auth';
+import { ClientResponse } from './types';
+export declare class StorageClient {
+    private auth;
+    constructor(auth: AuthClient);
+    /**
+     * Uploads a file to the storage bucket.
+     * This involves two steps:
+     * 1. Getting a signed upload URL from the API.
+     * 2. Uploading the file content directly to the cloud storage provider via the signed URL.
+     *
+     * @param file The File object to upload.
+     * @returns The key of the uploaded file.
+     */
+    upload(file: File): Promise<ClientResponse<{
+        key: string;
+        url: string;
+    }>>;
+}

package/dist/storage.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageClient = void 0;
+class StorageClient {
+    constructor(auth) {
+        this.auth = auth;
+    }
+    /**
+     * Uploads a file to the storage bucket.
+     * This involves two steps:
+     * 1. Getting a signed upload URL from the API.
+     * 2. Uploading the file content directly to the cloud storage provider via the signed URL.
+     *
+     * @param file The File object to upload.
+     * @returns The key of the uploaded file.
+     */
+    upload(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Get Signed URL
+            const { data: signData, error: signError } = yield this.auth.request('/storage/upload/sign', {
+                method: 'POST',
+                body: JSON.stringify({
+                    filename: file.name,
+                    contentType: file.type,
+                    size: file.size,
+                }),
+            });
+            if (signError) {
+                return { data: null, error: signError };
+            }
+            if (!signData) {
+                return { data: null, error: { message: 'Failed to retrieve signed upload URL.' } };
+            }
+            try {
+                // 2. Upload File to Signed URL
+                const uploadResponse = yield fetch(signData.uploadUrl, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': file.type,
+                    },
+                    body: file,
+                });
+                if (!uploadResponse.ok) {
+                    return {
+                        data: null,
+                        error: {
+                            message: `File upload failed with status ${uploadResponse.status}: ${uploadResponse.statusText}`
+                        }
+                    };
+                }
+                // Return success with the key. 
+                // The URL returned by sign is the upload URL (often with SAS/Signature params).
+                // Users typically store the 'key' to reference the file later.
+                return {
+                    data: {
+                        key: signData.key,
+                        url: signData.uploadUrl // Returning the upload URL might be useful for immediate access if it's still valid/public-read
+                    },
+                    error: null
+                };
+            }
+            catch (err) {
+                return { data: null, error: { message: err.message || 'Network error during file upload.' } };
+            }
+        });
+    }
+}
+exports.StorageClient = StorageClient;

package/dist/types.d.ts

@@ -15,7 +15,7 @@ export interface ApiResponse<T> {
     data?: T;
     error?: {
         message: string;
-        code: string;
+        code?: string;
         details?: string;
     };
 }
@@ -23,3 +23,12 @@ export interface ClientConfig {
     apiKey: string;
     baseUrl?: string;
 }
+export interface ClientResponse<T> {
+    data: T | null;
+    error: {
+        message: string;
+        code?: string;
+        details?: string;
+    } | null;
+    count?: number | null;
+}

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "corebase-js",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "JavaScript client for CoreBase",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./react": "./dist/react.js"
+  },
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"
@@ -20,6 +24,16 @@
   "license": "ISC",
   "type": "commonjs",
   "devDependencies": {
+    "@types/react": "^19.2.10",
+    "react": "^19.2.4",
     "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
   }
 }