@taruvi/sdk 1.1.6 → 1.1.8

package/README.md

@@ -1,703 +1,1328 @@
-# Taruvi SDK
+# Taruvi SDK - AI Implementation Guide
 
-> A TypeScript SDK for the Taruvi Platform - Backend-as-a-Service for modern applications
+> Quick reference for implementing Taruvi SDK features with copy-paste examples from production code
 
-[![Version](https://img.shields.io/badge/version-1.1.0-blue.svg)]() [![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue.svg)]() [![License](https://img.shields.io/badge/license-MIT-green.svg)]()
+## Installation
 
-## Overview
+```bash
+npm install @taruvi/sdk
+```
 
-Taruvi SDK is a type-safe client library that enables JavaScript/TypeScript applications to interact with the Taruvi Backend-as-a-Service platform. It provides a clean, intuitive API for authentication, user management, data storage, and serverless functions.
+## What's New
 
-### Key Features
+Recent updates to the SDK:
 
-- **Modern Architecture** - Dependency injection pattern, no singletons
-- **Type-Safe** - Full TypeScript support with strict typing
-- **Lazy Loading** - Only bundle the services you use
-- **Tree-Shakeable** - Optimized for minimal bundle size
-- **Testable** - Easy to mock and test with dependency injection
-- **Flexible** - Support for multiple instances and configurations
-- **Multi-Tenant** - Manage multiple apps under a single site
+- **Analytics Service**: New service for executing analytics queries with `execute()` method. Pass query name and parameters to run predefined analytics.
+- **Policy Service**: New service for checking resource-level permissions with `checkResource()` method. Supports batch resource checking with entity types, tables, and attributes.
+- **App Service**: New service to retrieve app roles with `roles()` method.
+- **User Types**: Added `UserCreateRequest`, `UserResponse`, and `UserDataResponse` types for user management.
+- **Auth Service**: Web UI Flow with `login()`, `signup()`, `logout()` methods that redirect to backend pages. Token refresh with rotation support, `getCurrentUser()` for JWT decoding.
+- **Database Service**: Added `create()` method for creating records. Added `populate()` method for eager loading related records. Comprehensive filter support with Django-style operators (`__gte`, `__lte`, `__icontains`, etc.).
+- **Storage Service**: Added `download()` method. Enhanced filter support with size, date, MIME type, visibility filters. `delete()` now accepts array of paths for bulk deletion.
+- **Client**: Automatic token extraction from URL hash after OAuth callback - no manual token handling needed.
+- **Types**: Comprehensive `StorageFilters` and `DatabaseFilters` interfaces with full operator support.
 
----
+## Core Setup
 
-## Installation
+### 1. Initialize Client
 
-```bash
-npm install @taruvi/sdk
-# or
-yarn add @taruvi/sdk
-# or
-pnpm add @taruvi/sdk
-```
+```typescript
+import { Client } from '@taruvi/sdk'
 
----
+const taruviClient = new Client({
+  apiKey: "your-site-api-key",
+  appSlug: "your-app-slug", 
+  baseUrl: "https://taruvi-site.taruvi.cloud"
+})
+```
 
-## Quick Start
+### 2. Pass to Components (React)
 
 ```typescript
-import { Client, Auth, User } from '@taruvi/sdk'
+// App.tsx
+<Route path="/page" element={<MyPage taruviClient={taruviClient} />} />
 
-// 1. Create the main client
-const client = new Client({
-  apiKey: 'your-site-api-key',
-  appSlug: 'my-app',
-  baseUrl: 'https://test-api.taruvi.cloud'
-})
+// MyPage.tsx
+interface MyPageProps {
+  taruviClient: Client;
+}
 
-// 2. Initialize only the services you need
-const auth = new Auth(client)
-const user = new User(client)
+export default function MyPage({ taruviClient }: MyPageProps) {
+  // Use SDK here
+}
+```
 
-// 3. Use the services
-await auth.authenticateUser()
-const userData = await user.getUserData()
-console.log(userData.username)
+### 3. Automatic Token Handling
+
+The Client automatically extracts authentication tokens from URL hash after OAuth callback:
+
+```typescript
+// After login redirect, URL contains:
+// #session_token=xxx&access_token=yyy&refresh_token=zzz&expires_in=172800&token_type=Bearer
+
+// Client automatically:
+// 1. Extracts tokens from URL hash
+// 2. Stores them in TokenClient
+// 3. Clears the hash from URL
+
+const taruviClient = new Client({ apiKey, appSlug, baseUrl })
+// Tokens are now available automatically if present in URL hash
 ```
 
 ---
 
-## Core Concepts
+## Auth Service
 
-### Dependency Injection Pattern
-
-Taruvi SDK uses dependency injection instead of singletons, allowing multiple client instances and better testability.
+### Check Authentication
 
 ```typescript
-// Multiple environments
-const prodClient = new Client({ apiKey: '...', appSlug: 'prod', baseUrl: '...' })
-const devClient = new Client({ apiKey: '...', appSlug: 'dev', baseUrl: '...' })
+import { Auth } from '@taruvi/sdk'
 
-// Services use the client they're given
-const prodUser = new User(prodClient)
-const devUser = new User(devClient)
+const auth = new Auth(taruviClient)
+const isAuthenticated = auth.isUserAuthenticated() // Returns boolean (synchronous)
 ```
 
-### Lazy Service Instantiation
-
-Services are manually instantiated, allowing tree-shaking to eliminate unused code.
+### Login Flow (Web UI Flow with Redirect)
 
 ```typescript
-// Only import what you need
-import { Client, User } from '@taruvi/sdk'  // ✅ Auth not bundled
+import { useEffect } from "react"
+import { Auth } from '@taruvi/sdk'
+
+export default function Login({ taruviClient }) {
+  const auth = new Auth(taruviClient)
+
+  useEffect(() => {
+    const isAuthenticated = auth.isUserAuthenticated()
+
+    if (isAuthenticated) {
+      window.location.href = "/dashboard"
+    } else {
+      // Redirects to backend login page, then returns with tokens in URL hash
+      auth.login() // Optional: pass callback URL
+    }
+  }, [])
 
-const client = new Client({ /* config */ })
-const user = new User(client)  // Only User service loaded
+  return <div>Checking authentication...</div>
+}
 ```
 
-### Multi-Tenancy Support
+### Signup Flow
+
+```typescript
+import { Auth } from '@taruvi/sdk'
+
+const auth = new Auth(taruviClient)
 
-Single site can manage multiple apps with isolated data using `appSlug`.
+// Redirect to signup page (Web UI Flow)
+auth.signup() // Optional: pass callback URL
+auth.signup("/dashboard") // Redirect to dashboard after signup
+```
+
+### Logout
 
 ```typescript
-const customerApp = new Client({
-  apiKey: 'site_abc123',      // Same site
-  appSlug: 'customer-portal', // Customer data
-  baseUrl: 'https://test-api.taruvi.cloud'
-})
+import { Auth } from '@taruvi/sdk'
 
-const adminApp = new Client({
-  apiKey: 'site_abc123',       // Same site
-  appSlug: 'admin-dashboard',  // Admin data (isolated)
-  baseUrl: 'https://test-api.taruvi.cloud'
-})
+const auth = new Auth(taruviClient)
+
+// Clear tokens and redirect to logout page
+await auth.logout() // Optional: pass callback URL
+await auth.logout("/") // Redirect to home after logout
 ```
 
----
+### Get Current User
 
-## Services
+```typescript
+import { Auth } from '@taruvi/sdk'
 
-### Auth Service
+const auth = new Auth(taruviClient)
 
-User authentication and session management.
+// Get user info from decoded JWT access token
+const user = auth.getCurrentUser()
+console.log(user?.user_id)
+console.log(user?.username)
+console.log(user?.email)
+```
 
-**Status**: 🚧 60% Complete
+### Token Management
 
 ```typescript
-import { Client, Auth } from '@taruvi/sdk'
+import { Auth } from '@taruvi/sdk'
 
-const client = new Client({ /* config */ })
-const auth = new Auth(client)
+const auth = new Auth(taruviClient)
 
-// Authenticate user
-await auth.authenticateUser()
+// Get tokens
+const accessToken = auth.getAccessToken()
+const refreshToken = auth.getRefreshToken()
 
-// Check authentication status
-const isAuth = await auth.isUserAuthenticated()  // true/false
-```
+// Check if token is expired
+const isExpired = auth.isTokenExpired()
 
-#### Available Methods
-- ✅ `authenticateUser()` - Login with email/password
-- ✅ `isUserAuthenticated()` - Check if user has valid session
-- 📋 `signInWithSSO()` - SSO authentication (planned)
-- 📋 `refreshSession()` - Refresh expired token (planned)
-- 📋 `signOut()` - End user session (planned)
+// Refresh access token (returns new access AND refresh tokens due to rotation)
+const newTokens = await auth.refreshAccessToken()
+if (newTokens) {
+  console.log(newTokens.access)
+  console.log(newTokens.refresh)
+  console.log(newTokens.expires_in)
+}
+```
 
 ---
 
-### User Service
-
-User profile and management operations.
+## User Service
 
-**Status**: ✅ 80% Complete (CRUD functional)
+### Get Current User
 
 ```typescript
-import { Client, User } from '@taruvi/sdk'
-
-const client = new Client({ /* config */ })
-const user = new User(client)
+import { User } from '@taruvi/sdk'
 
-// Get current user
+const user = new User(taruviClient)
 const userData = await user.getUserData()
 
-// Create new user
+console.log(userData.data.username)
+console.log(userData.data.email)
+console.log(userData.data.full_name)
+```
+
+### Create User (Registration)
+
+```typescript
+import { User } from '@taruvi/sdk'
+
+const user = new User(taruviClient)
+
 const newUser = await user.createUser({
-  username: 'john_doe',
-  email: 'john@example.com',
-  password: 'secure123'
+  username: "john_doe",
+  email: "john@example.com",
+  password: "secure123",
+  confirm_password: "secure123",
+  first_name: "John",
+  last_name: "Doe",
+  is_active: true,
+  is_staff: false,
+  attributes: ""
 })
+```
 
-// Update user
-await user.updateUser('john_doe', {
-  email: 'newemail@example.com'
-})
+### Update User
+
+```typescript
+const user = new User(taruviClient)
 
-// Delete user
-await user.deleteUser('john_doe')
+await user.updateUser("john_doe", {
+  email: "newemail@example.com",
+  first_name: "Johnny"
+})
 ```
 
-#### Available Methods
-- ✅ `getUserData()` - Fetch current user details
-- ✅ `createUser(data)` - Create new user account
-- ✅ `updateUser(username, data)` - Update user information
-- ✅ `deleteUser(username)` - Delete user account
+### Delete User
 
----
+```typescript
+const user = new User(taruviClient)
+await user.deleteUser("john_doe")
+```
 
-### Storage Service
+### List Users
 
-Query builder for app-specific data tables.
+```typescript
+const user = new User(taruviClient)
+
+const users = await user.list({
+  search: "john",
+  is_active: true,
+  is_staff: false,
+  is_superuser: false,
+  is_deleted: false,
+  ordering: "-date_joined",
+  page: 1,
+  page_size: 20
+})
+```
 
-**Status**: 🚧 70% Complete (Query builder working)
+### Get User Apps
 
 ```typescript
-import { Client, Storage } from '@taruvi/sdk'
+const user = new User(taruviClient)
+const apps = await user.getUserApps("john_doe")
 
-const client = new Client({ /* config */ })
-const storage = new Storage(client, {})
+// Returns array of apps the user has access to
+apps.forEach(app => {
+  console.log(app.name, app.slug, app.url)
+})
+```
 
-// Get all records from a table
-const allPosts = await storage
-  .from('posts')
-  .execute()
+### Complete Registration Form Example
 
-// Get specific record
-const post = await storage
-  .from('posts')
-  .get('post_123')
-  .execute()
-```
+```typescript
+import { useState } from "react"
+import { User } from "@taruvi/sdk"
+import { useNavigate } from "react-router"
+
+export default function Register({ taruviClient }) {
+  const navigate = useNavigate()
+  const [formData, setFormData] = useState({
+    username: "",
+    email: "",
+    password: "",
+    confirm_password: "",
+    first_name: "",
+    last_name: "",
+    is_active: true,
+    is_staff: false
+  })
+  const [error, setError] = useState("")
+  const [loading, setLoading] = useState(false)
+
+  const handleSubmit = async (e) => {
+    e.preventDefault()
+    
+    if (formData.password !== formData.confirm_password) {
+      setError("Passwords do not match")
+      return
+    }
+
+    setLoading(true)
+    try {
+      const userClient = new User(taruviClient)
+      await userClient.createUser(formData)
+      navigate("/login")
+    } catch (err) {
+      setError(err.message || "Failed to create user")
+    } finally {
+      setLoading(false)
+    }
+  }
 
-#### Available Methods
-- ✅ `from(tableName)` - Select table (chainable)
-- ✅ `get(recordId)` - Select specific record (chainable)
-- ✅ `execute()` - Execute the built query
-- 📋 `upload()` - File upload (planned)
-- 📋 `download()` - File download (planned)
-- 📋 `delete()` - Delete files (planned)
+  return (
+    <form onSubmit={handleSubmit}>
+      <input
+        name="username"
+        value={formData.username}
+        onChange={(e) => setFormData({...formData, username: e.target.value})}
+        required
+      />
+      {/* Add other fields */}
+      <button type="submit" disabled={loading}>
+        {loading ? "Creating..." : "Register"}
+      </button>
+      {error && <div>{error}</div>}
+    </form>
+  )
+}
+```
 
 ---
 
-### Settings Service
+## Database Service (CRUD Operations)
 
-Site configuration and settings.
+### Fetch All Records
 
-**Status**: ✅ 70% Complete
+```typescript
+import { Database } from '@taruvi/sdk'
+
+const db = new Database(taruviClient)
+const response = await db.from("accounts").execute()
+
+if (response.data) {
+  console.log(response.data) // Array of records
+}
+```
+
+### Fetch Single Record
 
 ```typescript
-import { Client, Settings } from '@taruvi/sdk'
+const db = new Database(taruviClient)
+const record = await db.from("accounts").get("record-id").execute()
+```
 
-const client = new Client({ /* config */ })
-const settings = new Settings(client)
+### Create Record
 
-// Fetch site configuration
-const siteConfig = await settings.get()
-console.log(siteConfig.site_slug)
+```typescript
+const db = new Database(taruviClient)
+await db.from("accounts").create({
+  name: "John Doe",
+  email: "john@example.com",
+  status: "active"
+}).execute()
 ```
 
----
+### Update Record
+
+```typescript
+const db = new Database(taruviClient)
+await db.from("accounts").get("record-id").update({
+  name: "Updated Name",
+  status: "active"
+}).execute()
+```
 
-### Database Service (Planned)
+### Delete Record
 
-Query builder for database operations.
+```typescript
+const db = new Database(taruviClient)
+await db.from("accounts").delete("record-id").execute()
+```
 
-**Status**: 📋 Not Implemented
+### Filter Records
 
 ```typescript
-import { Client, Database } from '@taruvi/sdk'
+const db = new Database(taruviClient)
+
+// Simple field filters
+const filtered = await db
+  .from("accounts")
+  .filter({
+    status: "active",
+    country: "USA"
+  })
+  .execute()
 
-const client = new Client({ /* config */ })
-const database = new Database(client)
+// Advanced filters with operators
+const advanced = await db
+  .from("accounts")
+  .filter({
+    age__gte: 18,           // age >= 18
+    age__lt: 65,            // age < 65
+    name__icontains: "john", // case-insensitive contains
+    created_at__gte: "2024-01-01",
+    ordering: "-created_at"  // Sort by created_at descending
+  })
+  .execute()
 
-// Planned API (not yet functional)
-const users = await database
-  .from('users')
-  .select('*')
-  .filter('age', 'gte', 18)
+// Pagination
+const paginated = await db
+  .from("accounts")
+  .filter({
+    page: 1,
+    pageSize: 20
+  })
   .execute()
 ```
 
----
+### Populate Related Records
 
-### Functions Service (Planned)
+Use `populate()` to eager load related records (foreign key relationships):
 
-Serverless function invocation.
+```typescript
+const db = new Database(taruviClient)
+
+// Populate a single relation
+const orders = await db
+  .from("orders")
+  .populate(["customer"])
+  .execute()
+
+// Each order now includes the full customer object instead of just the ID
+console.log(orders.data[0].customer.name)
+console.log(orders.data[0].customer.email)
+
+// Populate multiple relations
+const invoices = await db
+  .from("invoices")
+  .populate(["customer", "created_by", "items"])
+  .execute()
+
+// Combine with filters
+const recentOrders = await db
+  .from("orders")
+  .filter({
+    status: "completed",
+    created_at__gte: "2024-01-01",
+    ordering: "-created_at"
+  })
+  .populate(["customer", "product"])
+  .execute()
+
+// Combine with pagination
+const paginatedOrders = await db
+  .from("orders")
+  .filter({ page: 1, pageSize: 10 })
+  .populate(["customer"])
+  .execute()
+```
 
-**Status**: 📋 Not Implemented
+### Complete CRUD Example (CRM Table)
 
 ```typescript
-import { Client, Functions } from '@taruvi/sdk'
+import { useEffect, useState } from 'react'
+import { Database } from '@taruvi/sdk'
+
+export default function CrmTable({ taruviClient }) {
+  const [contacts, setContacts] = useState([])
+
+  const fetchContacts = async () => {
+    const db = new Database(taruviClient)
+    const response = await db.from("accounts").execute()
+    if (response.data) {
+      setContacts(response.data)
+    }
+  }
+
+  useEffect(() => {
+    fetchContacts()
+  }, [])
+
+  const handleCreate = async (data) => {
+    const db = new Database(taruviClient)
+    await db.from("accounts").create(data).execute()
+    fetchContacts() // Refresh
+  }
 
-const client = new Client({ /* config */ })
-const functions = new Functions(client)
+  const handleDelete = async (id) => {
+    const db = new Database(taruviClient)
+    await db.from("accounts").delete(id).execute()
+    fetchContacts() // Refresh
+  }
 
-// Planned API (not yet functional)
-const result = await functions.invoke('my-function', { data: 'value' })
+  const handleUpdate = async (id, data) => {
+    const db = new Database(taruviClient)
+    await db.from("accounts").get(id).update(data).execute()
+    fetchContacts() // Refresh
+  }
+
+  return (
+    <div>
+      <button onClick={() => handleCreate({ name: 'New Contact', status: 'active' })}>
+        Add Contact
+      </button>
+      <table>
+        {contacts.map(contact => (
+          <tr key={contact.id}>
+            <td>{contact.name}</td>
+            <td>
+              <button onClick={() => handleUpdate(contact.id, { status: 'updated' })}>
+                Edit
+              </button>
+              <button onClick={() => handleDelete(contact.id)}>
+                Delete
+              </button>
+            </td>
+          </tr>
+        ))}
+      </table>
+    </div>
+  )
+}
 ```
 
 ---
 
-## Configuration
+## Storage Service (File Management)
+
+### List Files in Bucket
+
+```typescript
+import { Storage } from '@taruvi/sdk'
+
+const storage = new Storage(taruviClient)
+const files = await storage.from("documents").execute()
+
+console.log(files.data) // Array of file objects
+```
 
-### TaruviConfig Interface
+### Upload Files
 
 ```typescript
-interface TaruviConfig {
-  apiKey: string      // Required: Site/organization identifier
-  appSlug: string     // Required: App identifier (multi-tenant)
-  baseUrl: string     // Required: API endpoint URL
-  token?: string      // Optional: Pre-existing session token
+const storage = new Storage(taruviClient)
+
+const filesData = {
+  files: [file1, file2], // File objects from input
+  metadatas: [{ name: "file1" }, { name: "file2" }],
+  paths: ["file1.pdf", "file2.pdf"]
 }
+
+await storage.from("documents").upload(filesData).execute()
 ```
 
-### Configuration Examples
+### Download File
 
-#### Basic Setup
 ```typescript
-const client = new Client({
-  apiKey: 'your-site-key',
-  appSlug: 'my-app',
-  baseUrl: 'https://test-api.taruvi.cloud'
-})
+const storage = new Storage(taruviClient)
+const file = await storage.from("documents").download("path/to/file.pdf").execute()
 ```
 
-#### With Existing Token
+### Delete Files
+
 ```typescript
-const client = new Client({
-  apiKey: 'your-site-key',
-  appSlug: 'my-app',
-  baseUrl: 'https://test-api.taruvi.cloud',
-  token: 'existing-session-token'  // Skip login
-})
+const storage = new Storage(taruviClient)
+
+// Delete single file
+await storage.from("documents").delete(["path/to/file.pdf"]).execute()
+
+// Delete multiple files
+await storage.from("documents").delete([
+  "path/to/file1.pdf",
+  "path/to/file2.pdf",
+  "path/to/file3.pdf"
+]).execute()
 ```
 
-#### Multiple Environments
+### Update File Metadata
+
 ```typescript
-const config = {
-  production: {
-    apiKey: process.env.PROD_API_KEY!,
-    appSlug: 'prod-app',
-    baseUrl: 'https://api.taruvi.cloud'
-  },
-  development: {
-    apiKey: process.env.DEV_API_KEY!,
-    appSlug: 'dev-app',
-    baseUrl: 'https://dev-api.taruvi.cloud'
+const storage = new Storage(taruviClient)
+await storage
+  .from("documents")
+  .update("path/to/file.pdf", {
+    filename: "newname.pdf",
+    visibility: "public",
+    metadata: { category: "reports" }
+  })
+  .execute()
+```
+
+### Filter Files
+
+```typescript
+const storage = new Storage(taruviClient)
+
+// Basic filters
+const filtered = await storage
+  .from("documents")
+  .filter({
+    search: "invoice",
+    visibility: "public",
+    mimetype_category: "document",
+    min_size: 1024,
+    ordering: "-created_at"
+  })
+  .execute()
+
+// Advanced filters with operators
+const advanced = await storage
+  .from("documents")
+  .filter({
+    // Size filters (bytes)
+    size__gte: 1024,           // >= 1KB
+    size__lte: 10485760,       // <= 10MB
+
+    // Date filters (ISO 8601)
+    created_at__gte: "2024-01-01",
+    created_at__lte: "2024-12-31",
+
+    // Search filters
+    filename__icontains: "report",
+    file__startswith: "invoice",
+    prefix: "uploads/2024/",
+
+    // MIME type filters
+    mimetype: "application/pdf",
+    mimetype_category: "image",  // image, document, video, audio, etc.
+
+    // Visibility & user filters
+    visibility: "public",
+    created_by_me: true,
+    created_by__username: "john",
+
+    // Pagination & sorting
+    page: 1,
+    pageSize: 50,
+    ordering: "-created_at"  // Sort by created_at descending
+  })
+  .execute()
+```
+
+### Complete File Upload Example
+
+```typescript
+import { useState, useRef } from 'react'
+import { Storage } from '@taruvi/sdk'
+
+export default function FileUploader({ taruviClient }) {
+  const [files, setFiles] = useState([])
+  const [uploading, setUploading] = useState(false)
+  const fileInputRef = useRef(null)
+
+  const handleFileSelect = (e) => {
+    const selectedFiles = Array.from(e.target.files)
+    setFiles(selectedFiles)
   }
-}
 
-const client = new Client(
-  process.env.NODE_ENV === 'production'
-    ? config.production
-    : config.development
-)
+  const uploadFiles = async () => {
+    if (files.length === 0) return
+
+    setUploading(true)
+    try {
+      const storage = new Storage(taruviClient)
+
+      const uploadData = {
+        files: files,
+        metadatas: files.map(f => ({ name: f.name })),
+        paths: files.map(f => f.name)
+      }
+
+      await storage.from("documents").upload(uploadData).execute()
+
+      alert("Upload successful!")
+      setFiles([])
+    } catch (error) {
+      alert("Upload failed: " + error.message)
+    } finally {
+      setUploading(false)
+    }
+  }
+
+  return (
+    <div>
+      <input
+        ref={fileInputRef}
+        type="file"
+        multiple
+        onChange={handleFileSelect}
+      />
+      <button onClick={uploadFiles} disabled={uploading || files.length === 0}>
+        {uploading ? "Uploading..." : `Upload ${files.length} file(s)`}
+      </button>
+    </div>
+  )
+}
 ```
 
 ---
 
-## Framework Integration
+## Functions Service (Serverless)
+
+### Execute Function (Sync)
+
+```typescript
+import { Functions } from '@taruvi/sdk'
+
+const functions = new Functions(taruviClient)
 
-### React
+const result = await functions.execute("my-function", {
+  async: false,
+  params: {
+    key1: "value1",
+    key2: 123
+  }
+})
+
+console.log(result.data) // Function response
+```
 
-Create context and custom hooks for app-wide access.
+### Execute Function (Async)
 
 ```typescript
-import { createContext, useContext, ReactNode } from 'react'
-import { Client, User, Auth } from '@taruvi/sdk'
+const functions = new Functions(taruviClient)
 
-// Create context
-const TaruviContext = createContext<Client | null>(null)
+const result = await functions.execute("long-running-task", {
+  async: true,
+  params: { data: "value" }
+})
 
-// Provider component
-export function TaruviProvider({ children }: { children: ReactNode }) {
-  const client = new Client({
-    apiKey: process.env.REACT_APP_TARUVI_API_KEY!,
-    appSlug: process.env.REACT_APP_TARUVI_APP_SLUG!,
-    baseUrl: process.env.REACT_APP_TARUVI_BASE_URL!
-  })
+console.log(result.invocation.invocation_id) // Track async execution
+console.log(result.invocation.celery_task_id)
+console.log(result.invocation.status)
+```
+
+### Complete Function Executor Example
+
+```typescript
+import { useState } from 'react'
+import { Functions } from '@taruvi/sdk'
+
+export default function FunctionExecutor({ taruviClient }) {
+  const [functionSlug, setFunctionSlug] = useState("")
+  const [params, setParams] = useState({})
+  const [isAsync, setIsAsync] = useState(false)
+  const [result, setResult] = useState(null)
+  const [loading, setLoading] = useState(false)
+
+  const executeFunction = async () => {
+    setLoading(true)
+    try {
+      const functions = new Functions(taruviClient)
+      const response = await functions.execute(functionSlug, {
+        async: isAsync,
+        params: params
+      })
+      setResult(response)
+    } catch (error) {
+      console.error(error)
+    } finally {
+      setLoading(false)
+    }
+  }
 
   return (
-    <TaruviContext.Provider value={client}>
-      {children}
-    </TaruviContext.Provider>
+    <div>
+      <input
+        placeholder="Function slug"
+        value={functionSlug}
+        onChange={(e) => setFunctionSlug(e.target.value)}
+      />
+      <label>
+        <input
+          type="checkbox"
+          checked={isAsync}
+          onChange={(e) => setIsAsync(e.target.checked)}
+        />
+        Async
+      </label>
+      <button onClick={executeFunction} disabled={loading}>
+        Execute
+      </button>
+      {result && <pre>{JSON.stringify(result, null, 2)}</pre>}
+    </div>
   )
 }
+```
 
-// Custom hooks
-export function useTaruvi() {
-  const client = useContext(TaruviContext)
-  if (!client) throw new Error('useTaruvi must be used within TaruviProvider')
-  return client
-}
+---
 
-export function useAuth() {
-  const client = useTaruvi()
-  return new Auth(client)
-}
+## Analytics Service
 
-export function useUser() {
-  const client = useTaruvi()
-  return new User(client)
-}
+### Execute Analytics Query
 
-// Usage in component
-function UserProfile() {
-  const user = useUser()
-  const [data, setData] = useState(null)
+```typescript
+import { Analytics } from '@taruvi/sdk'
 
-  useEffect(() => {
-    user.getUserData().then(setData)
-  }, [])
+const analytics = new Analytics(taruviClient)
 
-  return <div>Welcome, {data?.username}!</div>
-}
+const result = await analytics.execute("monthly-sales-report", {
+  params: {
+    start_date: "2024-01-01",
+    end_date: "2024-12-31"
+  }
+})
+
+console.log(result.data) // Analytics query result
 ```
 
-### Vue 3
+### Execute with Typed Response
+
+```typescript
+interface SalesData {
+  total_sales: number
+  orders_count: number
+  average_order_value: number
+}
+
+const analytics = new Analytics(taruviClient)
 
-Use provide/inject with Composition API.
+const result = await analytics.execute<SalesData>("sales-summary", {
+  params: { period: "monthly" }
+})
+
+console.log(result.data?.total_sales)
+console.log(result.data?.orders_count)
+```
+
+### Complete Analytics Dashboard Example
 
 ```typescript
-import { provide, inject, InjectionKey } from 'vue'
-import { Client, Auth, User } from '@taruvi/sdk'
+import { useEffect, useState } from 'react'
+import { Analytics } from '@taruvi/sdk'
 
-// Create injection key
-const TaruviKey: InjectionKey<Client> = Symbol('taruvi')
+export default function AnalyticsDashboard({ taruviClient }) {
+  const [metrics, setMetrics] = useState(null)
+  const [loading, setLoading] = useState(true)
 
-// Setup in main app or parent component
-export function setupTaruvi() {
-  const client = new Client({
-    apiKey: import.meta.env.VITE_TARUVI_API_KEY,
-    appSlug: import.meta.env.VITE_TARUVI_APP_SLUG,
-    baseUrl: import.meta.env.VITE_TARUVI_BASE_URL
-  })
+  useEffect(() => {
+    const fetchMetrics = async () => {
+      try {
+        const analytics = new Analytics(taruviClient)
+        const result = await analytics.execute("dashboard-metrics", {
+          params: {
+            date_range: "last_30_days"
+          }
+        })
+        setMetrics(result.data)
+      } catch (error) {
+        console.error("Failed to fetch analytics:", error)
+      } finally {
+        setLoading(false)
+      }
+    }
+    fetchMetrics()
+  }, [])
 
-  provide(TaruviKey, client)
-}
+  if (loading) return <div>Loading analytics...</div>
 
-// Composables
-export function useTaruvi() {
-  const client = inject(TaruviKey)
-  if (!client) throw new Error('Taruvi not provided')
-  return client
+  return (
+    <div>
+      <h2>Dashboard Metrics</h2>
+      <pre>{JSON.stringify(metrics, null, 2)}</pre>
+    </div>
+  )
 }
+```
 
-export function useAuth() {
-  const client = useTaruvi()
-  return new Auth(client)
-}
+---
 
-export function useUser() {
-  const client = useTaruvi()
-  return new User(client)
-}
+## Settings Service
 
-// Usage in component
-import { ref, onMounted } from 'vue'
-import { useUser } from '@/composables/taruvi'
+### Get Site Settings
 
-export default {
-  setup() {
-    const user = useUser()
-    const userData = ref(null)
+```typescript
+import { Settings } from '@taruvi/sdk'
 
-    onMounted(async () => {
-      userData.value = await user.getUserData()
-    })
+const settings = new Settings(taruviClient)
+const config = await settings.get()
 
-    return { userData }
-  }
-}
+console.log(config) // Site configuration object
 ```
 
-### Vanilla JavaScript
+---
+
+## Secrets Service
 
-Direct usage without framework.
+### List Secrets
 
 ```typescript
-import { Client, Auth, User } from '@taruvi/sdk'
+import { Secrets } from '@taruvi/sdk'
 
-// Create client
-const client = new Client({
-  apiKey: 'your-key',
-  appSlug: 'your-app',
-  baseUrl: 'https://test-api.taruvi.cloud'
-})
+const secrets = new Secrets(taruviClient)
+const result = await secrets.list().execute()
 
-// Initialize services
-const auth = new Auth(client)
-const user = new User(client)
+console.log(result.items) // Array of secrets
+```
 
-// Use services
-async function handleLogin() {
-  await auth.authenticateUser()
+### Get Secret
 
-  if (await auth.isUserAuthenticated()) {
-    const userData = await user.getUserData()
-    document.getElementById('username').textContent = userData.username
-  }
-}
+```typescript
+const secrets = new Secrets(taruviClient)
+const secret = await secrets.get("MY_SECRET_KEY").execute()
+
+console.log(secret) // Secret object with value
+```
 
-handleLogin()
+### Update Secret
+
+```typescript
+const secrets = new Secrets(taruviClient)
+
+await secrets.update("MY_SECRET", {
+  value: {
+    hostname: "db.example.com",
+    port_number: 3306,
+    username: "admin",
+    password: "secret123"
+  },
+  tags: ["mysql", "production"],
+  secret_type: "Mysql"
+}).execute()
 ```
 
 ---
 
-## TypeScript Types
+## Policy Service (Resource Permissions)
 
-All public types are exported from the main entry point.
+### Check Resource Permissions
 
 ```typescript
-import type {
-  TaruviConfig,
-  UserCreateRequest,
-  UserResponse,
-  UserDataResponse
-} from '@taruvi/sdk'
+import { Policy } from '@taruvi/sdk'
+
+const policy = new Policy(taruviClient)
+
+// Check permissions for multiple resources
+const result = await policy.checkResource([
+  {
+    entityType: "crm",
+    tableName: "accounts",
+    recordId: "record-123",
+    attributes: { owner_id: "user-456" },
+    actions: ["read", "update"]
+  },
+  {
+    entityType: "docs",
+    tableName: "documents",
+    recordId: "doc-789",
+    attributes: {},
+    actions: ["delete"]
+  }
+])
+```
 
-// Use types in your application
-const config: TaruviConfig = {
-  apiKey: 'key',
-  appSlug: 'app',
-  baseUrl: 'https://test-api.taruvi.cloud'
-}
+### Complete Permission Check Example
+
+```typescript
+import { useState, useEffect } from 'react'
+import { Policy } from '@taruvi/sdk'
+
+export default function ResourceGuard({ taruviClient, children, resource }) {
+  const [allowed, setAllowed] = useState(false)
+  const [loading, setLoading] = useState(true)
 
-const newUser: UserCreateRequest = {
-  username: 'john_doe',
-  email: 'john@example.com',
-  password: 'secure123'
+  useEffect(() => {
+    const checkPermission = async () => {
+      try {
+        const policy = new Policy(taruviClient)
+        const result = await policy.checkResource([
+          {
+            entityType: resource.entityType,
+            tableName: resource.table,
+            recordId: resource.id,
+            attributes: resource.attributes || {},
+            actions: ["read"]
+          }
+        ])
+        setAllowed(result.allowed)
+      } catch (error) {
+        console.error("Permission check failed:", error)
+        setAllowed(false)
+      } finally {
+        setLoading(false)
+      }
+    }
+    checkPermission()
+  }, [resource])
+
+  if (loading) return <div>Checking permissions...</div>
+  if (!allowed) return <div>Access denied</div>
+  return children
 }
 ```
 
 ---
 
-## Architecture
+## App Service
 
-### Design Principles
+### Get App Roles
 
-The Taruvi SDK follows these architectural principles:
-
-1. **Dependency Injection** - No singletons, explicit dependencies
-2. **Lazy Initialization** - Create only what you need
-3. **Internal API Protection** - Internal utilities marked with `@internal`
-4. **Type Safety** - Full TypeScript support with strict mode
-5. **Tree-Shaking** - Unused code is eliminated by bundlers
+```typescript
+import { App } from '@taruvi/sdk'
 
-### Project Structure
+const app = new App(taruviClient)
+const roles = await app.roles().execute()
 
+console.log(roles) // Array of role objects with id, name, permissions
 ```
-src/
-├── lib/                      # Public API (safe to use)
-│   ├── auth/                 # Auth service
-│   ├── user/                 # User service
-│   ├── storage/              # Storage service
-│   ├── settings/             # Settings service
-│   ├── database/             # Database service (planned)
-│   └── function/             # Functions service (planned)
-│
-├── lib-internal/             # Internal utilities (not public)
-│   ├── http/                 # HTTP client wrapper
-│   ├── token/                # Token management
-│   ├── routes/               # API route definitions
-│   ├── errors/               # Error handling
-│   └── utils/                # Helper functions
-│
-├── client.ts                 # Main Client class
-├── index.ts                  # Public exports
-└── types.ts                  # Shared types
-```
 
-### Internal vs Public API
+### Complete Roles List Example
+
+```typescript
+import { useEffect, useState } from 'react'
+import { App } from '@taruvi/sdk'
 
-**Public API** (safe to use):
-- `Client` - Main client class
-- `Auth`, `User`, `Database`, `Storage`, `Functions` - Service clients
-- `TaruviConfig` - Configuration interface
-- Exported types from `index.ts`
+export default function RolesList({ taruviClient }) {
+  const [roles, setRoles] = useState([])
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    const fetchRoles = async () => {
+      try {
+        const app = new App(taruviClient)
+        const response = await app.roles().execute()
+        setRoles(response.data || [])
+      } catch (error) {
+        console.error("Failed to fetch roles:", error)
+      } finally {
+        setLoading(false)
+      }
+    }
+    fetchRoles()
+  }, [])
 
-**Internal API** (do not use directly):
-- `client.httpClient` - Marked with `@internal`
-- `client.tokenClient` - Marked with `@internal`
-- Files in `lib-internal/` folder
+  if (loading) return <div>Loading roles...</div>
 
-> ⚠️ **Warning:** Using internal APIs may break in future versions without notice
+  return (
+    <ul>
+      {roles.map(role => (
+        <li key={role.id}>
+          <strong>{role.name}</strong>
+          <span>{role.permissions?.join(", ")}</span>
+        </li>
+      ))}
+    </ul>
+  )
+}
+```
 
 ---
 
-## Testing
+## Common Patterns
 
-### Mocking the SDK
+### Loading States
 
 ```typescript
-import { Client, User } from '@taruvi/sdk'
-import { vi, describe, it, expect } from 'vitest'
-
-describe('User Service', () => {
-  it('should fetch user data', async () => {
-    // Mock HttpClient
-    const mockHttpClient = {
-      get: vi.fn().mockResolvedValue({
-        username: 'testuser',
-        email: 'test@example.com'
-      })
+const [data, setData] = useState(null)
+const [loading, setLoading] = useState(true)
+const [error, setError] = useState(null)
+
+useEffect(() => {
+  const fetchData = async () => {
+    setLoading(true)
+    try {
+      const db = new Database(taruviClient)
+      const response = await db.from("table").execute()
+      setData(response.data)
+    } catch (err) {
+      setError(err.message)
+    } finally {
+      setLoading(false)
     }
+  }
+  fetchData()
+}, [])
 
-    // Mock Client
-    const mockClient = {
-      httpClient: mockHttpClient,
-      getConfig: () => ({
-        apiKey: 'test',
-        appSlug: 'test',
-        baseUrl: 'test'
-      })
-    } as unknown as Client
+if (loading) return <div>Loading...</div>
+if (error) return <div>Error: {error}</div>
+return <div>{/* Render data */}</div>
+```
 
-    // Test User service
-    const user = new User(mockClient)
-    const data = await user.getUserData()
+### Error Handling
 
-    expect(data.username).toBe('testuser')
-    expect(mockHttpClient.get).toHaveBeenCalledWith('api/users/me/')
-  })
-})
+```typescript
+try {
+  const user = new User(taruviClient)
+  await user.createUser(data)
+} catch (error) {
+  if (error.response?.status === 400) {
+    console.error("Validation error:", error.response.data)
+  } else if (error.response?.status === 401) {
+    console.error("Unauthorized")
+  } else {
+    console.error("Unknown error:", error.message)
+  }
+}
 ```
 
----
+### Refresh Data After Mutation
 
-## Development Status
+```typescript
+const [items, setItems] = useState([])
+
+const fetchItems = async () => {
+  const db = new Database(taruviClient)
+  const response = await db.from("items").execute()
+  setItems(response.data || [])
+}
 
-### Implementation Progress
+const createItem = async (data) => {
+  const db = new Database(taruviClient)
+  await db.from("items").create(data).execute()
+  await fetchItems() // Refresh list
+}
 
-| Service | Status | Progress | Notes |
-|---------|--------|----------|-------|
-| Core Infrastructure | ✅ Complete | 90% | Client, HTTP, Token management |
-| User Service | ✅ Functional | 80% | CRUD operations working |
-| Auth Service | 🚧 Partial | 60% | Basic auth working, SSO planned |
-| Storage Service | 🚧 Partial | 70% | Query builder working |
-| Settings Service | ✅ Functional | 70% | Site config fetching |
-| Database Service | 📋 Planned | 0% | Not yet implemented |
-| Functions Service | 📋 Planned | 0% | Not yet implemented |
+const deleteItem = async (id) => {
+  const db = new Database(taruviClient)
+  await db.from("items").delete(id).execute()
+  await fetchItems() // Refresh list
+}
 
-### Legend
-- ✅ **Complete/Functional**: Ready for production use
-- 🚧 **Partial**: Core functionality works, some features pending
-- 📋 **Planned**: Not yet implemented
+const updateItem = async (id, data) => {
+  const db = new Database(taruviClient)
+  await db.from("items").get(id).update(data).execute()
+  await fetchItems() // Refresh list
+}
+```
 
 ---
 
-## Roadmap
+## TypeScript Types
+
+### Import Types
+
+```typescript
+import type {
+  TaruviConfig,
+  AuthTokens,
+  UserCreateRequest,
+  UserResponse,
+  UserDataResponse,
+  FunctionRequest,
+  FunctionResponse,
+  FunctionInvocation,
+  DatabaseRequest,
+  DatabaseResponse,
+  DatabaseFilters,
+  StorageRequest,
+  StorageUpdateRequest,
+  StorageResponse,
+  StorageFilters,
+  SettingsResponse,
+  SecretRequest,
+  SecretResponse,
+  Principal,
+  Resource,
+  Resources,
+  RoleResponse,
+  AnalyticsRequest,
+  AnalyticsResponse
+} from '@taruvi/sdk'
+```
 
-### v1.2 (Next Release)
-- [ ] Complete Auth service (SSO, token refresh, sign out)
-- [ ] Add error handling classes
-- [ ] Implement token management (set, clear, expiration)
-- [ ] Add PATCH HTTP method
-- [ ] Add retry logic for failed requests
+### Type Usage
 
-### v1.3 (Future)
-- [ ] Database service with query builder
-- [ ] Functions service for serverless invocation
-- [ ] File upload/download in Storage
-- [ ] Comprehensive test suite
+```typescript
+const config: TaruviConfig = {
+  apiKey: "key",
+  appSlug: "app",
+  baseUrl: "https://api.taruvi.cloud",
+  deskUrl: "https://desk.taruvi.cloud", // optional
+  token: "existing-token" // optional
+}
 
-### v2.0 (Long-term)
-- [ ] Real-time subscriptions (WebSocket)
-- [ ] Offline support with local caching
-- [ ] Browser DevTools extension
+const userData: UserCreateRequest = {
+  username: "john",
+  email: "john@example.com",
+  password: "pass123",
+  confirm_password: "pass123",
+  first_name: "John",
+  last_name: "Doe",
+  is_active: true,
+  is_staff: false
+}
 
----
+// Database filters with operators
+const dbFilters: DatabaseFilters = {
+  page: 1,
+  pageSize: 20,
+  ordering: "-created_at",
+  status: "active",
+  age__gte: 18,
+  name__icontains: "john"
+}
 
-## API Reference
+// Storage filters with comprehensive options
+const storageFilters: StorageFilters = {
+  page: 1,
+  pageSize: 50,
+  search: "invoice",
+  visibility: "public",
+  mimetype_category: "document",
+  size__gte: 1024,
+  size__lte: 10485760,
+  created_at__gte: "2024-01-01",
+  ordering: "-created_at",
+  created_by_me: true
+}
 
-For complete API documentation, see [adr.md](./adr.md).
+// Policy types for permission checking
+const principal: Principal = {
+  id: "user-123",
+  roles: ["admin", "editor"],
+  attr: { department: "engineering" }
+}
 
-For usage examples, see [USAGE_EXAMPLE.md](./USAGE_EXAMPLE.md).
+const resources: Resources = [
+  {
+    entityType: "crm",
+    tableName: "accounts",
+    recordId: "acc-456",
+    attributes: { owner_id: "user-123" },
+    actions: ["read", "update", "delete"]
+  }
+]
+```
 
 ---
 
-## Contributing
+## Filter Operators Reference
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+### Database Filter Operators (Django-style)
 
-### Development Setup
+The Database service supports Django-style field lookups:
 
-```bash
-# Clone repository
-git clone https://github.com/taruvi/taruvi-sdk
-cd taruvi-sdk
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `field` | Exact match | `{ status: "active" }` |
+| `field__gte` | Greater than or equal | `{ age__gte: 18 }` |
+| `field__gt` | Greater than | `{ age__gt: 17 }` |
+| `field__lte` | Less than or equal | `{ age__lte: 65 }` |
+| `field__lt` | Less than | `{ age__lt: 66 }` |
+| `field__icontains` | Case-insensitive contains | `{ name__icontains: "john" }` |
+| `field__contains` | Case-sensitive contains | `{ name__contains: "John" }` |
+| `field__istartswith` | Case-insensitive starts with | `{ email__istartswith: "admin" }` |
+| `field__startswith` | Case-sensitive starts with | `{ code__startswith: "PRE" }` |
+| `field__iendswith` | Case-insensitive ends with | `{ domain__iendswith: ".com" }` |
+| `field__endswith` | Case-sensitive ends with | `{ filename__endswith: ".pdf" }` |
+| `field__in` | Value in list | `{ status__in: ["active", "pending"] }` |
+| `field__isnull` | Is null check | `{ deleted_at__isnull: true }` |
+| `ordering` | Sort results | `{ ordering: "-created_at" }` (- for desc) |
+| `page` | Page number | `{ page: 1 }` |
+| `pageSize` | Items per page | `{ pageSize: 20 }` |
 
-# Install dependencies
-npm install
+### Populate (Eager Loading)
 
-# Build SDK
-npm run build
+Use the `populate()` method to eager load related records:
 
-# Run tests (when available)
-npm test
+```typescript
+// Populate accepts an array of relation field names
+db.from("orders").populate(["customer", "items"]).execute()
+
+// This adds ?populate=customer,items to the query string
 ```
 
----
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `populate` | `string[]` | Array of relation field names to eager load |
 
-## License
+### Storage Filter Options
 
-MIT License - see [LICENSE](./LICENSE) file for details.
+The Storage service supports these specialized filters:
 
----
+| Category | Filters | Description |
+|----------|---------|-------------|
+| **Size** | `size__gte`, `size__lte`, `size__gt`, `size__lt`, `min_size`, `max_size` | Filter by file size in bytes |
+| **Dates** | `created_at__gte`, `created_at__lte`, `created_after`, `created_before`, `updated_at__gte`, `updated_at__lte` | Filter by dates (ISO 8601 format) |
+| **Search** | `search`, `filename__icontains`, `prefix`, `file`, `file__icontains`, `file__startswith`, `file__istartswith`, `metadata_search` | Search for files |
+| **MIME Type** | `mimetype`, `mimetype__in`, `mimetype_category` | Filter by file type (document, image, video, audio, etc.) |
+| **Visibility** | `visibility` | Filter by public/private visibility |
+| **User** | `created_by_me`, `modified_by_me`, `created_by__username`, `created_by__username__icontains` | Filter by user |
+| **Pagination** | `page`, `pageSize` | Paginate results |
+| **Sorting** | `ordering` | Sort results (e.g., "-created_at") |
 
-## Support
+---
 
-For questions, issues, or feature requests:
-- 📧 Email: support@taruvi.io
-- 🐛 Issues: [GitHub Issues](https://github.com/taruvi/taruvi-sdk/issues)
-- 📖 Docs: [Documentation](https://docs.taruvi.io)
+## Quick Reference
+
+| Service | Import | Purpose |
+|---------|--------|---------|
+| `Client` | `import { Client }` | Main SDK client |
+| `Auth` | `import { Auth }` | Authentication |
+| `User` | `import { User }` | User management |
+| `Database` | `import { Database }` | App data CRUD |
+| `Storage` | `import { Storage }` | File management |
+| `Functions` | `import { Functions }` | Serverless functions |
+| `Settings` | `import { Settings }` | Site configuration |
+| `Secrets` | `import { Secrets }` | Sensitive data |
+| `Policy` | `import { Policy }` | Resource permissions |
+| `App` | `import { App }` | App roles & config |
+| `Analytics` | `import { Analytics }` | Analytics queries |
 
 ---
 
-## Related Resources
+## Chaining Pattern
 
-- [Architecture Decision Record (ADR)](./adr.md) - Complete architectural documentation
-- [Usage Examples](./USAGE_EXAMPLE.md) - Additional code examples
-- [Taruvi Platform Docs](https://docs.taruvi.io) - Platform documentation
-- [API Reference](https://api-docs.taruvi.io) - REST API documentation
+All query-building services use method chaining:
+
+```typescript
+// Database
+const db = new Database(taruviClient)
+await db.from("table").get("id").update(data).execute()
+await db.from("table").filter({ status: "active" }).execute()
+await db.from("table").filter({ page: 1 }).populate(["related_field"]).execute()
+await db.from("table").create({ name: "New" }).execute()
+
+// Storage
+const storage = new Storage(taruviClient)
+await storage.from("bucket").delete(["path/to/file.pdf"]).execute()
+await storage.from("bucket").filter({ search: "query" }).execute()
+await storage.from("bucket").download("path/to/file.pdf").execute()
+```
+
+**Always call `.execute()` at the end to run the query!**
 
 ---
 
-## Acknowledgments
+## Environment Variables
+
+```env
+VITE_TARUVI_API_KEY=your-api-key
+VITE_TARUVI_APP_SLUG=your-app
+VITE_TARUVI_BASE_URL=https://taruvi-site.taruvi.cloud
+```
 
-Inspired by:
-- [Supabase JS](https://github.com/supabase/supabase-js) - Query builder pattern
-- [Appwrite SDK](https://github.com/appwrite/sdk-for-web) - Service architecture
-- [Stripe SDK](https://github.com/stripe/stripe-node) - Client pattern
+```typescript
+const client = new Client({
+  apiKey: import.meta.env.VITE_TARUVI_API_KEY,
+  appSlug: import.meta.env.VITE_TARUVI_APP_SLUG,
+  baseUrl: import.meta.env.VITE_TARUVI_BASE_URL
+})
+```
 
 ---
 
-**Built with ❤️ by the Taruvi Team**
+**Generated from production code examples • Last updated: 2026-01-05**