corebase-js 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # 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
 
@@ -10,60 +10,181 @@ npm install corebase-js
 
 ## 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);
+```
+
+## 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,10 @@
 import { AuthClient } from './auth';
+import { QueryBuilder } from './query';
 import { ClientConfig } from './types';
 export declare class CoreBaseClient {
     auth: AuthClient;
     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,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoreBaseClient = void 0;
 exports.createClient = createClient;
 const auth_1 = require("./auth");
+const query_1 = require("./query");
 class CoreBaseClient {
     constructor(config) {
         if (!config.apiKey) {
@@ -14,6 +15,9 @@ class CoreBaseClient {
         this.config = config;
         this.auth = new auth_1.AuthClient(config);
     }
+    from(table) {
+        return new query_1.QueryBuilder((path, options) => this.auth.request(path, options), table);
+    }
 }
 exports.CoreBaseClient = CoreBaseClient;
 function createClient(baseUrl, apiKey) {

package/dist/index.d.ts

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

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./client"), exports);
 __exportStar(require("./auth"), exports);
+__exportStar(require("./query"), 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/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,6 +1,6 @@
 {
   "name": "corebase-js",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "JavaScript client for CoreBase",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",