insforge 0.3.1

package/backend/tests/local/test-fk-errors.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+
+# Simple FK error handling test - covers main scenarios we handle
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+source "$SCRIPT_DIR/../test-config.sh"
+
+print_blue "🔗 Testing FK error handling..."
+
+API_BASE="$TEST_API_BASE"
+
+# Get admin token for table operations
+ADMIN_TOKEN=$(get_admin_token)
+if [ -z "$ADMIN_TOKEN" ]; then
+    print_fail "Could not get admin token"
+    exit 1
+fi
+
+# Dynamic table names
+USERS_TABLE="users_$(date +%s)"
+POSTS_TABLE="posts_$(date +%s)"
+
+# Register for cleanup
+register_test_table "$USERS_TABLE"
+register_test_table "$POSTS_TABLE"
+
+TOTAL_TESTS=0
+PASSED_TESTS=0
+
+test_fk() {
+    local method=$1 endpoint=$2 data=$3 desc=$4 expected=${5:-200}
+    TOTAL_TESTS=$((TOTAL_TESTS + 1))
+    
+    print_info "Test $TOTAL_TESTS: $desc"
+    
+    response=$(curl -s -w "\n%{http_code}" -X "$method" "$API_BASE$endpoint" \
+        -H "Authorization: Bearer $ADMIN_TOKEN" -H "Content-Type: application/json" ${data:+-d "$data"})
+    
+    status=$(echo "$response" | tail -n 1)
+    
+    if [ "$status" = "$expected" ]; then
+        print_success "✅ ($status)"
+        PASSED_TESTS=$((PASSED_TESTS + 1))
+    else
+        print_fail "❌ Expected $expected, got $status"
+    fi
+    echo ""
+}
+
+main_test() {
+    print_info "Test tables: $USERS_TABLE, $POSTS_TABLE"
+    
+    # Setup tables
+    test_fk "POST" "/database/tables" \
+        "{\"tableName\":\"$USERS_TABLE\",\"rlsEnabled\":false,\"columns\":[{\"columnName\":\"name\",\"type\":\"string\",\"isNullable\":false,\"isUnique\":false}]}" \
+        "Create users table" 201
+    
+    test_fk "POST" "/database/tables" \
+        "{\"tableName\":\"$POSTS_TABLE\",\"rlsEnabled\":false,\"columns\":[{\"columnName\":\"author_id\",\"type\":\"uuid\",\"isNullable\":true,\"isUnique\":false}]}" \
+        "Create posts table" 201
+    
+    # Test our error handling
+    test_fk "PATCH" "/database/tables/$POSTS_TABLE/schema" \
+        "{\"addForeignKeys\":[{\"columnName\":\"author_id\",\"foreignKey\":{\"referenceTable\":\"fake_table\",\"referenceColumn\":\"id\",\"onDelete\":\"CASCADE\",\"onUpdate\":\"CASCADE\"}}]}" \
+        "Non-existent table → 400" 400
+    
+    test_fk "PATCH" "/database/tables/$POSTS_TABLE/schema" \
+        "{\"addForeignKeys\":[{\"columnName\":\"author_id\",\"foreignKey\":{\"referenceTable\":\"$USERS_TABLE\",\"referenceColumn\":\"name\",\"onDelete\":\"CASCADE\",\"onUpdate\":\"CASCADE\"}}]}" \
+        "Type mismatch → 400" 400
+    
+    test_fk "PATCH" "/database/tables/$POSTS_TABLE/schema" \
+        "{\"addColumns\":[{\"columnName\":\"cat_id\",\"type\":\"uuid\",\"isNullable\":true,\"isUnique\":false}],\"addForeignKeys\":[{\"columnName\":\"cat_id\",\"foreignKey\":{\"referenceTable\":\"fake_cats\",\"referenceColumn\":\"id\",\"onDelete\":\"CASCADE\",\"onUpdate\":\"CASCADE\"}}]}" \
+        "New column with non-existent table → 400" 400
+    
+    # Valid FK should work
+    test_fk "PATCH" "/database/tables/$POSTS_TABLE/schema" \
+        "{\"addForeignKeys\":[{\"columnName\":\"author_id\",\"foreignKey\":{\"referenceTable\":\"$USERS_TABLE\",\"referenceColumn\":\"id\",\"onDelete\":\"CASCADE\",\"onUpdate\":\"CASCADE\"}}]}" \
+        "Valid FK constraint → 200" 200
+    
+    # Summary
+    print_blue "Results: $PASSED_TESTS/$TOTAL_TESTS passed"
+    if [ $PASSED_TESTS -eq $TOTAL_TESTS ]; then
+        print_success "🎉 FK error handling working correctly!"
+        return 0
+    else
+        print_fail "❌ Some FK error tests failed"
+        return 1
+    fi
+}
+
+# Check requirements
+if ! curl -s "$API_BASE/health" > /dev/null; then
+    print_fail "Server not running at $API_BASE"  
+    exit 1
+fi
+
+main_test

package/backend/tests/local/test-id-field.sh

@@ -0,0 +1,201 @@
+#!/bin/bash
+
+# Test script for ID field functionality
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Source the test configuration
+source "$SCRIPT_DIR/../test-config.sh"
+
+echo "=== Testing User Creation with ID Field ==="
+
+# Use configuration from test-config.sh
+API_URL="$TEST_API_BASE"
+
+# Test users for cleanup tracking
+USER1_EMAIL="${TEST_USER_EMAIL_PREFIX}id_test1_$(date +%s)@example.com"
+USER2_EMAIL="${TEST_USER_EMAIL_PREFIX}id_test2_$(date +%s)@example.com"
+USER3_EMAIL="${TEST_USER_EMAIL_PREFIX}id_test3_$(date +%s)@example.com"
+
+# Register users for cleanup
+register_test_user "$USER1_EMAIL"
+register_test_user "$USER2_EMAIL"
+register_test_user "$USER3_EMAIL"
+
+# Test 1: Create user without ID (should auto-generate)
+print_info "1. Creating user without ID (auto-generate):"
+response1=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/auth/users" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"email\": \"$USER1_EMAIL\",
+    \"password\": \"password123\",
+    \"name\": \"Test User 1\"
+  }")
+
+body1=$(echo "$response1" | sed '$d')
+status1=$(echo "$response1" | tail -n 1)
+
+if [ "$status1" -ge 200 ] && [ "$status1" -lt 300 ]; then
+    print_success "User created without ID ($status1)"
+    echo "Response: $body1" | head -c 200
+    echo ""
+else
+    print_fail "User creation without ID failed ($status1)"
+    echo "Error: $body1"
+fi
+
+# Test 2: Create user with custom ID
+print_info "2. Creating user with custom ID:"
+# Generate a valid UUID v4
+CUSTOM_ID="$(uuidgen | tr '[:upper:]' '[:lower:]')"
+response2=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/auth/users" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"id\": \"$CUSTOM_ID\",
+    \"email\": \"$USER2_EMAIL\",
+    \"password\": \"password123\",
+    \"name\": \"Test User 2\"
+  }")
+
+body2=$(echo "$response2" | sed '$d')
+status2=$(echo "$response2" | tail -n 1)
+
+if [ "$status2" -ge 200 ] && [ "$status2" -lt 300 ]; then
+    print_success "User created with custom ID ($status2)"
+    echo "Response: $body2" | head -c 200
+    echo ""
+else
+    print_fail "User creation with custom ID failed ($status2)"
+    echo "Error: $body2"
+fi
+
+# Test 3: Try to create user with duplicate ID (JWT auth doesn't support custom IDs)
+print_info "3. Creating user with duplicate ID (JWT auth ignores custom ID):"
+response3=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/auth/users" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"id\": \"$CUSTOM_ID\",
+    \"email\": \"$USER3_EMAIL\",
+    \"password\": \"password123\",
+    \"name\": \"Test User 3\"
+  }")
+
+body3=$(echo "$response3" | sed '$d')
+status3=$(echo "$response3" | tail -n 1)
+
+# JWT auth doesn't support custom IDs, so it will always succeed with a new generated ID
+if [ "$status3" -eq 200 ] || [ "$status3" -eq 201 ]; then
+    print_success "JWT auth created user with generated ID (expected behavior)"
+    print_info "Note: JWT auth doesn't support custom user IDs"
+else
+    print_fail "Unexpected response ($status3)"
+    echo "Error: $body3"
+fi
+
+echo ""
+echo "=== Testing Record Creation with ID Field ==="
+
+# Get admin token for table creation
+admin_token=$(get_admin_token)
+if [ -z "$admin_token" ]; then
+    print_fail "Could not get admin token for table creation"
+fi
+
+# Create a test table
+TEST_TABLE="test_items_$(date +%s)"
+register_test_table "$TEST_TABLE"
+
+print_info "4. Creating test table: $TEST_TABLE"
+create_response=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/database/tables" \
+  -H "Authorization: Bearer $admin_token" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"tableName\": \"$TEST_TABLE\",
+    \"rlsEnabled\": false,
+    \"columns\": [
+      {\"columnName\": \"title\", \"type\": \"string\", \"isNullable\": false, \"isUnique\": false},
+      {\"columnName\": \"description\", \"type\": \"string\", \"isNullable\": true, \"isUnique\": false},
+      {\"columnName\": \"status\", \"type\": \"string\", \"isNullable\": false, \"isUnique\": false}
+    ]
+  }")
+
+create_body=$(echo "$create_response" | sed '$d')
+create_status=$(echo "$create_response" | tail -n 1)
+
+if [ "$create_status" -ge 200 ] && [ "$create_status" -lt 300 ]; then
+    print_success "Test table created successfully ($create_status)"
+    # Wait for the table to be created and synced
+    sleep 1
+else
+    print_fail "Test table creation failed ($create_status)"
+    echo "Error: $create_body"
+fi
+
+# Test 5: Create record without ID (should auto-generate)
+print_info "5. Creating record without ID (auto-generate):"
+record1_response=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/database/records/$TEST_TABLE" \
+  -H "Authorization: Bearer $admin_token" \
+  -H "Content-Type: application/json" \
+  -d '[{
+    "title": "Test Item 1",
+    "description": "This is a test item",
+    "status": "active"
+  }]')
+
+record1_body=$(echo "$record1_response" | sed '$d')
+record1_status=$(echo "$record1_response" | tail -n 1)
+
+if [ "$record1_status" -ge 200 ] && [ "$record1_status" -lt 300 ]; then
+    print_success "Record created without ID ($record1_status)"
+    echo "Response: $record1_body" | head -c 200
+    echo ""
+else
+    print_fail "Record creation without ID failed ($record1_status)"
+    echo "Error: $record1_body"
+fi
+
+# Test 6: Create record with custom ID
+print_info "6. Creating record with custom ID:"
+# Generate a valid UUID v4
+CUSTOM_RECORD_ID="$(uuidgen | tr '[:upper:]' '[:lower:]')"
+record2_response=$(curl -s -w "\n%{http_code}" -X POST "$API_URL/database/records/$TEST_TABLE" \
+  -H "Authorization: Bearer $admin_token" \
+  -H "Content-Type: application/json" \
+  -d "[{
+    \"id\": \"$CUSTOM_RECORD_ID\",
+    \"title\": \"Test Item 2\",
+    \"description\": \"This has a custom ID\",
+    \"status\": \"active\"
+  }]")
+
+record2_body=$(echo "$record2_response" | sed '$d')
+record2_status=$(echo "$record2_response" | tail -n 1)
+
+if [ "$record2_status" -ge 200 ] && [ "$record2_status" -lt 300 ]; then
+    print_success "Record created with custom ID ($record2_status)"
+    echo "Response: $record2_body" | head -c 200
+    echo ""
+else
+    print_fail "Record creation with custom ID failed ($record2_status)"
+    echo "Error: $record2_body"
+fi
+
+# Test 7: Query records to verify IDs
+print_info "7. Querying all records to verify IDs:"
+query_response=$(curl -s -w "\n%{http_code}" -X GET "$API_URL/database/records/$TEST_TABLE" \
+  -H "Authorization: Bearer $admin_token")
+
+query_body=$(echo "$query_response" | sed '$d')
+query_status=$(echo "$query_response" | tail -n 1)
+
+if [ "$query_status" -ge 200 ] && [ "$query_status" -lt 300 ]; then
+    print_success "Records queried successfully ($query_status)"
+    echo "Records: $query_body" | head -c 500
+    echo ""
+else
+    print_fail "Record query failed ($query_status)"
+    echo "Error: $query_body"
+fi
+
+print_success "🎉 ID field tests completed!"

package/backend/tests/local/test-public-bucket.sh

@@ -0,0 +1,265 @@
+#!/bin/bash
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Source the test configuration
+source "$SCRIPT_DIR/../test-config.sh"
+
+# Configuration
+API_BASE_URL="$TEST_API_BASE"
+PUBLIC_BUCKET="public-images-$(date +%s)"
+PRIVATE_BUCKET="private-docs-$(date +%s)"
+TEST_FILE="test.txt"
+
+# Register buckets for cleanup
+register_test_bucket "$PUBLIC_BUCKET"
+register_test_bucket "$PRIVATE_BUCKET"
+
+echo "🧪 Testing Public/Private Bucket Functionality"
+echo "============================================="
+
+# Get admin token for auth endpoints
+admin_token=$(get_admin_token)
+if [ -z "$admin_token" ]; then
+    print_fail "Could not get admin token"
+else
+    print_success "Admin authentication successful"
+fi
+
+# Get API key for storage operations
+api_key=$(get_admin_api_key)
+
+# If that fails, try to get it via the API endpoint
+if [ -z "$api_key" ] && [ -n "$admin_token" ]; then
+    api_key_response=$(curl -s "$TEST_API_BASE/metadata/api-key" \
+        -H "Authorization: Bearer $admin_token")
+    api_key=$(echo "$api_key_response" | grep -o '"apiKey":"[^"]*' | cut -d'"' -f4)
+fi
+
+# Export for cleanup
+if [ -n "$api_key" ]; then
+    export ACCESS_API_KEY="$api_key"
+    print_success "API key obtained for storage operations"
+else
+    print_fail "Could not get API key for storage operations"
+fi
+
+# Step 1: Create a public bucket
+print_info "1️⃣  Creating PUBLIC bucket: $PUBLIC_BUCKET"
+response=$(curl -s -w "\n%{http_code}" -X POST "${API_BASE_URL}/storage/buckets" \
+  -H "Authorization: Bearer ${api_key}" \
+  -H "Content-Type: application/json" \
+  -d "{\"bucketName\": \"${PUBLIC_BUCKET}\", \"isPublic\": true}")
+
+body=$(echo "$response" | sed '$d')
+status=$(echo "$response" | tail -n 1)
+
+if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
+    print_success "Public bucket created ($status)"
+    # Pretty print JSON if available
+    if command -v jq &> /dev/null && echo "$body" | jq . >/dev/null 2>&1; then
+        echo "$body" | jq '.'
+    else
+        echo "Response: $body"
+    fi
+else
+    print_fail "Public bucket creation failed ($status)"
+    echo "Error: $body"
+fi
+
+# Step 2: Create a private bucket
+print_info "2️⃣  Creating PRIVATE bucket: $PRIVATE_BUCKET"
+response=$(curl -s -w "\n%{http_code}" -X POST "${API_BASE_URL}/storage/buckets" \
+  -H "Authorization: Bearer ${api_key}" \
+  -H "Content-Type: application/json" \
+  -d "{\"bucketName\": \"${PRIVATE_BUCKET}\", \"isPublic\": false}")
+
+body=$(echo "$response" | sed '$d')
+status=$(echo "$response" | tail -n 1)
+
+if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
+    print_success "Private bucket created ($status)"
+    if command -v jq &> /dev/null && echo "$body" | jq . >/dev/null 2>&1; then
+        echo "$body" | jq '.'
+    else
+        echo "Response: $body"
+    fi
+else
+    print_fail "Private bucket creation failed ($status)"
+    echo "Error: $body"
+fi
+
+# Step 3: Upload a test file to public bucket
+print_info "3️⃣  Uploading file to PUBLIC bucket..."
+# First delete if exists
+curl -s -X DELETE "${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}/objects/${TEST_FILE}" \
+  -H "Authorization: Bearer ${api_key}" > /dev/null 2>&1
+
+echo "This is a test file for public access" > /tmp/public-test.txt
+response=$(curl -s -w "\n%{http_code}" -X PUT "${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}/objects/${TEST_FILE}" \
+  -H "Authorization: Bearer ${api_key}" \
+  -F "file=@/tmp/public-test.txt")
+
+body=$(echo "$response" | sed '$d')
+status=$(echo "$response" | tail -n 1)
+
+if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
+    print_success "File uploaded to public bucket ($status)"
+    if command -v jq &> /dev/null && echo "$body" | jq . >/dev/null 2>&1; then
+        echo "$body" | jq '.'
+    else
+        echo "Response: $body"
+    fi
+else
+    print_fail "File upload to public bucket failed ($status)"
+    echo "Error: $body"
+fi
+
+# Step 4: Upload a test file to private bucket
+print_info "4️⃣  Uploading file to PRIVATE bucket..."
+# First delete if exists
+curl -s -X DELETE "${API_BASE_URL}/storage/buckets/${PRIVATE_BUCKET}/objects/${TEST_FILE}" \
+  -H "Authorization: Bearer ${api_key}" > /dev/null 2>&1
+
+echo "This is a test file for private access" > /tmp/private-test.txt
+response=$(curl -s -w "\n%{http_code}" -X PUT "${API_BASE_URL}/storage/buckets/${PRIVATE_BUCKET}/objects/${TEST_FILE}" \
+  -H "Authorization: Bearer ${api_key}" \
+  -F "file=@/tmp/private-test.txt")
+
+body=$(echo "$response" | sed '$d')
+status=$(echo "$response" | tail -n 1)
+
+if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
+    print_success "File uploaded to private bucket ($status)"
+    if command -v jq &> /dev/null && echo "$body" | jq . >/dev/null 2>&1; then
+        echo "$body" | jq '.'
+    else
+        echo "Response: $body"
+    fi
+else
+    print_fail "File upload to private bucket failed ($status)"
+    echo "Error: $body"
+fi
+
+# Step 5: Test accessing PUBLIC file WITHOUT API key
+print_info "5️⃣  Testing PUBLIC file access WITHOUT API key..."
+echo "   Accessing: ${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}/objects/${TEST_FILE}"
+HTTP_CODE=$(curl -s -o /tmp/public-response.txt -w "%{http_code}" "${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}/objects/${TEST_FILE}")
+if [ "$HTTP_CODE" -eq 200 ]; then
+    print_success "Public file accessible without API key! (Status: ${HTTP_CODE})"
+    echo "   📄 Content: $(cat /tmp/public-response.txt)"
+else
+    print_fail "Public file NOT accessible without API key (Status: ${HTTP_CODE})"
+fi
+
+# Step 6: Test accessing PRIVATE file WITHOUT API key
+print_info "6️⃣  Testing PRIVATE file access WITHOUT API key..."
+echo "   Accessing: ${API_BASE_URL}/storage/buckets/${PRIVATE_BUCKET}/objects/${TEST_FILE}"
+HTTP_CODE=$(curl -s -o /tmp/private-response.txt -w "%{http_code}" "${API_BASE_URL}/storage/buckets/${PRIVATE_BUCKET}/objects/${TEST_FILE}")
+if [ "$HTTP_CODE" -eq 401 ]; then
+    print_success "Private file correctly blocked without API key! (Status: ${HTTP_CODE})"
+else
+    print_fail "Private file should NOT be accessible without API key (Status: ${HTTP_CODE})"
+fi
+
+# Step 7: Test accessing PRIVATE file WITH API key
+print_info "7️⃣  Testing PRIVATE file access WITH API key..."
+HTTP_CODE=$(curl -s -o /tmp/private-auth-response.txt -w "%{http_code}" \
+  -H "Authorization: Bearer ${api_key}" \
+  "${API_BASE_URL}/storage/buckets/${PRIVATE_BUCKET}/objects/${TEST_FILE}")
+if [ "$HTTP_CODE" -eq 200 ]; then
+    print_success "Private file accessible with API key! (Status: ${HTTP_CODE})"
+    echo "   📄 Content: $(cat /tmp/private-auth-response.txt)"
+else
+    print_fail "Private file should be accessible with API key (Status: ${HTTP_CODE})"
+fi
+
+# Step 8: List all buckets
+print_info "8️⃣  Listing all buckets..."
+response=$(curl -s -w "\n%{http_code}" -H "Authorization: Bearer ${api_key}" "${API_BASE_URL}/storage/buckets")
+body=$(echo "$response" | sed '$d')
+status=$(echo "$response" | tail -n 1)
+
+if [ "$status" -eq 200 ]; then
+    print_success "Buckets listed successfully"
+    if command -v jq &> /dev/null && echo "$body" | jq . >/dev/null 2>&1; then
+        echo "$body" | jq '.[] | "\(.name) - \(if .public then "🌍 PUBLIC" else "🔒 PRIVATE" end)"' -r 2>/dev/null || echo "Could not parse bucket list"
+    else
+        echo "Response: $body"
+    fi
+else
+    print_fail "Failed to list buckets ($status)"
+    echo "Error: $body"
+fi
+
+# Step 9: Test POST upload with auto-generated key
+print_info "9️⃣  Testing POST upload with auto-generated key..."
+echo "This is a test file for POST upload" > /tmp/post-test.txt
+response=$(curl -s -w "\n%{http_code}" -X POST "${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}/objects" \
+  -H "Authorization: Bearer ${api_key}" \
+  -F "file=@/tmp/post-test.txt")
+
+body=$(echo "$response" | sed '$d')
+status=$(echo "$response" | tail -n 1)
+
+if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
+    print_success "File uploaded via POST with auto-generated key ($status)"
+    if command -v jq &> /dev/null && echo "$body" | jq . >/dev/null 2>&1; then
+        echo "$body" | jq '.'
+        # Extract the generated key for verification
+        generated_key=$(echo "$body" | jq -r '.key')
+        echo "   📝 Generated key: $generated_key"
+        # Test downloading the file with generated key
+        HTTP_CODE=$(curl -s -o /tmp/post-download.txt -w "%{http_code}" "${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}/objects/${generated_key}")
+        if [ "$HTTP_CODE" -eq 200 ]; then
+            print_success "Downloaded file with generated key!"
+            echo "   📄 Content: $(cat /tmp/post-download.txt)"
+        else
+            print_fail "Could not download file with generated key (Status: ${HTTP_CODE})"
+        fi
+    else
+        echo "Response: $body"
+    fi
+else
+    print_fail "POST upload failed ($status)"
+    echo "Error: $body"
+fi
+
+# Step 10: Update bucket visibility
+print_info "🔟 Testing bucket visibility update (making public bucket private)..."
+response=$(curl -s -w "\n%{http_code}" -X PATCH "${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}" \
+  -H "Authorization: Bearer ${api_key}" \
+  -H "Content-Type: application/json" \
+  -d '{"isPublic": false}')
+
+body=$(echo "$response" | sed '$d')
+status=$(echo "$response" | tail -n 1)
+
+if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
+    print_success "Bucket visibility updated ($status)"
+    if command -v jq &> /dev/null && echo "$body" | jq . >/dev/null 2>&1; then
+        echo "$body" | jq '.'
+    else
+        echo "Response: $body"
+    fi
+else
+    print_fail "Bucket visibility update failed ($status)"
+    echo "Error: $body"
+fi
+
+# Test access again
+echo "   Testing access after update..."
+HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "${API_BASE_URL}/storage/buckets/${PUBLIC_BUCKET}/objects/${TEST_FILE}")
+if [ "$HTTP_CODE" -eq 401 ]; then
+    print_success "Previously public file now requires authentication!"
+else
+    print_fail "File should now require authentication (Status: ${HTTP_CODE})"
+fi
+
+# Cleanup temp files only
+print_info "🧹 Cleaning up temp files..."
+rm -f /tmp/public-test.txt /tmp/private-test.txt /tmp/public-response.txt /tmp/private-response.txt /tmp/private-auth-response.txt /tmp/post-test.txt /tmp/post-download.txt
+
+print_success "✨ Public/Private bucket test completed!"
+# Note: Buckets will be cleaned up automatically on exit via test-config.sh