@wowsql/sdk 3.7.0 → 3.8.0

package/README.md

@@ -1,333 +1,332 @@
-# WOWSQL TypeScript SDK
+# WowSQL TypeScript/JavaScript SDK
 
-Official TypeScript/JavaScript SDK for WOWSQL - The powerful MySQL Backend-as-a-Service platform.
+Official TypeScript/JavaScript client for [WowSQL](https://wowsql.com) - PostgreSQL Backend-as-a-Service with built-in Authentication and Storage.
 
-[![npm version](https://badge.fury.io/js/%40WOWSQL%2Fsdk.svg)](https://www.npmjs.com/package/@wowsql/sdk)
+[![npm version](https://badge.fury.io/js/wowsql.svg)](https://www.npmjs.com/package/wowsql)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Features
-
-- 🚀 **Zero Configuration** - Get started in seconds
-- 🔒 **Type-Safe** - Full TypeScript support with generics
-- 🎯 **Fluent API** - Intuitive query builder pattern
-- ⚡ **Lightweight** - Minimal dependencies (only axios)
-- 🛡️ **Error Handling** - Comprehensive error messages
-- 📦 **Tree-Shakeable** - Import only what you need
-
 ## Installation
 
 ```bash
 # npm
-npm install @wowsql/sdk
+npm install wowsql
 
 # yarn
-yarn add @wowsql/sdk
+yarn add wowsql
 
 # pnpm
-pnpm add @wowsql/sdk
+pnpm add wowsql
 ```
 
 ## Quick Start
 
+### Database Operations
+
 ```typescript
-import WOWSQLClient from '@wowsql/sdk';
+import { WowSQLClient } from 'wowsql';
 
 // Initialize client
-const client = new WOWSQLClient({
-  projectUrl: 'myproject',  // Your project subdomain
-  apiKey: 'your-api-key-here'
+const client = new WowSQLClient({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-api-key'
 });
 
-// Query data
-const users = await client.table('users')
-  .select(['id', 'name', 'email'])
-  .filter({ column: 'age', operator: 'gt', value: 18 })
-  .order('created_at', 'desc')
-  .limit(10)
-  .get();
-
-console.log(users.data); // Array of user records
-```
-
-## Project Authentication
+// Select data
+const response = await client.table('users').select('*').limit(10).get();
+console.log(response.data); // [{ id: 1, name: 'John', ... }, ...]
 
-The SDK ships with a dedicated `ProjectAuthClient` to integrate with the project-level auth service (signup, login, sessions, OAuth helpers). Provide the project slug (or full URL) and the public auth key exposed in the dashboard.
-
-```typescript
-import { ProjectAuthClient } from '@wowsql/sdk';
-
-const auth = new ProjectAuthClient({
-  projectUrl: 'myproject',        // or https://myproject.wowsql.com
-  apiKey: 'your-anon-key'  // Use anon key for client-side, service key for server-side
+// Insert data
+const result = await client.table('users').create({
+  name: 'Jane Doe',
+  email: 'jane@example.com',
+  age: 25
 });
-```
 
-### Sign Up Users
-
-```typescript
-const { user, session } = await auth.signUp({
-  email: 'user@example.com',
-  password: 'SuperSecret123',
-  full_name: 'Demo User',
-  user_metadata: { referrer: 'landing-page' }
-});
+// Update data
+await client.table('users').update(1, { name: 'Jane Smith' });
 
-console.log('New auth user id:', user?.id);
-console.log('Access token:', session.accessToken);
+// Delete data
+await client.table('users').delete(1);
 ```
 
-### Sign In & Persist Sessions
+### Storage Operations
 
 ```typescript
-const { session } = await auth.signIn({
-  email: 'user@example.com',
-  password: 'SuperSecret123'
-});
+import { WowSQLStorage } from 'wowsql';
 
-// Save the session and reuse on page refresh
-auth.setSession({
-  accessToken: session.accessToken,
-  refreshToken: session.refreshToken
+const storage = new WowSQLStorage({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-api-key'
 });
 
-const currentUser = await auth.getUser(); // reads the stored token
-console.log('Welcome back,', currentUser.full_name);
-```
-
-### OAuth Authentication
-
-Complete OAuth flow with callback handling:
-
-```typescript
-// Step 1: Get authorization URL
-const { authorizationUrl } = await auth.getOAuthAuthorizationUrl(
-  'github',
-  'https://app.your-domain.com/auth/callback'
-);
-
-window.location.href = authorizationUrl;
+// Create a bucket
+await storage.createBucket('avatars', { public: true });
 
-// Step 2: After user authorizes, exchange code for tokens
-// (In your callback handler)
-const result = await auth.exchangeOAuthCallback(
-  'github',
-  code, // from URL query params
-  'https://app.your-domain.com/auth/callback'
-);
+// Upload a file
+await storage.upload('avatars', fileData, 'users/avatar.png');
 
-console.log('Logged in as:', result.user?.email);
-console.log('Access token:', result.session.accessToken);
-```
+// Get public URL
+const url = storage.getPublicUrl('avatars', 'users/avatar.png');
 
-### Password Reset
+// List files
+const files = await storage.listFiles('avatars', { prefix: 'users/' });
 
-```typescript
-// Request password reset
-const forgotResult = await auth.forgotPassword('user@example.com');
-console.log(forgotResult.message); // "If that email exists, a password reset link has been sent"
+// Download a file
+const data = await storage.download('avatars', 'users/avatar.png');
 
-// Reset password (after user clicks email link)
-const resetResult = await auth.resetPassword(
-  token, // from email link
-  'newSecurePassword123'
-);
-console.log(resetResult.message); // "Password reset successfully! You can now login with your new password"
+// Check quota
+const quota = await storage.getQuota();
+console.log(`Used: ${quota.used_gb} GB / ${quota.total_gb} GB`);
 ```
 
-### Session Management
-
-The client exposes `getSession`, `setSession`, and `clearSession` utilities so you can wire tokens into your own persistence layer (localStorage, cookies, etc.):
+### Authentication
 
 ```typescript
-// Get current session
-const session = auth.getSession();
-console.log('Access token:', session.accessToken);
-
-// Set session (e.g., from localStorage on page load)
-auth.setSession({
-  accessToken: localStorage.getItem('access_token')!,
-  refreshToken: localStorage.getItem('refresh_token')!
-});
-
-// Clear session (logout)
-auth.clearSession();
-```
-
-## Configuration
-
-### Basic Configuration
+import { ProjectAuthClient } from 'wowsql';
 
-```typescript
-const client = new WOWSQLClient({
-  projectUrl: 'myproject',        // Your project subdomain
-  apiKey: 'your-api-key'          // Your API key from dashboard
+const auth = new ProjectAuthClient({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-anon-key'
 });
-```
-
-### Advanced Configuration
 
-```typescript
-const client = new WOWSQLClient({
-  projectUrl: 'myproject',
-  apiKey: 'your-api-key',
-  baseDomain: 'wowsql.com',     // Custom domain (optional)
-  secure: true,                    // Use HTTPS (default: true)
-  timeout: 30000                   // Request timeout in ms (default: 30000)
+// Sign up
+const { user, session } = await auth.signUp({
+  email: 'user@example.com',
+  password: 'SuperSecret123',
+  fullName: 'Demo User'
 });
-```
-
-### Using Full URL
 
-```typescript
-const client = new WOWSQLClient({
-  projectUrl: 'https://myproject.wowsql.com',
-  apiKey: 'your-api-key'
+// Sign in
+const result = await auth.signIn({
+  email: 'user@example.com',
+  password: 'SuperSecret123'
 });
+console.log('Access token:', result.session.accessToken);
 ```
 
-## Usage Examples
+## Features
 
-### TypeScript with Generics
+### Database Features
+- Full CRUD operations (Create, Read, Update, Delete)
+- Advanced filtering (eq, neq, gt, gte, lt, lte, like, isNull, isNotNull, in, notIn, between, notBetween)
+- Logical operators (AND, OR)
+- GROUP BY and aggregate functions (COUNT, SUM, AVG, MAX, MIN)
+- HAVING clause for filtering aggregated results
+- Multiple ORDER BY columns
+- Date/time functions in SELECT and filters
+- Expressions in SELECT (e.g., `COUNT(*)`, `DATE(created_at) as date`)
+- Pagination (limit, offset, paginate)
+- Sorting (orderBy)
+- Get record by ID
+- Bulk insert
+- Upsert (insert or update on conflict)
+- Table schema introspection
+- Raw SQL queries
+- Full TypeScript generics support
+- Health check endpoint
+
+### Authentication Features
+- Email/password sign up and sign in
+- OAuth provider support (GitHub, Google, etc.)
+- Password reset flow (forgot + reset)
+- OTP (one-time password) via email
+- Magic link authentication
+- Email verification and resend
+- Session management (get, set, clear, refresh)
+- Change password
+- Update user profile
+- Custom token storage
+
+### Storage Features
+- Bucket management (create, list, get, update, delete)
+- File upload from data or local path
+- File download to memory or local path
+- File listing with prefix and pagination
+- File deletion
+- Public URL generation
+- Storage statistics and quota management
+
+## Database Operations
+
+### Select Queries
 
 ```typescript
-interface User {
-  id: number;
-  name: string;
-  email: string;
-  age: number;
-  created_at: string;
-}
+import { WowSQLClient } from 'wowsql';
 
-const client = new WOWSQLClient({
-  projectUrl: 'myproject',
+const client = new WowSQLClient({
+  projectUrl: 'https://your-project.wowsql.com',
   apiKey: 'your-api-key'
 });
 
-// Type-safe queries
-const users = await client.table<User>('users').get();
-users.data.forEach(user => {
-  console.log(user.name); // Type-safe!
-});
-```
+// Select all columns
+const users = await client.table('users').select('*').get();
 
-### Create Records
+// Select specific columns
+const users = await client.table('users')
+  .select('id', 'name', 'email')
+  .get();
 
-```typescript
-// Create a single user
-const result = await client.table('users').create({
-  name: 'John Doe',
-  email: 'john@example.com',
-  age: 25
-});
+// With filters
+const activeUsers = await client.table('users')
+  .select('*')
+  .eq('status', 'active')
+  .gt('age', 18)
+  .get();
 
-console.log(result.id); // New record ID
-```
+// With ordering
+const recentUsers = await client.table('users')
+  .select('*')
+  .orderBy('created_at', 'desc')
+  .limit(10)
+  .get();
 
-### Read Records
+// With pagination
+const page1 = await client.table('users').select('*').limit(20).offset(0).get();
+const page2 = await client.table('users').select('*').limit(20).offset(20).get();
+
+// Using paginate helper
+const paginated = await client.table('users').paginate(1, 20);
+console.log(paginated.data);       // records for page 1
+console.log(paginated.total);      // total record count
+console.log(paginated.page);       // current page
+console.log(paginated.perPage);    // items per page
+
+// Pattern matching
+const gmailUsers = await client.table('users')
+  .select('*')
+  .like('email', '%@gmail.com')
+  .get();
 
-```typescript
-// Get all records
-const allUsers = await client.table('users').get();
+// IN operator
+const categories = await client.table('products')
+  .select('*')
+  .in('category', ['electronics', 'books', 'clothing'])
+  .get();
 
-// Get by ID
-const user = await client.table('users').getById(1);
+// BETWEEN operator
+const priceRange = await client.table('products')
+  .select('*')
+  .between('price', [10, 100])
+  .get();
 
-// Select specific columns
-const users = await client.table('users')
-  .select(['id', 'name', 'email'])
+// NOT IN operator
+const active = await client.table('products')
+  .select('*')
+  .notIn('status', ['deleted', 'archived'])
   .get();
 
-// With filters
-const adults = await client.table('users')
-  .filter({ column: 'age', operator: 'gte', value: 18 })
+// NOT BETWEEN operator
+const outliers = await client.table('products')
+  .select('*')
+  .notBetween('price', [10, 100])
   .get();
 
-// Multiple filters
-const result = await client.table('users')
-  .filter({ column: 'age', operator: 'gte', value: 18 })
-  .filter({ column: 'country', operator: 'eq', value: 'USA' })
+// IS NULL / IS NOT NULL
+const noEmail = await client.table('users')
+  .select('*')
+  .isNull('email')
   .get();
 
-// With sorting
-const sorted = await client.table('users')
-  .order('created_at', 'desc')
+const hasEmail = await client.table('users')
+  .select('*')
+  .isNotNull('email')
   .get();
 
-// With pagination
-const page1 = await client.table('users')
-  .limit(10)
-  .offset(0)
+// OR conditions
+const results = await client.table('products')
+  .select('*')
+  .filter('category', 'eq', 'electronics', 'AND')
+  .or('price', 'gt', 1000)
   .get();
 
-// Get first record
+// Get first record only
 const firstUser = await client.table('users')
-  .filter({ column: 'email', operator: 'eq', value: 'john@example.com' })
+  .select('*')
+  .eq('email', 'john@example.com')
   .first();
+
+// Get single record (throws if not exactly one)
+const singleUser = await client.table('users')
+  .select('*')
+  .eq('id', 1)
+  .single();
+
+// Count records
+const totalUsers = await client.table('users').count();
+console.log(`Total users: ${totalUsers}`);
+
+// Sum a column
+const totalRevenue = await client.table('orders')
+  .select('*')
+  .eq('status', 'completed')
+  .sum('total');
+
+// Average a column
+const avgPrice = await client.table('products')
+  .select('*')
+  .avg('price');
 ```
 
-### Update Records
+### Insert Data
 
 ```typescript
-// Update by ID
-const result = await client.table('users').update(1, {
-  name: 'Jane Doe',
-  age: 26
+// Insert a single record
+const result = await client.table('users').create({
+  name: 'John Doe',
+  email: 'john@example.com',
+  age: 30
+});
+console.log(result.id); // new record ID
+
+// Using the insert alias
+const result = await client.table('users').insert({
+  name: 'Alice',
+  email: 'alice@example.com'
 });
 
-console.log(result.affected_rows); // Number of rows updated
+// Bulk insert multiple records
+const results = await client.table('users').bulkInsert([
+  { name: 'Alice', email: 'alice@example.com', age: 28 },
+  { name: 'Bob', email: 'bob@example.com', age: 32 },
+  { name: 'Carol', email: 'carol@example.com', age: 24 }
+]);
+console.log(`Inserted ${results.length} records`);
 ```
 
-### Delete Records
+### Upsert Data
 
 ```typescript
-// Delete by ID
-const result = await client.table('users').delete(1);
+// Insert or update on conflict (default conflict column: id)
+const result = await client.table('users').upsert({
+  id: 1,
+  name: 'John Updated',
+  email: 'john@example.com'
+});
 
-console.log(result.affected_rows); // Number of rows deleted
+// Specify conflict column
+const result = await client.table('users').upsert(
+  { email: 'john@example.com', name: 'John Updated' },
+  'email'
+);
 ```
 
-### Filter Operators
+### Update Data
 
 ```typescript
-// Equal
-.filter({ column: 'status', operator: 'eq', value: 'active' })
-
-// Not equal
-.filter({ column: 'status', operator: 'neq', value: 'deleted' })
-
-// Greater than
-.filter({ column: 'age', operator: 'gt', value: 18 })
-
-// Greater than or equal
-.filter({ column: 'age', operator: 'gte', value: 18 })
-
-// Less than
-.filter({ column: 'price', operator: 'lt', value: 100 })
-
-// Less than or equal
-.filter({ column: 'price', operator: 'lte', value: 100 })
-
-// Like (pattern matching)
-.filter({ column: 'name', operator: 'like', value: '%John%' })
-
-// Is null
-.filter({ column: 'deleted_at', operator: 'is', value: null })
-
-// IN operator (value must be an array)
-.filter('category', 'in', ['electronics', 'books', 'clothing'])
-
-// NOT IN operator
-.filter('status', 'not_in', ['deleted', 'archived'])
-
-// BETWEEN operator (value must be an array of 2 values)
-.filter('price', 'between', [10, 100])
+// Update by ID
+const result = await client.table('users').update(1, {
+  name: 'Jane Smith',
+  age: 26
+});
+console.log(result.affected_rows);
+```
 
-// NOT BETWEEN operator
-.filter('age', 'not_between', [18, 65])
+### Delete Data
 
-// OR logical operator
-.filter('category', 'eq', 'electronics', 'AND')
-.filter('price', 'gt', 1000, 'OR')  // OR condition
+```typescript
+// Delete by ID
+const result = await client.table('users').delete(1);
+console.log(result.affected_rows);
 ```
 
 ## Advanced Query Features
@@ -340,93 +339,198 @@ GROUP BY supports both simple column names and SQL expressions with functions. A
 
 ```typescript
 // Group by single column
-const result = await client.table("products")
-  .select("category", "COUNT(*) as count", "AVG(price) as avg_price")
-  .groupBy("category")
+const result = await client.table('products')
+  .select('category', 'COUNT(*) as count', 'AVG(price) as avg_price')
+  .groupBy('category')
   .get();
 
 // Group by multiple columns
-const result = await client.table("sales")
-  .select("region", "category", "SUM(amount) as total")
-  .groupBy(["region", "category"])
+const result = await client.table('sales')
+  .select('region', 'category', 'SUM(amount) as total')
+  .groupBy(['region', 'category'])
   .get();
 ```
 
 #### GROUP BY with Date/Time Functions
 
 ```typescript
-// Group by date
-const result = await client.table("orders")
-  .select("DATE(created_at) as date", "COUNT(*) as orders", "SUM(total) as revenue")
-  .groupBy("DATE(created_at)")
-  .orderBy("date", "desc")
+// Group by date (extract date part)
+const result = await client.table('orders')
+  .select('DATE(created_at) as date', 'COUNT(*) as orders', 'SUM(total) as revenue')
+  .groupBy('DATE(created_at)')
+  .orderBy('date', 'desc')
+  .get();
+
+// Group by year
+const result = await client.table('orders')
+  .select('YEAR(created_at) as year', 'COUNT(*) as orders')
+  .groupBy('YEAR(created_at)')
   .get();
 
 // Group by year and month
-const result = await client.table("orders")
-  .select("YEAR(created_at) as year", "MONTH(created_at) as month", "SUM(total) as revenue")
-  .groupBy(["YEAR(created_at)", "MONTH(created_at)"])
+const result = await client.table('orders')
+  .select(
+    'YEAR(created_at) as year',
+    'MONTH(created_at) as month',
+    'SUM(total) as revenue'
+  )
+  .groupBy(['YEAR(created_at)', 'MONTH(created_at)'])
+  .orderBy('year', 'desc')
+  .orderBy('month', 'desc')
   .get();
 
 // Group by week
-const result = await client.table("orders")
-  .select("WEEK(created_at) as week", "COUNT(*) as orders")
-  .groupBy("WEEK(created_at)")
+const result = await client.table('orders')
+  .select('WEEK(created_at) as week', 'COUNT(*) as orders')
+  .groupBy('WEEK(created_at)')
+  .get();
+
+// Group by quarter
+const result = await client.table('orders')
+  .select('QUARTER(created_at) as quarter', 'SUM(total) as revenue')
+  .groupBy('QUARTER(created_at)')
+  .get();
+```
+
+#### GROUP BY with String Functions
+
+```typescript
+// Group by first letter of name
+const result = await client.table('users')
+  .select('LEFT(name, 1) as first_letter', 'COUNT(*) as count')
+  .groupBy('LEFT(name, 1)')
+  .get();
+
+// Group by uppercase category
+const result = await client.table('products')
+  .select('UPPER(category) as category_upper', 'COUNT(*) as count')
+  .groupBy('UPPER(category)')
+  .get();
+```
+
+#### GROUP BY with Mathematical Functions
+
+```typescript
+// Group by rounded price ranges
+const result = await client.table('products')
+  .select('ROUND(price, -1) as price_range', 'COUNT(*) as count')
+  .groupBy('ROUND(price, -1)')
+  .get();
+
+// Group by price tier (using FLOOR)
+const result = await client.table('products')
+  .select('FLOOR(price / 10) * 10 as price_tier', 'COUNT(*) as count')
+  .groupBy('FLOOR(price / 10) * 10')
   .get();
 ```
 
 #### Supported Functions in GROUP BY
 
-**Date/Time:** `DATE()`, `YEAR()`, `MONTH()`, `DAY()`, `WEEK()`, `QUARTER()`, `HOUR()`, `MINUTE()`, `SECOND()`, `DATE_FORMAT()`, `DATE_ADD()`, `DATE_SUB()`, `DATEDIFF()`, `NOW()`, `CURRENT_TIMESTAMP()`, etc.
+The following functions are allowed in GROUP BY expressions:
+
+**Date/Time Functions:**
+- `DATE()`, `YEAR()`, `MONTH()`, `DAY()`, `DAYOFMONTH()`, `DAYOFWEEK()`, `DAYOFYEAR()`
+- `WEEK()`, `QUARTER()`, `HOUR()`, `MINUTE()`, `SECOND()`
+- `DATE_FORMAT()`, `TIME()`, `DATE_ADD()`, `DATE_SUB()`
+- `DATEDIFF()`, `TIMEDIFF()`, `TIMESTAMPDIFF()`
+- `NOW()`, `CURRENT_TIMESTAMP()`, `CURDATE()`, `CURRENT_DATE()`
+- `CURTIME()`, `CURRENT_TIME()`, `UNIX_TIMESTAMP()`
+
+**String Functions:**
+- `CONCAT()`, `CONCAT_WS()`, `SUBSTRING()`, `SUBSTR()`, `LEFT()`, `RIGHT()`
+- `LENGTH()`, `CHAR_LENGTH()`, `UPPER()`, `LOWER()`, `TRIM()`, `LTRIM()`, `RTRIM()`
+- `REPLACE()`, `LOCATE()`, `POSITION()`
 
-**String:** `CONCAT()`, `SUBSTRING()`, `LEFT()`, `RIGHT()`, `UPPER()`, `LOWER()`, `LENGTH()`, `TRIM()`, etc.
+**Mathematical Functions:**
+- `ABS()`, `ROUND()`, `CEIL()`, `CEILING()`, `FLOOR()`, `POW()`, `POWER()`, `SQRT()`, `MOD()`, `RAND()`
 
-**Mathematical:** `ROUND()`, `CEIL()`, `FLOOR()`, `ABS()`, `POW()`, `SQRT()`, `MOD()`, etc.
+> All expressions are validated for security. Only whitelisted functions are allowed.
 
 ### HAVING Clause
 
-HAVING filters aggregated results after GROUP BY. Supports aggregate functions and comparison operators.
+HAVING is used to filter aggregated results after GROUP BY. It supports aggregate functions and comparison operators.
+
+#### Basic HAVING
 
 ```typescript
 // Filter aggregated results
-const result = await client.table("products")
-  .select("category", "COUNT(*) as count")
-  .groupBy("category")
-  .having("COUNT(*)", "gt", 10)
+const result = await client.table('products')
+  .select('category', 'COUNT(*) as count')
+  .groupBy('category')
+  .having('COUNT(*)', 'gt', 10)
+  .get();
+
+// Multiple HAVING conditions (AND logic)
+const result = await client.table('orders')
+  .select('DATE(created_at) as date', 'SUM(total) as revenue')
+  .groupBy('DATE(created_at)')
+  .having('SUM(total)', 'gt', 1000)
+  .having('COUNT(*)', 'gte', 5)
+  .get();
+```
+
+#### HAVING with Aggregate Functions
+
+```typescript
+// Filter by average
+const result = await client.table('products')
+  .select('category', 'AVG(price) as avg_price', 'COUNT(*) as count')
+  .groupBy('category')
+  .having('AVG(price)', 'gt', 100)
+  .having('COUNT(*)', 'gte', 5)
   .get();
 
-// Multiple HAVING conditions
-const result = await client.table("orders")
-  .select("DATE(created_at) as date", "SUM(total) as revenue")
-  .groupBy("DATE(created_at)")
-  .having("SUM(total)", "gt", 1000)
-  .having("COUNT(*)", "gte", 5)
+// Filter by sum
+const result = await client.table('orders')
+  .select('customer_id', 'SUM(total) as total_spent')
+  .groupBy('customer_id')
+  .having('SUM(total)', 'gt', 1000)
   .get();
 
-// HAVING with different aggregate functions
-const result = await client.table("products")
-  .select("category", "AVG(price) as avg_price", "COUNT(*) as count")
-  .groupBy("category")
-  .having("AVG(price)", "gt", 100)
-  .having("COUNT(*)", "gte", 5)
+// Filter by max/min
+const result = await client.table('products')
+  .select('category', 'MAX(price) as max_price', 'MIN(price) as min_price')
+  .groupBy('category')
+  .having('MAX(price)', 'gt', 500)
   .get();
 ```
 
-**Supported HAVING Operators:** `eq`, `neq`, `gt`, `gte`, `lt`, `lte`
+#### Supported HAVING Operators
 
-**Supported Aggregate Functions:** `COUNT(*)`, `SUM()`, `AVG()`, `MAX()`, `MIN()`, `GROUP_CONCAT()`, `STDDEV()`, `VARIANCE()`
+- `eq` - Equal to
+- `neq` - Not equal to
+- `gt` - Greater than
+- `gte` - Greater than or equal to
+- `lt` - Less than
+- `lte` - Less than or equal to
+
+#### Supported Aggregate Functions in HAVING
+
+- `COUNT(*)` or `COUNT(column)` - Count of rows
+- `SUM(column)` - Sum of values
+- `AVG(column)` - Average of values
+- `MAX(column)` - Maximum value
+- `MIN(column)` - Minimum value
+- `GROUP_CONCAT(column)` - Concatenated values
+- `STDDEV(column)`, `STDDEV_POP(column)`, `STDDEV_SAMP(column)` - Standard deviation
+- `VARIANCE(column)`, `VAR_POP(column)`, `VAR_SAMP(column)` - Variance
 
 ### Multiple ORDER BY
 
 ```typescript
-// Order by multiple columns
-const result = await client.table("products")
-  .select("*")
-  .orderByMultiple([
-    { column: "category", direction: "asc" },
-    { column: "price", direction: "desc" },
-    { column: "created_at", direction: "desc" }
-  ])
+// Chain multiple orderBy calls
+const result = await client.table('products')
+  .select('*')
+  .orderBy('category', 'asc')
+  .orderBy('price', 'desc')
+  .orderBy('created_at', 'desc')
+  .get();
+
+// Using the order alias
+const result = await client.table('products')
+  .select('*')
+  .order('category', 'asc')
+  .order('price', 'desc')
   .get();
 ```
 
@@ -434,37 +538,23 @@ const result = await client.table("products")
 
 ```typescript
 // Filter by date range using functions
-const result = await client.table("orders")
-  .select("*")
-  .filter("created_at", "gte", "DATE_SUB(NOW(), INTERVAL 7 DAY)")
+const result = await client.table('orders')
+  .select('*')
+  .filter('created_at', 'gte', 'DATE_SUB(NOW(), INTERVAL 7 DAY)')
   .get();
 
 // Group by date
-const result = await client.table("orders")
-  .select("DATE(created_at) as date", "COUNT(*) as count")
-  .groupBy("DATE(created_at)")
+const result = await client.table('orders')
+  .select('DATE(created_at) as date', 'COUNT(*) as count')
+  .groupBy('DATE(created_at)')
   .get();
-```
-
-### Complex Queries
 
-```typescript
-// Combine multiple operations
-const result = await client.table<Product>('products')
-  .select(['id', 'name', 'price', 'category'])
-  .filter({ column: 'category', operator: 'eq', value: 'Electronics' })
-  .filter({ column: 'price', operator: 'lt', value: 1000 })
-  .filter({ column: 'in_stock', operator: 'eq', value: true })
-  .order('price', 'asc')
-  .limit(20)
-  .offset(0)
+// Filter by year/month
+const result = await client.table('orders')
+  .select('*')
+  .filter('YEAR(created_at)', 'eq', 2024)
+  .filter('MONTH(created_at)', 'eq', 1)
   .get();
-
-console.log(`Found ${result.total} products`);
-console.log(`Showing ${result.count} products`);
-result.data.forEach(product => {
-  console.log(`${product.name}: $${product.price}`);
-});
 ```
 
 ### Raw SQL Queries
@@ -472,15 +562,15 @@ result.data.forEach(product => {
 ```typescript
 // Execute custom SQL (read-only)
 const results = await client.query<User>(`
-  SELECT id, name, email 
-  FROM users 
-  WHERE age > 18 
-  ORDER BY created_at DESC 
+  SELECT id, name, email
+  FROM users
+  WHERE age > 18
+  ORDER BY created_at DESC
   LIMIT 10
 `);
 ```
 
-### Database Metadata
+### Utility Methods
 
 ```typescript
 // List all tables
@@ -489,448 +579,471 @@ console.log(tables); // ['users', 'posts', 'comments']
 
 // Get table schema
 const schema = await client.getTableSchema('users');
-console.log(schema.columns);
-console.log(schema.primary_key);
-```
+console.log(schema.columns);    // [{ name: 'id', type: 'INT', ... }, ...]
+console.log(schema.primary_key); // 'id'
 
-### Health Check
+// Get record by ID
+const user = await client.table('users').getById(1);
+console.log(user); // { id: 1, name: 'John', ... }
 
-```typescript
-// Check API health
+// Health check
 const health = await client.health();
-console.log(health.status); // 'ok'
+console.log(health.status);    // 'ok'
+console.log(health.timestamp); // '2024-01-15T10:30:00Z'
+
+// Close the client
+client.close();
 ```
 
-## Error Handling
+## Filter Operators
+
+Complete list of all available filter operators with examples:
 
 ```typescript
-import { WOWSQLClient, WOWSQLError } from '@wowsql/sdk';
+// Equal
+.eq('status', 'active')
 
-try {
-  const user = await client.table('users').getById(999);
-} catch (error) {
-  if (error instanceof WOWSQLError) {
-    console.error(`Error ${error.statusCode}: ${error.message}`);
-    console.error(error.response); // Full error response
-  } else {
-    console.error('Unexpected error:', error);
-  }
-}
-```
+// Not equal
+.neq('status', 'deleted')
+
+// Greater than
+.gt('age', 18)
 
-## API Reference
+// Greater than or equal
+.gte('age', 18)
 
-### WOWSQLClient
+// Less than
+.lt('price', 100)
 
-Main client class for interacting with WOWSQL API.
+// Less than or equal
+.lte('price', 100)
 
-#### Methods
+// Pattern matching (SQL LIKE)
+.like('email', '%@gmail.com')
 
-- `table<T>(tableName: string): Table<T>` - Get table interface
-- `listTables(): Promise<string[]>` - List all tables
-- `getTableSchema(tableName: string): Promise<TableSchema>` - Get table schema
-- `query<T>(sql: string): Promise<T[]>` - Execute raw SQL
-- `health(): Promise<{status: string, timestamp: string}>` - Health check
+// IS NULL
+.isNull('deleted_at')
 
-### Table<T>
+// IS NOT NULL
+.isNotNull('email')
 
-Fluent interface for table operations.
+// IN operator (value must be an array)
+.in('category', ['electronics', 'books', 'clothing'])
 
-#### Methods
+// NOT IN operator
+.notIn('status', ['deleted', 'archived'])
 
-- `select(columns: string | string[]): QueryBuilder<T>` - Select columns
-- `filter(filter: FilterExpression): QueryBuilder<T>` - Add filter
-- `get(options?: QueryOptions): Promise<QueryResponse<T>>` - Get records
-- `getById(id: string | number): Promise<T>` - Get by ID
-- `create(data: Partial<T>): Promise<CreateResponse>` - Create record
-- `update(id: string | number, data: Partial<T>): Promise<UpdateResponse>` - Update record
-- `delete(id: string | number): Promise<DeleteResponse>` - Delete record
+// BETWEEN operator (value must be an array of 2 values)
+.between('price', [10, 100])
 
-### QueryBuilder<T>
+// NOT BETWEEN operator
+.notBetween('age', [18, 65])
 
-Chainable query builder.
+// OR logical operator
+.filter('category', 'eq', 'electronics', 'AND')
+.filter('price', 'gt', 1000, 'OR')
 
-#### Methods
+// Using the generic filter method
+.filter('column', 'operator', value)
+.filter('column', 'operator', value, 'OR')
+```
 
-- `select(columns: string | string[]): this` - Select columns
-- `filter(filter: FilterExpression): this` - Add filter
-- `order(column: string, direction?: 'asc' | 'desc'): this` - Order by
-- `limit(limit: number): this` - Limit results
-- `offset(offset: number): this` - Skip records
-- `get(options?: QueryOptions): Promise<QueryResponse<T>>` - Execute query
-- `first(): Promise<T | null>` - Get first record
+## Authentication
 
-## Real-World Examples
+The `ProjectAuthClient` provides a complete authentication system for your application.
 
-### Next.js App Router
+### Initialization
 
 ```typescript
-// app/api/users/route.ts
-import { NextResponse } from 'next/server';
-import WOWSQLClient from '@wowsql/sdk';
+import { ProjectAuthClient } from 'wowsql';
 
-const client = new WOWSQLClient({
-  projectUrl: process.env.WOWSQL_PROJECT!,
-  apiKey: process.env.WOWSQL_API_KEY!
+const auth = new ProjectAuthClient({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-anon-key'
 });
 
-export async function GET(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const page = parseInt(searchParams.get('page') || '1');
-    const limit = 20;
-    
-    const users = await client.table('users')
-      .select(['id', 'name', 'email', 'created_at'])
-      .order('created_at', 'desc')
-      .limit(limit)
-      .offset((page - 1) * limit)
-      .get();
-    
-    return NextResponse.json(users);
-  } catch (error) {
-    return NextResponse.json(
-      { error: 'Failed to fetch users' },
-      { status: 500 }
-    );
+// With custom token storage (e.g., for React Native)
+const auth = new ProjectAuthClient({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-anon-key',
+  storage: {
+    getItem: (key: string) => AsyncStorage.getItem(key),
+    setItem: (key: string, value: string) => AsyncStorage.setItem(key, value),
+    removeItem: (key: string) => AsyncStorage.removeItem(key)
   }
-}
+});
+```
 
-export async function POST(request: Request) {
-  try {
-    const body = await request.json();
-    const result = await client.table('users').create(body);
-    return NextResponse.json(result, { status: 201 });
-  } catch (error) {
-    return NextResponse.json(
-      { error: 'Failed to create user' },
-      { status: 500 }
-    );
-  }
-}
-```
-
-### React Hook
+### Sign Up
 
 ```typescript
-// hooks/useWOWSQL.ts
-import { useState, useEffect } from 'react';
-import WOWSQLClient from '@wowsql/sdk';
-
-const client = new WOWSQLClient({
-  projectUrl: process.env.NEXT_PUBLIC_WOWSQL_PROJECT!,
-  apiKey: process.env.NEXT_PUBLIC_WOWSQL_API_KEY!
+const { user, session } = await auth.signUp({
+  email: 'user@example.com',
+  password: 'SuperSecret123',
+  fullName: 'Demo User',
+  userMetadata: { referrer: 'landing-page', plan: 'free' }
 });
 
-export function useUsers() {
-  const [users, setUsers] = useState([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-
-  useEffect(() => {
-    async function fetchUsers() {
-      try {
-        const result = await client.table('users').get();
-        setUsers(result.data);
-      } catch (err) {
-        setError(err);
-      } finally {
-        setLoading(false);
-      }
-    }
-    fetchUsers();
-  }, []);
-
-  return { users, loading, error };
-}
+console.log('User ID:', user?.id);
+console.log('Email:', user?.email);
+console.log('Access token:', session.accessToken);
 ```
 
-### Express.js API
+### Sign In
 
 ```typescript
-// server.ts
-import express from 'express';
-import WOWSQLClient from '@wowsql/sdk';
-
-const app = express();
-const client = new WOWSQLClient({
-  projectUrl: process.env.WOWSQL_PROJECT!,
-  apiKey: process.env.WOWSQL_API_KEY!
-});
-
-app.use(express.json());
-
-// Get all posts
-app.get('/api/posts', async (req, res) => {
-  try {
-    const { page = 1, limit = 10 } = req.query;
-    const posts = await client.table('posts')
-      .order('created_at', 'desc')
-      .limit(Number(limit))
-      .offset((Number(page) - 1) * Number(limit))
-      .get();
-    res.json(posts);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
+const { user, session } = await auth.signIn({
+  email: 'user@example.com',
+  password: 'SuperSecret123'
 });
 
-// Create post
-app.post('/api/posts', async (req, res) => {
-  try {
-    const result = await client.table('posts').create(req.body);
-    res.status(201).json(result);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
+// Persist the session for subsequent requests
+auth.setSession({
+  accessToken: session.accessToken,
+  refreshToken: session.refreshToken
 });
 
-app.listen(3000, () => console.log('Server running on port 3000'));
+console.log('Logged in as:', user?.email);
 ```
 
-## Best Practices
+### Get Current User
 
-### 1. Environment Variables
+```typescript
+// Uses the stored session token automatically
+const currentUser = await auth.getUser();
+console.log(currentUser.id);
+console.log(currentUser.email);
+console.log(currentUser.email_verified);
+console.log(currentUser.full_name);
+
+// Or pass a specific access token
+const user = await auth.getUser('specific-access-token');
+```
 
-Never hardcode API keys. Use environment variables:
+### OAuth Authentication
+
+Complete OAuth flow with provider callback handling:
 
 ```typescript
-// .env
-WOWSQL_PROJECT=myproject
-WOWSQL_API_KEY=your-api-key
+// Step 1: Get the authorization URL
+const { authorizationUrl } = await auth.getOAuthAuthorizationUrl(
+  'github',
+  'https://app.your-domain.com/auth/callback'
+);
+
+// Redirect user to the authorization URL
+window.location.href = authorizationUrl;
+
+// Step 2: Handle the callback (in your callback route)
+const urlParams = new URLSearchParams(window.location.search);
+const code = urlParams.get('code');
+
+const { user, session } = await auth.exchangeOAuthCallback(
+  'github',
+  code!,
+  'https://app.your-domain.com/auth/callback'
+);
 
-// app.ts
-import WOWSQLClient from '@wowsql/sdk';
+console.log('Logged in via GitHub:', user?.email);
+console.log('Access token:', session.accessToken);
 
-const client = new WOWSQLClient({
-  projectUrl: process.env.WOWSQL_PROJECT!,
-  apiKey: process.env.WOWSQL_API_KEY!
+// Save the session
+auth.setSession({
+  accessToken: session.accessToken,
+  refreshToken: session.refreshToken
 });
 ```
 
-### 2. Singleton Pattern
-
-Create a single client instance:
+### Password Reset
 
 ```typescript
-// lib/WOWSQL.ts
-import WOWSQLClient from '@wowsql/sdk';
-
-export const db = new WOWSQLClient({
-  projectUrl: process.env.WOWSQL_PROJECT!,
-  apiKey: process.env.WOWSQL_API_KEY!
-});
+// Step 1: Request a password reset email
+const result = await auth.forgotPassword('user@example.com');
+console.log(result.message);
+// "If that email exists, a password reset link has been sent"
 
-// Use in other files
-import { db } from './lib/WOWSQL';
-const users = await db.table('users').get();
+// Step 2: Reset the password (user clicks link in email, you extract the token)
+const resetResult = await auth.resetPassword(
+  'reset-token-from-email',
+  'NewSecurePassword123'
+);
+console.log(resetResult.message);
+// "Password reset successfully! You can now login with your new password"
 ```
 
-### 3. Type Definitions
-
-Define interfaces for your data:
+### OTP (One-Time Password)
 
 ```typescript
-// types/database.ts
-export interface User {
-  id: number;
-  name: string;
-  email: string;
-  created_at: string;
-}
+// Send OTP to user's email
+await auth.sendOtp('user@example.com', 'login');
+
+// Verify OTP entered by user
+const result = await auth.verifyOtp(
+  'user@example.com',
+  '123456',  // OTP code
+  'login'
+);
+console.log('Verified:', result);
+
+// OTP for password reset
+await auth.sendOtp('user@example.com', 'password_reset');
+const resetResult = await auth.verifyOtp(
+  'user@example.com',
+  '654321',
+  'password_reset',
+  'NewPassword123'  // new password
+);
+```
 
-export interface Post {
-  id: number;
-  user_id: number;
-  title: string;
-  content: string;
-  published_at: string | null;
-}
+### Magic Link
+
+```typescript
+// Send a magic link to user's email
+await auth.sendMagicLink('user@example.com', 'login');
 
-// Use in queries
-const users = await db.table<User>('users').get();
+// The user clicks the link in their email, which redirects to your app
+// with a token. No additional verification step needed on client side.
 ```
 
-### 4. Error Handling
+### Email Verification
 
-Always wrap API calls in try-catch:
+```typescript
+// Verify email with token (from verification email link)
+await auth.verifyEmail('verification-token-from-email');
+
+// Resend verification email
+await auth.resendVerification('user@example.com');
+```
+
+### Change Password
 
 ```typescript
-import { WOWSQLError } from '@wowsql/sdk';
+// Change password for authenticated user
+await auth.changePassword(
+  'currentPassword123',
+  'newSecurePassword456'
+);
 
-async function createUser(data: any) {
-  try {
-    const result = await db.table('users').create(data);
-    return { success: true, data: result };
-  } catch (error) {
-    if (error instanceof WOWSQLError) {
-      console.error(`Database error: ${error.message}`);
-      return { success: false, error: error.message };
-    }
-    throw error;
-  }
-}
+// With explicit access token
+await auth.changePassword(
+  'currentPassword123',
+  'newSecurePassword456',
+  'specific-access-token'
+);
 ```
 
-## API Keys
+### Update User Profile
 
-WOWSQL uses **different API keys for different operations**. Understanding which key to use is crucial for proper authentication.
+```typescript
+// Update user metadata
+const updatedUser = await auth.updateUser({
+  full_name: 'New Display Name',
+  user_metadata: { theme: 'dark', language: 'en' }
+});
 
-### Key Types Overview
+console.log('Updated name:', updatedUser.full_name);
 
-## 🔑 Unified Authentication
+// With explicit access token
+const user = await auth.updateUser(
+  { full_name: 'Admin User' },
+  'specific-access-token'
+);
+```
 
-**✨ One Project = One Set of Keys for ALL Operations**
+### Session Management
 
-WOWSQL uses **unified authentication** - the same API keys work for both database operations AND authentication operations.
+```typescript
+// Get current session
+const session = auth.getSession();
+if (session) {
+  console.log('Access token:', session.accessToken);
+  console.log('Refresh token:', session.refreshToken);
+}
 
-| Operation Type | Recommended Key | Alternative Key | Used By |
-|---------------|----------------|-----------------|---------|
-| **Database Operations** (CRUD) | Service Role Key (`wowsql_service_...`) | Anonymous Key (`wowsql_anon_...`) | `WOWSQLClient` |
-| **Authentication Operations** (OAuth, sign-in) | Anonymous Key (`wowsql_anon_...`) | Service Role Key (`wowsql_service_...`) | `ProjectAuthClient` |
+// Set session (e.g., restore from localStorage on page load)
+auth.setSession({
+  accessToken: localStorage.getItem('access_token')!,
+  refreshToken: localStorage.getItem('refresh_token')!
+});
 
-### Where to Find Your Keys
+// Refresh an expired session
+const newSession = await auth.refreshSession();
+// Or with explicit refresh token
+const newSession = await auth.refreshSession('stored-refresh-token');
 
-All keys are found in: **WOWSQL Dashboard → Settings → API Keys** or **Authentication → PROJECT KEYS**
+// Logout
+await auth.logout();
+// Or with explicit access token
+await auth.logout('specific-access-token');
 
-1. **Anonymous Key** (`wowsql_anon_...`) ✨ **Unified Key**
-   - Location: "Anonymous Key (Public)"
-   - Used for: 
-     - ✅ Client-side auth operations (signup, login, OAuth)
-     - ✅ Public/client-side database operations with limited permissions
-   - **Safe to expose** in frontend code (browser, mobile apps)
+// Clear local session data
+auth.clearSession();
+```
 
-2. **Service Role Key** (`wowsql_service_...`) ✨ **Unified Key**
-   - Location: "Service Role Key (keep secret)"
-   - Used for:
-     - ✅ Server-side auth operations (admin, full access)
-     - ✅ Server-side database operations (full access, bypass RLS)
-   - **NEVER expose** in frontend code - server-side only!
+## Storage Operations
 
-### Database Operations
+The `WowSQLStorage` client provides file storage capabilities backed by PostgreSQL.
 
-Use **Service Role Key** or **Anonymous Key** for database operations:
+### Initialization
 
 ```typescript
-import WOWSQLClient from '@wowsql/sdk';
-
-// Using Service Role Key (recommended for server-side, full access)
-const client = new WOWSQLClient({
-  projectUrl: 'myproject',
-  apiKey: 'wowsql_service_your-service-key-here'  // Service Role Key
-});
+import { WowSQLStorage } from 'wowsql';
 
-// Using Anonymous Key (for public/client-side access with limited permissions)
-const client = new WOWSQLClient({
-  projectUrl: 'myproject',
-  apiKey: 'wowsql_anon_your-anon-key-here'  // Anonymous Key
+const storage = new WowSQLStorage({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-api-key'
 });
-
-// Query data
-const users = await client.table('users').get();
 ```
 
-### Authentication Operations
-
-**✨ UNIFIED AUTHENTICATION:** Use the **same keys** as database operations!
+### Bucket Operations
 
 ```typescript
-import { ProjectAuthClient } from '@wowsql/sdk';
+// Create a new bucket
+await storage.createBucket('avatars', {
+  public: true,
+  allowedMimeTypes: ['image/png', 'image/jpeg', 'image/webp'],
+  fileSizeLimit: 5 * 1024 * 1024 // 5 MB
+});
 
-// Using Anonymous Key (recommended for client-side auth operations)
-const auth = new ProjectAuthClient({
-  projectUrl: 'myproject',
-  apiKey: 'wowsql_anon_your-anon-key-here'  // Same key as database operations!
+// List all buckets
+const buckets = await storage.listBuckets();
+buckets.forEach(bucket => {
+  console.log(`${bucket.name}: ${bucket.public ? 'public' : 'private'}`);
 });
 
-// Using Service Role Key (for server-side auth operations)
-const auth = new ProjectAuthClient({
-  projectUrl: 'myproject',
-  apiKey: 'wowsql_service_your-service-key-here'  // Same key as database operations!
+// Get bucket details
+const bucket = await storage.getBucket('avatars');
+console.log(bucket.name, bucket.created_at);
+
+// Update bucket settings
+await storage.updateBucket('avatars', {
+  public: false,
+  fileSizeLimit: 10 * 1024 * 1024 // increase to 10 MB
 });
 
-// OAuth authentication
-const { authorizationUrl } = await auth.getOAuthAuthorizationUrl(
-  'github',
-  'https://app.example.com/auth/callback'
-);
+// Delete a bucket
+await storage.deleteBucket('old-bucket');
 ```
 
-**Note:** The `publicApiKey` parameter is deprecated but still works for backward compatibility. Use `apiKey` instead.
+### File Upload
 
-### Environment Variables
+```typescript
+// Upload file data (Buffer, Blob, or File)
+const result = await storage.upload('documents', fileData, 'reports/q1.pdf');
+console.log('Uploaded:', result);
+
+// Using the uploadFile alias
+await storage.uploadFile('documents', fileBlob, 'reports/', 'q1-report.pdf');
+
+// Upload from a local file path (Node.js)
+await storage.uploadFromPath(
+  '/home/user/report.pdf',
+  'documents',
+  'reports/'
+);
+```
 
-Best practice: Use environment variables for API keys:
+### File Download
 
 ```typescript
-// UNIFIED AUTHENTICATION: Same keys for both operations!
+// Download file to memory
+const data = await storage.download('documents', 'reports/q1.pdf');
+
+// Download to a local file path (Node.js)
+await storage.downloadToFile(
+  'documents',
+  'reports/q1.pdf',
+  '/home/user/downloads/q1.pdf'
+);
+```
 
-// Database operations - Service Role Key
-const dbClient = new WOWSQLClient({
-  projectUrl: process.env.WOWSQL_PROJECT_URL!,
-  apiKey: process.env.WOWSQL_SERVICE_ROLE_KEY!  // or WOWSQL_ANON_KEY
+### File Listing
+
+```typescript
+// List all files in a bucket
+const files = await storage.listFiles('documents');
+files.forEach(file => {
+  console.log(`${file.name}: ${file.size} bytes`);
 });
 
-// Authentication operations - Use the SAME key!
-const authClient = new ProjectAuthClient({
-  projectUrl: process.env.WOWSQL_PROJECT_URL!,
-  apiKey: process.env.WOWSQL_ANON_KEY!  // Same key for client-side auth
-  // Or use WOWSQL_SERVICE_ROLE_KEY for server-side auth
+// List with options (prefix, limit, offset)
+const files = await storage.listFiles('documents', {
+  prefix: 'reports/',
+  limit: 50,
+  offset: 0
 });
 ```
 
-### Key Usage Summary
+### File Deletion and URLs
 
-**✨ UNIFIED AUTHENTICATION:**
-- **`WOWSQLClient`** → Uses **Service Role Key** or **Anonymous Key** for database operations
-- **`ProjectAuthClient`** → Uses **Anonymous Key** (client-side) or **Service Role Key** (server-side) for authentication operations
-- **Same keys work for both** database AND authentication operations! 🎉
-- **Anonymous Key** (`wowsql_anon_...`) → Client-side operations (auth + database)
-- **Service Role Key** (`wowsql_service_...`) → Server-side operations (auth + database)
+```typescript
+// Delete a file
+await storage.deleteFile('documents', 'reports/old-report.pdf');
 
-### Security Best Practices
+// Get a public URL for a file
+const url = storage.getPublicUrl('avatars', 'users/123/avatar.png');
+console.log(url); // https://your-project.wowsql.com/storage/v1/...
+```
 
-1. **Never expose Service Role Key** in client-side code or public repositories
-2. **Use Anonymous Key** for client-side authentication flows (same key as database operations)
-3. **Use Anonymous Key** for public database access with limited permissions
-4. **Store keys in environment variables**, never hardcode them
-5. **Rotate keys regularly** if compromised
+### Storage Stats and Quota
 
-### Troubleshooting
+```typescript
+// Get storage statistics
+const stats = await storage.getStats();
+console.log('Total files:', stats.total_files);
+console.log('Total size:', stats.total_size);
+
+// Check storage quota
+const quota = await storage.getQuota();
+console.log(`Used: ${quota.used_gb} GB`);
+console.log(`Total: ${quota.total_gb} GB`);
+console.log(`Available: ${quota.available_gb} GB`);
+
+// Check quota before uploading
+if (quota.available_gb > fileSizeInGb) {
+  await storage.upload('documents', fileData, 'path/to/file.pdf');
+} else {
+  console.log('Storage limit reached. Upgrade your plan.');
+}
+```
 
-**Error: "Invalid API key for project"**
-- Ensure you're using the correct key type for the operation
-- Database operations require Service Role Key or Anonymous Key
-- Authentication operations require Anonymous Key (client-side) or Service Role Key (server-side)
-- Verify the key is copied correctly (no extra spaces)
+### Storage Error Handling
 
-**Error: "Authentication failed"**
-- Check that you're using the correct key: Anonymous Key for client-side, Service Role Key for server-side
-- Verify the project URL matches your dashboard
-- Ensure the key hasn't been revoked or expired
+```typescript
+import { WowSQLStorage, StorageError, StorageLimitExceededError } from 'wowsql';
+
+try {
+  await storage.upload('documents', largeFile, 'path/to/huge-file.zip');
+} catch (error) {
+  if (error instanceof StorageLimitExceededError) {
+    console.error('Storage limit exceeded:', error.message);
+    console.error('Please upgrade your plan or delete old files');
+  } else if (error instanceof StorageError) {
+    console.error('Storage error:', error.message);
+  }
+}
+```
 
-## 🔧 Schema Management
+## Schema Management
 
-Programmatically manage your database schema with the `WOWSQLSchema` client.
+Programmatically manage your database schema with the `WowSQLSchema` client.
 
-> **⚠️ IMPORTANT**: Schema operations require a **Service Role Key** (`service_*`). Anonymous keys will return a 403 Forbidden error.
+> **IMPORTANT**: Schema operations require a **Service Role Key** (`wowsql_service_...`). Anonymous keys will return a 403 Forbidden error.
 
-### Quick Start
+### Initialization
 
 ```typescript
-import { WOWSQLSchema } from '@wowsql/sdk';
+import { WowSQLSchema } from 'wowsql';
 
-// Initialize schema client with SERVICE ROLE KEY
-const schema = new WOWSQLSchema(
-  'https://your-project.wowsql.com',
-  'service_xyz789...'  // ⚠️ Backend only! Never expose!
-);
+const schema = new WowSQLSchema({
+  projectUrl: 'https://your-project.wowsql.com',
+  serviceKey: 'wowsql_service_xyz789...'
+});
 ```
 
 ### Create Table
 
 ```typescript
-// Create a new table
 await schema.createTable({
   tableName: 'products',
   columns: [
@@ -946,8 +1059,6 @@ await schema.createTable({
     { name: 'idx_price', columns: ['price'] }
   ]
 });
-
-console.log('Table created successfully!');
 ```
 
 ### Alter Table
@@ -965,7 +1076,7 @@ await schema.alterTable({
 await schema.alterTable({
   tableName: 'products',
   modifyColumns: [
-    { name: 'price', type: 'DECIMAL(12,2)' }  // Increase precision
+    { name: 'price', type: 'DECIMAL(12,2)' }
   ]
 });
 
@@ -984,6 +1095,37 @@ await schema.alterTable({
 });
 ```
 
+### Column Operations
+
+```typescript
+// Add a column
+await schema.addColumn('products', 'description', 'TEXT', {
+  not_null: false,
+  default: "''"
+});
+
+// Drop a column
+await schema.dropColumn('products', 'old_field');
+
+// Rename a column
+await schema.renameColumn('products', 'name', 'product_name');
+
+// Modify a column type or constraints
+await schema.modifyColumn('products', 'price', 'DECIMAL(14,2)', {
+  not_null: true
+});
+```
+
+### Index Operations
+
+```typescript
+// Create an index
+await schema.createIndex('products', ['category', 'price'], {
+  name: 'idx_category_price',
+  unique: false
+});
+```
+
 ### Drop Table
 
 ```typescript
@@ -991,127 +1133,581 @@ await schema.alterTable({
 await schema.dropTable('old_table');
 
 // Drop with CASCADE (removes dependent objects)
-await schema.dropTable('products', { cascade: true });
+await schema.dropTable('products', true);
 ```
 
 ### Execute Raw SQL
 
 ```typescript
-// Execute custom schema SQL
 await schema.executeSQL(`
-  CREATE INDEX idx_product_name 
+  CREATE INDEX idx_product_name
   ON products(product_name);
 `);
 
-// Add a foreign key constraint
 await schema.executeSQL(`
-  ALTER TABLE orders 
-  ADD CONSTRAINT fk_product 
-  FOREIGN KEY (product_id) 
+  ALTER TABLE orders
+  ADD CONSTRAINT fk_product
+  FOREIGN KEY (product_id)
   REFERENCES products(id);
 `);
 ```
 
-### Security & Best Practices
+### Schema Introspection
+
+```typescript
+// List all tables
+const tables = await schema.listTables();
+console.log(tables);
+
+// Get detailed table schema
+const tableSchema = await schema.getTableSchema('users');
+console.log(tableSchema.columns);
+console.log(tableSchema.primary_key);
+console.log(tableSchema.indexes);
+```
+
+### Schema Error Handling
+
+```typescript
+import { WowSQLSchema, SchemaPermissionError } from 'wowsql';
 
-#### ✅ DO:
+try {
+  await schema.createTable({
+    tableName: 'test',
+    columns: [{ name: 'id', type: 'INT', auto_increment: true }],
+    primaryKey: 'id'
+  });
+} catch (error) {
+  if (error instanceof SchemaPermissionError) {
+    console.error('Permission denied:', error.message);
+    console.error('Make sure you are using a SERVICE ROLE KEY!');
+  } else {
+    console.error('Error:', error);
+  }
+}
+```
+
+### Schema Security Best Practices
+
+**DO:**
 - Use service role keys **only in backend/server code** (Node.js, Next.js API routes)
 - Store service keys in environment variables
 - Use anonymous keys for client-side data operations
 - Test schema changes in development first
 
-#### ❌ DON'T:
+**DON'T:**
 - Never expose service role keys in frontend/browser code
 - Never commit service keys to version control
-- Don't use anonymous keys for schema operations (will fail)
+- Don't use anonymous keys for schema operations (will fail with 403)
+
+## API Keys
+
+WowSQL uses **unified authentication** - the same API keys work for database operations, authentication, storage, and schema management.
+
+### Key Types
+
+| Operation Type | Recommended Key | Alternative Key | Used By |
+|---|---|---|---|
+| **Database Operations** (CRUD) | Service Role Key (`wowsql_service_...`) | Anonymous Key (`wowsql_anon_...`) | `WowSQLClient` |
+| **Authentication** (sign-up, login, OAuth) | Anonymous Key (`wowsql_anon_...`) | Service Role Key (`wowsql_service_...`) | `ProjectAuthClient` |
+| **Storage** (upload, download) | Service Role Key (`wowsql_service_...`) | Anonymous Key (`wowsql_anon_...`) | `WowSQLStorage` |
+| **Schema Management** (DDL) | Service Role Key (`wowsql_service_...`) | N/A | `WowSQLSchema` |
+
+### Where to Find Your Keys
+
+All keys are in: **WowSQL Dashboard > Settings > API Keys** or **Authentication > PROJECT KEYS**
+
+1. **Anonymous Key** (`wowsql_anon_...`)
+   - Client-side auth operations (signup, login, OAuth)
+   - Public/client-side database operations with limited permissions
+   - **Safe to expose** in frontend code (browser, mobile apps)
+
+2. **Service Role Key** (`wowsql_service_...`)
+   - Server-side operations with full access (bypass RLS)
+   - Schema management operations
+   - **NEVER expose** in frontend code - server-side only!
+
+### Environment Variables
+
+```bash
+# .env
+WOWSQL_PROJECT_URL=https://your-project.wowsql.com
+WOWSQL_ANON_KEY=wowsql_anon_your-anon-key
+WOWSQL_SERVICE_ROLE_KEY=wowsql_service_your-service-key
+```
+
+```typescript
+const dbClient = new WowSQLClient({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  apiKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+});
 
-### Example: Next.js API Route Migration
+const authClient = new ProjectAuthClient({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  apiKey: process.env.WOWSQL_ANON_KEY!
+});
+
+const storage = new WowSQLStorage({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  apiKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+});
+
+const schema = new WowSQLSchema({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  serviceKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+});
+```
+
+### Security Best Practices
+
+1. **Never expose Service Role Key** in client-side code or public repositories
+2. **Use Anonymous Key** for client-side authentication and limited database access
+3. **Store keys in environment variables**, never hardcode them
+4. **Rotate keys regularly** if compromised
+
+### Troubleshooting
+
+**Error: "Invalid API key for project"**
+- Ensure you're using the correct key type for the operation
+- Verify the key is copied correctly (no extra spaces)
+- Check that the project URL matches your dashboard
+
+**Error: "Authentication failed"**
+- Check that you're using the correct key: Anonymous Key for client-side, Service Role Key for server-side
+- Ensure the key hasn't been revoked or expired
+
+## Error Handling
+
+```typescript
+import {
+  WowSQLClient,
+  WowSQLStorage,
+  WOWSQLError,
+  StorageError,
+  StorageLimitExceededError,
+  SchemaPermissionError
+} from 'wowsql';
+
+// Database errors
+try {
+  const users = await client.table('users').select('*').get();
+} catch (error) {
+  if (error instanceof WOWSQLError) {
+    console.error(`Database error [${error.statusCode}]: ${error.message}`);
+    console.error('Response:', error.response);
+  }
+}
+
+// Storage errors
+try {
+  await storage.upload('bucket', fileData, 'path/to/file');
+} catch (error) {
+  if (error instanceof StorageLimitExceededError) {
+    console.error('Storage full:', error.message);
+  } else if (error instanceof StorageError) {
+    console.error('Storage error:', error.message);
+  }
+}
+
+// Schema errors
+try {
+  await schema.createTable({ tableName: 'test', columns: [] });
+} catch (error) {
+  if (error instanceof SchemaPermissionError) {
+    console.error('Use a Service Role Key for schema operations');
+  }
+}
+
+// Generic catch-all
+try {
+  await client.table('users').getById(999);
+} catch (error) {
+  if (error instanceof WOWSQLError) {
+    switch (error.statusCode) {
+      case 401: console.error('Unauthorized - check your API key'); break;
+      case 404: console.error('Record not found'); break;
+      case 429: console.error('Rate limit exceeded - slow down'); break;
+      default:  console.error(`Error ${error.statusCode}: ${error.message}`);
+    }
+  } else {
+    console.error('Unexpected error:', error);
+  }
+}
+```
+
+## Configuration
+
+### Basic Configuration
+
+```typescript
+const client = new WowSQLClient({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-api-key'
+});
+```
+
+### Advanced Configuration
+
+```typescript
+const client = new WowSQLClient({
+  projectUrl: 'your-project',            // subdomain or full URL
+  apiKey: 'your-api-key',
+  baseDomain: 'wowsql.com',             // custom domain (default: wowsql.com)
+  secure: true,                           // use HTTPS (default: true)
+  timeout: 30000,                         // request timeout in ms (default: 30000)
+  verifySsl: true                         // verify SSL certificates (default: true)
+});
+```
+
+### Storage Timeout
+
+```typescript
+const storage = new WowSQLStorage({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-api-key',
+  timeout: 120000 // 2 minutes for large file uploads
+});
+```
+
+### Auth with Custom Storage
+
+```typescript
+const auth = new ProjectAuthClient({
+  projectUrl: 'https://your-project.wowsql.com',
+  apiKey: 'your-anon-key',
+  storage: {
+    getItem: (key) => localStorage.getItem(key),
+    setItem: (key, value) => localStorage.setItem(key, value),
+    removeItem: (key) => localStorage.removeItem(key)
+  }
+});
+```
+
+### Disabling SSL Verification (development only)
+
+```typescript
+const client = new WowSQLClient({
+  projectUrl: 'https://localhost:8443',
+  apiKey: 'dev-key',
+  verifySsl: false
+});
+```
+
+## TypeScript Support
+
+The SDK is written in TypeScript and provides full type safety with generics.
+
+### Defining Your Types
+
+```typescript
+interface User {
+  id: number;
+  name: string;
+  email: string;
+  age: number;
+  created_at: string;
+}
+
+interface Post {
+  id: number;
+  user_id: number;
+  title: string;
+  content: string;
+  published: boolean;
+  published_at: string | null;
+}
+
+// Type-safe queries
+const users = await client.table<User>('users').get();
+users.data.forEach(user => {
+  console.log(user.name);  // TypeScript knows this is string
+  console.log(user.age);   // TypeScript knows this is number
+});
+
+// Type-safe getById
+const user: User = await client.table<User>('users').getById(1);
+
+// Type-safe create
+await client.table<User>('users').create({
+  name: 'John',
+  email: 'john@example.com',
+  age: 30
+});
+
+// Type-safe query builder
+const results = await client.table<User>('users')
+  .select('id', 'name', 'email')
+  .eq('age', 30)
+  .orderBy('name', 'asc')
+  .limit(10)
+  .get();
+```
+
+### Key Interfaces
+
+```typescript
+import type {
+  WowSQLConfig,
+  QueryOptions,
+  FilterExpression,
+  HavingFilter,
+  OrderByItem,
+  QueryResponse,
+  CreateResponse,
+  UpdateResponse,
+  DeleteResponse,
+  TableSchema,
+  ColumnInfo,
+  AuthTokenStorage,
+  AuthUser,
+  AuthSession,
+  AuthResponse,
+  StorageBucket,
+  StorageFile,
+  StorageQuota
+} from 'wowsql';
+```
+
+## Examples
+
+### Blog Application
+
+```typescript
+import { WowSQLClient } from 'wowsql';
+
+interface Post {
+  id: number;
+  title: string;
+  content: string;
+  author_id: number;
+  published: boolean;
+  created_at: string;
+}
+
+interface Comment {
+  id: number;
+  post_id: number;
+  author_name: string;
+  body: string;
+  created_at: string;
+}
+
+const client = new WowSQLClient({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  apiKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+});
+
+// Create a new post
+const post = await client.table<Post>('posts').create({
+  title: 'Hello World',
+  content: 'My first blog post',
+  author_id: 1,
+  published: true
+});
+
+// Get published posts with pagination
+const posts = await client.table<Post>('posts')
+  .select('id', 'title', 'content', 'created_at')
+  .eq('published', true)
+  .orderBy('created_at', 'desc')
+  .limit(10)
+  .get();
+
+// Get a single post by ID
+const singlePost = await client.table<Post>('posts').getById(1);
+
+// Get comments for a post
+const comments = await client.table<Comment>('comments')
+  .select('*')
+  .eq('post_id', 1)
+  .orderBy('created_at', 'asc')
+  .get();
+
+// Get post statistics
+const stats = await client.table<Post>('posts')
+  .select('DATE(created_at) as date', 'COUNT(*) as count')
+  .eq('published', true)
+  .groupBy('DATE(created_at)')
+  .orderBy('date', 'desc')
+  .limit(30)
+  .get();
+```
+
+### File Upload Application
 
 ```typescript
-// app/api/migrate/route.ts
-import { WOWSQLSchema } from '@wowsql/sdk';
+import { WowSQLClient, WowSQLStorage } from 'wowsql';
+
+const client = new WowSQLClient({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  apiKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+});
+
+const storage = new WowSQLStorage({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  apiKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+});
+
+// Create an avatars bucket
+await storage.createBucket('avatars', { public: true });
+
+// Upload user avatar
+const userId = 123;
+const avatarPath = `users/${userId}/avatar.jpg`;
+await storage.upload('avatars', avatarBuffer, avatarPath);
+
+// Get the public URL and save to database
+const avatarUrl = storage.getPublicUrl('avatars', avatarPath);
+await client.table('users').update(userId, {
+  avatar_url: avatarUrl
+});
+
+// List user's uploaded files
+const files = await storage.listFiles('avatars', {
+  prefix: `users/${userId}/`
+});
+console.log(`User has ${files.length} files`);
+
+// Check storage quota before upload
+const quota = await storage.getQuota();
+if (quota.available_gb > 0.1) {
+  await storage.upload('avatars', largeFile, 'users/123/banner.jpg');
+} else {
+  console.log('Low storage! Consider upgrading.');
+}
+```
+
+### Next.js API Route
+
+```typescript
+// app/api/users/route.ts
 import { NextResponse } from 'next/server';
+import { WowSQLClient } from 'wowsql';
+
+const client = new WowSQLClient({
+  projectUrl: process.env.WOWSQL_PROJECT_URL!,
+  apiKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+});
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const page = parseInt(searchParams.get('page') || '1');
+  const perPage = 20;
 
-export async function POST() {
-  const schema = new WOWSQLSchema(
-    process.env.WOWSQL_PROJECT_URL!,
-    process.env.WOWSQL_SERVICE_KEY!  // From env var
-  );
-  
   try {
-    // Create users table
-    await schema.createTable({
-      tableName: 'users',
-      columns: [
-        { name: 'id', type: 'INT', auto_increment: true },
-        { name: 'email', type: 'VARCHAR(255)', unique: true, not_null: true },
-        { name: 'name', type: 'VARCHAR(255)', not_null: true },
-        { name: 'created_at', type: 'TIMESTAMP', default: 'CURRENT_TIMESTAMP' }
-      ],
-      primaryKey: 'id',
-      indexes: [{ name: 'idx_email', columns: ['email'] }]
-    });
-    
-    return NextResponse.json({ success: true });
+    const result = await client.table('users')
+      .select('id', 'name', 'email', 'created_at')
+      .orderBy('created_at', 'desc')
+      .paginate(page, perPage);
+
+    return NextResponse.json(result);
   } catch (error) {
-    return NextResponse.json({ error: error.message }, { status: 500 });
+    return NextResponse.json({ error: 'Failed to fetch users' }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const result = await client.table('users').create(body);
+    return NextResponse.json(result, { status: 201 });
+  } catch (error) {
+    return NextResponse.json({ error: 'Failed to create user' }, { status: 500 });
   }
 }
 ```
 
-### Error Handling
+### Migration Script
 
 ```typescript
-import { WOWSQLSchema, PermissionError } from '@wowsql/sdk';
+// scripts/migrate.ts
+import { WowSQLSchema } from 'wowsql';
 
-try {
-  const schema = new WOWSQLSchema(
-    'https://your-project.wowsql.com',
-    'service_xyz...'
-  );
-  
+async function runMigration() {
+  const schema = new WowSQLSchema({
+    projectUrl: process.env.WOWSQL_PROJECT_URL!,
+    serviceKey: process.env.WOWSQL_SERVICE_ROLE_KEY!
+  });
+
+  // Create users table
   await schema.createTable({
-    tableName: 'test',
-    columns: [{ name: 'id', type: 'INT' }]
+    tableName: 'users',
+    columns: [
+      { name: 'id', type: 'INT', auto_increment: true },
+      { name: 'email', type: 'VARCHAR(255)', unique: true, not_null: true },
+      { name: 'name', type: 'VARCHAR(255)', not_null: true },
+      { name: 'created_at', type: 'TIMESTAMP', default: 'CURRENT_TIMESTAMP' }
+    ],
+    primaryKey: 'id',
+    indexes: [{ name: 'idx_email', columns: ['email'] }]
   });
-} catch (error) {
-  if (error instanceof PermissionError) {
-    console.error('Permission denied:', error.message);
-    console.error('Make sure you\'re using a SERVICE ROLE KEY!');
-  } else {
-    console.error('Error:', error);
-  }
+
+  // Create posts table
+  await schema.createTable({
+    tableName: 'posts',
+    columns: [
+      { name: 'id', type: 'INT', auto_increment: true },
+      { name: 'user_id', type: 'INT', not_null: true },
+      { name: 'title', type: 'VARCHAR(255)', not_null: true },
+      { name: 'content', type: 'TEXT' },
+      { name: 'published', type: 'BOOLEAN', default: 'false' },
+      { name: 'created_at', type: 'TIMESTAMP', default: 'CURRENT_TIMESTAMP' }
+    ],
+    primaryKey: 'id'
+  });
+
+  // Add foreign key
+  await schema.executeSQL(`
+    ALTER TABLE posts
+    ADD CONSTRAINT fk_user
+    FOREIGN KEY (user_id)
+    REFERENCES users(id);
+  `);
+
+  console.log('Migration completed!');
 }
+
+runMigration().catch(console.error);
 ```
 
----
+## Requirements
+
+- Node.js 16+
+- TypeScript 4.7+ (for TypeScript users)
+- Works in Node.js, browser, Deno, Bun, and edge runtimes
 
 ## FAQ
 
 ### Can I use this in the browser?
 
-Yes! The SDK works in both Node.js and browser environments. However, **never expose your Service Role Key in client-side code** for production applications. Use **Anonymous Key** for both authentication and limited database access. For full database operations, use a backend proxy with Service Role Key.
+Yes! The SDK works in both Node.js and browser environments. Use the **Anonymous Key** for client-side code. Never expose the Service Role Key in frontend code.
 
 ### What about rate limits?
 
-Rate limits depend on your WOWSQL plan. The SDK will throw a `WOWSQLError` with status code 429 when rate limits are exceeded.
+Rate limits depend on your WowSQL plan. The SDK throws a `WOWSQLError` with status code 429 when rate limits are exceeded.
 
 ### Does it support transactions?
 
-Currently, the SDK doesn't support transactions directly. Use raw SQL queries for complex transactional operations.
+Currently, the SDK doesn't support transactions directly. Use raw SQL queries via `client.query()` for complex transactional operations.
 
 ### How do I upgrade?
 
 ```bash
-npm update @wowsql/sdk
+npm update wowsql
 ```
 
+## Links
+
+- [Documentation](https://wowsql.com/docs)
+- [Website](https://wowsql.com)
+- [Discord](https://discord.gg/wowsql)
+- [GitHub Issues](https://github.com/wowsql/wowsql/issues)
+
 ## Support
 
-- 📧 Email: support@wowsql.com
-- 💬 Discord: [Join our community](https://discord.gg/WOWSQL)
-- 📚 Documentation: [docs.wowsql.com](https://docs.wowsql.com)
-- 🐛 Issues: [GitHub Issues](https://github.com/wowsql/wowsql/issues)
+- Email: support@wowsql.com
+- Discord: https://discord.gg/wowsql
+- Documentation: https://wowsql.com/docs
 
 ## Contributing
 
@@ -1127,6 +1723,4 @@ See [CHANGELOG.md](CHANGELOG.md) for version history.
 
 ---
 
-Made with ❤️ by the WOWSQL Team
-
-
+Made with care by the WowSQL Team