-
-
Privacy Controls
-
- This section is under development. You'll be able to control who can see
- your profile, playlists, and listening activity here.
-
+
+
);
}
+// Outer component that wraps content with SettingsPageWrapper
+export default function PrivacySettingsPage() {
+ return (
+
+
+
+ );
+}
diff --git a/apps/web/components/PrivacyToggle.jsx b/apps/web/components/PrivacyToggle.jsx
new file mode 100644
index 0000000..5f4111d
--- /dev/null
+++ b/apps/web/components/PrivacyToggle.jsx
@@ -0,0 +1,560 @@
+'use client';
+
+import { useState, useRef, useEffect } from 'react';
+import { Eye, EyeOff, Globe, Users, Lock, ChevronDown, AlertTriangle, X } from 'lucide-react';
+
+/**
+ * ConfirmationDialog - Modal dialog for confirming restrictive privacy changes
+ */
+function ConfirmationDialog({ isOpen, onConfirm, onCancel, title, message, confirmText = 'Confirm', cancelText = 'Cancel' }) {
+ if (!isOpen) return null;
+
+ // Focus management for accessibility
+ const cancelButtonRef = useRef(null);
+
+ useEffect(() => {
+ if (isOpen && cancelButtonRef.current) {
+ cancelButtonRef.current.focus();
+ }
+ }, [isOpen]);
+
+ // Handle keyboard events
+ const handleKeyDown = (e) => {
+ if (e.key === 'Escape') {
+ onCancel();
+ }
+ };
+
+ return (
+
+ {/* Backdrop */}
+
+
+ {/* Dialog */}
+
e.stopPropagation()}
+ >
+
+
+
+
+
+ {title}
+
+
+ {message}
+
+
+
+
+
+
+
+
+
+
+
+
+ );
+}
+
+/**
+ * PrivacyToggle - Reusable toggle component for boolean privacy settings
+ *
+ * @param {string} id - Input ID
+ * @param {string} label - Toggle label
+ * @param {string} description - Explanation text
+ * @param {boolean} checked - Current value
+ * @param {function} onChange - Change handler
+ * @param {boolean} disabled - Whether toggle is disabled
+ * @param {boolean} requireConfirmation - Whether to show confirmation dialog when turning off
+ */
+export function PrivacyToggle({
+ id,
+ label,
+ description,
+ checked,
+ onChange,
+ disabled = false,
+ requireConfirmation = false,
+ confirmationTitle = 'Restrict Privacy Setting?',
+ confirmationMessage = 'This will make your information less visible to others. Are you sure you want to continue?',
+}) {
+ const [showConfirmation, setShowConfirmation] = useState(false);
+ const [pendingValue, setPendingValue] = useState(null);
+
+ const handleToggle = (newValue) => {
+ // If turning off (making more restrictive) and confirmation is required
+ if (requireConfirmation && checked && !newValue) {
+ setPendingValue(newValue);
+ setShowConfirmation(true);
+ } else {
+ onChange(newValue);
+ }
+ };
+
+ const handleConfirm = () => {
+ if (pendingValue !== null) {
+ onChange(pendingValue);
+ setPendingValue(null);
+ }
+ setShowConfirmation(false);
+ };
+
+ const handleCancel = () => {
+ setPendingValue(null);
+ setShowConfirmation(false);
+ };
+
+ // Keyboard navigation support
+ const handleKeyDown = (e) => {
+ if (e.key === 'Enter' || e.key === ' ') {
+ e.preventDefault();
+ handleToggle(!checked);
+ }
+ };
+
+ return (
+ <>
+
+
+
+ {description && (
+
+ {description}
+
+ )}
+
+
+ {/* Visual indicator */}
+ {checked ? (
+
+ ) : (
+
+ )}
+
+ {/* Toggle switch */}
+
+
+
+
+
+
+ );
+}
+
+/**
+ * PrivacyRadioGroup - Reusable radio group for multi-option privacy settings
+ *
+ * @param {string} name - Radio group name
+ * @param {string} label - Group label
+ * @param {string} description - Explanation text
+ * @param {Array} options - Array of {value, label, description, icon}
+ * @param {string} value - Current selected value
+ * @param {function} onChange - Change handler
+ * @param {boolean} disabled - Whether group is disabled
+ * @param {boolean} requireConfirmation - Whether to show confirmation for restrictive changes
+ */
+export function PrivacyRadioGroup({
+ name,
+ label,
+ description,
+ options = [],
+ value,
+ onChange,
+ disabled = false,
+ requireConfirmation = false,
+}) {
+ const [showConfirmation, setShowConfirmation] = useState(false);
+ const [pendingValue, setPendingValue] = useState(null);
+
+ const IconMap = {
+ Globe,
+ Users,
+ Lock,
+ Eye,
+ EyeOff,
+ };
+
+ // Define privacy level hierarchy (higher = more restrictive)
+ const privacyLevels = {
+ 'public': 0,
+ 'friends': 1,
+ 'private': 2,
+ };
+
+ const getPrivacyLevel = (val) => {
+ return privacyLevels[val] ?? 0;
+ };
+
+ const handleChange = (newValue) => {
+ const currentLevel = getPrivacyLevel(value);
+ const newLevel = getPrivacyLevel(newValue);
+
+ // If making more restrictive and confirmation is required
+ if (requireConfirmation && newLevel > currentLevel) {
+ const newOption = options.find(opt => opt.value === newValue);
+ setPendingValue(newValue);
+ setShowConfirmation(true);
+ } else {
+ onChange(newValue);
+ }
+ };
+
+ const handleConfirm = () => {
+ if (pendingValue !== null) {
+ onChange(pendingValue);
+ setPendingValue(null);
+ }
+ setShowConfirmation(false);
+ };
+
+ const handleCancel = () => {
+ setPendingValue(null);
+ setShowConfirmation(false);
+ };
+
+ const pendingOption = pendingValue ? options.find(opt => opt.value === pendingValue) : null;
+
+ return (
+ <>
+
+
+
+ {label}
+
+ {description && (
+
+ {description}
+
+ )}
+
+
+
+ {options.map((option, index) => {
+ const Icon = IconMap[option.icon] || Globe;
+ const isSelected = value === option.value;
+ const optionId = `${name}-${option.value}`;
+
+ return (
+
+ );
+ })}
+
+
+
+
+
+ );
+}
+
+/**
+ * PrivacyDropdown - Dropdown/select component for visibility levels
+ *
+ * @param {string} id - Input ID
+ * @param {string} label - Dropdown label
+ * @param {string} description - Explanation text
+ * @param {Array} options - Array of {value, label, description, icon}
+ * @param {string} value - Current selected value
+ * @param {function} onChange - Change handler
+ * @param {boolean} disabled - Whether dropdown is disabled
+ */
+export function PrivacyDropdown({
+ id,
+ label,
+ description,
+ options = [],
+ value,
+ onChange,
+ disabled = false,
+}) {
+ const [isOpen, setIsOpen] = useState(false);
+ const dropdownRef = useRef(null);
+ const buttonRef = useRef(null);
+
+ const IconMap = {
+ Globe,
+ Users,
+ Lock,
+ Eye,
+ EyeOff,
+ };
+
+ const selectedOption = options.find(opt => opt.value === value) || options[0];
+ const SelectedIcon = selectedOption ? IconMap[selectedOption.icon] || Globe : Globe;
+
+ // Close dropdown when clicking outside
+ useEffect(() => {
+ const handleClickOutside = (event) => {
+ if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
+ setIsOpen(false);
+ }
+ };
+
+ if (isOpen) {
+ document.addEventListener('mousedown', handleClickOutside);
+ return () => document.removeEventListener('mousedown', handleClickOutside);
+ }
+ }, [isOpen]);
+
+ // Keyboard navigation
+ const handleKeyDown = (e) => {
+ if (e.key === 'Escape') {
+ setIsOpen(false);
+ buttonRef.current?.focus();
+ } else if (e.key === 'Enter' || e.key === ' ') {
+ e.preventDefault();
+ if (!isOpen) {
+ setIsOpen(true);
+ }
+ }
+ };
+
+ const handleSelect = (optionValue) => {
+ onChange(optionValue);
+ setIsOpen(false);
+ buttonRef.current?.focus();
+ };
+
+ return (
+
+
+
+ {description && (
+
+ {description}
+
+ )}
+
+
+
+
+
+ {isOpen && (
+
+
+ {options.map((option) => {
+ const Icon = IconMap[option.icon] || Globe;
+ const isSelected = value === option.value;
+ const optionId = `${id}-option-${option.value}`;
+
+ return (
+
+ );
+ })}
+
+
+ )}
+
+
+ );
+}
diff --git a/apps/web/hooks/usePrivacySettings.js b/apps/web/hooks/usePrivacySettings.js
new file mode 100644
index 0000000..07abf80
--- /dev/null
+++ b/apps/web/hooks/usePrivacySettings.js
@@ -0,0 +1,109 @@
+'use client';
+
+import { useMutation, useQueryClient, useQuery } from '@tanstack/react-query';
+
+/**
+ * Fetch user privacy settings
+ *
+ * @returns {Object} Query object with privacy settings, loading, and error states
+ */
+export function usePrivacySettings() {
+ return useQuery({
+ queryKey: ['privacy'],
+ queryFn: async () => {
+ const response = await fetch('/api/user/privacy');
+ if (!response.ok) {
+ const errorData = await response.json().catch(() => ({}));
+ throw new Error(errorData.error || 'Failed to fetch privacy settings');
+ }
+ return await response.json();
+ },
+ staleTime: 60 * 1000, // 1 minute
+ });
+}
+
+/**
+ * Custom hook for privacy settings updates using TanStack Query
+ *
+ * Features:
+ * - Optimistic updates
+ * - Cache invalidation
+ * - Loading and error states
+ * - Success/error notifications
+ *
+ * @returns {Object} Mutation object with mutate function and state
+ */
+export function usePrivacySettingsUpdate() {
+ const queryClient = useQueryClient();
+
+ const mutation = useMutation({
+ mutationFn: async (privacyData) => {
+ const response = await fetch('/api/user/privacy', {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify(privacyData),
+ });
+
+ if (!response.ok) {
+ const errorData = await response.json().catch(() => ({}));
+ throw new Error(errorData.error || 'Failed to update privacy settings');
+ }
+
+ return response.json();
+ },
+ onMutate: async (newPrivacySettings) => {
+ // Cancel any outgoing refetches (so they don't overwrite our optimistic update)
+ await queryClient.cancelQueries({ queryKey: ['privacy'] });
+
+ // Snapshot the previous value
+ const previousPrivacySettings = queryClient.getQueryData(['privacy']);
+
+ // Optimistically update to the new value
+ queryClient.setQueryData(['privacy'], (old) => ({ ...old, ...newPrivacySettings }));
+
+ return { previousPrivacySettings };
+ },
+ onError: (err, newPrivacySettings, context) => {
+ // Rollback to the previous value on error
+ if (context?.previousPrivacySettings) {
+ queryClient.setQueryData(['privacy'], context.previousPrivacySettings);
+ }
+
+ // Show error notification
+ if (typeof window !== 'undefined') {
+ window.dispatchEvent(new CustomEvent('show-toast', {
+ detail: {
+ type: 'error',
+ message: err.message || 'Failed to update privacy settings',
+ },
+ }));
+ }
+ },
+ onSuccess: (data) => {
+ // Update cache with server response
+ queryClient.setQueryData(['privacy'], data);
+
+ // Invalidate and refetch
+ queryClient.invalidateQueries({ queryKey: ['privacy'] });
+
+ // Show success notification
+ if (typeof window !== 'undefined') {
+ window.dispatchEvent(new CustomEvent('show-toast', {
+ detail: {
+ type: 'success',
+ message: data.message || 'Privacy settings updated successfully!',
+ },
+ }));
+ }
+ },
+ onSettled: () => {
+ // Ensure refetch happens after mutation is settled
+ queryClient.invalidateQueries({ queryKey: ['privacy'] });
+ },
+ });
+
+ return mutation;
+}
+
diff --git a/apps/web/lib/migrations/create_privacy_settings_table.sql b/apps/web/lib/migrations/create_privacy_settings_table.sql
new file mode 100644
index 0000000..9a256e8
--- /dev/null
+++ b/apps/web/lib/migrations/create_privacy_settings_table.sql
@@ -0,0 +1,161 @@
+-- ============================================
+-- Privacy Settings Table Migration
+-- Task 3.5: Create Privacy Database Table
+-- ============================================
+--
+-- This migration creates the user_privacy_settings table
+-- and related infrastructure for privacy settings management.
+--
+-- Run this migration in your Supabase SQL editor or via
+-- your database migration tool.
+--
+-- See SUPABASE_PRIVACY_SETTINGS_SETUP.md for detailed
+-- documentation and setup instructions.
+-- ============================================
+
+-- 1. Create user_privacy_settings table
+CREATE TABLE IF NOT EXISTS user_privacy_settings (
+ id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+ user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+
+ -- Visibility Settings
+ profile_visibility VARCHAR(20) NOT NULL DEFAULT 'public',
+ playlist_visibility VARCHAR(20) NOT NULL DEFAULT 'public',
+ song_of_day_visibility VARCHAR(20) NOT NULL DEFAULT 'public',
+
+ -- Boolean Settings
+ listening_activity_visible BOOLEAN NOT NULL DEFAULT true,
+ searchable BOOLEAN NOT NULL DEFAULT true,
+ activity_feed_visible BOOLEAN NOT NULL DEFAULT true,
+
+ -- Friend Request Settings
+ friend_request_setting VARCHAR(20) NOT NULL DEFAULT 'everyone',
+
+ -- Timestamps
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+
+ -- Constraints
+ UNIQUE(user_id),
+ CHECK (profile_visibility IN ('public', 'friends', 'private')),
+ CHECK (playlist_visibility IN ('public', 'friends', 'private')),
+ CHECK (song_of_day_visibility IN ('public', 'friends', 'private')),
+ CHECK (friend_request_setting IN ('everyone', 'friends_of_friends', 'nobody'))
+);
+
+-- 2. Create indexes for performance
+CREATE INDEX IF NOT EXISTS idx_user_privacy_settings_user_id
+ ON user_privacy_settings(user_id);
+
+-- 3. Create function to update updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+ NEW.updated_at = NOW();
+ RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- 4. Create trigger to automatically update updated_at
+DROP TRIGGER IF EXISTS update_user_privacy_settings_updated_at ON user_privacy_settings;
+CREATE TRIGGER update_user_privacy_settings_updated_at
+ BEFORE UPDATE ON user_privacy_settings
+ FOR EACH ROW
+ EXECUTE FUNCTION update_updated_at_column();
+
+-- 5. Enable Row Level Security
+ALTER TABLE user_privacy_settings ENABLE ROW LEVEL SECURITY;
+
+-- 6. Create RLS policies
+-- Policy: Users can view their own privacy settings
+DROP POLICY IF EXISTS "Users can view own privacy settings" ON user_privacy_settings;
+CREATE POLICY "Users can view own privacy settings"
+ON user_privacy_settings
+FOR SELECT
+USING (auth.uid() = user_id);
+
+-- Policy: Users can insert their own privacy settings
+DROP POLICY IF EXISTS "Users can insert own privacy settings" ON user_privacy_settings;
+CREATE POLICY "Users can insert own privacy settings"
+ON user_privacy_settings
+FOR INSERT
+WITH CHECK (auth.uid() = user_id);
+
+-- Policy: Users can update their own privacy settings
+DROP POLICY IF EXISTS "Users can update own privacy settings" ON user_privacy_settings;
+CREATE POLICY "Users can update own privacy settings"
+ON user_privacy_settings
+FOR UPDATE
+USING (auth.uid() = user_id)
+WITH CHECK (auth.uid() = user_id);
+
+-- Policy: Users can delete their own privacy settings
+DROP POLICY IF EXISTS "Users can delete own privacy settings" ON user_privacy_settings;
+CREATE POLICY "Users can delete own privacy settings"
+ON user_privacy_settings
+FOR DELETE
+USING (auth.uid() = user_id);
+
+-- 7. (Optional) Create audit log table for privacy changes
+CREATE TABLE IF NOT EXISTS privacy_settings_audit_log (
+ id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+ user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+ action VARCHAR(50) NOT NULL DEFAULT 'privacy_settings_updated',
+ details JSONB NOT NULL,
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Indexes for audit log
+CREATE INDEX IF NOT EXISTS idx_privacy_audit_log_user_id
+ ON privacy_settings_audit_log(user_id);
+CREATE INDEX IF NOT EXISTS idx_privacy_audit_log_created_at
+ ON privacy_settings_audit_log(created_at DESC);
+
+-- Enable RLS on audit log
+ALTER TABLE privacy_settings_audit_log ENABLE ROW LEVEL SECURITY;
+
+-- Policy: Users can view their own audit logs
+DROP POLICY IF EXISTS "Users can view own audit logs" ON privacy_settings_audit_log;
+CREATE POLICY "Users can view own audit logs"
+ON privacy_settings_audit_log
+FOR SELECT
+USING (auth.uid() = user_id);
+
+-- 8. (Optional) Create function to automatically create default privacy settings for new users
+CREATE OR REPLACE FUNCTION create_default_privacy_settings()
+RETURNS TRIGGER AS $$
+BEGIN
+ INSERT INTO user_privacy_settings (user_id)
+ VALUES (NEW.id)
+ ON CONFLICT (user_id) DO NOTHING;
+ RETURN NEW;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+
+-- Trigger to automatically create privacy settings when a new user is created
+DROP TRIGGER IF EXISTS on_user_created_create_privacy_settings ON auth.users;
+CREATE TRIGGER on_user_created_create_privacy_settings
+AFTER INSERT ON auth.users
+FOR EACH ROW
+EXECUTE FUNCTION create_default_privacy_settings();
+
+-- ============================================
+-- Migration Complete
+-- ============================================
+--
+-- The privacy settings table is now set up with:
+-- ✓ Table structure with all required columns
+-- ✓ Check constraints for enum validation
+-- ✓ Unique constraint on user_id
+-- ✓ Indexes for performance
+-- ✓ Automatic updated_at trigger
+-- ✓ Row Level Security policies
+-- ✓ Optional audit logging table
+-- ✓ Optional automatic default settings for new users
+--
+-- Next steps:
+-- 1. Verify the migration ran successfully
+-- 2. Test the API endpoints
+-- 3. Verify RLS policies work correctly
+-- ============================================
+
diff --git a/apps/web/lib/privacy/enforcer.js b/apps/web/lib/privacy/enforcer.js
new file mode 100644
index 0000000..439e22a
--- /dev/null
+++ b/apps/web/lib/privacy/enforcer.js
@@ -0,0 +1,469 @@
+/**
+ * Privacy Enforcement Middleware
+ *
+ * Utility functions to enforce privacy rules across the application.
+ * These functions check privacy settings and determine what content
+ * users can access based on their relationship and privacy preferences.
+ *
+ * @module privacy/enforcer
+ */
+
+/**
+ * Privacy level constants
+ */
+const PRIVACY_LEVELS = {
+ PUBLIC: 'public',
+ FRIENDS: 'friends',
+ PRIVATE: 'private',
+};
+
+/**
+ * Friend request setting constants
+ */
+const FRIEND_REQUEST_SETTINGS = {
+ EVERYONE: 'everyone',
+ FRIENDS_OF_FRIENDS: 'friends_of_friends',
+ NOBODY: 'nobody',
+};
+
+/**
+ * In-memory cache for privacy settings
+ * Key: user_id, Value: { settings, timestamp }
+ */
+const privacyCache = new Map();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Fetch privacy settings for a user (with caching)
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} userId - User ID to fetch settings for
+ * @param {boolean} forceRefresh - Force refresh cache
+ * @returns {Promise
} Privacy settings object or null if not found
+ */
+async function fetchPrivacySettings(supabase, userId, forceRefresh = false) {
+ // Check cache first
+ if (!forceRefresh) {
+ const cached = privacyCache.get(userId);
+ if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+ return cached.settings;
+ }
+ }
+
+ try {
+ const { data, error } = await supabase
+ .from('user_privacy_settings')
+ .select('*')
+ .eq('user_id', userId)
+ .single();
+
+ if (error && error.code !== 'PGRST116') {
+ console.error('[privacy/enforcer] Error fetching privacy settings:', error);
+ return null;
+ }
+
+ // Use defaults if no settings exist
+ const settings = data || getDefaultPrivacySettings();
+
+ // Cache the settings
+ privacyCache.set(userId, {
+ settings,
+ timestamp: Date.now(),
+ });
+
+ return settings;
+ } catch (error) {
+ console.error('[privacy/enforcer] Unexpected error fetching privacy settings:', error);
+ return null;
+ }
+}
+
+/**
+ * Get default privacy settings
+ *
+ * @returns {Object} Default privacy settings
+ */
+function getDefaultPrivacySettings() {
+ return {
+ profile_visibility: PRIVACY_LEVELS.PUBLIC,
+ playlist_visibility: PRIVACY_LEVELS.PUBLIC,
+ listening_activity_visible: true,
+ song_of_day_visibility: PRIVACY_LEVELS.PUBLIC,
+ friend_request_setting: FRIEND_REQUEST_SETTINGS.EVERYONE,
+ searchable: true,
+ activity_feed_visible: true,
+ };
+}
+
+/**
+ * Check if two users are friends
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} userId1 - First user ID
+ * @param {string} userId2 - Second user ID
+ * @returns {Promise} True if users are friends
+ */
+async function areFriends(supabase, userId1, userId2) {
+ if (userId1 === userId2) {
+ return true; // User is always "friends" with themselves
+ }
+
+ try {
+ // Check if there's a friendship in either direction
+ const { data, error } = await supabase
+ .from('friends')
+ .select('id')
+ .or(`user_id.eq.${userId1},friend_id.eq.${userId1}`)
+ .or(`user_id.eq.${userId2},friend_id.eq.${userId2}`)
+ .limit(1);
+
+ if (error) {
+ console.error('[privacy/enforcer] Error checking friendship:', error);
+ return false;
+ }
+
+ // Check if the friendship exists between these two users
+ return data?.some(friendship => {
+ const u1 = friendship.user_id === userId1 || friendship.friend_id === userId1;
+ const u2 = friendship.user_id === userId2 || friendship.friend_id === userId2;
+ return u1 && u2;
+ }) || false;
+ } catch (error) {
+ console.error('[privacy/enforcer] Unexpected error checking friendship:', error);
+ return false;
+ }
+}
+
+/**
+ * Check if a viewer can view a target user's profile
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} viewerId - ID of the user viewing (null/undefined for anonymous)
+ * @param {string} targetUserId - ID of the user whose profile is being viewed
+ * @returns {Promise} True if viewer can see the profile
+ */
+export async function canViewProfile(supabase, viewerId, targetUserId) {
+ // User can always view their own profile
+ if (viewerId === targetUserId) {
+ return true;
+ }
+
+ // Fetch target user's privacy settings
+ const privacySettings = await fetchPrivacySettings(supabase, targetUserId);
+ if (!privacySettings) {
+ // Default to public if no settings
+ return true;
+ }
+
+ const visibility = privacySettings.profile_visibility;
+
+ // Public profiles are visible to everyone
+ if (visibility === PRIVACY_LEVELS.PUBLIC) {
+ return true;
+ }
+
+ // Private profiles are only visible to the user
+ if (visibility === PRIVACY_LEVELS.PRIVATE) {
+ return false;
+ }
+
+ // Friends-only profiles require authentication and friendship
+ if (visibility === PRIVACY_LEVELS.FRIENDS) {
+ if (!viewerId) {
+ return false; // Anonymous users can't see friends-only profiles
+ }
+ return await areFriends(supabase, viewerId, targetUserId);
+ }
+
+ // Default to false for unknown visibility levels
+ return false;
+}
+
+/**
+ * Check if a viewer can view a target user's playlists
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} viewerId - ID of the user viewing (null/undefined for anonymous)
+ * @param {string} targetUserId - ID of the user whose playlists are being viewed
+ * @returns {Promise} True if viewer can see the playlists
+ */
+export async function canViewPlaylists(supabase, viewerId, targetUserId) {
+ // User can always view their own playlists
+ if (viewerId === targetUserId) {
+ return true;
+ }
+
+ // Fetch target user's privacy settings
+ const privacySettings = await fetchPrivacySettings(supabase, targetUserId);
+ if (!privacySettings) {
+ // Default to public if no settings
+ return true;
+ }
+
+ const visibility = privacySettings.playlist_visibility;
+
+ // Public playlists are visible to everyone
+ if (visibility === PRIVACY_LEVELS.PUBLIC) {
+ return true;
+ }
+
+ // Private playlists are only visible to the user
+ if (visibility === PRIVACY_LEVELS.PRIVATE) {
+ return false;
+ }
+
+ // Friends-only playlists require authentication and friendship
+ if (visibility === PRIVACY_LEVELS.FRIENDS) {
+ if (!viewerId) {
+ return false; // Anonymous users can't see friends-only playlists
+ }
+ return await areFriends(supabase, viewerId, targetUserId);
+ }
+
+ // Default to false for unknown visibility levels
+ return false;
+}
+
+/**
+ * Check if a viewer can see a target user's listening activity
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} viewerId - ID of the user viewing (null/undefined for anonymous)
+ * @param {string} targetUserId - ID of the user whose activity is being viewed
+ * @returns {Promise} True if viewer can see the listening activity
+ */
+export async function canViewListeningActivity(supabase, viewerId, targetUserId) {
+ // User can always view their own listening activity
+ if (viewerId === targetUserId) {
+ return true;
+ }
+
+ // Fetch target user's privacy settings
+ const privacySettings = await fetchPrivacySettings(supabase, targetUserId);
+ if (!privacySettings) {
+ // Default to visible if no settings
+ return true;
+ }
+
+ // Check if listening activity is visible
+ return privacySettings.listening_activity_visible === true;
+}
+
+/**
+ * Check if a viewer can see a target user's Song of the Day
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} viewerId - ID of the user viewing (null/undefined for anonymous)
+ * @param {string} targetUserId - ID of the user whose Song of the Day is being viewed
+ * @returns {Promise} True if viewer can see the Song of the Day
+ */
+export async function canViewSongOfDay(supabase, viewerId, targetUserId) {
+ // User can always view their own Song of the Day
+ if (viewerId === targetUserId) {
+ return true;
+ }
+
+ // Fetch target user's privacy settings
+ const privacySettings = await fetchPrivacySettings(supabase, targetUserId);
+ if (!privacySettings) {
+ // Default to public if no settings
+ return true;
+ }
+
+ const visibility = privacySettings.song_of_day_visibility;
+
+ // Public Song of the Day is visible to everyone
+ if (visibility === PRIVACY_LEVELS.PUBLIC) {
+ return true;
+ }
+
+ // Private Song of the Day is only visible to the user
+ if (visibility === PRIVACY_LEVELS.PRIVATE) {
+ return false;
+ }
+
+ // Friends-only Song of the Day requires authentication and friendship
+ if (visibility === PRIVACY_LEVELS.FRIENDS) {
+ if (!viewerId) {
+ return false; // Anonymous users can't see friends-only Song of the Day
+ }
+ return await areFriends(supabase, viewerId, targetUserId);
+ }
+
+ // Default to false for unknown visibility levels
+ return false;
+}
+
+/**
+ * Check if a user appears in search results
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} userId - User ID to check
+ * @returns {Promise} True if user should appear in search
+ */
+export async function isSearchable(supabase, userId) {
+ const privacySettings = await fetchPrivacySettings(supabase, userId);
+ if (!privacySettings) {
+ // Default to searchable if no settings
+ return true;
+ }
+
+ return privacySettings.searchable === true;
+}
+
+/**
+ * Check if a viewer can see a target user's activity feed
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {string} viewerId - ID of the user viewing (null/undefined for anonymous)
+ * @param {string} targetUserId - ID of the user whose activity feed is being viewed
+ * @returns {Promise} True if viewer can see the activity feed
+ */
+export async function canViewActivityFeed(supabase, viewerId, targetUserId) {
+ // User can always view their own activity feed
+ if (viewerId === targetUserId) {
+ return true;
+ }
+
+ // Fetch target user's privacy settings
+ const privacySettings = await fetchPrivacySettings(supabase, targetUserId);
+ if (!privacySettings) {
+ // Default to visible if no settings
+ return true;
+ }
+
+ // Check if activity feed is visible
+ return privacySettings.activity_feed_visible === true;
+}
+
+/**
+ * Apply privacy filter to a users query
+ * Filters out users that shouldn't appear based on privacy settings
+ *
+ * @param {Object} supabase - Supabase client instance
+ * @param {Object} query - Supabase query builder (users table)
+ * @param {string} viewerId - ID of the user viewing (null/undefined for anonymous)
+ * @returns {Promise