insforge 0.3.1

package/backend/tests/README.md

@@ -0,0 +1,134 @@
+# Insforge Backend Tests
+
+This directory contains all test scripts for the Insforge backend.
+
+## Prerequisites
+
+- Backend server running on `http://localhost:7130`
+- Admin credentials: `admin@example.com` / `change-this-password`
+- API key for storage operations
+
+## Environment Variables
+
+Set these before running tests:
+
+```bash
+# Required for API authentication
+export ACCESS_API_KEY="your_api_key_here"
+
+# Optional - defaults shown
+export ADMIN_EMAIL="admin@example.com"
+export ADMIN_PASSWORD="change-this-password"
+export TEST_API_BASE="http://localhost:7130/api"
+
+# Required for cloud/S3 tests
+export AWS_S3_BUCKET="your-s3-bucket"
+export AWS_REGION="us-east-1"
+export AWS_ACCESS_KEY_ID="your-access-key"
+export AWS_SECRET_ACCESS_KEY="your-secret-key"
+export APP_KEY="app12345"  # 7-9 character tenant identifier
+```
+
+## Test Organization
+
+Tests are organized into two categories:
+
+### Local Tests (`./local/`)
+Tests for local Docker deployment with local file storage:
+- `test-auth-router.sh` - Authentication and JWT tests
+- `test-database-router.sh` - Database CRUD operations
+- `test-e2e.sh` - End-to-end workflows
+- `test-public-bucket.sh` - Local storage bucket tests
+- `test-config.sh` - Configuration management
+- `test-oauth-config.sh` - OAuth configuration
+- `comprehensive-curl-tests.sh` - Comprehensive API tests
+
+### Cloud Tests (`./cloud/`)
+Tests for cloud deployment with S3 multi-tenant storage:
+- `test-s3-multitenant.sh` - S3 storage with APP_KEY folder structure
+
+## Running Tests
+
+### Run all tests
+```bash
+./run-all-tests.sh
+```
+
+### Run local tests only
+```bash
+cd local && for test in test-*.sh; do ./$test; done
+```
+
+### Run cloud tests only
+```bash
+cd cloud && for test in test-*.sh; do ./$test; done
+```
+
+### Run individual test
+```bash
+./local/test-auth-router.sh
+./cloud/test-s3-multitenant.sh
+```
+
+## Test Data Cleanup
+
+All tests automatically clean up after themselves by:
+- Deleting test users (email prefix: `testuser_`)
+- Removing test tables
+- Deleting test storage buckets
+
+### Manual cleanup
+
+To remove ALL test data from the system:
+
+```bash
+./cleanup-all-test-data.sh
+```
+
+This will prompt for confirmation and then delete:
+- All users with email prefix `testuser_`
+- All tables containing `test_`, `temp_`, `_test`, `_temp`
+- All buckets containing `test`, `temp`, `public-images-`, `private-docs-`
+- All API keys with "test" in their name
+
+## Test Configuration
+
+All tests source `test-config.sh` which provides:
+- Shared configuration and environment variables
+- Color output utilities
+- Automatic cleanup functions
+- Error tracking
+
+## Writing New Tests
+
+1. Create a new shell script in the appropriate subdirectory (`local/` or `cloud/`)
+2. Source the test configuration:
+   ```bash
+   source "$SCRIPT_DIR/test-config.sh"
+   ```
+3. Register resources for cleanup:
+   ```bash
+   register_test_user "$email"
+   register_test_table "$table_name"
+   register_test_bucket "$bucket_name"
+   ```
+4. Use utility functions:
+   ```bash
+   print_success "Test passed"
+   print_fail "Test failed"
+   print_info "Running test..."
+   ```
+5. Tests will automatically clean up on exit
+
+## Authentication
+
+- **Auth endpoints** (users, profiles): Use JWT tokens via `Authorization: Bearer $token`
+- **Database endpoints**: Use JWT tokens via `Authorization: Bearer $token`
+- **Storage endpoints**: Use API keys via `x-api-key: $api_key`
+
+## Exit Codes
+
+- `0`: All tests passed
+- `1`: One or more tests failed
+
+Tests track failures and return appropriate exit codes for CI/CD integration.

package/backend/tests/cleanup-all-test-data.sh

@@ -0,0 +1,231 @@
+#!/bin/bash
+
+# Comprehensive cleanup script for all test data
+# This script removes ALL test data from the system including:
+# - Test users (with email prefix "testuser_")
+# - Test tables
+# - Test buckets
+# - Test API keys
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Source the test configuration for utilities
+source "$SCRIPT_DIR/test-config.sh"
+
+echo "=================================================="
+echo "🧹 COMPREHENSIVE TEST DATA CLEANUP"
+echo "=================================================="
+echo ""
+echo "⚠️  WARNING: This will delete ALL test data!"
+echo "   - All users with email prefix: ${TEST_USER_EMAIL_PREFIX}"
+echo "   - All tables with test prefixes"
+echo "   - All test buckets"
+echo ""
+read -p "Are you sure you want to continue? (yes/no): " -n 3 -r
+echo ""
+
+if [[ ! $REPLY =~ ^[Yy][Ee][Ss]$ ]]; then
+    echo "Cleanup cancelled."
+    exit 0
+fi
+
+# Get admin credentials
+admin_token=$(get_admin_token)
+if [ -z "$admin_token" ]; then
+    print_fail "Could not authenticate as admin. Please check admin credentials."
+    exit 1
+fi
+
+print_success "Admin authentication successful"
+
+# Get API key for storage operations
+api_key=$(get_admin_api_key)
+if [ -z "$api_key" ]; then
+    print_info "No API key available for storage operations"
+fi
+
+# 1. Clean up test users
+print_info "🧑 Searching for test users..."
+users_response=$(curl -s -X GET "$TEST_API_BASE/auth/users?limit=100" \
+    -H "Authorization: Bearer $admin_token" \
+    -H "Content-Type: application/json")
+
+if echo "$users_response" | grep -q '\['; then
+    # Find all test users
+    test_user_ids=()
+    test_user_emails=()
+    
+    # Parse users and find test users
+    while IFS= read -r line; do
+        if [[ $line =~ \"email\":\"($TEST_USER_EMAIL_PREFIX[^\"]+)\" ]]; then
+            email="${BASH_REMATCH[1]}"
+            # Get the ID for this user
+            id_line=$(echo "$users_response" | grep -B5 "\"email\":\"$email\"" | grep '"id"' | head -1)
+            if [[ $id_line =~ \"id\":\"([^\"]+)\" ]]; then
+                id="${BASH_REMATCH[1]}"
+                test_user_ids+=("$id")
+                test_user_emails+=("$email")
+                print_info "  Found test user: $email (ID: $id)"
+            fi
+        fi
+    done <<< "$users_response"
+    
+    if [ ${#test_user_ids[@]} -gt 0 ]; then
+        print_info "Found ${#test_user_ids[@]} test users to delete"
+        
+        # Bulk delete test users
+        delete_response=$(curl -s -X DELETE "$TEST_API_BASE/auth/users/bulk-delete" \
+            -H "Authorization: Bearer $admin_token" \
+            -H "Content-Type: application/json" \
+            -d "{\"userIds\": [$(printf '"%s",' "${test_user_ids[@]}" | sed 's/,$//' )]}")
+        
+        if ! echo "$delete_response" | grep -q '"error"'; then
+            print_success "✅ Deleted ${#test_user_ids[@]} test users"
+        else
+            print_fail "Failed to delete test users"
+            echo "Response: $delete_response"
+        fi
+    else
+        print_info "No test users found"
+    fi
+else
+    print_fail "Could not list users"
+fi
+
+# 2. Clean up test tables
+print_info "📋 Searching for test tables..."
+tables_response=$(curl -s -X GET "$TEST_API_BASE/database/tables" \
+    -H "Authorization: Bearer $admin_token" \
+    -H "Content-Type: application/json")
+
+if echo "$tables_response" | grep -q '\['; then
+    # Find test tables (common patterns)
+    test_tables=()
+    test_patterns=("test_" "temp_" "_test" "_temp")
+    
+    while IFS= read -r line; do
+        if [[ $line =~ \"table_name\":\"([^\"]+)\" ]]; then
+            table="${BASH_REMATCH[1]}"
+            # Check if table matches any test pattern
+            for pattern in "${test_patterns[@]}"; do
+                if [[ $table == *"$pattern"* ]]; then
+                    test_tables+=("$table")
+                    print_info "  Found test table: $table"
+                    break
+                fi
+            done
+        fi
+    done <<< "$tables_response"
+    
+    if [ ${#test_tables[@]} -gt 0 ]; then
+        print_info "Found ${#test_tables[@]} test tables to delete"
+        
+        for table in "${test_tables[@]}"; do
+            print_info "  Deleting table: $table"
+            curl -s -X DELETE "$TEST_API_BASE/database/tables/$table" \
+                -H "Authorization: Bearer $admin_token" \
+                -H "Content-Type: application/json" > /dev/null 2>&1
+        done
+        
+        print_success "✅ Deleted ${#test_tables[@]} test tables"
+    else
+        print_info "No test tables found"
+    fi
+else
+    print_fail "Could not list tables"
+fi
+
+# 3. Clean up test buckets
+if [ -n "$api_key" ]; then
+    print_info "🪣 Searching for test buckets..."
+    buckets_response=$(curl -s -X GET "$TEST_API_BASE/storage/buckets" \
+        -H "x-api-key: $api_key" \
+        -H "Content-Type: application/json")
+    
+    if echo "$buckets_response" | grep -q '\['; then
+        # Find test buckets
+        test_buckets=()
+        bucket_patterns=("test" "temp" "public-images-" "private-docs-")
+        
+        while IFS= read -r line; do
+            if [[ $line =~ \"name\":\"([^\"]+)\" ]]; then
+                bucket="${BASH_REMATCH[1]}"
+                # Check if bucket matches any test pattern
+                for pattern in "${bucket_patterns[@]}"; do
+                    if [[ $bucket == *"$pattern"* ]]; then
+                        test_buckets+=("$bucket")
+                        print_info "  Found test bucket: $bucket"
+                        break
+                    fi
+                done
+            fi
+        done <<< "$buckets_response"
+        
+        if [ ${#test_buckets[@]} -gt 0 ]; then
+            print_info "Found ${#test_buckets[@]} test buckets to delete"
+            
+            for bucket in "${test_buckets[@]}"; do
+                print_info "  Deleting bucket: $bucket"
+                delete_response=$(curl -s -w "\n%{http_code}" -X DELETE "$TEST_API_BASE/storage/$bucket" \
+                    -H "x-api-key: $api_key")
+                status=$(echo "$delete_response" | tail -n 1)
+                if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
+                    echo "    ✓ Deleted"
+                else
+                    echo "    ✗ Failed (status: $status)"
+                fi
+            done
+            
+            print_success "✅ Deleted ${#test_buckets[@]} test buckets"
+        else
+            print_info "No test buckets found"
+        fi
+    else
+        print_fail "Could not list buckets"
+    fi
+else
+    print_info "Skipping bucket cleanup (no API key available)"
+fi
+
+# 4. Clean up test API keys
+print_info "🔑 Searching for test API keys..."
+api_keys_response=$(curl -s -X GET "$TEST_API_BASE/auth/api-keys" \
+    -H "Authorization: Bearer $admin_token" \
+    -H "Content-Type: application/json")
+
+if echo "$api_keys_response" | grep -q '\['; then
+    # Find test API keys
+    test_key_ids=()
+    
+    while IFS= read -r line; do
+        if [[ $line =~ \"name\":\"([^\"]*[Tt]est[^\"]*)\".+\"id\":\"([^\"]+)\" ]]; then
+            name="${BASH_REMATCH[1]}"
+            id="${BASH_REMATCH[2]}"
+            test_key_ids+=("$id")
+            print_info "  Found test API key: $name (ID: $id)"
+        fi
+    done <<< "$api_keys_response"
+    
+    if [ ${#test_key_ids[@]} -gt 0 ]; then
+        print_info "Found ${#test_key_ids[@]} test API keys to delete"
+        
+        for key_id in "${test_key_ids[@]}"; do
+            print_info "  Deleting API key: $key_id"
+            curl -s -X DELETE "$TEST_API_BASE/auth/api-keys/$key_id" \
+                -H "Authorization: Bearer $admin_token" \
+                -H "Content-Type: application/json" > /dev/null 2>&1
+        done
+        
+        print_success "✅ Deleted ${#test_key_ids[@]} test API keys"
+    else
+        print_info "No test API keys found"
+    fi
+else
+    print_fail "Could not list API keys"
+fi
+
+echo ""
+echo "=================================================="
+print_success "🎉 Cleanup completed!"
+echo "=================================================="

package/backend/tests/cloud/test-s3-multitenant.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+
+# Test script for multi-tenant S3 storage
+# This script tests the storage API with S3 backend and app key folder structure
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
+
+# Load .env file if AWS variables not already set
+if [ -z "$AWS_S3_BUCKET" ] && [ -f "$PROJECT_ROOT/.env" ]; then
+    echo "Loading environment from .env file..."
+    set -a  # automatically export all variables
+    source "$PROJECT_ROOT/.env"
+    set +a  # turn off automatic export
+fi
+
+# Source test configuration
+source "$SCRIPT_DIR/../test-config.sh"
+
+API_KEY="${ACCESS_API_KEY:-}"
+# Use TEST_API_BASE if set, otherwise default to localhost
+if [ -n "$TEST_API_BASE" ]; then
+    # TEST_API_BASE already includes /api
+    BASE_URL="$TEST_API_BASE"
+else
+    BASE_URL="http://localhost:7130/api"
+fi
+
+echo "=== Testing Multi-tenant S3 Storage ==="
+echo "Note: Ensure AWS_S3_BUCKET and APP_KEY are set in your .env file"
+echo "Base URL: $BASE_URL"
+echo "API Key: ${API_KEY:0:10}..." # Show first 10 chars only
+echo "AWS Bucket: ${AWS_S3_BUCKET:-not set}"
+echo "App Key: ${APP_KEY:-not set}"
+echo ""
+
+# Create a test bucket
+echo "1. Creating test bucket..."
+curl -X POST "$BASE_URL/storage/buckets" \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: $API_KEY" \
+  -d '{"bucketName": "test-bucket", "isPublic": true}' | jq .
+
+echo ""
+
+# List buckets
+echo "2. Listing buckets..."
+curl "$BASE_URL/storage/buckets" \
+  -H "x-api-key: $API_KEY" | jq .
+
+echo ""
+
+# Upload a file with specific key
+echo "3. Uploading file with specific key..."
+echo "Test content for S3" > test-file.txt
+curl -X PUT "$BASE_URL/storage/test-bucket/test-file.txt" \
+  -H "x-api-key: $API_KEY" \
+  -F "file=@test-file.txt" | jq .
+
+echo ""
+
+# Upload a file with auto-generated key
+echo "4. Uploading file with auto-generated key..."
+curl -X POST "$BASE_URL/storage/test-bucket" \
+  -H "x-api-key: $API_KEY" \
+  -F "file=@test-file.txt" | jq .
+
+echo ""
+
+# List objects in bucket
+echo "5. Listing objects in bucket..."
+curl "$BASE_URL/storage/test-bucket" \
+  -H "x-api-key: $API_KEY" | jq .
+
+echo ""
+
+# Download a file (public bucket, no auth needed)
+echo "6. Downloading file from public bucket..."
+curl "$BASE_URL/storage/test-bucket/test-file.txt" \
+  -o downloaded-file.txt
+echo "Downloaded content:"
+cat downloaded-file.txt
+echo ""
+
+# Update bucket visibility to private
+echo "7. Making bucket private..."
+curl -X PATCH "$BASE_URL/storage/buckets/test-bucket" \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: $API_KEY" \
+  -d '{"isPublic": false}' | jq .
+
+echo ""
+
+# Try downloading from private bucket without auth (should fail)
+echo "8. Trying to download from private bucket without auth (should fail)..."
+curl -v "$BASE_URL/api/storage/test-bucket/test-file.txt" 2>&1 | grep "< HTTP"
+
+echo ""
+
+# Download from private bucket with auth
+echo "9. Downloading from private bucket with auth..."
+curl "$BASE_URL/storage/test-bucket/test-file.txt" \
+  -H "x-api-key: $API_KEY" \
+  -o downloaded-private.txt
+echo "Downloaded content:"
+cat downloaded-private.txt
+echo ""
+
+# Delete a file
+echo "10. Deleting a file..."
+curl -X DELETE "$BASE_URL/storage/test-bucket/test-file.txt" \
+  -H "x-api-key: $API_KEY" | jq .
+
+echo ""
+
+# Delete the bucket
+echo "11. Deleting the bucket..."
+curl -X DELETE "$BASE_URL/storage/test-bucket" \
+  -H "x-api-key: $API_KEY" | jq .
+
+echo ""
+
+# Clean up
+rm -f test-file.txt downloaded-file.txt downloaded-private.txt
+
+echo "=== S3 Multi-tenant Storage Test Complete ==="
+echo ""
+echo "When AWS_S3_BUCKET is set, files are stored in S3 with structure:"
+echo "  s3://\${AWS_S3_BUCKET}/\${APP_KEY}/\${bucket}/\${key}"
+echo ""
+echo "Example: s3://my-bucket/app12345/test-bucket/test-file.txt"

package/backend/tests/local/comprehensive-curl-tests.sh

@@ -0,0 +1,156 @@
+#!/bin/bash
+
+# Comprehensive curl tests for Traditional REST format
+# Tests all major endpoints to verify response formats
+
+BASE_URL="http://localhost:7130/api"
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo "🧪 Comprehensive Traditional REST Format Tests"
+echo "============================================="
+
+# 1. Health Check - Returns object directly
+echo -e "\n${BLUE}1. Health Check (Object Response)${NC}"
+echo "curl -s $BASE_URL/health"
+curl -s "$BASE_URL/health" | jq '.'
+echo -e "${GREEN}✓ Returns object directly (no wrapper)${NC}"
+
+# 2. Authentication - Returns object with user and token
+echo -e "\n${BLUE}2. Authentication Tests${NC}"
+EMAIL="test-$(date +%s)@example.com"
+echo "Creating test user: $EMAIL"
+
+# Register
+echo -e "\n${BLUE}2a. Register (Object Response)${NC}"
+REGISTER_RESPONSE=$(curl -s -X POST "$BASE_URL/auth/users" \
+  -H "Content-Type: application/json" \
+  -d "{\"email\": \"$EMAIL\", \"password\": \"Test123!\", \"name\": \"Test User\"}")
+echo "$REGISTER_RESPONSE" | jq '.'
+TOKEN=$(echo "$REGISTER_RESPONSE" | jq -r '.accessToken')
+echo -e "${GREEN}✓ Returns user object with token (no wrapper)${NC}"
+
+# Login
+echo -e "\n${BLUE}2b. Login (Object Response)${NC}"
+curl -s -X POST "$BASE_URL/auth/sessions" \
+  -H "Content-Type: application/json" \
+  -d "{\"email\": \"$EMAIL\", \"password\": \"Test123!\"}" | jq '.'
+echo -e "${GREEN}✓ Returns user object with token (no wrapper)${NC}"
+
+# Get current user
+echo -e "\n${BLUE}2c. Get Current User (Object Response)${NC}"
+curl -s "$BASE_URL/auth/sessions/current" \
+  -H "Authorization: Bearer $TOKEN" | jq '.'
+echo -e "${GREEN}✓ Returns user object directly${NC}"
+
+# 3. Error Response
+echo -e "\n${BLUE}3. Error Response Format${NC}"
+echo "Testing with invalid credentials:"
+curl -s -X POST "$BASE_URL/auth/sessions" \
+  -H "Content-Type: application/json" \
+  -d '{"email": "nonexistent@example.com", "password": "wrong"}' | jq '.'
+echo -e "${GREEN}✓ Error format: {error, message, statusCode, nextActions}${NC}"
+
+# 4. Database Tables - Returns array
+echo -e "\n${BLUE}4. Database Tables (Array Response)${NC}"
+curl -s "$BASE_URL/database/tables" \
+  -H "Authorization: Bearer $TOKEN" | jq '.'
+echo -e "${GREEN}✓ Returns array directly${NC}"
+
+# 5. Create a test table
+echo -e "\n${BLUE}5. Create Table (Object Response)${NC}"
+TABLE_NAME="test_products_$(date +%s)"
+CREATE_TABLE_RESPONSE=$(curl -s -X POST "$BASE_URL/database/tables" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"tableName\": \"$TABLE_NAME\",
+    \"columns\": [
+      {\"columnName\": \"name\", \"type\": \"string\", \"isNullable\": false, \"isUnique\": false},
+      {\"columnName\": \"price\", \"type\": \"float\", \"isNullable\": false, \"isUnique\": false}
+    ]
+  }")
+echo "$CREATE_TABLE_RESPONSE" | jq '.'
+echo -e "${GREEN}✓ Returns table info object directly${NC}"
+
+# 6. Database Records - PostgREST returns array
+echo -e "\n${BLUE}6. Database Records (PostgREST Array)${NC}"
+
+# Insert a record
+echo -e "\n${BLUE}6a. Insert Record${NC}"
+curl -s -X POST "$BASE_URL/database/records/$TABLE_NAME" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '[{"name": "Test Product", "price": 99.99}]' | jq '.'
+echo -e "${GREEN}✓ PostgREST returns empty array for INSERT${NC}"
+
+# Get records
+echo -e "\n${BLUE}6b. Get Records (Array Response)${NC}"
+curl -s "$BASE_URL/database/records/$TABLE_NAME" \
+  -H "Authorization: Bearer $TOKEN" | jq '.'
+echo -e "${GREEN}✓ PostgREST returns array of records${NC}"
+
+# 7. Storage endpoints
+echo -e "\n${BLUE}7. Storage Endpoints${NC}"
+
+# Get API key first
+echo "Getting API key..."
+API_KEY_RESPONSE=$(curl -s -X POST "$BASE_URL/config/apikey" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "test-key"}')
+API_KEY=$(echo "$API_KEY_RESPONSE" | jq -r '.key' 2>/dev/null || echo "")
+
+if [ -n "$API_KEY" ] && [ "$API_KEY" != "null" ]; then
+  # List buckets
+  echo -e "\n${BLUE}7a. List Buckets (Array Response)${NC}"
+  curl -s "$BASE_URL/storage/buckets" \
+    -H "Authorization: Bearer $API_KEY" | jq '.'
+  echo -e "${GREEN}✓ Returns array of buckets${NC}"
+else
+  echo -e "${RED}✗ Could not get API key for storage tests${NC}"
+fi
+
+# 8. Logs with pagination
+echo -e "\n${BLUE}8. Logs with Pagination Headers${NC}"
+echo "Request: curl -s -i \"$BASE_URL/logs?limit=5\""
+LOGS_RESPONSE=$(curl -s -i "$BASE_URL/logs?limit=5" \
+  -H "Authorization: Bearer $TOKEN")
+echo "$LOGS_RESPONSE" | head -20
+echo -e "${GREEN}✓ Returns array with pagination in headers${NC}"
+
+# 9. Documentation
+echo -e "\n${BLUE}9. Documentation Endpoints${NC}"
+
+# List docs
+echo -e "\n${BLUE}9a. List Documentation (Array Response)${NC}"
+curl -s "$BASE_URL/docs" | jq '.'
+echo -e "${GREEN}✓ Returns array of available docs${NC}"
+
+# Get specific doc
+echo -e "\n${BLUE}9b. Get Specific Doc (Object Response)${NC}"
+curl -s "$BASE_URL/docs/db-api" | jq '.type'
+echo -e "${GREEN}✓ Returns doc object directly${NC}"
+
+# 10. 404 Error
+echo -e "\n${BLUE}10. 404 Not Found${NC}"
+curl -s "$BASE_URL/nonexistent" | jq '.'
+echo -e "${GREEN}✓ Traditional error format${NC}"
+
+# Cleanup
+echo -e "\n${BLUE}Cleanup${NC}"
+if [ -n "$TOKEN" ]; then
+  # Delete test table
+  curl -s -X DELETE "$BASE_URL/database/tables/$TABLE_NAME" \
+    -H "Authorization: Bearer $TOKEN" > /dev/null
+  echo "✓ Deleted test table: $TABLE_NAME"
+fi
+
+echo -e "\n${GREEN}✅ All tests completed!${NC}"
+echo -e "\n${BLUE}Summary of Response Formats:${NC}"
+echo "• Objects: health, auth, table info, specific doc"
+echo "• Arrays: database tables, database records (PostgREST), storage buckets, docs list"
+echo "• Errors: Consistent format with error, message, statusCode, nextActions"
+echo "• Pagination: Via HTTP headers (X-Total-Count, X-Page, etc.)"