diff --git a/CHANGELOG.md b/CHANGELOG.md index e2168ef..2ff08d4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,149 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [2.0.0] - 2025-10-09 + +### Added + +- **Real-time Collaboration Infrastructure**: Complete real-time collaboration system for all document types + + - WebSocket-based real-time updates using Supabase Realtime channels + - Live presence indicators showing active users and their cursor positions + - Broadcast-first architecture for immediate UI updates before database saves + - Conflict detection and resolution with version-based optimistic locking + - User avatars and activity indicators in collaboration toolbar + - Connection status monitoring with automatic reconnection + - Save status indicators (saving, saved, error states) with retry functionality + - Version history modal showing all document changes with timestamps and authors + - Document activity logging for audit trails and collaboration tracking + +- **Shared Edit Links**: Anonymous editing capabilities for all document types + + - Secure share codes for view-only and edit access + - Anonymous users can edit documents via shared edit links without authentication + - RLS-bypassing RPC function (`update_shared_resource`) with SECURITY DEFINER for anonymous saves + - Share link access tracking (last accessed timestamps, access counts) + - Seamless integration with real-time collaboration for shared users + +- **Document Versioning System**: Comprehensive version tracking and history + + - Automatic version increments on every save with optimistic locking + - Full document history tables for all document types (patch sheets, stage plots, technical riders, run of shows, production schedules, pixel maps, corporate mic plots, theater mic plots) + - Database triggers for automatic history capture on updates + - `last_edited` timestamp tracking on all documents + - Metadata JSONB columns for extensible document properties + +- **Collaboration Components**: Rich UI components for collaboration features + + - `CollaborationToolbar`: Unified toolbar showing save status, active users, connection status, and history access + - `SaveIndicator`: Real-time save status with spinning indicators and error messages + - `PresenceIndicator`: Avatar stack showing all active users with tooltips + - `ConnectionStatus`: Connection health indicator with automatic reconnection + - `ConflictResolution`: Modal for resolving version conflicts with side-by-side comparison + - `History` components: Version history viewer with diff capabilities + +- **Offline Support Infrastructure**: Queue-based offline editing capabilities + + - `pending_saves` table for queuing saves when offline + - Automatic retry logic when connection is restored + - Local state persistence using browser storage + - Optimistic UI updates with background synchronization + +- **Document Locks**: Optimistic locking to prevent concurrent edit conflicts + - `document_locks` table tracking active editors + - Lock expiration (5 minutes) to prevent stale locks + - Visual indicators showing who is currently editing + - Automatic lock cleanup on disconnect or timeout + +### Changed + +- **PatchSheetEditor**: Integrated real-time collaboration + + - Added broadcast calls for all input/output channel changes + - Fixed infinite re-render loop in PatchSheetOutputs component + - Counter-based remote update detection to handle React Strict Mode + - Real-time propagation of channel additions, deletions, and property changes + +- **StagePlotEditor**: Complete collaboration integration + + - Added broadcast calls for all 13 state-changing operations (add element, drag, rotate, resize, delete, duplicate, property changes, stage size, background image, name) + - Moved CollaborationToolbar to Header component for consistent UI + - Real-time element synchronization across all collaborators + - Shared edit link support with anonymous user editing + +- **TheaterMicPlotEditor**: Enabled real-time collaboration + + - Added broadcast calls for all actor management operations (add, update, delete, name changes) + - Fixed 406 errors for anonymous users by adding shareCode parameter to useAutoSave + - Real-time actor list synchronization + +- **CorporateMicPlotEditor**: Enabled real-time collaboration + + - Added broadcast calls for all presenter management operations (add, update, delete, name changes) + - Fixed 406 errors for anonymous users by adding shareCode parameter to useAutoSave + - Real-time presenter list synchronization + +- **Database Schema**: Major collaboration infrastructure additions + + - Added `version` and `last_edited` columns to all document tables + - Created 8 history tables (one per document type) with automatic triggers + - Added `document_activity` table for audit logging + - Added `pending_saves` table for offline queue + - Added `document_locks` table for editing locks + - Added `metadata` JSONB columns to all document tables + - Enabled Supabase Realtime replication for all document tables + - Created 166+ RLS policies for collaboration tables + +- **Hooks**: New collaboration-focused React hooks + + - `useCollaboration`: Central hook managing realtime subscriptions, broadcasts, and remote update handling + - `usePresence`: Manages user presence tracking and active user list + - `useAutoSave`: Enhanced with shareCode support for anonymous editing and version conflict detection + +- **Libraries**: New collaboration utility libraries + + - `collaboration.ts`: Core collaboration logic (broadcasts, subscriptions, conflict resolution) + - `autoSave.ts`: Enhanced with RPC routing for shared edit links + - `offlineQueue.ts`: Queue management for offline editing support + +- **Web App Version**: Updated to `2.0.0` (major version bump for collaboration features) + +### Fixed + +- **PatchSheetOutputs Infinite Loop**: Eliminated infinite re-render cycles + + - Removed unnecessary ref tracking logic that caused circular dependencies + - Simplified useEffect structure to match working PatchSheetInputs pattern + - Fixed state synchronization between parent and child components + +- **Shared Edit Link Saves**: Fixed 406 errors for anonymous users + + - Added shareCode parameter routing through `update_shared_resource` RPC function + - RPC function uses SECURITY DEFINER to bypass RLS policies + - Anonymous users can now save edits on all shared edit documents + +- **JSONB Data Handling**: Fixed data corruption in shared resource updates + - Created helper functions (`is_jsonb_column`, `pg_typeof_column`) to detect JSONB columns + - Used `->` operator for JSONB columns (preserves structure), `->>` for other types + - Changed RETURNING clause from `to_jsonb()` to `row_to_json()` to prevent double-serialization + - Ensured JSONB columns maintain their structure through save/load cycles + +### Database Migrations + +- `20251007100000_add_version_columns_to_documents.sql` - Version tracking columns +- `20251007110000_create_document_history_tables.sql` - History tables for all document types +- `20251007120000_create_document_activity_table.sql` - Activity audit logging +- `20251007130000_create_pending_saves_table.sql` - Offline save queue +- `20251007140000_create_document_locks_table.sql` - Document locking system +- `20251007145000_add_metadata_columns_to_documents.sql` - Extensible metadata storage +- `20251007150000_add_automatic_history_triggers.sql` - Automatic history capture +- `20251007160000_enable_realtime_replication.sql` - Realtime replication for collaboration +- `20251007170000_add_rls_policies_for_collaboration.sql` - Security policies for collaboration tables +- `20251008180000_add_update_shared_resource_rpc.sql` - RPC function for shared edit links +- `20251008190000_fix_update_shared_resource_jsonb_extraction.sql` - JSONB extraction fix (attempt 1) +- `20251008204809_fix_jsonb_extraction_in_update_shared_resource.sql` - JSONB extraction fix (attempt 2) +- `20251008210000_fix_update_shared_resource_returning.sql` - RETURNING clause fix using row_to_json() + ## [1.5.6.8] - 2025-09-30 ### Added diff --git a/apps/web/package.json b/apps/web/package.json index 3cf04fe..bdeadeb 100644 --- a/apps/web/package.json +++ b/apps/web/package.json @@ -1,7 +1,7 @@ { "name": "@sounddocs/web", "private": true, - "version": "1.5.6.8", + "version": "2.0.0", "type": "module", "scripts": { "dev": "vite", @@ -16,6 +16,7 @@ "@radix-ui/react-radio-group": "^1.3.8", "@radix-ui/react-scroll-area": "^1.2.10", "@radix-ui/react-slot": "^1.2.3", + "@radix-ui/react-tooltip": "^1.2.8", "@sounddocs/analyzer-lite": "workspace:*", "@sounddocs/analyzer-protocol": "workspace:*", "@supabase/supabase-js": "^2.49.4", diff --git a/apps/web/src/App.tsx b/apps/web/src/App.tsx index 20b1ee5..23a7ffe 100644 --- a/apps/web/src/App.tsx +++ b/apps/web/src/App.tsx @@ -74,7 +74,7 @@ function App() { return (
- + } /> } /> diff --git a/apps/web/src/components/CollaborationToolbar.tsx b/apps/web/src/components/CollaborationToolbar.tsx new file mode 100644 index 0000000..09fe73b --- /dev/null +++ b/apps/web/src/components/CollaborationToolbar.tsx @@ -0,0 +1,520 @@ +import * as React from "react"; +import { History, Users, Wifi, WifiOff, Check, Loader2, AlertCircle } from "lucide-react"; +import { cn } from "@/lib/utils"; +import { Button } from "@/components/ui/button"; +import type { SaveStatus, PresenceUser, ConnectionStatus } from "@/types/collaboration"; + +export interface CollaborationToolbarProps { + /** Current save status */ + saveStatus: SaveStatus; + /** Timestamp when last saved */ + lastSavedAt?: Date; + /** Error message for save failures */ + saveError?: string; + /** Callback when user clicks retry button */ + onRetry?: () => void; + /** List of active users */ + activeUsers: PresenceUser[]; + /** Current user ID (to exclude from active users list) */ + currentUserId?: string; + /** Connection status */ + connectionStatus: ConnectionStatus; + /** Connection latency in milliseconds */ + latency?: number; + /** Callback when user clicks history button */ + onOpenHistory: () => void; + /** Whether to show the history button */ + showHistory?: boolean; + /** Layout variant */ + variant?: "horizontal" | "vertical"; + /** Position on screen */ + position?: "top-right" | "top-left" | "bottom-right" | "bottom-left"; + /** Additional CSS classes */ + className?: string; +} + +type ExpandedSection = "connection" | "users" | "save" | null; + +/** + * Generates initials from a name or email + */ +const getInitials = (name: string | undefined, email: string): string => { + if (name) { + const parts = name.trim().split(/\s+/); + if (parts.length >= 2) { + return `${parts[0][0]}${parts[parts.length - 1][0]}`.toUpperCase(); + } + return name.substring(0, 2).toUpperCase(); + } + return email.substring(0, 2).toUpperCase(); +}; + +/** + * CollaborationToolbar Component + * + * Icon-based toolbar with expandable sections showing save status, active users, + * connection status, and access to version history. Sections auto-expand on important events. + * + * @example + * ```tsx + * setHistoryOpen(true)} + * /> + * ``` + */ +export const CollaborationToolbar: React.FC = ({ + saveStatus, + lastSavedAt, + saveError, + onRetry, + activeUsers, + currentUserId, + connectionStatus, + latency, + onOpenHistory, + showHistory = true, + position = "top-right", + className, +}) => { + const [expandedSection, setExpandedSection] = React.useState(null); + const [autoExpandedSection, setAutoExpandedSection] = React.useState(null); + const [isPulsing, setIsPulsing] = React.useState(false); + const autoCollapseTimerRef = React.useRef(null); + + // Filter out current user + const otherUsers = React.useMemo(() => { + return activeUsers.filter((user) => user.userId !== currentUserId); + }, [activeUsers, currentUserId]); + + // Auto-expand on important events + React.useEffect(() => { + // Save errors + if (saveStatus === "error") { + setAutoExpandedSection("save"); + setIsPulsing(true); + clearAutoCollapseTimer(); + autoCollapseTimerRef.current = setTimeout(() => { + setAutoExpandedSection(null); + setIsPulsing(false); + }, 5000); + } + // New user joins (check if count increased) + // Note: This is a simplified check - could be enhanced with prev users comparison + }, [saveStatus]); + + // Auto-expand on connection issues + React.useEffect(() => { + if (connectionStatus === "disconnected" || connectionStatus === "error") { + setAutoExpandedSection("connection"); + setIsPulsing(true); + clearAutoCollapseTimer(); + autoCollapseTimerRef.current = setTimeout(() => { + setAutoExpandedSection(null); + setIsPulsing(false); + }, 4000); + } + }, [connectionStatus]); + + // Auto-expand when new user joins + const prevUserCountRef = React.useRef(otherUsers.length); + React.useEffect(() => { + if (otherUsers.length > prevUserCountRef.current && otherUsers.length > 0) { + setAutoExpandedSection("users"); + setIsPulsing(true); + clearAutoCollapseTimer(); + autoCollapseTimerRef.current = setTimeout(() => { + setAutoExpandedSection(null); + setIsPulsing(false); + }, 3000); + } + prevUserCountRef.current = otherUsers.length; + }, [otherUsers.length]); + + const clearAutoCollapseTimer = () => { + if (autoCollapseTimerRef.current) { + clearTimeout(autoCollapseTimerRef.current); + autoCollapseTimerRef.current = null; + } + }; + + // Cleanup on unmount + React.useEffect(() => { + return () => clearAutoCollapseTimer(); + }, []); + + const getPositionClasses = (): string => { + switch (position) { + case "top-right": + return "top-20 right-4 md:top-16"; + case "top-left": + return "top-20 left-4 md:top-16"; + case "bottom-right": + return "bottom-4 right-4"; + case "bottom-left": + return "bottom-4 left-4"; + } + }; + + const isExpanded = (section: ExpandedSection) => { + return expandedSection === section || autoExpandedSection === section; + }; + + const toggleSection = (section: ExpandedSection) => { + setExpandedSection((prev) => (prev === section ? null : section)); + clearAutoCollapseTimer(); + setAutoExpandedSection(null); + setIsPulsing(false); + }; + + const formatTime = (date: Date): string => { + return date.toLocaleTimeString("en-US", { + hour: "2-digit", + minute: "2-digit", + hour12: false, + }); + }; + + const getConnectionStatusConfig = () => { + switch (connectionStatus) { + case "connected": + return { + icon: , + color: "text-green-500", + bgColor: "bg-green-500/10", + label: "Online", + description: latency ? `${latency}ms latency` : "Connection active", + }; + case "connecting": + return { + icon: , + color: "text-yellow-500", + bgColor: "bg-yellow-500/10", + label: "Connecting", + description: "Attempting to reconnect...", + }; + case "disconnected": + case "error": + return { + icon: , + color: "text-red-500", + bgColor: "bg-red-500/10", + label: "Offline", + description: "Not connected to server", + }; + } + }; + + const getSaveStatusConfig = () => { + switch (saveStatus) { + case "idle": + return { + icon: , + color: "text-gray-400", + bgColor: "bg-gray-400/10", + label: "All changes saved", + }; + case "typing": + return { + icon: null, + color: "text-blue-400", + bgColor: "bg-blue-400/10", + label: "Typing...", + }; + case "saving": + return { + icon: , + color: "text-blue-400", + bgColor: "bg-blue-400/10", + label: "Saving...", + }; + case "saved": + return { + icon: , + color: "text-green-400", + bgColor: "bg-green-400/10", + label: lastSavedAt ? `Saved at ${formatTime(lastSavedAt)}` : "Saved", + }; + case "error": + return { + icon: , + color: "text-red-400", + bgColor: "bg-red-400/10", + label: saveError || "Failed to save", + }; + case "offline": + return { + icon: , + color: "text-yellow-400", + bgColor: "bg-yellow-400/10", + label: "Offline - Saved locally", + }; + } + }; + + const connectionConfig = getConnectionStatusConfig(); + const saveConfig = getSaveStatusConfig(); + + return ( +
+
+ {/* Connection Status Section */} +
+ +
+ +
+ + {/* Active Users Section */} +
+ +
+ +
+ + {/* Save Status Section */} +
+ +
+ + {/* History Button */} + {showHistory && ( + <> +
+ + + )} +
+
+ ); +}; + +CollaborationToolbar.displayName = "CollaborationToolbar"; diff --git a/apps/web/src/components/ConflictResolution.tsx b/apps/web/src/components/ConflictResolution.tsx new file mode 100644 index 0000000..a4c7395 --- /dev/null +++ b/apps/web/src/components/ConflictResolution.tsx @@ -0,0 +1,351 @@ +import * as React from "react"; +import { AlertTriangle, Check } from "lucide-react"; +import { cn } from "@/lib/utils"; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, +} from "@/components/ui/dialog"; +import { Button } from "@/components/ui/button"; +import { ScrollArea } from "@/components/ui/scroll-area"; +import { Checkbox } from "@/components/ui/checkbox"; +import { Label } from "@/components/ui/label"; +import type { DocumentConflict } from "@/types/collaboration"; + +export interface ConflictResolutionProps { + /** Whether the dialog is open */ + open: boolean; + /** Callback when dialog should close */ + onOpenChange: (open: boolean) => void; + /** List of conflicting fields */ + conflicts: DocumentConflict[]; + /** Document ID */ + documentId: string; + /** Callback when user chooses resolution strategy */ + onResolve: ( + strategy: "local" | "remote" | "merge", + mergedFields?: Record, + ) => void; + /** Whether resolution is in progress */ + resolving?: boolean; + /** Additional CSS classes */ + className?: string; +} + +/** + * ConflictField Component - Individual field conflict + */ +const ConflictField: React.FC<{ + conflict: DocumentConflict; + selectedVersion: "local" | "remote"; + onSelectionChange: (version: "local" | "remote") => void; +}> = ({ conflict, selectedVersion, onSelectionChange }) => { + const formatValue = (value: unknown): string => { + if (value === null) return "null"; + if (value === undefined) return "—"; + if (typeof value === "string") return value; + if (typeof value === "boolean") return value ? "true" : "false"; + if (typeof value === "number") return value.toString(); + if (Array.isArray(value)) { + if (value.length === 0) return "[]"; + return `[${value.length} items]`; + } + if (typeof value === "object") { + return JSON.stringify(value, null, 2); + } + return String(value); + }; + + const formatTimestamp = (timestamp: string): string => { + const date = new Date(timestamp); + return date.toLocaleString("en-US", { + month: "short", + day: "numeric", + hour: "2-digit", + minute: "2-digit", + }); + }; + + return ( +
+ {/* Field name */} +
+

{conflict.field}

+
+ + {/* Conflict options */} +
+ {/* Local version */} +
onSelectionChange("local")} + > +
+
+ checked && onSelectionChange("local")} + className="h-4 w-4" + /> +
+
+ +

+ Modified {formatTimestamp(conflict.localTimestamp)} +

+
+ 
+                  {formatValue(conflict.localValue)}
+
+
+
+
+
+ + {/* Remote version */} +
onSelectionChange("remote")} + > +
+
+ checked && onSelectionChange("remote")} + className="h-4 w-4" + /> +
+
+ +

+ Modified {formatTimestamp(conflict.remoteTimestamp)} +

+
+ 
+                  {formatValue(conflict.remoteValue)}
+
+
+
+
+
+
+
+ ); +}; + +/** + * ConflictResolution Component + * + * Displays a modal dialog when version conflicts are detected, + * allowing users to choose between their changes, remote changes, + * or manually merge field by field. + * + * @example + * ```tsx + * + * ``` + */ +export const ConflictResolution: React.FC = ({ + open, + onOpenChange, + conflicts = [], + documentId, + onResolve, + resolving = false, + className, +}) => { + const [resolutionMode, setResolutionMode] = React.useState<"choice" | "merge">("choice"); + const [fieldSelections, setFieldSelections] = React.useState>( + {}, + ); + + // Initialize field selections with suggested resolutions + React.useEffect(() => { + if (conflicts.length > 0) { + const initialSelections: Record = {}; + conflicts.forEach((conflict) => { + // Default to more recent change + const localTime = new Date(conflict.localTimestamp).getTime(); + const remoteTime = new Date(conflict.remoteTimestamp).getTime(); + initialSelections[conflict.field] = localTime > remoteTime ? "local" : "remote"; + }); + setFieldSelections(initialSelections); + } + }, [conflicts]); + + const handleQuickResolve = (strategy: "local" | "remote") => { + onResolve(strategy); + setResolutionMode("choice"); + }; + + const handleMergeResolve = () => { + onResolve("merge", fieldSelections); + setResolutionMode("choice"); + }; + + const handleFieldSelection = (field: string, version: "local" | "remote") => { + setFieldSelections((prev) => ({ + ...prev, + [field]: version, + })); + }; + + const allFieldsSelected = conflicts.every((conflict) => conflict.field in fieldSelections); + + return ( + + + + + + Version Conflict Detected + + + This document was modified by another user. Choose how to resolve the conflict. + + + + {resolutionMode === "choice" ? ( + /* Quick resolution options */ +
+

+ {conflicts.length} field{conflicts.length === 1 ? "" : "s"} ha + {conflicts.length === 1 ? "s" : "ve"} conflicting changes. Choose a resolution + strategy: +

+ +
+ {/* Keep my changes */} + + + {/* Use their changes */} + + + {/* Merge manually */} + +
+
+ ) : ( + /* Manual merge interface */ +
+
+

Select which version to keep for each field:

+ +
+ + +
+ {conflicts.map((conflict) => ( + handleFieldSelection(conflict.field, version)} + /> + ))} +
+ + + + + + +
+ )} + + + ); +}; + +ConflictResolution.displayName = "ConflictResolution"; diff --git a/apps/web/src/components/Header.tsx b/apps/web/src/components/Header.tsx index e1ec046..04dd93d 100644 --- a/apps/web/src/components/Header.tsx +++ b/apps/web/src/components/Header.tsx @@ -13,12 +13,14 @@ import { Link, useNavigate, useLocation } from "react-router-dom"; import { supabase } from "../lib/supabase"; import { ScheduleForExport } from "../lib/types"; import ProductionScheduleExport from "./production-schedule/ProductionScheduleExport"; +import { CollaborationToolbar, CollaborationToolbarProps } from "./CollaborationToolbar"; interface HeaderProps { dashboard?: boolean; onSignOut?: () => void; scheduleForExport?: ScheduleForExport; scheduleType?: "production" | "run-of-show"; + collaborationToolbar?: Omit; } const Header: React.FC = ({ @@ -26,6 +28,7 @@ const Header: React.FC = ({ onSignOut, scheduleForExport, scheduleType, + collaborationToolbar, }) => { const navigate = useNavigate(); const location = useLocation(); @@ -124,6 +127,13 @@ const Header: React.FC = ({ SoundDocs
+ {/* Collaboration Toolbar - integrated into header */} + {collaborationToolbar && ( +
+ +
+ )} + {/* Desktop Navigation */}
- {saveError && ( + {/* Error messages (for new documents or manual save errors) */} + {!collaborationEnabled && saveError && (

{saveError}

)} - {saveSuccess && ( + + {!collaborationEnabled && saveSuccess && (

Mic plot saved successfully!

@@ -337,22 +717,56 @@ const CorporateMicPlotEditor: React.FC = () => { ))}
-
- -
+ {/* Bottom Save button (only for new documents or shared edits) */} + {!collaborationEnabled && ( +
+ +
+ )}
+ {/* Collaboration Modals */} + {collaborationEnabled && ( + <> + + + { + // Handle conflict resolution + console.log("Conflict resolved with strategy:", resolution); + setShowConflict(false); + setConflict(null); + }} + /> + + )}
); }; diff --git a/apps/web/src/pages/LedPixelMapEditor.tsx b/apps/web/src/pages/LedPixelMapEditor.tsx index 12df8fc..651564d 100644 --- a/apps/web/src/pages/LedPixelMapEditor.tsx +++ b/apps/web/src/pages/LedPixelMapEditor.tsx @@ -1,13 +1,26 @@ import React, { useState, useEffect } from "react"; -import { useNavigate, useLocation } from "react-router-dom"; -import { User } from "@supabase/supabase-js"; +import { useNavigate, useLocation, useParams } from "react-router-dom"; import Header from "../components/Header"; import Footer from "../components/Footer"; import LedPixelMapControls from "../components/pixel-map/LedPixelMapControls"; import LedPixelMapPreview from "../components/pixel-map/LedPixelMapPreview"; import { ArrowLeft, Save, Download, Loader, AlertCircle } from "lucide-react"; import { gcd } from "../utils/math"; -import { supabase, savePixelMap } from "../lib/supabase"; +import { supabase } from "../lib/supabase"; +import { useAuth } from "../lib/AuthContext"; +import { useAutoSave } from "@/hooks/useAutoSave"; +import { useCollaboration } from "@/hooks/useCollaboration"; +import { usePresence } from "@/hooks/usePresence"; +import { CollaborationToolbar } from "@/components/CollaborationToolbar"; +import { ConflictResolution } from "@/components/ConflictResolution"; +import type { DocumentConflict } from "@/types/collaboration"; +import { v4 as uuidv4 } from "uuid"; +import { + getSharedResource, + updateSharedResource, + getShareUrl, + SharedLink, +} from "../lib/shareUtils"; export interface LedPixelMapData { projectName: string; @@ -29,14 +42,26 @@ export interface PreviewOptions { } const LedPixelMapEditor = () => { + const { id, shareCode } = useParams(); // Get both id and shareCode const navigate = useNavigate(); const location = useLocation(); + const { user } = useAuth(); const [loading, setLoading] = useState(true); const [saving, setSaving] = useState(false); const [downloading, setDownloading] = useState(false); - const [user, setUser] = useState(null); const [saveSuccess, setSaveSuccess] = useState(false); const [saveError, setSaveError] = useState(null); + const [showConflict, setShowConflict] = useState(false); + const [conflict, setConflict] = useState(null); + const [documentId, setDocumentId] = useState(null); + const [isSharedEdit, setIsSharedEdit] = useState(false); + const [currentShareLink, setCurrentShareLink] = useState(null); + + // For unauthenticated shared edit users, generate a temporary ID + const [anonymousUserId] = useState(() => `anonymous-${uuidv4()}`); + const effectiveUserId = user?.id || (isSharedEdit ? anonymousUserId : ""); + const effectiveUserEmail = user?.email || (isSharedEdit ? `${anonymousUserId}@shared` : ""); + const effectiveUserName = user?.user_metadata?.name || (isSharedEdit ? "Anonymous User" : ""); const [mapData, setMapData] = useState({ projectName: "My Awesome Show", @@ -59,16 +84,259 @@ const LedPixelMapEditor = () => { const backPath = location.state?.from || "/video"; + // Enable collaboration for existing documents (including edit-mode shared links) + // For shared links, id will be undefined, so we check documentId instead + // For edit-mode shared links, allow collaboration even without authentication + const collaborationEnabled = + (id ? id !== "new" : true) && // Allow if no id param (shared link) or if id !== "new" + (!isSharedEdit || currentShareLink?.link_type === "edit") && + !!documentId && + (!!user || (isSharedEdit && currentShareLink?.link_type === "edit")); // Allow unauthenticated for edit-mode shared links + + // Debug: Log collaboration status useEffect(() => { - const fetchUser = async () => { - const { - data: { user }, - } = await supabase.auth.getUser(); - setUser(user); - setLoading(false); + const status = { + collaborationEnabled, + id, + idCheck: id ? id !== "new" : true, + isNew: id === "new", + isSharedEdit, + currentShareLinkType: currentShareLink?.link_type, + shareEditCheck: !isSharedEdit || currentShareLink?.link_type === "edit", + hasDocumentId: !!documentId, + hasUser: !!user, + userId: user?.id, + documentId, + }; + console.log("[LedPixelMapEditor] Collaboration status:"); + console.log(JSON.stringify(status, null, 2)); + }, [collaborationEnabled, id, isSharedEdit, currentShareLink, documentId, user]); + + const { + saveStatus, + lastSavedAt, + forceSave, + error: autoSaveError, + } = useAutoSave({ + documentId: documentId || "", + documentType: "pixel_maps", + userId: effectiveUserId, + data: mapData, + enabled: collaborationEnabled, + debounceMs: 1500, + onBeforeSave: async (data) => { + if (!data.projectName || data.projectName.trim() === "") return false; + return true; + }, + }); + + const { activeUsers, status: connectionStatus } = useCollaboration({ + documentId: documentId || "", + documentType: "pixel_maps", + userId: effectiveUserId, + userEmail: effectiveUserEmail, + userName: effectiveUserName, + enabled: collaborationEnabled, + onRemoteUpdate: (payload) => { + if (payload.type === "field_update" && payload.field) { + setMapData((prev) => (prev ? { ...prev, [payload.field!]: payload.value } : prev)); + } + }, + }); + + usePresence({ channel: null, userId: effectiveUserId }); + + useEffect(() => { + const handleKeyDown = (e: KeyboardEvent) => { + if ((e.metaKey || e.ctrlKey) && e.key === "s") { + e.preventDefault(); + forceSave(); + } + }; + window.addEventListener("keydown", handleKeyDown); + return () => window.removeEventListener("keydown", handleKeyDown); + }, [forceSave]); + + // Real-time database subscription for syncing changes across users + useEffect(() => { + if (!collaborationEnabled || !documentId) { + return; + } + + console.log("[LedPixelMapEditor] Setting up real-time subscription for pixel map:", documentId); + + const channel = supabase + .channel(`pixel_map_db_${documentId}`) + .on( + "postgres_changes", + { + event: "UPDATE", + schema: "public", + table: "pixel_maps", + filter: `id=eq.${documentId}`, + }, + (payload) => { + console.log("[LedPixelMapEditor] Received database UPDATE event:", payload); + // Update local state with the new data + // IMPORTANT: Exclude metadata fields to prevent triggering auto-save + if (payload.new) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const { last_edited, ...userEditableFields } = payload.new as Record; + setMapData((prev) => ({ + ...prev, + ...userEditableFields, + })); + } + }, + ) + .subscribe(); + + return () => { + console.log("[LedPixelMapEditor] Cleaning up real-time subscription"); + supabase.removeChannel(channel); }; - fetchUser(); - }, []); + }, [collaborationEnabled, documentId]); + + useEffect(() => { + const fetchUserAndPixelMap = async () => { + setLoading(true); + if (!user && !shareCode) { + console.error("User not authenticated"); + navigate("/login"); + return; + } + + const currentPathIsSharedEdit = location.pathname.includes("/shared/pixel-map/edit/"); + console.log( + `[LedPixelMapEditor] Path: ${location.pathname}, shareCode: ${shareCode}, currentPathIsSharedEdit: ${currentPathIsSharedEdit}`, + ); + + if (currentPathIsSharedEdit && shareCode) { + console.log( + "[LedPixelMapEditor] Attempting to fetch SHARED resource with shareCode:", + shareCode, + ); + try { + const { resource, shareLink: fetchedShareLink } = await getSharedResource(shareCode); + + console.log( + "[LedPixelMapEditor] DEBUG: Fetched Shared Link Details:", + JSON.stringify(fetchedShareLink, null, 2), + ); + console.log( + "[LedPixelMapEditor] DEBUG: Fetched Resource Details:", + JSON.stringify(resource, null, 2), + ); + + if (fetchedShareLink.resource_type !== "pixel_map") { + console.error( + "[LedPixelMapEditor] Share code is for a different resource type:", + fetchedShareLink.resource_type, + "Expected: pixel_map", + ); + navigate("/dashboard"); + setLoading(false); + return; + } + + if (fetchedShareLink.link_type !== "edit") { + console.warn( + `[LedPixelMapEditor] Link type is '${fetchedShareLink.link_type}', not 'edit'. Redirecting to view page.`, + ); + window.location.href = getShareUrl(shareCode, "pixel_map", "view"); + return; + } + + // Transform database format to component state format + const settings = resource.settings || {}; + const sharedMapData: LedPixelMapData = { + projectName: resource.project_name || "My Awesome Show", + screenName: resource.screen_name || "Main LED Wall", + mapWidth: settings.mapWidth || 16, + mapHeight: settings.mapHeight || 9, + halfHeightRow: settings.halfHeightRow || false, + panelWidth: settings.panelWidth || 120, + panelHeight: settings.panelHeight || 120, + panelType: settings.panelType || "custom", + }; + setMapData(sharedMapData); + setPreviewOptions(settings.previewOptions || previewOptions); + setDocumentId(resource.id); + setCurrentShareLink(fetchedShareLink); + setIsSharedEdit(true); + console.log( + "[LedPixelMapEditor] SHARED pixel_map resource loaded successfully for editing.", + ); + console.log( + "[LedPixelMapEditor] Set currentShareLink:", + fetchedShareLink, + "Set isSharedEdit: true", + ); + } catch (error) { + const err = error as Error; + console.error("[LedPixelMapEditor] Error fetching SHARED pixel map:", err.message, err); + navigate("/dashboard"); + } finally { + setLoading(false); + } + } else if (id === "new") { + if (!user) { + navigate("/login"); + return; + } + // Keep default mapData for new documents + setIsSharedEdit(false); + setLoading(false); + } else if (id) { + if (!user) { + navigate("/login"); + return; + } + try { + const { data, error } = await supabase + .from("pixel_maps") + .select("*") + .eq("id", id) + .eq("user_id", user.id) + .single(); + + if (error) throw error; + + if (data) { + // Transform database format to component state format + const settings = data.settings || {}; + setMapData({ + projectName: data.project_name || "My Awesome Show", + screenName: data.screen_name || "Main LED Wall", + mapWidth: settings.mapWidth || 16, + mapHeight: settings.mapHeight || 9, + halfHeightRow: settings.halfHeightRow || false, + panelWidth: settings.panelWidth || 120, + panelHeight: settings.panelHeight || 120, + panelType: settings.panelType || "custom", + }); + setPreviewOptions(settings.previewOptions || previewOptions); + setDocumentId(data.id); + } else { + navigate("/all-pixel-maps"); + } + } catch (error) { + console.error("Error fetching pixel map:", error); + navigate("/all-pixel-maps"); + } finally { + setIsSharedEdit(false); + setLoading(false); + } + } else { + console.error("[LedPixelMapEditor] Invalid route state. No id, no shareCode, not 'new'."); + navigate("/dashboard"); + setLoading(false); + } + }; + + fetchUserAndPixelMap(); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [id, shareCode, navigate, location.pathname]); const screenWidth = mapData.mapWidth * mapData.panelWidth; const screenHeight = mapData.mapHeight * mapData.panelHeight; @@ -85,8 +353,20 @@ const LedPixelMapEditor = () => { mapData.screenName.trim() !== ""; const handleSave = async () => { - if (!user || !isDataValid) { - setSaveError("User not logged in or data is invalid."); + if (!isDataValid) { + setSaveError("Data is invalid."); + return; + } + + // For existing documents with collaboration enabled, use forceSave + if (collaborationEnabled) { + await forceSave(); + return; + } + + if (!user && !isSharedEdit) { + setSaveError("You must be logged in to save."); + setTimeout(() => setSaveError(null), 5000); return; } @@ -94,31 +374,79 @@ const LedPixelMapEditor = () => { setSaveError(null); setSaveSuccess(false); + const baseDataToSave = { + project_name: mapData.projectName, + screen_name: mapData.screenName, + aspect_ratio_w: aspectWidth, + aspect_ratio_h: aspectHeight, + resolution_w: screenWidth, + resolution_h: screenHeight, + last_edited: new Date().toISOString(), + settings: { + mapWidth: mapData.mapWidth, + mapHeight: mapData.mapHeight, + panelWidth: mapData.panelWidth, + panelHeight: mapData.panelHeight, + panelType: mapData.panelType, + halfHeightRow: mapData.halfHeightRow, + previewOptions: previewOptions, + }, + }; + try { - await savePixelMap({ - userId: user.id, - mapType: "led", - projectName: mapData.projectName, - screenName: mapData.screenName, - aspectRatioW: aspectWidth, - aspectRatioH: aspectHeight, - resolutionW: screenWidth, - resolutionH: screenHeight, - settings: { - mapWidth: mapData.mapWidth, - mapHeight: mapData.mapHeight, - panelWidth: mapData.panelWidth, - panelHeight: mapData.panelHeight, - panelType: mapData.panelType, - halfHeightRow: mapData.halfHeightRow, - previewOptions: previewOptions, - }, - }); + let savedData; + if (isSharedEdit && shareCode) { + console.log("[LedPixelMapEditor] Saving SHARED pixel map with shareCode:", shareCode); + savedData = await updateSharedResource(shareCode, "pixel_map", baseDataToSave); + if (savedData) { + // Keep mapData state as is, since it's already in the correct format + // Just update the document ID if needed + if (!documentId && savedData.id) { + setDocumentId(savedData.id); + } + } + } else if (user) { + const dataForOwnedSave = { + ...baseDataToSave, + user_id: user.id, + map_type: "led" as const, + }; + + if (id === "new") { + dataForOwnedSave.created_at = new Date().toISOString(); + const { data, error } = await supabase + .from("pixel_maps") + .insert(dataForOwnedSave) + .select() + .single(); + if (error) throw error; + savedData = data; + if (data) { + setDocumentId(data.id); + navigate(`/pixel-map/led/${data.id}`, { state: { from: location.state?.from } }); + } + } else if (documentId) { + const { data, error } = await supabase + .from("pixel_maps") + .update(dataForOwnedSave) + .eq("id", documentId) + .eq("user_id", user.id) + .select() + .single(); + if (error) throw error; + savedData = data; + } + } else { + throw new Error("Cannot save: No user session and not a shared edit."); + } + setSaveSuccess(true); setTimeout(() => setSaveSuccess(false), 3000); - } catch (error: any) { - console.error("Failed to save map:", error); - setSaveError(`Failed to save map: ${error.message}`); + } catch (error) { + const err = error as Error; + console.error("Failed to save map:", err); + setSaveError(`Failed to save map: ${err.message || "Please try again."}`); + setTimeout(() => setSaveError(null), 5000); } finally { setSaving(false); } @@ -162,7 +490,7 @@ const LedPixelMapEditor = () => { try { const errorJson = JSON.parse(errorBody); serverError = errorJson.error || errorBody; - } catch (e) { + } catch { /* Not a JSON response, use raw text */ } throw new Error(`Server returned status ${response.status}: ${serverError}`); @@ -178,9 +506,10 @@ const LedPixelMapEditor = () => { a.click(); window.URL.revokeObjectURL(url); a.remove(); - } catch (err: any) { - console.error("Failed to download image:", err); - setSaveError(`Download failed. ${err.message}`); + } catch (err) { + const error = err as Error; + console.error("Failed to download image:", error); + setSaveError(`Download failed. ${error.message}`); } finally { setDownloading(false); } @@ -197,6 +526,20 @@ const LedPixelMapEditor = () => { return (
+ {collaborationEnabled && ( + {}} // History not implemented yet for pixel_maps + showHistory={false} // History not implemented yet for pixel_maps + position="top-right" + /> + )}
@@ -226,28 +569,30 @@ const LedPixelMapEditor = () => { )} Download - + {!collaborationEnabled && ( + + )}
- {saveError && ( + {!collaborationEnabled && saveError && (

{saveError}

)} - {saveSuccess && ( + {!collaborationEnabled && saveSuccess && (

Pixel map saved successfully!

@@ -285,27 +630,44 @@ const LedPixelMapEditor = () => {
-
- -
+ {!collaborationEnabled && ( +
+ +
+ )}
); }; diff --git a/apps/web/src/pages/PatchSheetEditor.tsx b/apps/web/src/pages/PatchSheetEditor.tsx index c808c02..03662e9 100644 --- a/apps/web/src/pages/PatchSheetEditor.tsx +++ b/apps/web/src/pages/PatchSheetEditor.tsx @@ -1,6 +1,7 @@ import React, { useState, useEffect } from "react"; import { useParams, useNavigate, useLocation } from "react-router-dom"; import { supabase } from "../lib/supabase"; +import { useAuth } from "../lib/AuthContext"; import Header from "../components/Header"; import Footer from "../components/Footer"; import PatchSheetInputs from "../components/patch-sheet/PatchSheetInputs"; @@ -8,7 +9,20 @@ import PatchSheetOutputs from "../components/patch-sheet/PatchSheetOutputs"; // import MobileScreenWarning from "../components/MobileScreenWarning"; // Removed // import { useScreenSize } from "../hooks/useScreenSize"; // Removed import { Loader, ArrowLeft, Save, AlertCircle } from "lucide-react"; -import { getSharedResource, updateSharedResource, getShareUrl } from "../lib/shareUtils"; +import { + getSharedResource, + updateSharedResource, + getShareUrl, + SharedLink, +} from "../lib/shareUtils"; +import { useAutoSave } from "@/hooks/useAutoSave"; +import { useCollaboration } from "@/hooks/useCollaboration"; +import { usePresence } from "@/hooks/usePresence"; +import { CollaborationToolbar } from "@/components/CollaborationToolbar"; +import { DocumentHistory } from "@/components/History/DocumentHistory"; +import { ConflictResolution } from "@/components/ConflictResolution"; +import type { DocumentConflict } from "@/types/collaboration"; +import { v4 as uuidv4 } from "uuid"; interface InputChannel { id: string; @@ -53,41 +67,232 @@ const PatchSheetEditor = () => { const { id, shareCode } = useParams(); const navigate = useNavigate(); const location = useLocation(); + const { user } = useAuth(); // const screenSize = useScreenSize(); // Removed const [loading, setLoading] = useState(true); - const [saving, setSaving] = useState(false); const [patchSheet, setPatchSheet] = useState(null); const [activeTab, setActiveTab] = useState("inputs"); - const [user, setUser] = useState(null); const [inputs, setInputs] = useState([]); const [outputs, setOutputs] = useState([]); - const [saveError, setSaveError] = useState(null); - const [saveSuccess, setSaveSuccess] = useState(false); // const [showMobileWarning, setShowMobileWarning] = useState(false); // Removed const [isSharedEdit, setIsSharedEdit] = useState(false); const [shareLink, setShareLink] = useState(null); - + const [currentShareLink, setCurrentShareLink] = useState(null); + + // Collaboration state + const [showHistory, setShowHistory] = useState(false); + const [showConflict, setShowConflict] = useState(false); + const [conflict, setConflict] = useState(null); + + // For unauthenticated shared edit users, generate a temporary ID + const [anonymousUserId] = useState(() => `anonymous-${uuidv4()}`); + const effectiveUserId = user?.id || (isSharedEdit ? anonymousUserId : ""); + const effectiveUserEmail = user?.email || (isSharedEdit ? `${anonymousUserId}@shared` : ""); + const effectiveUserName = user?.user_metadata?.name || (isSharedEdit ? "Anonymous User" : ""); + + // useEffect for isSharedEdit removed - now set inside fetchPatchSheetData to avoid re-render loop + + // Enable collaboration for existing documents (including edit-mode shared links) + // For shared links, id will be undefined, so we check patchSheet?.id instead + // For edit-mode shared links, allow collaboration even without authentication + const collaborationEnabled = + (id ? id !== "new" : true) && // Allow if no id param (shared link) or if id !== "new" + (!isSharedEdit || currentShareLink?.link_type === "edit") && + !!patchSheet?.id && + (!!user || (isSharedEdit && currentShareLink?.link_type === "edit")); // Allow unauthenticated for edit-mode shared links + + // Debug: Log collaboration status useEffect(() => { - // if (screenSize === "mobile" || screenSize === "tablet") { // Removed - // setShowMobileWarning(true); - // } - setIsSharedEdit(location.pathname.includes("/shared/edit/")); - }, [location.pathname]); // screenSize dependency removed + const status = { + collaborationEnabled, + id, + idCheck: id ? id !== "new" : true, + isNew: id === "new", + isSharedEdit, + currentShareLinkType: currentShareLink?.link_type, + shareEditCheck: !isSharedEdit || currentShareLink?.link_type === "edit", + hasPatchSheetId: !!patchSheet?.id, + hasUser: !!user, + userId: user?.id, + patchSheetId: patchSheet?.id, + }; + console.log("[PatchSheetEditor] Collaboration status:"); + console.log(JSON.stringify(status, null, 2)); + }, [collaborationEnabled, id, isSharedEdit, currentShareLink, patchSheet?.id, user]); + + // Auto-save hook + const { + saveStatus, + lastSavedAt, + forceSave, + error: autoSaveError, + markAsRemoteUpdate, + } = useAutoSave({ + documentId: patchSheet?.id || "", + documentType: "patch_sheets", + userId: effectiveUserId, + data: patchSheet, + enabled: collaborationEnabled, + debounceMs: 1500, + shareCode: isSharedEdit ? shareCode : undefined, + onBeforeSave: async (data) => { + // Validate data before saving + if (!data.name || data.name.trim() === "") { + return false; + } + return true; + }, + onSaveComplete: (success, error, changedFields) => { + // CRITICAL: After successfully saving, broadcast the changes to other users + // This is how real-time collaboration works - we don't rely on database UPDATE events + if (success && patchSheet && changedFields) { + console.log( + "[PatchSheetEditor] Save successful, broadcasting changes to other users:", + changedFields, + ); + // Broadcast each changed field to all connected users + changedFields.forEach((field) => { + const value = patchSheet[field as keyof typeof patchSheet]; + console.log(`[PatchSheetEditor] Broadcasting ${field}:`, { + valueType: Array.isArray(value) ? `Array[${value.length}]` : typeof value, + firstItem: Array.isArray(value) ? value[0] : undefined, + }); + broadcast({ + type: "field_update", + field, + value, + userId: effectiveUserId, + }).catch((err) => + console.error(`[PatchSheetEditor] Broadcast failed for ${field}:`, err), + ); + }); + } + }, + }); + + // Collaboration hook + const { + activeUsers, + broadcast, + status: connectionStatus, + } = useCollaboration({ + documentId: patchSheet?.id || "", + documentType: "patch_sheets", + userId: effectiveUserId, + userEmail: effectiveUserEmail, + userName: effectiveUserName, + enabled: collaborationEnabled, + onRemoteUpdate: (payload) => { + if (payload.type === "field_update" && payload.field) { + console.log(`[PatchSheetEditor] Applying remote update for field: ${payload.field}`); + + // CRITICAL: Mark as remote update BEFORE state change + // This prevents the autosave effect from treating it as a local change + markAsRemoteUpdate(); + + // Update local state with remote change + setPatchSheet((prev: any) => { + if (!prev) return prev; + return { ...prev, [payload.field!]: payload.value }; + }); + + // CRITICAL: Also update inputs/outputs state if those fields changed + // The UI components use these separate state variables + if (payload.field === "inputs" && Array.isArray(payload.value)) { + console.log("[PatchSheetEditor] Updating inputs state from remote broadcast", { + receivedLength: payload.value.length, + firstItem: payload.value[0], + }); + // Create a new array reference to ensure React detects the change + setInputs([...payload.value]); + } else if (payload.field === "outputs" && Array.isArray(payload.value)) { + console.log("[PatchSheetEditor] Updating outputs state from remote broadcast", { + receivedLength: payload.value.length, + firstItem: payload.value[0], + }); + // Create a new array reference to ensure React detects the change + setOutputs([...payload.value]); + } + } + }, + }); + + // Presence hook + const { setEditingField } = usePresence({ + channel: null, // Will be set up when collaboration channels are ready + userId: effectiveUserId, + }); + + // Keyboard shortcut for manual save (Cmd/Ctrl+S) useEffect(() => { - const fetchUser = async () => { - const { data } = await supabase.auth.getUser(); - if (data.user) { - setUser(data.user); + const handleKeyDown = (e: KeyboardEvent) => { + if ((e.metaKey || e.ctrlKey) && e.key === "s") { + e.preventDefault(); + forceSave(); } }; + window.addEventListener("keydown", handleKeyDown); + return () => window.removeEventListener("keydown", handleKeyDown); + }, [forceSave]); + + // Real-time database subscription for syncing changes across users + useEffect(() => { + if (!collaborationEnabled || !patchSheet?.id) { + return; + } + + console.log( + "[PatchSheetEditor] Setting up real-time subscription for patch sheet:", + patchSheet.id, + ); + + const channel = supabase + .channel(`patch_sheet_db_${patchSheet.id}`) + .on( + "postgres_changes", + { + event: "UPDATE", + schema: "public", + table: "patch_sheets", + filter: `id=eq.${patchSheet.id}`, + }, + (payload) => { + console.log("[PatchSheetEditor] Received database UPDATE event:", payload); + // NOTE: We intentionally DO NOT update local state from database UPDATE events + // because they include our own saves echoing back, which creates an infinite loop + // when using the RPC function for shared edits (the RPC function may return data + // in a slightly different format due to JSONB serialization). + // Real-time collaboration updates happen via the broadcast channel in useCollaboration, + // which properly filters out the current user's own changes and ensures data consistency. + console.log( + "[PatchSheetEditor] Ignoring database UPDATE to prevent infinite loop with RPC saves", + ); + }, + ) + .subscribe(); + + return () => { + console.log("[PatchSheetEditor] Cleaning up real-time subscription"); + supabase.removeChannel(channel); + }; + }, [collaborationEnabled, patchSheet?.id]); + useEffect(() => { const fetchPatchSheetData = async () => { setLoading(true); + + // Allow unauthenticated access ONLY if there's a shareCode + if (!user && !shareCode) { + console.error("[PatchSheetEditor] User not authenticated and no shareCode"); + navigate("/login"); + return; + } + const currentPathIsSharedEdit = location.pathname.includes("/shared/edit/"); console.log( - `[PatchSheetEditor] Fetching. Path: ${location.pathname}, ID: ${id}, ShareCode: ${shareCode}, CalculatedIsShared: ${currentPathIsSharedEdit}`, + `[PatchSheetEditor] Fetching. Path: ${location.pathname}, ID: ${id}, ShareCode: ${shareCode}, IsShared: ${currentPathIsSharedEdit}`, ); if (currentPathIsSharedEdit && shareCode) { @@ -112,6 +317,7 @@ const PatchSheetEditor = () => { setPatchSheet(resource); setShareLink(fetchedShareLink); + setCurrentShareLink(fetchedShareLink); setInputs(resource.inputs && Array.isArray(resource.inputs) ? resource.inputs : []); const updatedOutputs = ( resource.outputs && Array.isArray(resource.outputs) ? resource.outputs : [] @@ -120,6 +326,7 @@ const PatchSheetEditor = () => { destinationGear: output.destinationGear || "", })); setOutputs(updatedOutputs); + setIsSharedEdit(true); setLoading(false); console.log("[PatchSheetEditor] SHARED resource loaded successfully."); return; @@ -129,27 +336,31 @@ const PatchSheetEditor = () => { setLoading(false); return; } + } else if (id === "new") { + console.log( + `[PatchSheetEditor] Proceeding with OWNED document logic. ID: ${id}, User:`, + user, + ); + setPatchSheet({ + name: "Untitled Patch Sheet", + created_at: new Date().toISOString(), + info: { + /* ... default info object ... */ + }, + inputs: [], + outputs: [], + }); + setInputs([]); + setOutputs([]); + setIsSharedEdit(false); + setLoading(false); + console.log("[PatchSheetEditor] New OWNED document initialized."); + return; } else { console.log( `[PatchSheetEditor] Proceeding with OWNED document logic. ID: ${id}, User:`, user, ); - if (id === "new") { - setPatchSheet({ - name: "Untitled Patch Sheet", - created_at: new Date().toISOString(), - info: { - /* ... default info object ... */ - }, - inputs: [], - outputs: [], - }); - setInputs([]); - setOutputs([]); - setLoading(false); - console.log("[PatchSheetEditor] New OWNED document initialized."); - return; - } if (!id) { console.error("[PatchSheetEditor] OWNED logic: No ID, and not 'new'. Invalid state."); @@ -191,25 +402,26 @@ const PatchSheetEditor = () => { destinationGear: output.destinationGear || "", })); setOutputs(updatedOutputs); + setIsSharedEdit(false); setLoading(false); console.log("[PatchSheetEditor] OWNED patch sheet loaded successfully."); } catch (error) { console.error("[PatchSheetEditor] Catch block for OWNED patch sheet fetch error:", error); navigate("/dashboard"); + setIsSharedEdit(false); setLoading(false); } } }; - fetchUser(); fetchPatchSheetData(); - }, [id, shareCode, location.pathname, navigate]); + // Note: `user` is intentionally excluded from deps to prevent re-fetch on auth state updates + // This matches the pattern in ProductionScheduleEditor.tsx and prevents infinite re-render loops + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [id, shareCode, navigate, location.pathname]); + // Manual save handler (for new documents only - existing documents use auto-save) const handleSave = async () => { - setSaving(true); - setSaveError(null); - setSaveSuccess(false); - const updatedInputs = inputs.map((input) => ({ ...input, connectionDetails: input.connection ? input.connectionDetails || {} : undefined, @@ -234,8 +446,6 @@ const PatchSheetEditor = () => { setPatchSheet(patchSheetData); setInputs(updatedInputs); setOutputs(updatedOutputs); - setSaveSuccess(true); - setTimeout(() => setSaveSuccess(false), 3000); } } else if (user) { if (id === "new") { @@ -248,37 +458,33 @@ const PatchSheetEditor = () => { navigate(`/patch-sheet/${data[0].id}`, { state: { from: location.state?.from } }); } } else { - const { error } = await supabase.from("patch_sheets").update(patchSheetData).eq("id", id); - if (error) throw error; - setPatchSheet(patchSheetData); - setInputs(updatedInputs); - setOutputs(updatedOutputs); - setSaveSuccess(true); - setTimeout(() => setSaveSuccess(false), 3000); + // For existing documents, use forceSave from auto-save hook + await forceSave(); } } else { console.warn( "[PatchSheetEditor] Save attempt failed: Not a shared edit and user is not logged in.", ); - setSaveError( - "You must be logged in to save changes to your own documents, or this shared link may not support editing.", - ); } } catch (error) { console.error("Error saving patch sheet:", error); - setSaveError("Error saving patch sheet. Please try again."); - setTimeout(() => setSaveError(null), 5000); - } finally { - setSaving(false); } }; const updateInputs = (newInputs: InputChannel[]) => { setInputs(newInputs); + // Update patchSheet to trigger auto-save + if (patchSheet) { + setPatchSheet({ ...patchSheet, inputs: newInputs }); + } }; const updateOutputs = (newOutputs: OutputChannel[]) => { setOutputs(newOutputs); + // Update patchSheet to trigger auto-save + if (patchSheet) { + setPatchSheet({ ...patchSheet, outputs: newOutputs }); + } }; const handleBackNavigation = () => { @@ -324,6 +530,22 @@ const PatchSheetEditor = () => {
+ {/* Collaboration Toolbar (for existing documents) */} + {collaborationEnabled && ( + setShowHistory(true)} + showHistory={true} + position="top-right" + /> + )} +
@@ -348,38 +570,25 @@ const PatchSheetEditor = () => {
-
- -
+ {/* Manual Save button (only for new documents) */} + {id === "new" && ( +
+ +
+ )} - {saveError && ( + {/* Error messages (for new documents or manual save errors) */} + {!collaborationEnabled && autoSaveError && (
-

{saveError}

-
- )} - - {saveSuccess && ( -
- -

Patch sheet saved successfully!

+

{autoSaveError}

)} @@ -428,27 +637,44 @@ const PatchSheetEditor = () => { -
- -
+ {/* Bottom Save button (only for new documents) */} + {id === "new" && ( +
+ +
+ )}
+ {/* Collaboration Modals */} + {collaborationEnabled && ( + <> + setShowHistory(false)} + documentId={patchSheet?.id || ""} + documentType="patch_sheets" + /> + + setShowConflict(false)} + conflict={conflict} + onResolve={(resolution) => { + // Handle conflict resolution + console.log("Conflict resolved with strategy:", resolution); + setShowConflict(false); + setConflict(null); + }} + /> + + )} +