@e-techsolutions/e-baas-sdk 1.2.5 → 1.3.0

package/README.md

@@ -246,6 +246,221 @@ const query = ebaas.rpc("get_user_stats", {
 const { data, error } = await query.execute();
 ```
 
+### Advanced Filtering & Query Operators
+
+The E-BaaS SDK supports PostgREST-style operators for powerful filtering capabilities:
+
+#### Comparison Operators
+
+```typescript
+// Equality
+const users = await ebaas.from("users")
+  .select("*")
+  .eq("status", "active")  // status = 'active'
+  .execute();
+
+// Not equal
+const users = await ebaas.from("users")
+  .select("*")
+  .neq("status", "deleted")  // status != 'deleted'
+  .execute();
+
+// Greater than
+const users = await ebaas.from("users")
+  .select("*")
+  .gt("age", 18)  // age > 18
+  .execute();
+
+// Greater than or equal
+const users = await ebaas.from("users")
+  .select("*")
+  .gte("created_at", "2024-01-01")  // created_at >= '2024-01-01'
+  .execute();
+
+// Less than
+const users = await ebaas.from("users")
+  .select("*")
+  .lt("age", 65)  // age < 65
+  .execute();
+
+// Less than or equal
+const users = await ebaas.from("users")
+  .select("*")
+  .lte("updated_at", "2024-12-31")  // updated_at <= '2024-12-31'
+  .execute();
+```
+
+#### Text Search Operators
+
+```typescript
+// Case-sensitive pattern matching
+const users = await ebaas.from("users")
+  .select("*")
+  .like("name", "%John%")  // name LIKE '%John%'
+  .execute();
+
+// Case-insensitive pattern matching
+const users = await ebaas.from("users")
+  .select("*")
+  .ilike("email", "%@gmail.com")  // email ILIKE '%@gmail.com'
+  .execute();
+```
+
+#### Null Checks
+
+```typescript
+// Check for null values
+const users = await ebaas.from("users")
+  .select("*")
+  .is("deleted_at", null)  // deleted_at IS NULL
+  .execute();
+```
+
+#### Multiple Filters on Same Field
+
+**NEW**: You can now apply multiple filters to the same field for range queries:
+
+```typescript
+// Date range filtering (multiple filters on same field)
+const expenses = await ebaas.from("expenses")
+  .select("id, user_id, description, amount, due_date")
+  .eq("user_id", "7a79cc66-140e-41e0-9bde-ba51e338adac")
+  .gte("due_date", "2025-11-01")  // due_date >= '2025-11-01'
+  .lt("due_date", "2025-12-01")   // due_date < '2025-12-01'
+  .order("due_date", { ascending: true })
+  .execute();
+
+// Numeric range filtering
+const products = await ebaas.from("products")
+  .select("*")
+  .gte("price", 100)    // price >= 100
+  .lte("price", 500)    // price <= 500
+  .execute();
+
+// Age range
+const users = await ebaas.from("users")
+  .select("*")
+  .gt("age", 18)        // age > 18
+  .lt("age", 65)        // age < 65
+  .execute();
+```
+
+#### Combining Multiple Filters
+
+```typescript
+// Multiple conditions (AND logic)
+const activeUsers = await ebaas.from("users")
+  .select("id, name, email, status, created_at")
+  .eq("status", "active")
+  .gte("created_at", "2024-01-01")
+  .ilike("email", "%@company.com")
+  .order("created_at", { ascending: false })
+  .limit(50)
+  .execute();
+
+// Complex date and status filtering
+const recentExpenses = await ebaas.from("expenses")
+  .select("*")
+  .eq("status", "pending")
+  .gte("due_date", "2025-11-01")
+  .lt("due_date", "2025-12-01")
+  .gt("amount", 0)
+  .order("due_date", { ascending: true })
+  .execute();
+```
+
+#### Ordering and Pagination
+
+```typescript
+// Single column ordering
+const users = await ebaas.from("users")
+  .select("*")
+  .order("created_at", { ascending: false })  // ORDER BY created_at DESC
+  .execute();
+
+// Multiple column ordering
+const expenses = await ebaas.from("expenses")
+  .select("*")
+  .order("due_date", { ascending: true })
+  .order("created_at", { ascending: false })  // Secondary sort
+  .execute();
+
+// Pagination
+const users = await ebaas.from("users")
+  .select("*")
+  .order("id", { ascending: true })
+  .range(0, 9)    // LIMIT 10 OFFSET 0 (first 10 records)
+  .execute();
+
+const nextPage = await ebaas.from("users")
+  .select("*")
+  .order("id", { ascending: true })
+  .range(10, 19)  // LIMIT 10 OFFSET 10 (next 10 records)
+  .execute();
+```
+
+#### Performance Tips
+
+```typescript
+// Select only needed columns for better performance
+const users = await ebaas.from("users")
+  .select("id, name, email")  // Instead of select("*")
+  .eq("status", "active")
+  .limit(100)
+  .execute();
+
+// Use indexes for filtering - ensure your database has indexes on:
+// - Frequently filtered columns (status, user_id, etc.)
+// - Date columns used in range queries (created_at, due_date, etc.)
+// - Foreign keys (user_id, category_id, etc.)
+```
+
+#### Query Builder Pattern
+
+```typescript
+// Build queries conditionally
+let query = ebaas.from("expenses")
+  .select("id, description, amount, due_date, status");
+
+// Add filters conditionally
+if (userId) {
+  query = query.eq("user_id", userId);
+}
+
+if (startDate) {
+  query = query.gte("due_date", startDate);
+}
+
+if (endDate) {
+  query = query.lt("due_date", endDate);
+}
+
+if (status) {
+  query = query.eq("status", status);
+}
+
+// Execute the final query
+const { data, error } = await query
+  .order("due_date", { ascending: true })
+  .limit(100)
+  .execute();
+```
+
+#### Raw SQL Queries
+
+For complex queries beyond the query builder, use RPC functions:
+
+```typescript
+// Create a stored procedure for complex filtering
+const query = ebaas.rpc("get_expenses_by_date_range", {
+  p_user_id: "7a79cc66-140e-41e0-9bde-ba51e338adac",
+  p_start_date: "2025-11-01",
+  p_end_date: "2025-12-01",
+  p_status: "pending"
+});
+const { data, error } = await query.execute();
+```
+
 ### Custom Database
 
 ```typescript

package/dist/index.cjs

@@ -139,6 +139,9 @@ class HttpClient {
             throw this.handleError(error);
         }
     }
+    getBaseUrl() {
+        return this.baseURL;
+    }
     setAuthToken(token) {
         this.client.defaults.headers.common['Authorization'] = `Bearer ${token}`;
     }
@@ -164,16 +167,9 @@ class AuthClient {
     async signUp(data) {
         try {
             const headers = {};
-            console.log('🔍 [SDK DEBUG] SignUp - workspaceId:', this.workspaceId);
-            // Incluir x-workspace-id se workspaceId foi fornecido (igual ao signIn)
             if (this.workspaceId) {
                 headers['x-workspace-id'] = this.workspaceId;
-                console.log('✅ [SDK DEBUG] SignUp - header x-workspace-id adicionado:', this.workspaceId);
-            }
-            else {
-                console.log('❌ [SDK DEBUG] SignUp - workspaceId é undefined, header não adicionado');
             }
-            console.log('🔍 [SDK DEBUG] SignUp - headers finais:', headers);
             const payload = this.buildSignUpPayload(data);
             const response = await this.httpClient.post('/auth/v1/signup', payload, {
                 headers
@@ -181,6 +177,16 @@ class AuthClient {
             if (response.data.session) {
                 this.setSessionInternal(response.data.session);
             }
+            // autoSignIn: if requested and no session returned by signUp, automatically sign in
+            if (data.autoSignIn && !response.data.session) {
+                try {
+                    const signInResponse = await this.signIn({ email: data.email, password: data.password });
+                    return signInResponse;
+                }
+                catch (_) {
+                    // If auto sign-in fails, still return the original signUp response
+                }
+            }
             return response.data;
         }
         catch (error) {
@@ -382,6 +388,16 @@ class AuthClient {
         return new EBaaSError(error.message || 'Authentication failed', error.status || 0, error);
     }
 }
+/**
+ * Returns session expiration as milliseconds timestamp.
+ * Handles both seconds and milliseconds formats from the API.
+ */
+function getExpiresAtMs(session) {
+    if (typeof session.expires_at === 'number' && session.expires_at < 1e12) {
+        return session.expires_at * 1000; // seconds -> ms
+    }
+    return Number(session.expires_at); // already ms
+}
 
 class QueryBuilder {
     constructor(httpClient, table, schema, workspaceId, restUrl) {
@@ -399,7 +415,9 @@ class QueryBuilder {
         return this;
     }
     insert(data, options) {
-        return this.executeQuery('POST', `${this.restUrl}/${this.table}?operation=insert`, { data, options });
+        this.query.insertData = data;
+        this.query.insertOptions = options;
+        return this;
     }
     update(data, options) {
         this.query.updateData = data;
@@ -491,7 +509,14 @@ class QueryBuilder {
     // Execution method for SELECT, UPDATE, or DELETE
     async execute() {
         // Detectar tipo de operação baseado nos dados do query
-        if (this.query.updateData) {
+        if (this.query.insertData) {
+            // INSERT operation
+            return this.executeQuery('POST', `${this.restUrl}/${this.table}?operation=insert`, {
+                data: this.query.insertData,
+                options: this.query.insertOptions
+            });
+        }
+        else if (this.query.updateData) {
             // UPDATE operation
             return this.executeQuery('PATCH', `${this.restUrl}/${this.table}`, {
                 data: this.query.updateData,
@@ -517,6 +542,9 @@ class QueryBuilder {
             });
         }
     }
+    then(onfulfilled, onrejected) {
+        return this.execute().then(onfulfilled, onrejected);
+    }
     // Single row execution
     async single() {
         this.limit(1);
@@ -578,9 +606,6 @@ class QueryBuilder {
                     });
                 }
                 const deleteUrl = `${baseUrl}?${existingParams.toString()}`;
-                console.log('🔧 DELETE URL construída:', deleteUrl);
-                console.log('🔧 DELETE headers:', headers);
-                console.log('🔧 DELETE filtros originais:', payload.filters);
                 response = await this.httpClient.delete(deleteUrl, { headers });
             }
             else if (method === 'PATCH') {
@@ -1916,8 +1941,13 @@ class RealtimeClient {
 }
 
 class FunctionsClient {
-    constructor(httpClient) {
+    constructor(httpClient, workspaceId, defaultUnwrap = false) {
         this.httpClient = httpClient;
+        this.workspaceId = workspaceId;
+        this.defaultUnwrap = defaultUnwrap;
+    }
+    setWorkspaceId(workspaceId) {
+        this.workspaceId = workspaceId;
     }
     async invoke(functionName, options) {
         try {
@@ -1926,33 +1956,43 @@ class FunctionsClient {
                 'Content-Type': 'application/json',
                 ...options?.headers
             };
+            if (this.workspaceId) {
+                headers['x-workspace-id'] = this.workspaceId;
+            }
             let response;
-            const url = `/functions/v1/${functionName}`;
+            const url = `/functions/v1/${functionName}/invoke`;
+            const config = { headers, timeout: 120000 };
             switch (method.toUpperCase()) {
                 case 'GET':
                     response = await this.httpClient.get(url, {
-                        headers,
+                        ...config,
                         params: options?.body
                     });
                     break;
                 case 'POST':
-                    response = await this.httpClient.post(url, options?.body, { headers });
+                    response = await this.httpClient.post(url, options?.body, config);
                     break;
                 case 'PUT':
-                    response = await this.httpClient.put(url, options?.body, { headers });
+                    response = await this.httpClient.put(url, options?.body, config);
                     break;
                 case 'PATCH':
-                    response = await this.httpClient.patch(url, options?.body, { headers });
+                    response = await this.httpClient.patch(url, options?.body, config);
                     break;
                 case 'DELETE':
                     response = await this.httpClient.delete(url, {
-                        headers,
+                        ...config,
                         data: options?.body
                     });
                     break;
                 default:
                     throw new EBaaSError(`Unsupported HTTP method: ${method}`, 400);
             }
+            const shouldUnwrap = options?.unwrap ?? this.defaultUnwrap;
+            if (shouldUnwrap) {
+                const raw = response.data;
+                const unwrapped = raw?.data?.body ?? raw?.body ?? raw;
+                return { data: unwrapped, error: null };
+            }
             return {
                 data: response.data,
                 error: null
@@ -1965,6 +2005,51 @@ class FunctionsClient {
             };
         }
     }
+    async invokeExternal(functionName, options) {
+        try {
+            const baseUrl = this.httpClient.getBaseUrl();
+            const method = (options.method || 'POST').toUpperCase();
+            const url = `${baseUrl}/functions/v1/public/${functionName}?workspaceId=${options.workspaceId}`;
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-api-key': options.apiKey,
+                'x-workspace-id': options.workspaceId,
+            };
+            let response;
+            const config = { headers, timeout: 120000 };
+            switch (method) {
+                case 'GET':
+                    response = await this.httpClient.get(url, { ...config, params: options.body });
+                    break;
+                case 'POST':
+                    response = await this.httpClient.post(url, options.body, config);
+                    break;
+                case 'PUT':
+                    response = await this.httpClient.put(url, options.body, config);
+                    break;
+                case 'PATCH':
+                    response = await this.httpClient.patch(url, options.body, config);
+                    break;
+                case 'DELETE':
+                    response = await this.httpClient.delete(url, { ...config, data: options.body });
+                    break;
+                default:
+                    throw new EBaaSError(`Unsupported HTTP method: ${method}`, 400);
+            }
+            if (options.unwrap) {
+                const raw = response.data;
+                const unwrapped = raw?.data?.body ?? raw?.body ?? raw;
+                return { data: unwrapped, error: null };
+            }
+            return { data: response.data, error: null };
+        }
+        catch (error) {
+            return {
+                data: null,
+                error: error instanceof EBaaSError ? error : new EBaaSError(error instanceof Error ? error.message : 'External function invocation failed', 0, error)
+            };
+        }
+    }
     async list() {
         try {
             const response = await this.httpClient.get('/functions/v1');
@@ -2126,7 +2211,7 @@ class EBaaSClient {
         this.database = new DatabaseClient(this.httpClient, options?.database?.workspaceId, options?.rest?.url);
         this.storage = new StorageClient(this.httpClient, options?.database?.workspaceId);
         this.realtime = new RealtimeClient(supabaseUrl, supabaseKey, options?.realtime);
-        this.functions = new FunctionsClient(this.httpClient);
+        this.functions = new FunctionsClient(this.httpClient, options?.database?.workspaceId, options?.functions?.defaultUnwrap);
         // Initialize custom database detection if enabled
         this.initializeCustomDatabase();
     }
@@ -2150,6 +2235,19 @@ class EBaaSClient {
     invoke(functionName, options) {
         return this.functions.invoke(functionName, options);
     }
+    /**
+     * Creates a new EBaaSClient instance configured for a different workspace.
+     * Reuses the same base URL.
+     */
+    forWorkspace(workspaceId, apiKey) {
+        return new EBaaSClient(this.httpClient.getBaseUrl(), apiKey, {
+            ...this.options,
+            database: {
+                ...this.options?.database,
+                workspaceId,
+            },
+        });
+    }
     /**
      * Inicializa a detecção automática de banco customizado
      */
@@ -2170,6 +2268,7 @@ class EBaaSClient {
         this.auth.setWorkspaceId(workspaceId);
         this.database.setWorkspaceId(workspaceId);
         this.storage.setWorkspaceId(workspaceId);
+        this.functions.setWorkspaceId(workspaceId);
         // Se auto-detecção estiver habilitada, re-detecta configuração para o novo workspace
         if (this.options?.database?.autoDetectCustomDatabase) {
             await this.database.initialize();
@@ -2195,7 +2294,7 @@ function createClient(supabaseUrl, supabaseKey, options) {
 
 // Main client export
 // Version
-const version = "1.1.8";
+const version = "1.3.0";
 
 exports.AuthClient = AuthClient;
 exports.CustomDatabaseManager = CustomDatabaseManager;
@@ -2210,5 +2309,6 @@ exports.RealtimeClient = RealtimeClient;
 exports.StorageBucket = StorageBucket;
 exports.StorageClient = StorageClient;
 exports.createClient = createClient;
+exports.getExpiresAtMs = getExpiresAtMs;
 exports.version = version;
 //# sourceMappingURL=index.cjs.map