insforge 0.3.1

package/backend/tests/local/test-traditional-rest.sh

@@ -0,0 +1,209 @@
+#!/bin/bash
+
+# Test Traditional REST Response Format
+# This script tests various API endpoints to ensure they follow traditional REST conventions
+
+# 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"
+
+# Check requirements
+check_requirements
+
+print_blue "🧪 Testing Traditional REST Response Format..."
+
+# API Configuration
+API_BASE="$TEST_API_BASE"
+TEST_USER_EMAIL="testuser_rest_$(date +%s)@example.com"
+TEST_USER_PASSWORD="TestPass123!"
+AUTH_TOKEN=""
+
+# Function to test response format
+test_response_format() {
+    local test_name="$1"
+    local response="$2"
+    local expected_pattern="$3"
+    local should_not_exist="${4:-false}"
+    
+    if [ "$should_not_exist" == "true" ]; then
+        # Check that pattern does NOT exist
+        if ! echo "$response" | grep -q "$expected_pattern"; then
+            print_success "$test_name"
+            return 0
+        else
+            print_fail "$test_name - found unwanted pattern: $expected_pattern"
+            track_test_failure
+            return 1
+        fi
+    else
+        # Check that pattern exists
+        if echo "$response" | grep -q "$expected_pattern"; then
+            print_success "$test_name"
+            return 0
+        else
+            print_fail "$test_name - missing pattern: $expected_pattern"
+            echo "  Response: $(echo "$response" | head -c 200)..."
+            track_test_failure
+            return 1
+        fi
+    fi
+}
+
+# 1. Test Health Endpoint
+print_info "1. Testing Health Endpoint (Success Response)"
+response=$(curl -s "$API_BASE/health")
+test_response_format "Direct data response" "$response" '"status":"ok"'
+test_response_format "No success wrapper" "$response" '"success":true' "true"
+test_response_format "No data wrapper" "$response" '"data":{' "true"
+
+# 2. Test Authentication Errors
+print_info "2. Testing Authentication Errors"
+response=$(curl -s "$API_BASE/auth/sessions/current")
+test_response_format "Error format" "$response" '"error":"AUTH_INVALID_CREDENTIALS"'
+test_response_format "Message field" "$response" '"message":"Invalid token"'
+# JWT auth includes error and message fields
+
+# 3. Test Login Endpoint (Missing Credentials)
+print_info "3. Testing Login Endpoint (Missing Credentials)"
+response=$(curl -s -X POST "$API_BASE/auth/sessions" \
+    -H "Content-Type: application/json" \
+    -d '{}')
+test_response_format "Error response" "$response" '"error":"INVALID_INPUT"'
+test_response_format "Message field" "$response" '"message":"email: Required, password: Required"'
+
+# 4. Test Invalid Endpoint (404)
+print_info "4. Testing Invalid Endpoint (404)"
+response=$(curl -s "$API_BASE/nonexistent")
+test_response_format "404 error" "$response" '"statusCode":404'
+test_response_format "Not found message" "$response" '"error":"NOT_FOUND"'
+
+ADMIN_TOKEN=$(get_admin_token)
+
+# 5. Test with Authentication
+print_info "5. Creating test user for authenticated tests"
+auth_response=$(curl -s -X POST "$API_BASE/auth/users" \
+    -H "Content-Type: application/json" \
+    -d "{
+        \"email\": \"$TEST_USER_EMAIL\",
+        \"password\": \"$TEST_USER_PASSWORD\",
+        \"name\": \"Test User\"
+    }")
+
+# Check if registration was successful
+if echo "$auth_response" | grep -q '"accessToken"'; then
+    AUTH_TOKEN=$(echo "$auth_response" | grep -o '"accessToken":"[^"]*' | cut -d'"' -f4)
+    print_success "User registered successfully"
+    register_test_user "$TEST_USER_EMAIL"
+    
+    # Test authenticated endpoints
+    print_info "6. Testing Database Tables List (Authenticated)"
+    response=$(curl -s "$API_BASE/database/tables" \
+        -H "Authorization: Bearer $AUTH_TOKEN")
+    test_response_format "Direct array response" "$response" '^\['
+    test_response_format "No wrapper object" "$response" '"data":\[' "true"
+    
+    # Test table creation
+    print_info "7. Testing Create Table (Success Response)"
+    TABLE_NAME="test_rest_table_$(date +%s)"
+    response=$(curl -s -X POST "$API_BASE/database/tables" \
+        -H "Authorization: Bearer $ADMIN_TOKEN" \
+        -H "Content-Type: application/json" \
+        -d "{
+            \"tableName\": \"$TABLE_NAME\",
+            \"rlsEnabled\": false,
+            \"columns\": [
+                {\"columnName\": \"id\", \"type\": \"uuid\", \"isNullable\": false, \"isUnique\": false, \"defaultValue\": \"gen_random_uuid()\"},
+                {\"columnName\": \"title\", \"type\": \"string\", \"isNullable\": false, \"isUnique\": false}
+            ]
+        }")
+    
+    if echo "$response" | grep -q '"tableName"'; then
+        print_success "Table created"
+        register_test_table "$TABLE_NAME"
+        test_response_format "Direct object response" "$response" "\"tableName\":\"$TABLE_NAME\""
+        test_response_format "No success wrapper" "$response" '"success":true' "true"
+    else
+        print_fail "Table creation failed"
+        echo "Response: $response"
+        track_test_failure
+    fi
+    
+    # Test pagination headers
+    print_info "8. Testing Pagination Headers"
+    # Use -I for headers, but we need both headers and body
+    full_response=$(curl -s -i "$API_BASE/logs/audits?limit=10" \
+        -H "Authorization: Bearer $ADMIN_TOKEN")
+    
+    # Extract headers (everything before empty line)
+    headers=$(echo "$full_response" | awk 'BEGIN{RS="\r\n\r\n"} NR==1')
+    
+    # Test for PostgREST-style Content-Range header (format: start-end/total)
+    test_response_format "Content-Range header" "$headers" 'Content-Range:'
+    test_response_format "Preference-Applied header" "$headers" 'Preference-Applied:'
+    
+else
+    print_fail "Failed to register user"
+    echo "Response: $auth_response"
+    track_test_failure
+fi
+
+# 9. Test Storage API (requires API key)
+print_info "9. Testing Storage API Format"
+# First get admin token if we don't have it
+if [ -z "$AUTH_TOKEN" ]; then
+    admin_token=$(get_admin_token)
+else
+    admin_token="$AUTH_TOKEN"
+fi
+
+# Try to get API key from the API endpoint first
+if [ -n "$admin_token" ]; then
+    api_key_response=$(curl -s "$API_BASE/metadata/api-key" \
+        -H "Authorization: Bearer $admin_token")
+    API_KEY=$(echo "$api_key_response" | grep -o '"apiKey":"[^"]*' | cut -d'"' -f4)
+fi
+
+# If that fails, try the helper function  
+if [ -z "$API_KEY" ]; then
+    API_KEY=$(get_admin_api_key)
+fi
+
+# Export for cleanup
+if [ -n "$API_KEY" ]; then
+    export ACCESS_API_KEY="$API_KEY"
+    # List buckets
+    response=$(curl -s "$API_BASE/storage/buckets" \
+        -H "Authorization: Bearer $API_KEY")
+    test_response_format "Direct array for buckets" "$response" '^\['
+    
+    # Create a test bucket
+    BUCKET_NAME="test-rest-bucket-$(date +%s)"
+    response=$(curl -s -X POST "$API_BASE/storage/buckets" \
+        -H "Content-Type: application/json" \
+        -H "Authorization: Bearer $API_KEY" \
+        -d "{\"bucketName\": \"$BUCKET_NAME\", \"isPublic\": true}")
+    
+    if echo "$response" | grep -q '"bucketName"'; then
+        print_success "Bucket created"
+        register_test_bucket "$BUCKET_NAME"
+        test_response_format "Success message field" "$response" '"message":"Bucket created successfully"'
+        test_response_format "NextAction guidance" "$response" '"nextActions":'
+    else
+        print_fail "Bucket creation failed"
+        echo "Response: $response"
+        track_test_failure
+    fi
+else
+    print_info "Skipping storage tests (no API key available)"
+fi
+
+# Summary
+echo ""
+print_blue "=========================================="
+print_blue "Traditional REST Format Test Complete"
+print_blue "=========================================="
+
+# Exit with proper status
+exit_with_status

package/backend/tests/manual/README.md

@@ -0,0 +1,51 @@
+# Manual Tests
+
+This directory contains tests that need to be run manually and are not included in the automated test suite.
+
+## Better Auth Tests
+
+These tests are for the Better Auth v2 implementation.
+
+### Running Better Auth Tests
+
+Run the Better Auth test:
+```bash
+./tests/manual/test-better-auth.sh
+```
+
+### Prerequisites
+
+- Docker must be running with the InsForge backend on port 7130
+- Admin credentials should be configured in environment variables:
+  - `ADMIN_EMAIL` (default: admin@example.com)
+  - `ADMIN_PASSWORD` (default: change-this-password)
+
+### Example Commands
+
+```bash
+# Run from the backend directory
+cd backend
+
+# Run Better Auth test
+./tests/manual/test-better-auth.sh
+
+# Run with custom admin credentials
+ADMIN_EMAIL=admin@mycompany.com ADMIN_PASSWORD=mysecurepass ./tests/manual/test-better-auth.sh
+```
+
+### Test Coverage
+
+The test covers:
+- Admin authentication (sign-in, wrong password, non-admin email)
+- User registration and sign-in
+- Admin user management (list users with pagination)
+- JWT token verification (admin role and type claims)
+- Authorization checks (admin-only endpoints)
+- Error handling (invalid email format, missing fields)
+
+### Why These Tests Are Manual
+
+These tests are kept separate because:
+1. They use authentication endpoints (`/api/auth/v2/*`) that require specific setup
+2. They test admin-specific functionality that needs manual verification
+3. They verify JWT token structure and claims that may vary between environments

package/backend/tests/manual/create-large-table-simple.sql

@@ -0,0 +1,11 @@
+-- Create large_table with basic structure
+CREATE TABLE IF NOT EXISTS large_table (
+    id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+    user_id UUID NOT NULL,
+    title TEXT NOT NULL,
+    content TEXT,
+    status VARCHAR(50) DEFAULT 'active',
+    metadata JSONB DEFAULT '{}',
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);

package/backend/tests/manual/seed-large-table.sql

@@ -0,0 +1,101 @@
+-- Insert 1500 test records into large_table
+-- Using generate_series for efficient bulk insertion
+
+INSERT INTO large_table (user_id, title, content, status, metadata, created_at, updated_at)
+SELECT 
+    -- Generate random user_ids from a pool of 10 different users
+    (ARRAY[
+        '550e8400-e29b-41d4-a716-446655440001'::uuid,
+        '550e8400-e29b-41d4-a716-446655440002'::uuid,
+        '550e8400-e29b-41d4-a716-446655440003'::uuid,
+        '550e8400-e29b-41d4-a716-446655440004'::uuid,
+        '550e8400-e29b-41d4-a716-446655440005'::uuid,
+        '550e8400-e29b-41d4-a716-446655440006'::uuid,
+        '550e8400-e29b-41d4-a716-446655440007'::uuid,
+        '550e8400-e29b-41d4-a716-446655440008'::uuid,
+        '550e8400-e29b-41d4-a716-446655440009'::uuid,
+        '550e8400-e29b-41d4-a716-446655440010'::uuid
+    ])[1 + floor(random() * 10)::int] as user_id,
+    
+    -- Generate title
+    'Test Record #' || i || ' - ' || (ARRAY['Important', 'Regular', 'Draft', 'Published', 'Archived'])[1 + floor(random() * 5)::int] as title,
+    
+    -- Generate content with varying lengths
+    'This is the content for record ' || i || '. ' || 
+    repeat('Lorem ipsum dolor sit amet, consectetur adipiscing elit. ', 1 + floor(random() * 10)::int) || 
+    'End of content.' as content,
+    
+    -- Random status
+    (ARRAY['active', 'inactive', 'pending', 'completed', 'archived'])[1 + floor(random() * 5)::int] as status,
+    
+    -- Generate random metadata
+    jsonb_build_object(
+        'record_number', i,
+        'category', (ARRAY['technology', 'business', 'personal', 'research', 'other'])[1 + floor(random() * 5)::int],
+        'priority', floor(random() * 10 + 1)::int,
+        'tags', (ARRAY['["tag1"]', '["tag1", "tag2"]', '["tag1", "tag2", "tag3"]', '["important"]', '[]'])[1 + floor(random() * 5)::int]::jsonb,
+        'is_featured', (random() > 0.5),
+        'view_count', floor(random() * 1000)::int,
+        'test_data', true
+    ) as metadata,
+    
+    -- Generate created_at timestamps spread over the last 90 days
+    CURRENT_TIMESTAMP - (interval '1 hour' * floor(random() * 2160)) as created_at,
+    
+    -- Updated_at should be equal or after created_at
+    CURRENT_TIMESTAMP - (interval '1 hour' * floor(random() * 720)) as updated_at
+FROM generate_series(1, 1500) AS i;
+
+-- Add some additional records with specific patterns for testing
+-- Records with null content
+INSERT INTO large_table (user_id, title, content, status, metadata)
+VALUES 
+    ('550e8400-e29b-41d4-a716-446655440001'::uuid, 'Record with null content #1', NULL, 'active', '{"special": "null_content"}'),
+    ('550e8400-e29b-41d4-a716-446655440002'::uuid, 'Record with null content #2', NULL, 'inactive', '{"special": "null_content"}'),
+    ('550e8400-e29b-41d4-a716-446655440003'::uuid, 'Record with null content #3', NULL, 'pending', '{"special": "null_content"}');
+
+-- Records with very long content
+INSERT INTO large_table (user_id, title, content, status, metadata)
+VALUES 
+    ('550e8400-e29b-41d4-a716-446655440004'::uuid, 
+     'Record with very long content', 
+     repeat('This is a very long text. ', 500), 
+     'active', 
+     '{"special": "long_content"}');
+
+-- Records with special characters
+INSERT INTO large_table (user_id, title, content, status, metadata)
+VALUES 
+    ('550e8400-e29b-41d4-a716-446655440005'::uuid, 
+     'Record with special chars: ñ, é, ü, 中文, 🎉', 
+     'Content with special characters: "quoted", ''single quotes'', backslash \, tab	character, newline
+character', 
+     'active', 
+     '{"special": "special_chars", "unicode": "测试"}');
+
+-- Records with complex JSON metadata
+INSERT INTO large_table (user_id, title, content, status, metadata)
+VALUES 
+    ('550e8400-e29b-41d4-a716-446655440006'::uuid, 
+     'Record with complex metadata', 
+     'This record has complex nested JSON metadata', 
+     'active', 
+     '{
+        "nested": {
+            "level1": {
+                "level2": {
+                    "level3": "deep value"
+                }
+            }
+        },
+        "array": [1, 2, 3, 4, 5],
+        "mixed": {
+            "string": "text",
+            "number": 123.45,
+            "boolean": true,
+            "null_value": null
+        }
+     }');
+
+-- Summary comment
+-- Total records inserted: 1506 (1500 from generate_series + 6 special test cases)

package/backend/tests/manual/setup-large-table-extras.sql

@@ -0,0 +1,34 @@
+-- Add indexes
+CREATE INDEX IF NOT EXISTS idx_large_table_user_id ON large_table(user_id);
+CREATE INDEX IF NOT EXISTS idx_large_table_created_at ON large_table(created_at);
+CREATE INDEX IF NOT EXISTS idx_large_table_status ON large_table(status);
+
+-- Create trigger function for updating updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create trigger to automatically update updated_at
+DROP TRIGGER IF EXISTS update_large_table_updated_at ON large_table;
+CREATE TRIGGER update_large_table_updated_at 
+    BEFORE UPDATE ON large_table
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- Enable Row Level Security
+ALTER TABLE large_table ENABLE ROW LEVEL SECURITY;
+
+-- Create RLS policies
+DROP POLICY IF EXISTS "Enable read access for all users" ON large_table;
+CREATE POLICY "Enable read access for all users" 
+    ON large_table 
+    FOR SELECT 
+    USING (true);
+
+-- Grant permissions
+GRANT ALL ON large_table TO anon;
+GRANT ALL ON large_table TO authenticated;