From b44245196728143d4befde3fcc6590e624f611a9 Mon Sep 17 00:00:00 2001 From: urjitc <135136842+urjitc@users.noreply.github.com> Date: Fri, 10 Apr 2026 21:15:43 +0000 Subject: [PATCH 1/4] Wire ZeroProvider and replace event-sourced reads with Zero useQuery --- src/app/dashboard/page.tsx | 15 ++- .../workspace-canvas/WorkspaceContent.tsx | 10 +- src/contexts/RealtimeContext.tsx | 24 ++-- src/hooks/workspace/use-workspace-state.ts | 120 +++++++++++------- src/lib/zero/provider.tsx | 14 +- 5 files changed, 109 insertions(+), 74 deletions(-) diff --git a/src/app/dashboard/page.tsx b/src/app/dashboard/page.tsx index a2eed848..4f713349 100644 --- a/src/app/dashboard/page.tsx +++ b/src/app/dashboard/page.tsx @@ -34,6 +34,7 @@ import { PdfEngineWrapper } from "@/components/pdf/PdfEngineWrapper"; import WorkspaceSettingsModal from "@/components/workspace/WorkspaceSettingsModal"; import ShareWorkspaceDialog from "@/components/workspace/ShareWorkspaceDialog"; import { RealtimeProvider } from "@/contexts/RealtimeContext"; +import { ZeroProvider } from "@/lib/zero/provider"; import { toast } from "sonner"; import { InviteGuard } from "@/components/workspace/InviteGuard"; import { useReactiveNavigation } from "@/hooks/ui/use-reactive-navigation"; @@ -510,12 +511,14 @@ function DashboardView() { useFolderUrl(); return ( - - - + + + + + ); } diff --git a/src/components/workspace-canvas/WorkspaceContent.tsx b/src/components/workspace-canvas/WorkspaceContent.tsx index cda768ee..a5c91e8e 100644 --- a/src/components/workspace-canvas/WorkspaceContent.tsx +++ b/src/components/workspace-canvas/WorkspaceContent.tsx @@ -97,18 +97,13 @@ export default function WorkspaceContent({ if (detail?.error) { console.error("[OCR-processing-complete] OCR failed:", detail.error); } - if (workspaceId) { - queryClient.invalidateQueries({ - queryKey: ["workspace", workspaceId, "events"], - }); - } }; window.addEventListener(OCR_COMPLETE_EVENT, handleOcrComplete); return () => { window.removeEventListener(OCR_COMPLETE_EVENT, handleOcrComplete); }; - }, [workspaceId, queryClient]); + }, []); useEffect(() => { const handleAudioComplete = (e: Event) => { @@ -135,9 +130,6 @@ export default function WorkspaceContent({ } if (workspaceId) { - queryClient.invalidateQueries({ - queryKey: ["workspace", workspaceId, "events"], - }); queryClient.invalidateQueries({ queryKey: transcriptSegmentsQueryKey(workspaceId, itemId), }); diff --git a/src/contexts/RealtimeContext.tsx b/src/contexts/RealtimeContext.tsx index 2b76918b..bae4ecc3 100644 --- a/src/contexts/RealtimeContext.tsx +++ b/src/contexts/RealtimeContext.tsx @@ -8,7 +8,7 @@ "use client"; import React, { createContext, useContext, useMemo } from "react"; -import { useWorkspaceRealtime } from "@/hooks/workspace/use-workspace-realtime"; +import { useConnectionState } from "@rocicorp/zero/react"; import { useWorkspacePresence, type CollaboratorPresence, @@ -37,10 +37,21 @@ export function RealtimeProvider({ workspaceId, }: RealtimeProviderProps) { const { data: session } = useSession(); + const zeroConnectionState = useConnectionState(); - // Track connection status - const [connectionStatus, setConnectionStatus] = - React.useState("connecting"); + const connectionStatus = useMemo( + () => { + switch (zeroConnectionState.name) { + case "connected": + return "connected"; + case "connecting": + return "connecting"; + default: + return "disconnected"; + } + }, + [zeroConnectionState], + ); // Current user info for presence const currentUser = session?.user @@ -51,11 +62,6 @@ export function RealtimeProvider({ } : null; - // Subscribe to realtime events - useWorkspaceRealtime(workspaceId, { - onStatusChange: setConnectionStatus, - }); - // Track presence (which users are in workspace) const { collaborators } = useWorkspacePresence(workspaceId, { currentUser, diff --git a/src/hooks/workspace/use-workspace-state.ts b/src/hooks/workspace/use-workspace-state.ts index c638f2a3..5aeff238 100644 --- a/src/hooks/workspace/use-workspace-state.ts +++ b/src/hooks/workspace/use-workspace-state.ts @@ -1,52 +1,84 @@ import { useMemo } from "react"; -import { useQuery } from "@tanstack/react-query"; -import { useWorkspaceEvents } from "./use-workspace-events"; -import { - deriveWorkspaceStateFromCaches, - type WorkspaceStateResponse, - workspaceStateQueryKey, -} from "./workspace-state-cache"; - -async function fetchWorkspaceState( - workspaceId: string, -): Promise { - const response = await fetch(`/api/workspaces/${workspaceId}/state`); - - if (!response.ok) { - throw new Error(`Failed to fetch workspace state: ${response.statusText}`); - } - - return (await response.json()) as WorkspaceStateResponse; -} +import { useQuery } from "@rocicorp/zero/react"; +import { rehydrateWorkspaceItem } from "@/lib/workspace/workspace-item-model"; +import type { WorkspaceItemContentProjection } from "@/lib/workspace/workspace-item-model-types"; +import type { Item } from "@/lib/workspace-state/types"; +import { zql } from "@/lib/zero/zero-schema.gen"; +import type { + WorkspaceItemContentRow, + WorkspaceItemsRow, +} from "@/lib/zero/zero-schema.gen"; + +type WorkspaceItemQueryRow = WorkspaceItemsRow & { + workspaceItemContent?: readonly WorkspaceItemContentRow[] | WorkspaceItemContentRow; +}; export function useWorkspaceState(workspaceId: string | null) { - const stateQuery = useQuery({ - queryKey: workspaceStateQueryKey(workspaceId), - queryFn: () => fetchWorkspaceState(workspaceId!), - enabled: !!workspaceId, - staleTime: 1000 * 30, - gcTime: 1000 * 60 * 10, - refetchOnWindowFocus: false, - }); - const eventsQuery = useWorkspaceEvents(workspaceId); - - const derived = useMemo( - () => - deriveWorkspaceStateFromCaches({ - workspaceId, - stateData: stateQuery.data, - eventLog: eventsQuery.data, - }), - [workspaceId, stateQuery.data, eventsQuery.data], + const [rawRows, status] = useQuery( + workspaceId + ? zql.workspace_items + .where("workspaceId", workspaceId) + .related("workspaceItemContent") + : null, ); + const rows = rawRows as unknown as readonly WorkspaceItemQueryRow[] | undefined; + + const state = useMemo(() => { + if (!rows) { + return []; + } + + return rows.map((row) => { + const contentRow = Array.isArray(row.workspaceItemContent) + ? row.workspaceItemContent[0] ?? null + : (row.workspaceItemContent ?? null); + + return rehydrateWorkspaceItem({ + shell: { + itemId: row.itemId, + type: row.type as Item["type"], + name: row.name, + subtitle: row.subtitle, + color: (row.color as Item["color"]) ?? null, + folderId: row.folderId ?? null, + layout: (row.layout as Item["layout"]) ?? null, + lastModified: row.lastModified ?? null, + ocrStatus: row.ocrStatus ?? null, + processingStatus: row.processingStatus ?? null, + }, + content: contentRow + ? { + textContent: contentRow.textContent ?? null, + structuredData: + (contentRow.structuredData as Record) ?? null, + assetData: + (contentRow.assetData as Record) ?? null, + embedData: + (contentRow.embedData as Record) ?? null, + sourceData: + (contentRow.sourceData as WorkspaceItemContentProjection["sourceData"]) ?? + null, + } + : null, + extracted: null, + userStates: null, + }); + }); + }, [rows]); + + const error = useMemo(() => { + if (status.type !== "error") { + return null; + } + + return new Error(status.error.message); + }, [status]); return { - state: derived.state, - isLoading: stateQuery.isLoading && !stateQuery.data, - error: stateQuery.error ?? eventsQuery.error, - version: derived.version, - refetch: async () => { - await Promise.all([stateQuery.refetch(), eventsQuery.refetch()]); - }, + state, + isLoading: Boolean(workspaceId) && status.type === "unknown", + error, + version: 0, + refetch: async () => {}, }; } diff --git a/src/lib/zero/provider.tsx b/src/lib/zero/provider.tsx index 8010cdbc..e90cae19 100644 --- a/src/lib/zero/provider.tsx +++ b/src/lib/zero/provider.tsx @@ -61,17 +61,19 @@ export function ZeroProvider({ children }: { children: ReactNode }) { }, [userId]); const zero = useMemo(() => { - if (!userId || !token) { - if (!userId) { - destroyZero(); - } + if (!userId) { + destroyZero(); return null; } - return getZero({ userId, auth: token }); + return getZero({ userId, auth: token ?? "" }); }, [token, userId]); - if (isPending || !zero) { + if (isPending) { + return null; + } + + if (!zero) { return <>{children}; } From 014a6b0d26d8d6a7b5c47f1c490621c112443f5b Mon Sep 17 00:00:00 2001 From: urjitc <135136842+urjitc@users.noreply.github.com> Date: Fri, 10 Apr 2026 21:19:07 +0000 Subject: [PATCH 2/4] Fix ZeroProvider unauthenticated render --- src/lib/zero/provider.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/zero/provider.tsx b/src/lib/zero/provider.tsx index e90cae19..5a773119 100644 --- a/src/lib/zero/provider.tsx +++ b/src/lib/zero/provider.tsx @@ -74,7 +74,7 @@ export function ZeroProvider({ children }: { children: ReactNode }) { } if (!zero) { - return <>{children}; + return null; } return {children}; From 4733193a83cf3ab34dd0df06d113832aeabc574b Mon Sep 17 00:00:00 2001 From: urjitc <135136842+urjitc@users.noreply.github.com> Date: Fri, 10 Apr 2026 21:26:12 +0000 Subject: [PATCH 3/4] Fix ZeroProvider token initialization --- src/lib/zero/provider.tsx | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/lib/zero/provider.tsx b/src/lib/zero/provider.tsx index 5a773119..ce856a6f 100644 --- a/src/lib/zero/provider.tsx +++ b/src/lib/zero/provider.tsx @@ -61,12 +61,11 @@ export function ZeroProvider({ children }: { children: ReactNode }) { }, [userId]); const zero = useMemo(() => { - if (!userId) { - destroyZero(); + if (!userId || !token) { return null; } - return getZero({ userId, auth: token ?? "" }); + return getZero({ userId, auth: token }); }, [token, userId]); if (isPending) { From b5fc22ab212f1fc2136cf66fc1db003b46e5fbc8 Mon Sep 17 00:00:00 2001 From: Urjit Chakraborty <135136842+urjitc@users.noreply.github.com> Date: Thu, 16 Apr 2026 18:07:38 -0400 Subject: [PATCH 4/4] Refactor: workspace writes to Zero mutators (#336) * Replace event-sourcing writes with Zero mutators * Fix audio duration persistence * Make workflow persistence atomic * Refactor: remove event sourcing and user state infrastructure (#339) * Delete event-sourcing infrastructure and remove per-user state persistence * Remove auth secret fallback * Preserve legacy workspace tables * Remove unused workspace table migration * Fix Zero createdAt column type * Migrate Zero integration to 1.x query/mutator architecture * Refactor Zero auth to cookie-based + dedup server mutators * Fix Zero query auth: fail-closed + rename hasWorkspaceReadAccess (#385) * Enforce authentication and workspace read access checks on Zero query endpoint * Fix Zero query workspace context checks Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --------- Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --------- Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --------- Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --- .env.example | 2 +- package.json | 1 - src/app/api/share/[id]/route.ts | 2 +- .../workspaces/[id]/collaborators/route.ts | 12 +- src/app/api/workspaces/[id]/events/route.ts | 271 ------ src/app/api/workspaces/[id]/route.ts | 2 +- src/app/api/workspaces/[id]/state/route.ts | 28 - src/app/api/workspaces/route.ts | 55 +- src/app/api/workspaces/slug/[slug]/route.ts | 2 +- src/app/api/zero/mutate/route.ts | 19 +- src/app/api/zero/query/route.ts | 119 +++ src/app/api/zero/token/route.ts | 33 - src/app/dashboard/page.tsx | 88 +- .../FlashcardWorkspaceCard.tsx | 5 +- .../workspace-canvas/QuizContent.tsx | 80 +- .../workspace-canvas/WorkspaceContent.tsx | 22 +- src/hooks/workspace/use-workspace-events.ts | 35 - src/hooks/workspace/use-workspace-mutation.ts | 224 ----- .../workspace/use-workspace-operations.ts | 875 +++++++++--------- src/hooks/workspace/use-workspace-realtime.ts | 207 ----- src/hooks/workspace/use-workspace-state.ts | 19 +- .../workspace/workspace-state-cache.test.ts | 129 --- src/hooks/workspace/workspace-state-cache.ts | 102 -- src/lib/ai/tools/tool-utils.ts | 2 +- src/lib/ai/tools/workspace-tools.ts | 2 +- .../__tests__/workspace-worker.edit.test.ts | 428 --------- src/lib/ai/workers/common.ts | 2 +- src/lib/ai/workers/workspace-worker.ts | 397 ++++---- src/lib/auth.ts | 35 +- src/lib/db/relations.ts | 48 +- src/lib/db/schema.ts | 167 ---- src/lib/db/types.ts | 28 +- src/lib/realtime/server-broadcast.ts | 75 -- src/lib/stores/workspace-store.ts | 58 +- src/lib/utils/format-workspace-context.ts | 25 +- src/lib/workspace-state/item-data-schemas.ts | 41 - src/lib/workspace-state/item-helpers.ts | 5 - src/lib/workspace-state/state.ts | 1 - src/lib/workspace-state/types.ts | 23 +- .../event-reducer.bulk-items-patched.test.ts | 80 -- .../event-reducer.lightweight-ocr.test.ts | 105 --- .../__tests__/version-helpers.test.ts | 99 -- .../workspace-event-client-payload.test.ts | 86 -- .../__tests__/workspace-event-store.test.ts | 127 --- .../__tests__/workspace-item-model.test.ts | 173 +--- .../workspace-items-projector.test.ts | 188 ---- src/lib/workspace/event-reducer.ts | 181 ---- src/lib/workspace/events.ts | 158 ---- src/lib/workspace/mutation-helpers.ts | 2 +- src/lib/workspace/state-loader.ts | 38 - src/lib/workspace/version-helpers.ts | 61 -- .../workspace-event-client-payload.ts | 117 --- src/lib/workspace/workspace-event-store.ts | 226 ----- .../workspace/workspace-item-model-schemas.ts | 8 +- .../workspace/workspace-item-model-shared.ts | 24 +- .../workspace/workspace-item-model-types.ts | 20 +- src/lib/workspace/workspace-item-model.ts | 112 +-- src/lib/workspace/workspace-item-sanitize.ts | 11 + src/lib/workspace/workspace-item-write.ts | 303 ++++++ .../workspace/workspace-items-projector.ts | 787 ---------------- src/lib/workspace/workspace-state-read.ts | 108 +++ src/lib/zero/client.ts | 16 +- src/lib/zero/mutators.ts | 523 ++++++----- src/lib/zero/provider.tsx | 52 +- src/lib/zero/queries.ts | 15 + src/lib/zero/server-mutators.ts | 279 +++--- src/lib/zero/zero-schema.gen.ts | 18 +- .../audio-transcribe/steps/persist-result.ts | 191 ++-- .../ocr-dispatch/steps/persist-results.ts | 138 +-- 69 files changed, 1996 insertions(+), 5919 deletions(-) delete mode 100644 src/app/api/workspaces/[id]/events/route.ts delete mode 100644 src/app/api/workspaces/[id]/state/route.ts create mode 100644 src/app/api/zero/query/route.ts delete mode 100644 src/app/api/zero/token/route.ts delete mode 100644 src/hooks/workspace/use-workspace-events.ts delete mode 100644 src/hooks/workspace/use-workspace-mutation.ts delete mode 100644 src/hooks/workspace/use-workspace-realtime.ts delete mode 100644 src/hooks/workspace/workspace-state-cache.test.ts delete mode 100644 src/hooks/workspace/workspace-state-cache.ts delete mode 100644 src/lib/ai/workers/__tests__/workspace-worker.edit.test.ts delete mode 100644 src/lib/realtime/server-broadcast.ts delete mode 100644 src/lib/workspace/__tests__/event-reducer.bulk-items-patched.test.ts delete mode 100644 src/lib/workspace/__tests__/event-reducer.lightweight-ocr.test.ts delete mode 100644 src/lib/workspace/__tests__/version-helpers.test.ts delete mode 100644 src/lib/workspace/__tests__/workspace-event-client-payload.test.ts delete mode 100644 src/lib/workspace/__tests__/workspace-event-store.test.ts delete mode 100644 src/lib/workspace/__tests__/workspace-items-projector.test.ts delete mode 100644 src/lib/workspace/event-reducer.ts delete mode 100644 src/lib/workspace/events.ts delete mode 100644 src/lib/workspace/state-loader.ts delete mode 100644 src/lib/workspace/version-helpers.ts delete mode 100644 src/lib/workspace/workspace-event-client-payload.ts delete mode 100644 src/lib/workspace/workspace-event-store.ts create mode 100644 src/lib/workspace/workspace-item-sanitize.ts create mode 100644 src/lib/workspace/workspace-item-write.ts delete mode 100644 src/lib/workspace/workspace-items-projector.ts create mode 100644 src/lib/workspace/workspace-state-read.ts create mode 100644 src/lib/zero/queries.ts diff --git a/.env.example b/.env.example index f4607424..04a42e85 100644 --- a/.env.example +++ b/.env.example @@ -48,4 +48,4 @@ MISTRAL_API_KEY=your-mistral-api-key # Optional: MISTRAL_OCR_MODEL=mistral-ocr-latest # Zero Sync NEXT_PUBLIC_ZERO_SERVER=http://localhost:4848 -ZERO_AUTH_SECRET=your-shared-secret-for-jwt-signing +ZERO_COOKIE_DOMAIN=.thinkex.app diff --git a/package.json b/package.json index 1a4ca3b9..629f271f 100644 --- a/package.json +++ b/package.json @@ -120,7 +120,6 @@ "drizzle-orm": "^0.45.2", "gsap": "^3.14.2", "heic2any": "^0.0.4", - "jose": "^6.2.2", "jsonrepair": "^3.13.2", "katex": "^0.16.45", "lodash.throttle": "^4.1.1", diff --git a/src/app/api/share/[id]/route.ts b/src/app/api/share/[id]/route.ts index d94e9b08..c235fd1b 100644 --- a/src/app/api/share/[id]/route.ts +++ b/src/app/api/share/[id]/route.ts @@ -1,7 +1,7 @@ import { NextRequest, NextResponse } from "next/server"; import { db, workspaces } from "@/lib/db/client"; import { eq } from "drizzle-orm"; -import { loadWorkspaceState } from "@/lib/workspace/state-loader"; +import { loadWorkspaceState } from "@/lib/workspace/workspace-state-read"; /** * GET /api/share/[id] diff --git a/src/app/api/workspaces/[id]/collaborators/route.ts b/src/app/api/workspaces/[id]/collaborators/route.ts index 6b23cb1d..6e35c36f 100644 --- a/src/app/api/workspaces/[id]/collaborators/route.ts +++ b/src/app/api/workspaces/[id]/collaborators/route.ts @@ -25,7 +25,9 @@ import { import { Resend } from "resend"; import { InviteEmailTemplate } from "@/components/email/invite-email"; -const resend = new Resend(process.env.RESEND_API_KEY); +function getResend() { + return process.env.RESEND_API_KEY ? new Resend(process.env.RESEND_API_KEY) : null; +} // GET /api/workspaces/[id]/collaborators async function handleGET( @@ -195,6 +197,10 @@ async function handlePOST( try { const identifier = ws.slug || workspaceId; const workspaceUrl = `https://thinkex.app/workspace/${identifier}`; + const resend = getResend(); + if (!resend) { + throw new Error("RESEND_API_KEY is not configured"); + } const { data, error } = await resend.emails.send( { from: 'ThinkEx ', @@ -283,6 +289,10 @@ async function handlePOST( try { const identifier = ws.slug || workspaceId; const workspaceUrl = `https://thinkex.app/workspace/${identifier}?invite=${token}`; + const resend = getResend(); + if (!resend) { + throw new Error("RESEND_API_KEY is not configured"); + } const { error } = await resend.emails.send( { from: 'ThinkEx ', diff --git a/src/app/api/workspaces/[id]/events/route.ts b/src/app/api/workspaces/[id]/events/route.ts deleted file mode 100644 index b562ce66..00000000 --- a/src/app/api/workspaces/[id]/events/route.ts +++ /dev/null @@ -1,271 +0,0 @@ -import { NextRequest, NextResponse } from "next/server"; -import { - isClientVisibleWorkspaceEvent, - type EventResponse, - type WorkspaceEvent, -} from "@/lib/workspace/events"; -import { loadWorkspaceState } from "@/lib/workspace/state-loader"; -import { appendWorkspaceEventWithBaseVersion } from "@/lib/workspace/workspace-event-store"; -import { toClientWorkspaceEvents } from "@/lib/workspace/workspace-event-client-payload"; -import { hasDuplicateName } from "@/lib/workspace/unique-name"; -import { db, workspaceEvents } from "@/lib/db/client"; -import { eq, sql } from "drizzle-orm"; -import { - requireAuthWithUserInfo, - verifyWorkspaceAccess, - withErrorHandling, -} from "@/lib/api/workspace-helpers"; - -/** - * GET /api/workspaces/[id]/events - * Fetch all events for a workspace (owner or collaborator) - */ -async function handleGET( - _request: NextRequest, - { params }: { params: Promise<{ id: string }> }, -) { - const paramsPromise = params; - const authPromise = requireAuthWithUserInfo(); - - const paramsResolved = await paramsPromise; - const id = paramsResolved.id; - const { userId } = await authPromise; - await verifyWorkspaceAccess(id, userId, "viewer"); - const eventCountResult = await db - .select({ count: sql`count(*)::int` }) - .from(workspaceEvents) - .where(eq(workspaceEvents.workspaceId, id)); - const eventCount = eventCountResult[0]?.count ?? 0; - - const PAGE_SIZE = 1000; - let eventsData: any[] = []; - - if (eventCount === 0) { - } else if (eventCount <= PAGE_SIZE) { - const fastQueryResult = await db.execute(sql` - SELECT - event_id as "eventId", - event_type as "eventType", - payload, - timestamp, - user_id as "userId", - user_name as "userName", - version - FROM get_workspace_events_fast( - ${id}::uuid, - 0::integer, - ${PAGE_SIZE}::integer - ) - `); - - eventsData = fastQueryResult.map((row: any) => ({ - eventId: row.eventId, - eventType: row.eventType, - payload: row.payload, - timestamp: row.timestamp, - userId: row.userId, - userName: row.userName, - version: row.version, - })); - } else { - let allEvents: any[] = []; - let page = 0; - let hasMore = true; - - while (hasMore) { - const pageDataResult = await db.execute(sql` - SELECT - event_id as "eventId", - event_type as "eventType", - payload, - timestamp, - user_id as "userId", - user_name as "userName", - version - FROM workspace_events - WHERE workspace_id = ${id}::uuid - ORDER BY version ASC - LIMIT ${PAGE_SIZE} - OFFSET ${page * PAGE_SIZE} - `); - - const pageData = pageDataResult.map((row: any) => ({ - eventId: row.eventId, - eventType: row.eventType, - payload: row.payload, - timestamp: row.timestamp, - userId: row.userId, - userName: row.userName, - version: row.version, - })); - - allEvents = allEvents.concat(pageData); - hasMore = pageData.length === PAGE_SIZE; - page++; - } - - eventsData = allEvents; - } - - const events = eventsData - .map( - (e) => - ({ - type: e.eventType, - payload: e.payload, - timestamp: Number.isFinite(Number(e.timestamp)) - ? Number(e.timestamp) - : Date.now(), - userId: e.userId, - userName: e.userName || undefined, - id: e.eventId, - version: e.version, - }) as WorkspaceEvent, - ) - .filter(isClientVisibleWorkspaceEvent); - - const maxVersion = - eventsData && eventsData.length > 0 - ? Math.max(...eventsData.map((e) => e.version)) - : 0; - - const response: EventResponse = { - events: toClientWorkspaceEvents(events), - version: maxVersion, - }; - - return NextResponse.json(response); -} - -export const GET = withErrorHandling( - handleGET, - "GET /api/workspaces/[id]/events", -); - -/** - * POST /api/workspaces/[id]/events - * Append new event(s) to workspace event log (owner only) - */ -async function handlePOST( - request: NextRequest, - { params }: { params: Promise<{ id: string }> }, -) { - const startTime = Date.now(); - const timings: Record = {}; - - const paramsPromise = params; - const authPromise = requireAuthWithUserInfo(); - const bodyPromise = request.json(); - - const paramsResolved = await paramsPromise; - const id = paramsResolved.id; - - const authStart = Date.now(); - const { userId, name: userName } = await authPromise; - timings.auth = Date.now() - authStart; - - const bodyStart = Date.now(); - const body = await bodyPromise; - timings.bodyParse = Date.now() - bodyStart; - - const { event: rawEvent, baseVersion } = body ?? {}; - if ( - !rawEvent || - typeof rawEvent.type !== "string" || - typeof rawEvent.id !== "string" || - baseVersion === undefined || - isNaN(baseVersion) - ) { - return NextResponse.json( - { error: "Event and valid baseVersion are required" }, - { status: 400 }, - ); - } - - const event: WorkspaceEvent = { - ...rawEvent, - userId, - userName, - }; - - const workspaceCheckStart = Date.now(); - await verifyWorkspaceAccess(id, userId, "editor"); - timings.workspaceCheck = Date.now() - workspaceCheckStart; - - if (event.type === "ITEM_CREATED") { - const item = event.payload?.item; - if (item?.name != null && item?.type) { - const state = await loadWorkspaceState(id, { userId }); - if ( - hasDuplicateName(state, item.name, item.type, item.folderId ?? null) - ) { - return NextResponse.json( - { - error: `A ${item.type} named "${item.name}" already exists in this folder`, - }, - { status: 400 }, - ); - } - } - } - if (event.type === "ITEM_UPDATED" && event.payload?.changes?.name != null) { - const itemId = event.payload?.id; - const newName = event.payload.changes.name as string; - if (itemId && newName) { - const state = await loadWorkspaceState(id, { userId }); - const existingItem = state.find((i: { id: string }) => i.id === itemId); - if (existingItem) { - const newFolderId = - (event.payload.changes as Record).folderId as string | undefined ?? existingItem.folderId ?? null; - if ( - hasDuplicateName( - state, - newName, - existingItem.type, - newFolderId, - itemId, - ) - ) { - return NextResponse.json( - { - error: `A ${existingItem.type} named "${newName}" already exists in this folder`, - }, - { status: 400 }, - ); - } - } - } - } - - const appendStart = Date.now(); - const appendResult = await appendWorkspaceEventWithBaseVersion({ - workspaceId: id, - event, - baseVersion, - }); - timings.appendFunction = Date.now() - appendStart; - - if (appendResult.conflict) { - const totalTime = Date.now() - startTime; - timings.total = totalTime; - - return NextResponse.json({ - conflict: true, - version: appendResult.version, - }); - } - - const totalTime = Date.now() - startTime; - timings.total = totalTime; - - return NextResponse.json({ - success: true, - version: appendResult.version, - conflict: false, - }); -} - -export const POST = withErrorHandling( - handlePOST, - "POST /api/workspaces/[id]/events", -); diff --git a/src/app/api/workspaces/[id]/route.ts b/src/app/api/workspaces/[id]/route.ts index 9ca08c58..e9dbb39d 100644 --- a/src/app/api/workspaces/[id]/route.ts +++ b/src/app/api/workspaces/[id]/route.ts @@ -1,7 +1,7 @@ import { NextRequest, NextResponse } from "next/server"; import { db, workspaces } from "@/lib/db/client"; import { eq, and, ne } from "drizzle-orm"; -import { loadWorkspaceState } from "@/lib/workspace/state-loader"; +import { loadWorkspaceState } from "@/lib/workspace/workspace-state-read"; import { requireAuth, verifyWorkspaceOwnership, diff --git a/src/app/api/workspaces/[id]/state/route.ts b/src/app/api/workspaces/[id]/state/route.ts deleted file mode 100644 index 279ca028..00000000 --- a/src/app/api/workspaces/[id]/state/route.ts +++ /dev/null @@ -1,28 +0,0 @@ -import { NextRequest, NextResponse } from "next/server"; -import { - requireAuth, - verifyWorkspaceAccess, - withErrorHandling, -} from "@/lib/api/workspace-helpers"; -import { loadWorkspaceStatePayload } from "@/lib/workspace/state-loader"; - -async function handleGET( - _request: NextRequest, - { params }: { params: Promise<{ id: string }> }, -) { - const paramsPromise = params; - const authPromise = requireAuth(); - - const { id } = await paramsPromise; - const userId = await authPromise; - - await verifyWorkspaceAccess(id, userId, "viewer"); - - const statePayload = await loadWorkspaceStatePayload(id, { userId }); - return NextResponse.json(statePayload); -} - -export const GET = withErrorHandling( - handleGET, - "GET /api/workspaces/[id]/state", -); diff --git a/src/app/api/workspaces/route.ts b/src/app/api/workspaces/route.ts index d0f3dd4f..8a80fa4c 100644 --- a/src/app/api/workspaces/route.ts +++ b/src/app/api/workspaces/route.ts @@ -7,7 +7,6 @@ import type { } from "@/lib/workspace-state/types"; import type { CardColor } from "@/lib/workspace-state/colors"; import { normalizeWorkspaceItems } from "@/lib/workspace-state/state"; -import { createEvent } from "@/lib/workspace/events"; import { db, workspaces } from "@/lib/db/client"; import { workspaceCollaborators } from "@/lib/db/schema"; import { eq, desc, asc, inArray } from "drizzle-orm"; @@ -16,8 +15,7 @@ import { requireAuthWithUserInfo, withErrorHandling, } from "@/lib/api/workspace-helpers"; -import { appendWorkspaceEventOrThrow } from "@/lib/workspace/workspace-event-store"; -import { workspaceItemProjectionState } from "@/lib/db/schema"; +import { insertWorkspaceItem } from "@/lib/workspace/workspace-item-write"; /** * GET /api/workspaces @@ -245,44 +243,19 @@ async function handlePOST(request: NextRequest) { ? normalizeWorkspaceItems(customInitialItems) : getTemplateInitialItems(effectiveTemplate); - if (initialItems.length > 0) { - await db - .insert(workspaceItemProjectionState) - .values({ - workspaceId: workspace.id, - lastAppliedVersion: 0, - createdAt: new Date().toISOString(), - updatedAt: new Date().toISOString(), - }) - .onConflictDoNothing(); - - const event = createEvent( - "BULK_ITEMS_CREATED", - { items: initialItems }, - userId, - user.name || user.email || undefined, - ); - - try { - await appendWorkspaceEventOrThrow({ - workspaceId: workspace.id, - event, - baseVersion: 0, - }); - } catch (eventError) { - await db.delete(workspaces).where(eq(workspaces.id, workspace.id)); - throw eventError; - } - } else { - await db - .insert(workspaceItemProjectionState) - .values({ - workspaceId: workspace.id, - lastAppliedVersion: 0, - createdAt: new Date().toISOString(), - updatedAt: new Date().toISOString(), - }) - .onConflictDoNothing(); + try { + await db.transaction(async (tx) => { + for (const item of initialItems) { + await insertWorkspaceItem(tx, { + workspaceId: workspace.id, + item, + sourceVersion: 0, + }); + } + }); + } catch (insertError) { + await db.delete(workspaces).where(eq(workspaces.id, workspace.id)); + throw insertError; } // Return workspace with full state for immediate use diff --git a/src/app/api/workspaces/slug/[slug]/route.ts b/src/app/api/workspaces/slug/[slug]/route.ts index 7790dfe4..0b62811c 100644 --- a/src/app/api/workspaces/slug/[slug]/route.ts +++ b/src/app/api/workspaces/slug/[slug]/route.ts @@ -2,7 +2,7 @@ import { NextRequest, NextResponse } from "next/server"; import { db, workspaces } from "@/lib/db/client"; import { workspaceCollaborators } from "@/lib/db/schema"; import { eq, and, or, inArray } from "drizzle-orm"; -import { loadWorkspaceState } from "@/lib/workspace/state-loader"; +import { loadWorkspaceState } from "@/lib/workspace/workspace-state-read"; import { requireAuth, withErrorHandling } from "@/lib/api/workspace-helpers"; /** diff --git a/src/app/api/zero/mutate/route.ts b/src/app/api/zero/mutate/route.ts index 37be54a8..3f811f33 100644 --- a/src/app/api/zero/mutate/route.ts +++ b/src/app/api/zero/mutate/route.ts @@ -1,8 +1,7 @@ -import { headers } from "next/headers"; import { NextRequest, NextResponse } from "next/server"; -import { zeroDrizzle } from "@rocicorp/zero/server/adapters/drizzle"; -import { handleMutateRequest } from "@rocicorp/zero/server"; import { mustGetMutator } from "@rocicorp/zero"; +import { handleMutateRequest } from "@rocicorp/zero/server"; +import { zeroDrizzle } from "@rocicorp/zero/server/adapters/drizzle"; import { auth } from "@/lib/auth"; import { db } from "@/lib/db/client"; import { serverMutators } from "@/lib/zero/server-mutators"; @@ -11,24 +10,20 @@ import { schema } from "@/lib/zero/zero-schema.gen"; const dbProvider = zeroDrizzle(schema, db); export async function POST(request: NextRequest) { - const session = await auth.api.getSession({ headers: await headers() }); + const session = await auth.api.getSession({ headers: request.headers }); - if (!session) { + if (!session?.user?.id) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }); } + const ctx = { userId: session.user.id }; + const result = await handleMutateRequest( dbProvider, async (transact) => { return transact(async (tx, name, args) => { const mutator = mustGetMutator(serverMutators, name); - await mutator.fn({ - tx, - args, - ctx: { - userId: session.user.id, - }, - }); + await mutator.fn({ tx, args, ctx }); }); }, request, diff --git a/src/app/api/zero/query/route.ts b/src/app/api/zero/query/route.ts new file mode 100644 index 00000000..9a1c1d92 --- /dev/null +++ b/src/app/api/zero/query/route.ts @@ -0,0 +1,119 @@ +import { NextRequest, NextResponse } from "next/server"; +import { mustGetQuery, type ReadonlyJSONValue } from "@rocicorp/zero"; +import { handleQueryRequest } from "@rocicorp/zero/server"; +import { and, eq } from "drizzle-orm"; +import { auth } from "@/lib/auth"; +import { db } from "@/lib/db/client"; +import { workspaceCollaborators, workspaces } from "@/lib/db/schema"; +import { queries } from "@/lib/zero/queries"; +import { schema } from "@/lib/zero/zero-schema.gen"; + +const WORKSPACE_ACCESS_DENIED_ERROR = "Workspace access denied"; + +type QueryRequest = { + args?: readonly unknown[]; +}; + +async function hasWorkspaceReadAccess( + workspaceId: string, + userId: string, +): Promise { + const [workspace] = await db + .select({ ownerId: workspaces.userId }) + .from(workspaces) + .where(eq(workspaces.id, workspaceId)) + .limit(1); + + if (!workspace) { + return false; + } + + if (workspace.ownerId === userId) { + return true; + } + + const [collaborator] = await db + .select({ id: workspaceCollaborators.id }) + .from(workspaceCollaborators) + .where( + and( + eq(workspaceCollaborators.workspaceId, workspaceId), + eq(workspaceCollaborators.userId, userId), + ), + ) + .limit(1); + + return !!collaborator; +} + +export async function POST(request: NextRequest) { + const session = await auth.api.getSession({ headers: request.headers }); + + if (!session?.user?.id) { + return NextResponse.json({ error: "Unauthorized" }, { status: 401 }); + } + + const userId = session.user.id; + const ctx = { userId }; + + try { + const body = (await request.json()) as unknown; + const queryRequests = + Array.isArray(body) && Array.isArray(body[1]) + ? (body[1] as QueryRequest[]) + : []; + const workspaceIds = [ + ...new Set( + queryRequests.flatMap((queryRequest) => { + const args = queryRequest.args; + const firstArg = args?.[0]; + + if ( + firstArg && + typeof firstArg === "object" && + "workspaceId" in firstArg && + typeof firstArg.workspaceId === "string" + ) { + return [firstArg.workspaceId]; + } + + return []; + }), + ), + ]; + + if (workspaceIds.length === 0) { + return NextResponse.json( + { error: "No workspace context provided" }, + { status: 400 }, + ); + } + + for (const workspaceId of workspaceIds) { + const hasAccess = await hasWorkspaceReadAccess(workspaceId, userId); + if (!hasAccess) { + throw new Error(WORKSPACE_ACCESS_DENIED_ERROR); + } + } + + const result = await handleQueryRequest( + (name, args) => mustGetQuery(queries, name).fn({ args, ctx }), + schema, + body as ReadonlyJSONValue, + ); + + return NextResponse.json(result); + } catch (error) { + if ( + error instanceof Error && + error.message === WORKSPACE_ACCESS_DENIED_ERROR + ) { + return NextResponse.json({ error: "Forbidden" }, { status: 403 }); + } + + return NextResponse.json( + { error: "Internal server error" }, + { status: 500 }, + ); + } +} diff --git a/src/app/api/zero/token/route.ts b/src/app/api/zero/token/route.ts deleted file mode 100644 index ffb23aa3..00000000 --- a/src/app/api/zero/token/route.ts +++ /dev/null @@ -1,33 +0,0 @@ -import { headers } from "next/headers"; -import { NextResponse } from "next/server"; -import { SignJWT } from "jose"; -import { auth } from "@/lib/auth"; - -export async function GET() { - const session = await auth.api.getSession({ headers: await headers() }); - - if (!session) { - return NextResponse.json({ error: "Unauthorized" }, { status: 401 }); - } - - const zeroAuthSecret = process.env.ZERO_AUTH_SECRET; - if (!zeroAuthSecret) { - return NextResponse.json( - { error: "ZERO_AUTH_SECRET is not configured" }, - { status: 500 }, - ); - } - - const secret = new TextEncoder().encode(zeroAuthSecret); - const token = await new SignJWT({ - sub: session.user.id, - name: session.user.name, - email: session.user.email, - }) - .setProtectedHeader({ alg: "HS256" }) - .setIssuedAt() - .setExpirationTime("1h") - .sign(secret); - - return NextResponse.json({ token }); -} diff --git a/src/app/dashboard/page.tsx b/src/app/dashboard/page.tsx index 4f713349..c1d9bfff 100644 --- a/src/app/dashboard/page.tsx +++ b/src/app/dashboard/page.tsx @@ -7,7 +7,6 @@ import { useKeyboardShortcuts } from "@/hooks/ui/use-keyboard-shortcuts"; import useMediaQuery from "@/hooks/ui/use-media-query"; import { useWorkspaceState } from "@/hooks/workspace/use-workspace-state"; import { useWorkspaceOperations } from "@/hooks/workspace/use-workspace-operations"; -import { useWorkspaceEvents } from "@/hooks/workspace/use-workspace-events"; import { WorkspaceProvider, useWorkspaceContext, @@ -35,6 +34,7 @@ import WorkspaceSettingsModal from "@/components/workspace/WorkspaceSettingsModa import ShareWorkspaceDialog from "@/components/workspace/ShareWorkspaceDialog"; import { RealtimeProvider } from "@/contexts/RealtimeContext"; import { ZeroProvider } from "@/lib/zero/provider"; +import { useConnectionState } from "@rocicorp/zero/react"; import { toast } from "sonner"; import { InviteGuard } from "@/components/workspace/InviteGuard"; import { useReactiveNavigation } from "@/hooks/ui/use-reactive-navigation"; @@ -83,22 +83,11 @@ function DashboardContent({ // }, [shouldShowOnboarding, isLoadingOnboarding]); // Get workspace context (now only manages workspace list) const { currentSlug, switchWorkspace } = useWorkspaceContext(); + const zeroConnectionState = useConnectionState(); + const isSaving = zeroConnectionState.name === "connecting"; - // Get save status from Zustand store - const { - isSaving, - updateSaveStatus, - updateLastSaved, - updateHasUnsavedChanges, - } = useWorkspaceStore(); - - // ===== EVENT-BASED STATE MANAGEMENT ===== - // Event sourcing + React Query replaces the old autosave/loader hooks - // State is derived from events, mutations are optimistic - const { - state, - isLoading: isLoadingWorkspace, - } = useWorkspaceState(currentWorkspaceId); + const { state, isLoading: isLoadingWorkspace } = + useWorkspaceState(currentWorkspaceId); // Open audio recorder when landing from home Record flow (store flag set before navigate). const openAudioDialog = useAudioRecordingStore((s) => s.openDialog); @@ -136,11 +125,9 @@ function DashboardContent({ setShouldOpenOnWorkspaceLoad, ]); - // Workspace operations (emits events with optimistic updates) + // Workspace operations const operations = useWorkspaceOperations(currentWorkspaceId, state); - const { data: eventLog } = useWorkspaceEvents(currentWorkspaceId); - // Track sign-in prompt dismissal per workspace for anonymous users. const [ dismissedSignInPromptWorkspaceId, @@ -153,71 +140,14 @@ function DashboardContent({ const showSignInPrompt = !!session?.user?.isAnonymous && - !!eventLog && !isLoadingWorkspace && !!currentWorkspaceId && - (eventLog.events?.length ?? 0) >= 15 && + state.length >= 15 && dismissedSignInPromptWorkspaceId !== currentWorkspaceId; // Get sidebar state and controls const { toggleSidebar } = useSidebar(); - // Update save status based on mutation status - useEffect(() => { - updateSaveStatus(operations.isPending); - if (!operations.isPending && !operations.isError) { - updateHasUnsavedChanges(false); - updateLastSaved(new Date()); - } - }, [ - operations.isPending, - operations.isError, - updateSaveStatus, - updateHasUnsavedChanges, - updateLastSaved, - ]); - - // Mark as saved when workspace is loaded from events - useEffect(() => { - if (!isLoadingWorkspace && currentWorkspaceId) { - // Use the last event's timestamp if available, otherwise use current time - let lastSavedDate: Date; - if (eventLog?.events && eventLog.events.length > 0) { - // Events are ordered by version, so the last event is the most recent - const lastEvent = eventLog.events[eventLog.events.length - 1]; - // Ensure timestamp exists and is valid - if (lastEvent.timestamp != null) { - // Ensure timestamp is a number (might be string from JSON) - const timestamp = - typeof lastEvent.timestamp === "number" - ? lastEvent.timestamp - : Number(lastEvent.timestamp); - lastSavedDate = new Date(timestamp); - // Validate the date is valid - if (isNaN(lastSavedDate.getTime())) { - // If invalid, fallback to current time - lastSavedDate = new Date(); - } - } else { - // If timestamp is missing, fallback to current time - lastSavedDate = new Date(); - } - } else { - // Fallback to current time if no events exist (new workspace) - lastSavedDate = new Date(); - } - updateLastSaved(lastSavedDate); - updateHasUnsavedChanges(false); - } - }, [ - isLoadingWorkspace, - currentWorkspaceId, - state, - eventLog, - updateLastSaved, - updateHasUnsavedChanges, - ]); - // UI State from Zustand stores - using individual selectors to prevent unnecessary re-renders // NOTE: Each selector only triggers a re-render when that specific value changes const isDesktop = useMediaQuery("(min-width: 768px)"); @@ -360,9 +290,7 @@ function DashboardContent({ setIsChatExpanded={setIsChatExpanded} setIsChatMaximized={setIsChatMaximized} workspaceHeader={ - !isChatMaximized && - currentWorkspaceId && - !isLoadingWorkspace ? ( + !isChatMaximized && currentWorkspaceId && !isLoadingWorkspace ? ( setSearchDialogOpen(true)} currentWorkspaceId={currentWorkspaceId} diff --git a/src/components/workspace-canvas/FlashcardWorkspaceCard.tsx b/src/components/workspace-canvas/FlashcardWorkspaceCard.tsx index 583e64a4..b5b02a19 100644 --- a/src/components/workspace-canvas/FlashcardWorkspaceCard.tsx +++ b/src/components/workspace-canvas/FlashcardWorkspaceCard.tsx @@ -173,9 +173,7 @@ export function FlashcardWorkspaceCard({ const flashcardData = item.data as FlashcardData; // Navigation State - const [currentIndex, setCurrentIndex] = useState( - flashcardData.currentIndex || 0, - ); + const [currentIndex, setCurrentIndex] = useState(0); const cards = useMemo( () => flashcardData.cards ?? [], @@ -195,7 +193,6 @@ export function FlashcardWorkspaceCard({ // For now just local state is smooth, maybe updating item is fine. // Let's keep it local for now, prop update on unmount? setCurrentIndex(newIndex); - // If we want persistence: onUpdateItem(item.id, { data: { ...flashcardData, currentIndex: newIndex }}); }, []); const currentCard = useMemo((): FlashcardItem => { diff --git a/src/components/workspace-canvas/QuizContent.tsx b/src/components/workspace-canvas/QuizContent.tsx index f7e4d287..18ef0237 100644 --- a/src/components/workspace-canvas/QuizContent.tsx +++ b/src/components/workspace-canvas/QuizContent.tsx @@ -6,7 +6,6 @@ import type { ItemData, QuizData, QuizQuestion, - QuizSessionData, } from "@/lib/workspace-state/types"; import { cn } from "@/lib/utils"; import { @@ -35,7 +34,7 @@ interface QuizContentProps { export function QuizContent({ item, - onUpdateData, + onUpdateData: _onUpdateData, isScrollLocked = false, className, }: QuizContentProps) { @@ -48,24 +47,13 @@ export function QuizContent({ const toggleCardSelection = useUIStore((state) => state.toggleCardSelection); // Session state - const [currentIndex, setCurrentIndex] = useState( - quizData.session?.currentIndex || 0, - ); + const [currentIndex, setCurrentIndex] = useState(0); const [selectedAnswer, setSelectedAnswer] = useState(null); const [isSubmitted, setIsSubmitted] = useState(false); const [answeredQuestions, setAnsweredQuestions] = useState< - QuizSessionData["answeredQuestions"] - >(quizData.session?.answeredQuestions || []); - - // Initialize showResults based on whether quiz is completed - // Quiz is completed ONLY if: completedAt exists AND all questions are answered - const isInitiallyCompleted = !!( - quizData.session?.completedAt && - quizData.session?.answeredQuestions?.length && - questions.length > 0 && - quizData.session.answeredQuestions.length >= questions.length - ); - const [showResults, setShowResults] = useState(isInitiallyCompleted); + Array<{ questionId: string; userAnswer: number; isCorrect: boolean }> + >([]); + const [showResults, setShowResults] = useState(false); // Track previous question count and IDs to detect when new questions are added const prevQuestionCountRef = useRef(questions.length); @@ -102,19 +90,6 @@ export function QuizContent({ setCurrentIndex(prevCount); // Go to first new question setSelectedAnswer(null); setIsSubmitted(false); - - // Clear completedAt since we're no longer complete - onUpdateData((prev) => { - const current = prev as QuizData; - return { - ...current, - session: { - ...current.session, - currentIndex: prevCount, - completedAt: undefined, - } as QuizSessionData, - }; - }); } else { // Just notify user toast.success( @@ -130,13 +105,7 @@ export function QuizContent({ // Update refs for next comparison prevQuestionCountRef.current = currentCount; prevQuestionIdsRef.current = currentIds; - }, [ - questions, - showResults, - answeredQuestions.length, - currentIndex, - onUpdateData, - ]); + }, [questions, showResults, answeredQuestions.length, currentIndex]); // Check if current question was already answered const previousAnswer = useMemo(() => { @@ -154,25 +123,6 @@ export function QuizContent({ } }, [currentIndex, previousAnswer]); - // Persist session state - const persistSession = useCallback( - (updates: Partial) => { - onUpdateData((prev) => { - const current = prev as QuizData; - return { - ...current, - session: { - currentIndex, - answeredQuestions, - ...current.session, - ...updates, - }, - }; - }); - }, - [onUpdateData, currentIndex, answeredQuestions], - ); - // Handle answer selection const handleSelectAnswer = (index: number) => { if (isSubmitted) return; @@ -197,13 +147,6 @@ export function QuizContent({ setAnsweredQuestions(newAnsweredQuestions); setIsSubmitted(true); - - // Persist to data - persistSession({ - currentIndex, - answeredQuestions: newAnsweredQuestions, - startedAt: quizData.session?.startedAt || Date.now(), - }); }; // Navigation @@ -211,11 +154,9 @@ export function QuizContent({ if (currentIndex < totalQuestions - 1) { const nextIndex = currentIndex + 1; setCurrentIndex(nextIndex); - persistSession({ currentIndex: nextIndex }); } else { // Show results setShowResults(true); - persistSession({ completedAt: Date.now() }); } }; @@ -224,7 +165,6 @@ export function QuizContent({ if (currentIndex < totalQuestions - 1) { const nextIndex = currentIndex + 1; setCurrentIndex(nextIndex); - persistSession({ currentIndex: nextIndex }); } }; @@ -232,7 +172,6 @@ export function QuizContent({ if (currentIndex > 0) { const prevIndex = currentIndex - 1; setCurrentIndex(prevIndex); - persistSession({ currentIndex: prevIndex }); } }; @@ -242,13 +181,6 @@ export function QuizContent({ setIsSubmitted(false); setAnsweredQuestions([]); setShowResults(false); - onUpdateData((prev) => { - const current = prev as QuizData; - return { - ...current, - session: undefined, - }; - }); }; // Handle Update Quiz - programmatically send message to add more questions diff --git a/src/components/workspace-canvas/WorkspaceContent.tsx b/src/components/workspace-canvas/WorkspaceContent.tsx index a5c91e8e..1cccec17 100644 --- a/src/components/workspace-canvas/WorkspaceContent.tsx +++ b/src/components/workspace-canvas/WorkspaceContent.tsx @@ -7,6 +7,7 @@ import type { Item, CardType } from "@/lib/workspace-state/types"; import { filterItemsByFolder } from "@/lib/workspace-state/search"; import { useAutoScroll } from "@/hooks/ui/use-auto-scroll"; import { transcriptSegmentsQueryKey } from "@/hooks/workspace/use-transcript-segments"; +import { AUDIO_COMPLETE_EVENT } from "@/lib/audio/poll-audio-processing"; import { WorkspaceGrid } from "./WorkspaceGrid"; import { useUIStore } from "@/lib/stores/ui-store"; import { useSelectedCardIds } from "@/hooks/ui/use-selected-card-ids"; @@ -116,9 +117,9 @@ export default function WorkspaceContent({ ).detail ?? {}; if (!itemId) return; - const existingData = viewState.find((i) => i.id === itemId)?.data ?? {}; - if (retrying) { + const existingData = + viewState.find((item) => item.id === itemId)?.data ?? {}; updateItem(itemId, { data: { ...existingData, @@ -129,19 +130,16 @@ export default function WorkspaceContent({ return; } - if (workspaceId) { - queryClient.invalidateQueries({ - queryKey: transcriptSegmentsQueryKey(workspaceId, itemId), - }); - } + if (!workspaceId) return; + + queryClient.invalidateQueries({ + queryKey: transcriptSegmentsQueryKey(workspaceId, itemId), + }); }; - window.addEventListener("audio-processing-complete", handleAudioComplete); + window.addEventListener(AUDIO_COMPLETE_EVENT, handleAudioComplete); return () => { - window.removeEventListener( - "audio-processing-complete", - handleAudioComplete, - ); + window.removeEventListener(AUDIO_COMPLETE_EVENT, handleAudioComplete); }; }, [updateItem, viewState, workspaceId, queryClient]); diff --git a/src/hooks/workspace/use-workspace-events.ts b/src/hooks/workspace/use-workspace-events.ts deleted file mode 100644 index 61f12ef1..00000000 --- a/src/hooks/workspace/use-workspace-events.ts +++ /dev/null @@ -1,35 +0,0 @@ -import { useQuery } from "@tanstack/react-query"; -import type { EventResponse } from "@/lib/workspace/events"; - -export function workspaceEventsQueryKey(workspaceId: string | null) { - return ["workspace", workspaceId, "events"] as const; -} - -async function fetchWorkspaceEvents( - workspaceId: string, -): Promise { - try { - const response = await fetch(`/api/workspaces/${workspaceId}/events`); - - if (!response.ok) { - throw new Error(`Failed to fetch events: ${response.statusText}`); - } - - return await response.json(); - } catch (err) { - console.error(`[EVENTS] Failed to fetch events for ${workspaceId}`, err); - throw err; - } -} - -export function useWorkspaceEvents(workspaceId: string | null) { - return useQuery({ - queryKey: workspaceEventsQueryKey(workspaceId), - queryFn: () => fetchWorkspaceEvents(workspaceId!), - enabled: !!workspaceId, - staleTime: 1000 * 30, - gcTime: 1000 * 60 * 10, - refetchInterval: false, - refetchOnWindowFocus: false, - }); -} diff --git a/src/hooks/workspace/use-workspace-mutation.ts b/src/hooks/workspace/use-workspace-mutation.ts deleted file mode 100644 index d43e9bfa..00000000 --- a/src/hooks/workspace/use-workspace-mutation.ts +++ /dev/null @@ -1,224 +0,0 @@ -import { useMutation, useQueryClient } from "@tanstack/react-query"; -import type { WorkspaceEvent, EventResponse } from "@/lib/workspace/events"; -import { - computeBaseVersion, - removeOptimisticEvent, - confirmOptimisticEvent, -} from "@/lib/workspace/version-helpers"; -import { workspaceEventsQueryKey } from "./use-workspace-events"; -import { applyConfirmedWorkspaceEventToStateQuery } from "./workspace-state-cache"; -import { useRef } from "react"; -import { toast } from "sonner"; - -const MAX_RETRY_ATTEMPTS = 3; - -type AppendEventResponse = - | { success: true; version: number; conflict: false } - | { conflict: true; version: number }; - -async function appendWorkspaceEvent(params: { - workspaceId: string; - event: WorkspaceEvent; - baseVersion: number; -}): Promise { - const { workspaceId, event, baseVersion } = params; - const response = await fetch(`/api/workspaces/${workspaceId}/events`, { - method: "POST", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ event, baseVersion }), - }); - - if (!response.ok) { - if (response.status === 403) { - throw new Error("PERMISSION_DENIED"); - } - const errorText = await response.text(); - throw new Error( - `Failed to append event: ${response.statusText} - ${errorText}`, - ); - } - - return response.json(); -} - -/** - * Hook to mutate workspace by appending events. - * Implements optimistic updates with automatic conflict retry. - */ -export function useWorkspaceMutation(workspaceId: string | null) { - const queryClient = useQueryClient(); - const retryAttemptsRef = useRef>(new Map()); - - return useMutation({ - mutationFn: (event: WorkspaceEvent) => { - if (!workspaceId) { - throw new Error("No workspace ID provided"); - } - - const cacheData = queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ); - - const { baseVersion } = computeBaseVersion(cacheData); - - return appendWorkspaceEvent({ - workspaceId, - event, - baseVersion, - }); - }, - - onMutate: async (event: WorkspaceEvent) => { - if (!workspaceId) return; - - await queryClient.cancelQueries({ - queryKey: workspaceEventsQueryKey(workspaceId), - }); - - const previous = queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ); - - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => { - if (!old) { - return { events: [{ ...event }], version: 0 }; - } - return { - ...old, - events: [...old.events, { ...event }], - version: old.version, - }; - }, - ); - - return { previous }; - }, - - onError: (err, event, context) => { - if (!workspaceId || !context?.previous) return; - - if (err.message === "PERMISSION_DENIED") { - toast.error("You don't have permission to edit this workspace"); - } - - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - context.previous, - ); - }, - - onSuccess: (data, event, context) => { - if (!workspaceId) return; - - if (data.conflict) { - const currentRetries = retryAttemptsRef.current.get(event.id) || 0; - - if (currentRetries < MAX_RETRY_ATTEMPTS) { - retryAttemptsRef.current.set(event.id, currentRetries + 1); - - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => removeOptimisticEvent(old, event.id, data.version), - ); - - queryClient - .invalidateQueries({ - queryKey: workspaceEventsQueryKey(workspaceId), - }) - .then(() => { - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => { - if (!old) return old; - return { - ...old, - events: [...old.events, { ...event }], - }; - }, - ); - - const currentData = queryClient.getQueryData([ - "workspace", - workspaceId, - "events", - ]); - if (!currentData) return; - - const { baseVersion: retryBase } = - computeBaseVersion(currentData); - - appendWorkspaceEvent({ - workspaceId, - event, - baseVersion: retryBase, - }) - .then((retryResult) => { - if (retryResult.conflict) { - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => removeOptimisticEvent(old, event.id), - ); - retryAttemptsRef.current.delete(event.id); - queryClient.invalidateQueries({ - queryKey: workspaceEventsQueryKey(workspaceId), - }); - } else { - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => - confirmOptimisticEvent( - old, - event.id, - retryResult.version, - ), - ); - retryAttemptsRef.current.delete(event.id); - applyConfirmedWorkspaceEventToStateQuery( - queryClient, - workspaceId, - { ...event, version: retryResult.version }, - ); - } - }) - .catch(() => { - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => removeOptimisticEvent(old, event.id), - ); - retryAttemptsRef.current.delete(event.id); - if (context?.previous) { - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - context.previous, - ); - } - }); - }); - } else { - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => removeOptimisticEvent(old, event.id), - ); - retryAttemptsRef.current.delete(event.id); - queryClient.invalidateQueries({ - queryKey: workspaceEventsQueryKey(workspaceId), - }); - } - } else { - retryAttemptsRef.current.delete(event.id); - - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => confirmOptimisticEvent(old, event.id, data.version), - ); - - applyConfirmedWorkspaceEventToStateQuery(queryClient, workspaceId, { - ...event, - version: data.version, - }); - } - }, - }); -} diff --git a/src/hooks/workspace/use-workspace-operations.ts b/src/hooks/workspace/use-workspace-operations.ts index 16ab9ab8..06b415c8 100644 --- a/src/hooks/workspace/use-workspace-operations.ts +++ b/src/hooks/workspace/use-workspace-operations.ts @@ -1,15 +1,7 @@ -import { useCallback, useRef, useEffect } from "react"; +import { useCallback, useEffect, useRef } from "react"; +import { useZero } from "@rocicorp/zero/react"; import { Debouncer } from "@tanstack/pacer/debouncer"; -import { useSession } from "@/lib/auth-client"; import { toast } from "sonner"; -import { useQueryClient } from "@tanstack/react-query"; -import { useWorkspaceMutation } from "./use-workspace-mutation"; -import { createEvent, type EventResponse } from "@/lib/workspace/events"; -import { workspaceEventsQueryKey } from "./use-workspace-events"; -import { - deriveWorkspaceStateFromCaches, - getCachedWorkspaceState, -} from "./workspace-state-cache"; import type { Item, ItemData, @@ -17,10 +9,10 @@ import type { DocumentData, } from "@/lib/workspace-state/types"; import type { CardColor } from "@/lib/workspace-state/colors"; -import { generateItemId } from "@/lib/workspace-state/item-helpers"; import { defaultDataFor } from "@/lib/workspace-state/item-helpers"; import { getRandomCardColor } from "@/lib/workspace-state/colors"; import { logger } from "@/lib/utils/logger"; +import { mutators } from "@/lib/zero/mutators"; import { useUIStore } from "@/lib/stores/ui-store"; import { getLayoutForBreakpoint, @@ -31,9 +23,33 @@ import { getNextUniqueDefaultName, } from "@/lib/workspace/unique-name"; import { filterItemIdsForFolderCreation } from "@/lib/workspace-state/search"; +import { + sanitizeWorkspaceItemChanges, + sanitizeWorkspaceItemForPersistence, +} from "@/lib/workspace/workspace-item-sanitize"; const ITEM_UPDATE_DEBOUNCE_MS = 500; +type JsonValue = + | string + | number + | boolean + | null + | JsonValue[] + | { [key: string]: JsonValue }; + +type JsonObject = { [key: string]: JsonValue }; + +type WorkspaceItemMutatorChanges = { + name?: string; + subtitle?: string; + data?: JsonObject; + color?: string | null; + folderId?: string | null; + layout?: JsonObject | null; + lastModified?: number; +}; + function getAllDescendantIds(folderId: string, items: Item[]): string[] { const directChildren = items.filter((item) => item.folderId === folderId); const descendantIds: string[] = []; @@ -48,6 +64,40 @@ function getAllDescendantIds(folderId: string, items: Item[]): string[] { return descendantIds; } +function toMutatorChanges(changes: Partial): WorkspaceItemMutatorChanges { + const sanitized = sanitizeWorkspaceItemChanges(changes); + const mutatorChanges: WorkspaceItemMutatorChanges = {}; + + if (sanitized.name !== undefined) { + mutatorChanges.name = sanitized.name; + } + if (sanitized.subtitle !== undefined) { + mutatorChanges.subtitle = sanitized.subtitle; + } + if (sanitized.data !== undefined) { + mutatorChanges.data = sanitized.data as JsonObject; + } + if (sanitized.color !== undefined) { + mutatorChanges.color = sanitized.color ?? null; + } + if (sanitized.folderId !== undefined) { + mutatorChanges.folderId = sanitized.folderId ?? null; + } + if (sanitized.layout !== undefined) { + mutatorChanges.layout = + (sanitized.layout as JsonObject | undefined) ?? null; + } + if (sanitized.lastModified !== undefined) { + mutatorChanges.lastModified = sanitized.lastModified; + } + + return mutatorChanges; +} + +function isEmptyChanges(changes: WorkspaceItemMutatorChanges): boolean { + return Object.keys(changes).length === 0; +} + /** * Return type for workspace operations */ @@ -76,7 +126,6 @@ export interface WorkspaceOperations { updateAllItems: (items: Item[]) => void; flushPendingChanges: (itemId: string) => void; getDocumentMarkdownForExport: (itemId: string) => string; - // Folder operations createFolder: (name: string, color?: CardColor) => string; createFolderWithItems: ( name: string, @@ -93,54 +142,47 @@ export interface WorkspaceOperations { error: Error | null; } -/** - * High-level workspace operations hook - * Wraps useWorkspaceMutation with convenient methods for common operations - * All operations emit events for optimistic updates - */ export function useWorkspaceOperations( workspaceId: string | null, currentItems: Item[], ): WorkspaceOperations { - const { data: session } = useSession(); - const user = session?.user; - const queryClient = useQueryClient(); - - const mutation = useWorkspaceMutation(workspaceId); + const zero = useZero(); - const userId = user?.id || "anonymous"; - const userName = user?.name || user?.email || undefined; + const workspaceIdRef = useRef(workspaceId); + const currentItemsRef = useRef(currentItems); + const zeroRef = useRef(zero); - // Debouncer refs for updateItem and updateItemData keyed by item ID. const updateItemDebouncerRef = useRef void>>>( new Map(), ); const updateItemDataDebouncerRef = useRef void>>>( new Map(), ); - // Store pending changes to merge them const pendingItemChangesRef = useRef>>(new Map()); const pendingItemDataUpdatersRef = useRef< Map Item["data"]> >(new Map()); + const commitPendingItemUpdateRef = useRef<(itemId: string) => void>(() => {}); + const commitPendingItemDataUpdateRef = useRef<(itemId: string) => void>( + () => {}, + ); - const getLatestItemsFromState = useCallback(() => { - if (!workspaceId) { - return currentItems; - } + useEffect(() => { + workspaceIdRef.current = workspaceId; + }, [workspaceId]); - const stateData = getCachedWorkspaceState(queryClient, workspaceId); - const eventData = queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ); - const derived = deriveWorkspaceStateFromCaches({ - workspaceId, - stateData, - eventLog: eventData, - }); + useEffect(() => { + currentItemsRef.current = currentItems; + }, [currentItems]); + + useEffect(() => { + zeroRef.current = zero; + }, [zero]); - return stateData ? derived.state : currentItems; - }, [workspaceId, queryClient, currentItems]); + const getLatestItemsFromState = useCallback( + () => currentItemsRef.current, + [], + ); const getLatestItemFromState = useCallback( (itemId: string) => @@ -155,7 +197,7 @@ export function useWorkspaceOperations( const pendingChanges = pendingItemChangesRef.current.get(itemId); const itemWithPendingChanges = pendingChanges - ? { ...item, ...pendingChanges } + ? ({ ...item, ...pendingChanges } as Item) : item; const pendingUpdater = pendingItemDataUpdatersRef.current.get(itemId); @@ -179,6 +221,7 @@ export function useWorkspaceOperations( return; } + const currentWorkspaceId = workspaceIdRef.current; const latestItems = getLatestItemsFromState(); const item = latestItems.find((candidate) => candidate.id === itemId); if (!item) { @@ -202,19 +245,25 @@ export function useWorkspaceOperations( } } - mutation.mutate( - createEvent( - "ITEM_UPDATED", - { id: itemId, changes: finalChanges, name: newName }, - userId, - userName, - ), + const changes = toMutatorChanges(finalChanges); + if (!currentWorkspaceId || isEmptyChanges(changes)) { + pendingItemChangesRef.current.delete(itemId); + updateItemDebouncerRef.current.delete(itemId); + return; + } + + zeroRef.current.mutate( + mutators.item.update({ + workspaceId: currentWorkspaceId, + id: itemId, + changes, + }), ); pendingItemChangesRef.current.delete(itemId); updateItemDebouncerRef.current.delete(itemId); }, - [getLatestItemsFromState, mutation, userId, userName], + [getLatestItemsFromState], ); const commitPendingItemDataUpdate = useCallback( @@ -225,43 +274,14 @@ export function useWorkspaceOperations( return; } - // Read latest state from cache instead of relying on closure state so - // newly-created items remain addressable while optimistic events settle. - let latestItem: Item | undefined; - if (workspaceId) { - const cacheData = queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ); - if (cacheData?.events) { - const latestState = deriveWorkspaceStateFromCaches({ - workspaceId, - stateData: getCachedWorkspaceState(queryClient, workspaceId), - eventLog: cacheData, - }).state; - latestItem = latestState.find((item) => item.id === itemId); - } - } - if (!latestItem) { - latestItem = currentItems.find((item) => item.id === itemId); - } + const currentWorkspaceId = workspaceIdRef.current; + const latestItem = getLatestItemFromState(itemId); if (!latestItem) { - const cacheData = workspaceId - ? queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ) - : null; - const itemCount = cacheData?.events - ? deriveWorkspaceStateFromCaches({ - workspaceId, - stateData: getCachedWorkspaceState(queryClient, workspaceId), - eventLog: cacheData, - }).state.length - : 0; logger.warn( - `[OCR/UPDATE] updateItemData: Item ${itemId} not found. Item may have been deleted. Cache has ${itemCount} items.`, + `[OCR/UPDATE] updateItemData: Item ${itemId} not found. Item may have been deleted.`, { itemId, - workspaceId, + workspaceId: currentWorkspaceId, }, ); pendingItemDataUpdatersRef.current.delete(itemId); @@ -269,66 +289,71 @@ export function useWorkspaceOperations( return; } - const newData = finalUpdater(latestItem.data); + const newData = sanitizeWorkspaceItemForPersistence({ + ...latestItem, + data: finalUpdater(latestItem.data), + }).data; - mutation.mutate( - createEvent( - "ITEM_UPDATED", - { + if (currentWorkspaceId) { + zeroRef.current.mutate( + mutators.item.update({ + workspaceId: currentWorkspaceId, id: itemId, - changes: { data: newData }, - name: latestItem.name, - }, - userId, - userName, - ), - ); + changes: { data: newData as JsonObject }, + }), + ); + } pendingItemDataUpdatersRef.current.delete(itemId); updateItemDataDebouncerRef.current.delete(itemId); }, - [workspaceId, queryClient, currentItems, mutation, userId, userName], + [getLatestItemFromState], ); - const getOrCreateUpdateItemDebouncer = useCallback( - (itemId: string) => { - const existing = updateItemDebouncerRef.current.get(itemId); - if (existing) { - return existing; - } + useEffect(() => { + commitPendingItemUpdateRef.current = commitPendingItemUpdate; + }, [commitPendingItemUpdate]); + + useEffect(() => { + commitPendingItemDataUpdateRef.current = commitPendingItemDataUpdate; + }, [commitPendingItemDataUpdate]); - const debouncer = new Debouncer(() => commitPendingItemUpdate(itemId), { + const getOrCreateUpdateItemDebouncer = useCallback((itemId: string) => { + const existing = updateItemDebouncerRef.current.get(itemId); + if (existing) { + return existing; + } + + const debouncer = new Debouncer( + () => commitPendingItemUpdateRef.current(itemId), + { wait: ITEM_UPDATE_DEBOUNCE_MS, - }); - updateItemDebouncerRef.current.set(itemId, debouncer); - return debouncer; - }, - [commitPendingItemUpdate], - ); + }, + ); + updateItemDebouncerRef.current.set(itemId, debouncer); + return debouncer; + }, []); - const getOrCreateUpdateItemDataDebouncer = useCallback( - (itemId: string) => { - const existing = updateItemDataDebouncerRef.current.get(itemId); - if (existing) { - return existing; - } + const getOrCreateUpdateItemDataDebouncer = useCallback((itemId: string) => { + const existing = updateItemDataDebouncerRef.current.get(itemId); + if (existing) { + return existing; + } - const debouncer = new Debouncer( - () => commitPendingItemDataUpdate(itemId), - { wait: ITEM_UPDATE_DEBOUNCE_MS }, - ); - updateItemDataDebouncerRef.current.set(itemId, debouncer); - return debouncer; - }, - [commitPendingItemDataUpdate], - ); + const debouncer = new Debouncer( + () => commitPendingItemDataUpdateRef.current(itemId), + { wait: ITEM_UPDATE_DEBOUNCE_MS }, + ); + updateItemDataDebouncerRef.current.set(itemId, debouncer); + return debouncer; + }, []); - // Cleanup timeouts on unmount useEffect(() => { const updateItemDebouncers = updateItemDebouncerRef.current; const updateItemDataDebouncers = updateItemDataDebouncerRef.current; const pendingItemChanges = pendingItemChangesRef.current; const pendingItemDataUpdaters = pendingItemDataUpdatersRef.current; + return () => { updateItemDebouncers.forEach((debouncer) => debouncer.cancel()); updateItemDataDebouncers.forEach((debouncer) => debouncer.cancel()); @@ -358,24 +383,21 @@ export function useWorkspaceOperations( "document", ]; const validType = validTypes.includes(type) ? type : "document"; + const id = crypto.randomUUID(); + const activeFolderId = useUIStore.getState().activeFolderId; + const folderId = activeFolderId ?? null; + const finalName = + name || + getNextUniqueDefaultName(currentItemsRef.current, validType, folderId); - const id = generateItemId(); - - // Merge default data with initial data const baseData = defaultDataFor(validType); const mergedData = initialData ? { ...baseData, ...initialData } : baseData; - const activeFolderId = useUIStore.getState().activeFolderId; - - const folderId = activeFolderId ?? null; - const finalName = - name || getNextUniqueDefaultName(currentItems, validType, folderId); - let layout: Item["layout"] = undefined; if (initialLayout) { - const itemsInView = currentItems.filter((item) => + const itemsInView = currentItemsRef.current.filter((item) => activeFolderId ? item.folderId === activeFolderId : !item.folderId, ); const position = findNextAvailablePosition( @@ -388,24 +410,39 @@ export function useWorkspaceOperations( layout = { lg: position }; } - const item: Item = { + const item = sanitizeWorkspaceItemForPersistence({ id, type: validType, name: finalName, subtitle: "", data: mergedData as ItemData, - color: getRandomCardColor(), // Assign random color to new cards - folderId: activeFolderId ?? undefined, // Auto-assign to active folder + color: getRandomCardColor(), + folderId: activeFolderId ?? undefined, ...(layout && { layout }), - }; - - const event = createEvent("ITEM_CREATED", { id, item }, userId, userName); + }); - mutation.mutate(event); + if (workspaceIdRef.current) { + zeroRef.current.mutate( + mutators.item.create({ + workspaceId: workspaceIdRef.current, + id, + item: { + id: item.id, + type: item.type, + name: item.name, + subtitle: item.subtitle, + data: item.data as JsonObject, + color: item.color ?? null, + folderId: item.folderId ?? null, + layout: (item.layout as JsonObject | undefined) ?? null, + }, + }), + ); + } - return id; // Return ID for further operations + return id; }, - [mutation, userId, userName, workspaceId, currentItems], + [], ); const createItems = useCallback( @@ -423,23 +460,14 @@ export function useWorkspaceOperations( } const activeFolderId = useUIStore.getState().activeFolderId; - - // Get items in current view for layout calculation - // We need to maintain a running list including newly created items to prevent stacking - const itemsInCurrentView = currentItems.filter((item) => + const itemsInCurrentView = currentItemsRef.current.filter((item) => activeFolderId ? item.folderId === activeFolderId : !item.folderId, ); - - // Mutable array to track items for position calculation as we generate them const itemsForLayout = [...itemsInCurrentView]; - - // Track items we're creating to detect within-batch duplicates const itemsSoFar: Item[] = []; - // Create all items const createdItems: Item[] = items .map(({ type, name, initialData, initialLayout }) => { - // Validate type is a valid CardType const validTypes: CardType[] = [ "pdf", "flashcard", @@ -452,15 +480,13 @@ export function useWorkspaceOperations( "document", ]; const validType = validTypes.includes(type) ? type : "document"; - - const id = generateItemId(); + const id = crypto.randomUUID(); const folderId = activeFolderId ?? null; const allItemsSoFar = [...itemsInCurrentView, ...itemsSoFar]; const finalName = name || getNextUniqueDefaultName(allItemsSoFar, validType, folderId); - // Check duplicate against existing + already-created in this batch (only when explicit name given) if ( name && hasDuplicateName(allItemsSoFar, finalName, validType, folderId) @@ -468,26 +494,23 @@ export function useWorkspaceOperations( return null; } - // Merge default data with initial data const baseData = defaultDataFor(validType); const mergedData = initialData ? { ...baseData, ...initialData } : baseData; - // Calculate layout if initial dimensions provided - let layout = undefined; - let layoutPlaceholderItem: Item | null = null; + let layout: Item["layout"] | undefined; if (initialLayout) { const position = findNextAvailablePosition( itemsForLayout, validType, - 4, // Default cols + 4, initialLayout.w, initialLayout.h, ); layout = { lg: position }; - layoutPlaceholderItem = { + itemsForLayout.push({ id, type: validType, name: finalName, @@ -496,22 +519,19 @@ export function useWorkspaceOperations( color: getRandomCardColor(), folderId: activeFolderId ?? undefined, layout, - }; - - // Add placeholder item to layout tracking array so next item doesn't overlap - itemsForLayout.push(layoutPlaceholderItem); + }); } - const newItem: Item = { + const newItem = sanitizeWorkspaceItemForPersistence({ id, type: validType, name: finalName, subtitle: "", data: mergedData as ItemData, - color: getRandomCardColor(), // Assign random color to new cards - folderId: activeFolderId ?? undefined, // Auto-assign to active folder + color: getRandomCardColor(), + folderId: activeFolderId ?? undefined, layout, - }; + }); itemsSoFar.push(newItem); return newItem; }) @@ -528,26 +548,32 @@ export function useWorkspaceOperations( ); } - // Create single batch event with all items - const event = createEvent( - "BULK_ITEMS_CREATED", - { items: createdItems }, - userId, - userName, - ); - - mutation.mutate(event); + if (workspaceIdRef.current) { + zeroRef.current.mutate( + mutators.item.createMany({ + workspaceId: workspaceIdRef.current, + items: createdItems.map((item) => ({ + id: item.id, + type: item.type, + name: item.name, + subtitle: item.subtitle, + data: item.data as JsonObject, + color: item.color ?? null, + folderId: item.folderId ?? null, + layout: (item.layout as JsonObject | undefined) ?? null, + })), + }), + ); + } - // Show success toast with count if (options?.showSuccessToast !== false) { const itemCount = createdItems.length; toast.success(`${itemCount} card${itemCount === 1 ? "" : "s"} created`); } - // Return array of created item IDs return createdItems.map((item) => item.id); }, - [mutation, userId, userName, workspaceId, currentItems], + [], ); const updateItem = useCallback( @@ -560,50 +586,47 @@ export function useWorkspaceOperations( [getOrCreateUpdateItemDebouncer], ); - const deleteItem = useCallback( - async (id: string) => { - // If this is a PDF card, delete the file from Supabase storage first - const itemToDelete = currentItems.find((item) => item.id === id); - if (itemToDelete && itemToDelete.type === "pdf") { - const pdfData = itemToDelete.data as { - fileUrl?: string; - filename?: string; - }; - if (pdfData?.fileUrl) { - try { - const deleteResponse = await fetch( - `/api/delete-file?url=${encodeURIComponent(pdfData.fileUrl)}`, - { - method: "DELETE", - }, - ); + const deleteItem = useCallback(async (id: string) => { + const itemToDelete = currentItemsRef.current.find((item) => item.id === id); + if (itemToDelete && itemToDelete.type === "pdf") { + const pdfData = itemToDelete.data as { + fileUrl?: string; + filename?: string; + }; + if (pdfData?.fileUrl) { + try { + const deleteResponse = await fetch( + `/api/delete-file?url=${encodeURIComponent(pdfData.fileUrl)}`, + { + method: "DELETE", + }, + ); - if (!deleteResponse.ok) { - const errorData = await deleteResponse - .json() - .catch(() => ({ error: "Failed to delete file" })); - logger.warn("Failed to delete PDF file:", errorData.error); - } - } catch (error) { - logger.error("Error deleting PDF file:", error); - // Continue with card deletion even if file deletion fails + if (!deleteResponse.ok) { + const errorData = await deleteResponse + .json() + .catch(() => ({ error: "Failed to delete file" })); + logger.warn("Failed to delete PDF file:", errorData.error); } + } catch (error) { + logger.error("Error deleting PDF file:", error); } } + } - // Delete the card (include name for UX copy and diagnostics) - const event = createEvent( - "ITEM_DELETED", - { id, name: itemToDelete?.name }, - userId, - userName, - ); - mutation.mutate(event); - }, - [mutation, userId, userName, currentItems], - ); + if (!workspaceIdRef.current) { + return; + } + + zeroRef.current.mutate( + mutators.item.delete({ + workspaceId: workspaceIdRef.current, + id, + name: itemToDelete?.name, + }), + ); + }, []); - // Helper for updating item data (used by field actions) const updateItemData = useCallback( (itemId: string, updater: (prev: Item["data"]) => Item["data"]) => { const existingUpdater = pendingItemDataUpdatersRef.current.get(itemId); @@ -619,147 +642,145 @@ export function useWorkspaceOperations( [getOrCreateUpdateItemDataDebouncer], ); - // Update all items at once (used for layout changes, reordering, and bulk delete) - const updateAllItems = useCallback( - (items: Item[]) => { - // Read the latest state from cache (including optimistic updates) - // instead of using the potentially stale currentState prop (including optimistic updates) - // instead of using the potentially stale currentState prop - // This ensures we compare against the most recent state even when a previous mutation is pending - let latestState: Item[]; - if (workspaceId) { - const cacheData = queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ); - if (cacheData?.events) { - latestState = deriveWorkspaceStateFromCaches({ - workspaceId, - stateData: getCachedWorkspaceState(queryClient, workspaceId), - eventLog: cacheData, - }).state; - } else { - // Fallback to prop if cache is empty (shouldn't happen in normal flow) - latestState = currentItems; - } - } else { - latestState = currentItems; - } + const updateAllItems = useCallback((items: Item[]) => { + const currentWorkspaceId = workspaceIdRef.current; + if (!currentWorkspaceId) { + return; + } - const previousItemCount = latestState.length; - const currentIds = new Set(latestState.map((i) => i.id)); - const newIds = new Set(items.map((i) => i.id)); - - // Send only what changed – no full item data (avoids huge payloads for textbooks) - - // Count decreased: bulk delete – send only deletedIds - if (items.length < previousItemCount) { - const deletedIds = latestState - .filter((i) => !newIds.has(i.id)) - .map((i) => i.id); - mutation.mutate( - createEvent( - "BULK_ITEMS_UPDATED", - { deletedIds, previousItemCount }, - userId, - userName, - ), + const latestState = currentItemsRef.current; + const previousItemCount = latestState.length; + const currentIds = new Set(latestState.map((item) => item.id)); + const newIds = new Set(items.map((item) => item.id)); + + if (items.length < previousItemCount) { + const deletedIds = latestState + .filter((item) => !newIds.has(item.id)) + .map((item) => item.id); + if (deletedIds.length > 0) { + zeroRef.current.mutate( + mutators.item.updateMany({ + workspaceId: currentWorkspaceId, + deletedIds, + previousItemCount, + }), ); - return; } + return; + } - // Count increased: items added – send only the new items (typically 1–2) - if (items.length > previousItemCount) { - const addedItems = items.filter((i) => !currentIds.has(i.id)); - mutation.mutate( - createEvent( - "BULK_ITEMS_UPDATED", - { addedItems, previousItemCount }, - userId, - userName, - ), + if (items.length > previousItemCount) { + const addedItems = items + .filter((item) => !currentIds.has(item.id)) + .map((item) => sanitizeWorkspaceItemForPersistence(item)); + + if (addedItems.length > 0) { + zeroRef.current.mutate( + mutators.item.updateMany({ + workspaceId: currentWorkspaceId, + addedItems: addedItems.map((item) => ({ + id: item.id, + type: item.type, + name: item.name, + subtitle: item.subtitle, + data: item.data as JsonObject, + color: item.color ?? null, + folderId: item.folderId ?? null, + layout: (item.layout as JsonObject | undefined) ?? null, + })), + previousItemCount, + }), ); - return; } + return; + } - // Extract only layout changes to minimize payload size - // Compare with latest state (from cache) to find items whose layout changed - const layoutUpdates: Array<{ - id: string; - x: number; - y: number; - w: number; - h: number; - }> = []; - const currentItemsMap = new Map( - latestState.map((item) => [item.id, item]), - ); - - for (const item of items) { - const currentItem = currentItemsMap.get(item.id); - const currentLayout = currentItem - ? getLayoutForBreakpoint(currentItem, "lg") - : undefined; - const newLayout = getLayoutForBreakpoint(item, "lg"); - - // Only include if layout exists and has changed - if ( - newLayout && - (!currentLayout || - currentLayout.x !== newLayout.x || - currentLayout.y !== newLayout.y || - currentLayout.w !== newLayout.w || - currentLayout.h !== newLayout.h) - ) { - layoutUpdates.push({ - id: item.id, - x: newLayout.x, - y: newLayout.y, - w: newLayout.w, - h: newLayout.h, - }); - } - } - // Only create event if there are actual layout changes - if (layoutUpdates.length > 0) { - const event = createEvent( - "BULK_ITEMS_UPDATED", - { - layoutUpdates, - previousItemCount, - }, - userId, - userName, - ); - mutation.mutate(event); + const layoutUpdates: Array<{ + id: string; + x: number; + y: number; + w: number; + h: number; + }> = []; + const currentItemsMap = new Map(latestState.map((item) => [item.id, item])); + + for (const item of items) { + const currentItem = currentItemsMap.get(item.id); + const currentLayout = currentItem + ? getLayoutForBreakpoint(currentItem, "lg") + : undefined; + const newLayout = getLayoutForBreakpoint(item, "lg"); + + if ( + newLayout && + (!currentLayout || + currentLayout.x !== newLayout.x || + currentLayout.y !== newLayout.y || + currentLayout.w !== newLayout.w || + currentLayout.h !== newLayout.h) + ) { + layoutUpdates.push({ + id: item.id, + x: newLayout.x, + y: newLayout.y, + w: newLayout.w, + h: newLayout.h, + }); } - }, - [workspaceId, queryClient, currentItems, mutation, userId, userName], - ); + } - // ===================================================== - // FOLDER OPERATIONS - // Folders are now items with type: 'folder' - // ===================================================== + if (layoutUpdates.length > 0) { + zeroRef.current.mutate( + mutators.item.updateMany({ + workspaceId: currentWorkspaceId, + layoutUpdates, + previousItemCount, + }), + ); + } + }, []); const createFolder = useCallback( (name: string, color?: CardColor): string => { - // Create a folder as an item with type: 'folder' - const folderId = createItem("folder", name); - // Update color if provided (createItem uses random color) - if (color) { - updateItem(folderId, { color }); + const folderId = crypto.randomUUID(); + const activeFolderId = useUIStore.getState().activeFolderId; + const folder = sanitizeWorkspaceItemForPersistence({ + id: folderId, + type: "folder", + name: name || "New Folder", + subtitle: "", + data: defaultDataFor("folder") as ItemData, + color: color || getRandomCardColor(), + folderId: activeFolderId ?? undefined, + }); + + if (workspaceIdRef.current) { + zeroRef.current.mutate( + mutators.item.create({ + workspaceId: workspaceIdRef.current, + id: folderId, + item: { + id: folder.id, + type: folder.type, + name: folder.name, + subtitle: folder.subtitle, + data: folder.data as JsonObject, + color: folder.color ?? null, + folderId: folder.folderId ?? null, + layout: null, + }, + }), + ); } + return folderId; }, - [createItem, updateItem], + [], ); const createFolderWithItems = useCallback( (name: string, itemIds: string[], color?: CardColor): string => { - // Get active folder - auto-assign new folder to the currently viewed folder const activeFolderId = useUIStore.getState().activeFolderId; - - // Prevent cycles: exclude active folder and its ancestors from selection const safeItemIds = filterItemIdsForFolderCreation( itemIds, activeFolderId, @@ -770,44 +791,48 @@ export function useWorkspaceOperations( toast.error( "Cannot create folder: selected items would create a circular reference.", ); - return ""; // Return empty string since no folder was created + return ""; } - const folderId = generateItemId(); - - const baseData = defaultDataFor("folder"); - - const folder: Item = { + const folderId = crypto.randomUUID(); + const folder = sanitizeWorkspaceItemForPersistence({ id: folderId, type: "folder", name: name || "New Folder", subtitle: "", - data: baseData as ItemData, + data: defaultDataFor("folder") as ItemData, color: color || getRandomCardColor(), - folderId: activeFolderId ?? undefined, // Auto-assign to active folder (can be nested) - }; - - // Create single atomic event that creates folder and moves items - const event = createEvent( - "FOLDER_CREATED_WITH_ITEMS", - { folder, itemIds: safeItemIds }, - userId, - userName, - ); + folderId: activeFolderId ?? undefined, + }); - mutation.mutate(event); + if (workspaceIdRef.current) { + zeroRef.current.mutate( + mutators.folder.createWithItems({ + workspaceId: workspaceIdRef.current, + folder: { + id: folder.id, + type: "folder", + name: folder.name, + subtitle: folder.subtitle, + data: folder.data as JsonObject, + color: folder.color ?? null, + folderId: folder.folderId ?? null, + layout: null, + }, + itemIds: safeItemIds, + }), + ); + } - // Show success toast toast.success( `Folder created with ${safeItemIds.length} item${safeItemIds.length === 1 ? "" : "s"}`, ); return folderId; }, - [mutation, userId, userName, getLatestItemsFromState], + [getLatestItemsFromState], ); - // updateFolder now just calls updateItem (folders are items) const updateFolder = useCallback( (folderId: string, changes: Partial) => { updateItem(folderId, changes); @@ -815,57 +840,29 @@ export function useWorkspaceOperations( [updateItem], ); - // deleteFolder now just calls deleteItem (folders are items) const deleteFolder = useCallback( (folderId: string) => { - const folder = currentItems?.find( - (i) => i.id === folderId && i.type === "folder", + const folder = currentItemsRef.current.find( + (item) => item.id === folderId && item.type === "folder", ); - deleteItem(folderId); + void deleteItem(folderId); toast.success( folder ? `Folder "${folder.name}" deleted` : "Folder deleted", ); }, - [deleteItem, currentItems], + [deleteItem], ); - // deleteFolderWithContents deletes the folder and all items inside it (including nested) - // Uses atomic bulk update pattern (same as handleBulkDelete in WorkspaceSection) const deleteFolderWithContents = useCallback( (folderId: string) => { - // CRITICAL: Read latest state from cache to avoid stale data issues - // (same pattern as updateAllItems - currentState prop can be stale) - let latestItems: Item[]; - if (workspaceId) { - const cacheData = queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ); - if (cacheData?.events) { - const latestState = deriveWorkspaceStateFromCaches({ - workspaceId, - stateData: getCachedWorkspaceState(queryClient, workspaceId), - eventLog: cacheData, - }).state; - latestItems = latestState; - } else { - latestItems = currentItems; - } - } else { - latestItems = currentItems; - } - + const latestItems = getLatestItemsFromState(); const folder = latestItems.find( - (i) => i.id === folderId && i.type === "folder", + (item) => item.id === folderId && item.type === "folder", ); - // Find all descendant items recursively (handles nested folders) const allDescendantIds = getAllDescendantIds(folderId, latestItems); - - // Create set of all IDs to delete (descendants + folder itself) const idsToDelete = new Set([...allDescendantIds, folderId]); const itemCount = allDescendantIds.length; - // Delete PDF files from storage (fire-and-forget, non-blocking) - // This is best-effort cleanup - files may become orphaned if this fails const itemsToDelete = latestItems.filter((item) => idsToDelete.has(item.id), ); @@ -883,11 +880,24 @@ export function useWorkspaceOperations( } } - // Atomic bulk delete using updateAllItems pattern (single BULK_ITEMS_UPDATED event) - const remainingItems = latestItems.filter( - (item) => !idsToDelete.has(item.id), - ); - updateAllItems(remainingItems); + const currentWorkspaceId = workspaceIdRef.current; + if (currentWorkspaceId) { + for (const descendantId of allDescendantIds) { + zeroRef.current.mutate( + mutators.item.delete({ + workspaceId: currentWorkspaceId, + id: descendantId, + }), + ); + } + zeroRef.current.mutate( + mutators.item.delete({ + workspaceId: currentWorkspaceId, + id: folderId, + name: folder?.name, + }), + ); + } toast.success( folder @@ -895,40 +905,56 @@ export function useWorkspaceOperations( : `Folder and ${itemCount} ${itemCount === 1 ? "item" : "items"} deleted`, ); }, - [workspaceId, queryClient, currentItems, updateAllItems], + [getLatestItemsFromState], ); const moveItemToFolder = useCallback( (itemId: string, folderId: string | null) => { - const item = currentItems.find((i) => i.id === itemId); - const event = createEvent( - "ITEM_MOVED_TO_FOLDER", - { itemId, folderId, itemName: item?.name }, - userId, - userName, + const currentWorkspaceId = workspaceIdRef.current; + if (!currentWorkspaceId) { + return; + } + + const item = currentItemsRef.current.find( + (candidate) => candidate.id === itemId, + ); + zeroRef.current.mutate( + mutators.item.move({ + workspaceId: currentWorkspaceId, + itemId, + folderId, + itemName: item?.name, + }), ); - mutation.mutate(event); }, - [mutation, userId, userName, currentItems], + [], ); const moveItemsToFolder = useCallback( (itemIds: string[], folderId: string | null) => { + const currentWorkspaceId = workspaceIdRef.current; + if (!currentWorkspaceId) { + return; + } + const itemNames = itemIds - .map((id) => currentItems.find((i) => i.id === id)?.name) - .filter((n): n is string => n != null); - const event = createEvent( - "ITEMS_MOVED_TO_FOLDER", - { itemIds, folderId, itemNames }, - userId, - userName, + .map( + (id) => currentItemsRef.current.find((item) => item.id === id)?.name, + ) + .filter((name): name is string => name != null); + + zeroRef.current.mutate( + mutators.item.moveMany({ + workspaceId: currentWorkspaceId, + itemIds, + folderId, + itemNames, + }), ); - mutation.mutate(event); }, - [mutation, userId, userName, currentItems], + [], ); - // Flush pending debounced changes for an item (called when modal closes) const flushPendingChanges = useCallback((itemId: string) => { updateItemDebouncerRef.current.get(itemId)?.flush(); updateItemDataDebouncerRef.current.get(itemId)?.flush(); @@ -952,7 +978,6 @@ export function useWorkspaceOperations( updateAllItems, flushPendingChanges, getDocumentMarkdownForExport, - // Folder operations createFolder, createFolderWithItems, updateFolder, @@ -960,8 +985,8 @@ export function useWorkspaceOperations( deleteFolderWithContents, moveItemToFolder, moveItemsToFolder, - isPending: mutation.isPending, - isError: mutation.isError, - error: mutation.error, + isPending: false, + isError: false, + error: null, }; } diff --git a/src/hooks/workspace/use-workspace-realtime.ts b/src/hooks/workspace/use-workspace-realtime.ts deleted file mode 100644 index baf73233..00000000 --- a/src/hooks/workspace/use-workspace-realtime.ts +++ /dev/null @@ -1,207 +0,0 @@ -/** - * Real-time workspace subscription hook. - * - * Workspace events are saved first, then broadcast from the server as the - * canonical event/version pair. Clients subscribe and merge those confirmed - * events into the React Query cache. - */ - -import { useCallback, useEffect, useRef, useState } from "react"; -import { useQueryClient } from "@tanstack/react-query"; -import type { RealtimeChannel } from "@supabase/supabase-js"; -import { getSupabaseClient } from "@/lib/supabase-client"; -import { logger } from "@/lib/utils/logger"; -import type { EventResponse, WorkspaceEvent } from "@/lib/workspace/events"; -import { workspaceEventsQueryKey } from "./use-workspace-events"; -import { applyConfirmedWorkspaceEventToStateQuery } from "./workspace-state-cache"; - -interface WorkspaceRealtimeOptions { - onStatusChange?: ( - status: "connecting" | "connected" | "disconnected" | "error", - ) => void; - onRemoteEvent?: (event: WorkspaceEvent) => void; -} - -interface WorkspaceRealtimeReturn { - isConnected: boolean; - reconnect: () => void; -} - -function sortConfirmedEvents(events: WorkspaceEvent[]) { - return [...events].sort((a, b) => { - const versionA = - typeof a.version === "number" ? a.version : Number.MAX_SAFE_INTEGER; - const versionB = - typeof b.version === "number" ? b.version : Number.MAX_SAFE_INTEGER; - - if (versionA !== versionB) return versionA - versionB; - if (a.timestamp !== b.timestamp) return a.timestamp - b.timestamp; - return a.id.localeCompare(b.id); - }); -} - -function mergeRealtimeEvent( - old: EventResponse, - event: WorkspaceEvent, -): EventResponse { - if (old.events.some((existing) => existing.id === event.id)) { - return old; - } - - const confirmedEvents = old.events.filter( - (existing) => typeof existing.version === "number", - ); - const optimisticEvents = old.events.filter( - (existing) => typeof existing.version !== "number", - ); - - return { - ...old, - events: [ - ...sortConfirmedEvents([...confirmedEvents, event]), - ...optimisticEvents, - ], - version: - typeof event.version === "number" - ? Math.max(old.version, event.version) - : old.version, - }; -} - -export function useWorkspaceRealtime( - workspaceId: string | null, - options: WorkspaceRealtimeOptions = {}, -): WorkspaceRealtimeReturn { - const queryClient = useQueryClient(); - const channelRef = useRef(null); - const { onStatusChange, onRemoteEvent } = options; - const [isConnected, setIsConnected] = useState(false); - const [reconnectNonce, setReconnectNonce] = useState(0); - - const removeChannel = useCallback((channel: RealtimeChannel | null) => { - if (!channel) return; - const supabase = getSupabaseClient(); - supabase.removeChannel(channel); - }, []); - - const cleanup = useCallback(() => { - if (!channelRef.current) return; - - removeChannel(channelRef.current); - channelRef.current = null; - setIsConnected(false); - }, [removeChannel]); - - useEffect(() => { - if (!workspaceId) { - if (channelRef.current) { - removeChannel(channelRef.current); - channelRef.current = null; - } - onStatusChange?.("disconnected"); - return; - } - - const supabase = getSupabaseClient(); - const channelName = `workspace:${workspaceId}:events`; - onStatusChange?.("connecting"); - - const channel = supabase.channel(channelName, { - config: { - broadcast: { self: false }, - }, - }); - - channelRef.current = channel; - - channel.on("broadcast", { event: "workspace_event" }, (payload) => { - const event = payload.payload as WorkspaceEvent; - - if (!event || !event.id) { - logger.warn( - "[REALTIME] Ignoring invalid workspace event payload", - payload, - ); - return; - } - - onRemoteEvent?.(event); - - const existing = queryClient.getQueryData( - workspaceEventsQueryKey(workspaceId), - ); - - const hasVersionGap = - !!existing && - typeof event.version === "number" && - event.version > existing.version + 1; - - queryClient.setQueryData( - workspaceEventsQueryKey(workspaceId), - (old) => { - if (!old) return old; - return mergeRealtimeEvent(old, event); - }, - ); - applyConfirmedWorkspaceEventToStateQuery(queryClient, workspaceId, event); - - if (hasVersionGap) { - logger.warn("[REALTIME] Detected workspace event version gap", { - workspaceId, - eventId: event.id, - eventVersion: event.version, - knownVersion: existing.version, - }); - - queryClient.invalidateQueries({ - queryKey: workspaceEventsQueryKey(workspaceId), - }); - } - }); - - channel.subscribe((status) => { - switch (status) { - case "SUBSCRIBED": - setIsConnected(true); - onStatusChange?.("connected"); - break; - case "CHANNEL_ERROR": - setIsConnected(false); - onStatusChange?.("error"); - break; - case "CLOSED": - case "TIMED_OUT": - setIsConnected(false); - onStatusChange?.("disconnected"); - break; - default: - onStatusChange?.("connecting"); - } - }); - - return () => { - if (channelRef.current === channel) { - channelRef.current = null; - } - removeChannel(channel); - setIsConnected(false); - }; - }, [ - workspaceId, - queryClient, - cleanup, - onStatusChange, - onRemoteEvent, - reconnectNonce, - removeChannel, - ]); - - return { - isConnected: !!workspaceId && isConnected, - reconnect: useCallback(() => { - if (!workspaceId) return; - cleanup(); - setReconnectNonce((value) => value + 1); - }, [workspaceId, cleanup]), - }; -} diff --git a/src/hooks/workspace/use-workspace-state.ts b/src/hooks/workspace/use-workspace-state.ts index 5aeff238..f5cd5e73 100644 --- a/src/hooks/workspace/use-workspace-state.ts +++ b/src/hooks/workspace/use-workspace-state.ts @@ -3,25 +3,25 @@ import { useQuery } from "@rocicorp/zero/react"; import { rehydrateWorkspaceItem } from "@/lib/workspace/workspace-item-model"; import type { WorkspaceItemContentProjection } from "@/lib/workspace/workspace-item-model-types"; import type { Item } from "@/lib/workspace-state/types"; -import { zql } from "@/lib/zero/zero-schema.gen"; +import { queries } from "@/lib/zero/queries"; import type { WorkspaceItemContentRow, WorkspaceItemsRow, } from "@/lib/zero/zero-schema.gen"; type WorkspaceItemQueryRow = WorkspaceItemsRow & { - workspaceItemContent?: readonly WorkspaceItemContentRow[] | WorkspaceItemContentRow; + workspaceItemContent?: + | readonly WorkspaceItemContentRow[] + | WorkspaceItemContentRow; }; export function useWorkspaceState(workspaceId: string | null) { const [rawRows, status] = useQuery( - workspaceId - ? zql.workspace_items - .where("workspaceId", workspaceId) - .related("workspaceItemContent") - : null, + workspaceId ? queries.workspace.items({ workspaceId }) : null, ); - const rows = rawRows as unknown as readonly WorkspaceItemQueryRow[] | undefined; + const rows = rawRows as unknown as + | readonly WorkspaceItemQueryRow[] + | undefined; const state = useMemo(() => { if (!rows) { @@ -30,7 +30,7 @@ export function useWorkspaceState(workspaceId: string | null) { return rows.map((row) => { const contentRow = Array.isArray(row.workspaceItemContent) - ? row.workspaceItemContent[0] ?? null + ? (row.workspaceItemContent[0] ?? null) : (row.workspaceItemContent ?? null); return rehydrateWorkspaceItem({ @@ -61,7 +61,6 @@ export function useWorkspaceState(workspaceId: string | null) { } : null, extracted: null, - userStates: null, }); }); }, [rows]); diff --git a/src/hooks/workspace/workspace-state-cache.test.ts b/src/hooks/workspace/workspace-state-cache.test.ts deleted file mode 100644 index bc28d19d..00000000 --- a/src/hooks/workspace/workspace-state-cache.test.ts +++ /dev/null @@ -1,129 +0,0 @@ -import { describe, expect, it } from "vitest"; -import type { EventResponse, WorkspaceEvent } from "@/lib/workspace/events"; -import { toClientWorkspaceEvent } from "@/lib/workspace/workspace-event-client-payload"; -import type { Item } from "@/lib/workspace-state/types"; -import { deriveWorkspaceStateFromCaches } from "./workspace-state-cache"; - -const baseState = { - state: [ - { - id: "doc-1", - type: "document", - name: "Doc", - subtitle: "", - data: { markdown: "base" }, - }, - ], - version: 2, -} satisfies { state: Item[]; version: number }; - -function event(version: number | undefined, changes: string): WorkspaceEvent { - return { - id: `evt-${version ?? "optimistic"}-${changes}`, - type: "ITEM_UPDATED", - payload: { - id: "doc-1", - changes: { data: { markdown: changes } }, - }, - timestamp: Date.now(), - userId: "user-1", - ...(typeof version === "number" ? { version } : {}), - } as WorkspaceEvent; -} - -describe("workspace-state-cache", () => { - it("applies only delta and optimistic events on top of projection state", () => { - const eventLog: EventResponse = { - version: 4, - events: [ - event(1, "ignored"), - event(3, "confirmed"), - event(undefined, "optimistic"), - ], - }; - - const derived = deriveWorkspaceStateFromCaches({ - workspaceId: "ws-1", - stateData: baseState, - eventLog, - }); - - expect(derived.version).toBe(4); - expect(derived.state).toEqual([ - { - id: "doc-1", - type: "document", - name: "Doc", - subtitle: "", - data: { markdown: "optimistic" }, - lastModified: eventLog.events[2].timestamp, - }, - ]); - }); - - it("returns empty initial state before the projection payload arrives", () => { - const derived = deriveWorkspaceStateFromCaches({ - workspaceId: "ws-1", - stateData: null, - eventLog: { version: 5, events: [event(5, "ignored until state loads")] }, - }); - - expect(derived.state).toEqual([]); - expect(derived.version).toBe(5); - }); - - it("does not leak another user's confirmed per-user state via delta overlay", () => { - const stateData = { - state: [ - { - id: "yt-1", - type: "youtube", - name: "Video", - subtitle: "", - data: { - url: "https://youtu.be/1", - progress: 12, - playbackRate: 1, - }, - }, - ] satisfies Item[], - version: 2, - }; - - const leakedConfirmedEvent: WorkspaceEvent = { - id: "evt-confirmed", - type: "ITEM_UPDATED", - payload: { - id: "yt-1", - changes: { - data: { - progress: 77, - playbackRate: 1.75, - }, - }, - }, - timestamp: Date.now(), - userId: "other-user", - version: 3, - } as WorkspaceEvent; - - const eventLog: EventResponse = { - version: 3, - events: [toClientWorkspaceEvent(leakedConfirmedEvent)], - }; - - const derived = deriveWorkspaceStateFromCaches({ - workspaceId: "ws-1", - stateData, - eventLog, - }); - - expect(derived.state).toEqual([ - { - ...stateData.state[0], - lastModified: leakedConfirmedEvent.timestamp, - }, - ]); - expect(derived.version).toBe(3); - }); -}); diff --git a/src/hooks/workspace/workspace-state-cache.ts b/src/hooks/workspace/workspace-state-cache.ts deleted file mode 100644 index 604f52fb..00000000 --- a/src/hooks/workspace/workspace-state-cache.ts +++ /dev/null @@ -1,102 +0,0 @@ -import type { QueryClient } from "@tanstack/react-query"; -import { initialItems } from "@/lib/workspace-state/state"; -import type { Item } from "@/lib/workspace-state/types"; -import { eventReducer } from "@/lib/workspace/event-reducer"; -import type { EventResponse, WorkspaceEvent } from "@/lib/workspace/events"; - -export interface WorkspaceStateResponse { - state: Item[]; - version: number; -} - -export function workspaceStateQueryKey(workspaceId: string | null) { - return ["workspace", workspaceId, "state"] as const; -} - -export function applyConfirmedWorkspaceEventToState( - stateData: WorkspaceStateResponse | null | undefined, - event: WorkspaceEvent, -): WorkspaceStateResponse | null { - if (!stateData || typeof event.version !== "number") { - return stateData ?? null; - } - - if (event.version <= stateData.version) { - return stateData; - } - - const nextState = eventReducer(stateData.state, event); - - return { - state: nextState, - version: event.version, - }; -} - -export function deriveWorkspaceStateFromCaches(params: { - workspaceId: string | null; - stateData?: WorkspaceStateResponse | null; - eventLog?: EventResponse | null; -}): WorkspaceStateResponse { - if (!params.workspaceId) { - return { - state: [...initialItems], - version: 0, - }; - } - - const stateData = params.stateData ?? null; - const eventLog = params.eventLog ?? null; - - if (!stateData) { - return { - state: [...initialItems], - version: eventLog?.version ?? 0, - }; - } - - const deltaEvents = (eventLog?.events ?? []).filter( - (event) => - typeof event.version !== "number" || event.version > stateData.version, - ); - - const derivedState = - deltaEvents.length > 0 - ? deltaEvents.reduce(eventReducer, stateData.state) - : stateData.state; - - return { - state: derivedState, - version: Math.max(stateData.version, eventLog?.version ?? 0), - }; -} - -export function getCachedWorkspaceState( - queryClient: QueryClient, - workspaceId: string | null, -): WorkspaceStateResponse | null { - if (!workspaceId) { - return null; - } - - return ( - queryClient.getQueryData( - workspaceStateQueryKey(workspaceId), - ) ?? null - ); -} - -export function applyConfirmedWorkspaceEventToStateQuery( - queryClient: QueryClient, - workspaceId: string | null, - event: WorkspaceEvent, -): void { - if (!workspaceId) { - return; - } - - queryClient.setQueryData( - workspaceStateQueryKey(workspaceId), - (old) => applyConfirmedWorkspaceEventToState(old, event), - ); -} diff --git a/src/lib/ai/tools/tool-utils.ts b/src/lib/ai/tools/tool-utils.ts index e1f5b3f1..205838da 100644 --- a/src/lib/ai/tools/tool-utils.ts +++ b/src/lib/ai/tools/tool-utils.ts @@ -2,7 +2,7 @@ * Shared utilities for AI tools */ -import { loadWorkspaceState } from "@/lib/workspace/state-loader"; +import { loadWorkspaceState } from "@/lib/workspace/workspace-state-read"; import type { Item } from "@/lib/workspace-state/types"; import type { WorkspaceToolContext } from "./workspace-tools"; import { resolveItemByPath } from "./workspace-search-utils"; diff --git a/src/lib/ai/tools/workspace-tools.ts b/src/lib/ai/tools/workspace-tools.ts index d24d3f50..9c7abe71 100644 --- a/src/lib/ai/tools/workspace-tools.ts +++ b/src/lib/ai/tools/workspace-tools.ts @@ -2,7 +2,7 @@ import { tool, zodSchema } from "ai"; import { z } from "zod"; import { logger } from "@/lib/utils/logger"; import { workspaceWorker } from "@/lib/ai/workers"; -import { loadWorkspaceState } from "@/lib/workspace/state-loader"; +import { loadWorkspaceState } from "@/lib/workspace/workspace-state-read"; import type { Item } from "@/lib/workspace-state/types"; import { loadStateForTool, resolveItem, getAvailableItemsList, withSanitizedModelOutput } from "./tool-utils"; import { normalizeWorkspaceItems } from "@/lib/workspace-state/state"; diff --git a/src/lib/ai/workers/__tests__/workspace-worker.edit.test.ts b/src/lib/ai/workers/__tests__/workspace-worker.edit.test.ts deleted file mode 100644 index b3d61328..00000000 --- a/src/lib/ai/workers/__tests__/workspace-worker.edit.test.ts +++ /dev/null @@ -1,428 +0,0 @@ -import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; - -const mockGetSession = vi.fn(); -const mockHeaders = vi.fn(); -const mockLoadWorkspaceState = vi.fn(); -const mockCreateEvent = vi.fn(); -const mockExecute = vi.fn(); -const mockTransaction = vi.fn(); -const mockBroadcastWorkspaceEventFromServer = vi.fn(); - -const mockLimit = vi.fn(); -const mockWhere = vi.fn(() => ({ limit: mockLimit })); -const mockFrom = vi.fn(() => ({ where: mockWhere })); -const mockSelect = vi.fn(() => ({ from: mockFrom })); - -vi.mock("next/headers", () => ({ - headers: () => mockHeaders(), -})); - -vi.mock("@/lib/auth", () => ({ - auth: { - api: { - getSession: (...args: any[]) => mockGetSession(...args), - }, - }, -})); - -vi.mock("@/lib/db/client", () => ({ - db: { - select: (...args: any[]) => - (mockSelect as (...a: any[]) => unknown).apply(null, args), - execute: (...args: any[]) => - (mockExecute as (...a: any[]) => unknown).apply(null, args), - transaction: (...args: any[]) => - (mockTransaction as (...a: any[]) => unknown).apply(null, args), - }, - workspaces: { - id: "id", - userId: "userId", - }, -})); - -vi.mock("@/lib/db/schema", () => ({ - workspaceCollaborators: { - userId: "userId", - permissionLevel: "permissionLevel", - }, -})); - -vi.mock("@/lib/workspace/state-loader", () => ({ - loadWorkspaceState: (...args: any[]) => mockLoadWorkspaceState(...args), -})); - -vi.mock("@/lib/workspace/events", () => ({ - createEvent: (...args: any[]) => mockCreateEvent(...args), -})); - -vi.mock("@/lib/realtime/server-broadcast", () => ({ - broadcastWorkspaceEventFromServer: (...args: any[]) => - mockBroadcastWorkspaceEventFromServer(...args), -})); - -vi.mock("@/lib/workspace/unique-name", () => ({ - hasDuplicateName: () => false, -})); - -vi.mock("@/lib/workspace/workspace-event-store", () => ({ - appendWorkspaceEventOrThrow: async ({ workspaceId, event }: any) => { - const result = await mockTransaction(async (tx: any) => { - await tx.execute(); - return tx.execute(); - }); - const raw = result?.[0]?.result as string | undefined; - const match = raw?.match(/\((\d+),(t|f|true|false)\)/i); - const version = match ? Number(match[1]) : 0; - await mockBroadcastWorkspaceEventFromServer(workspaceId, { - ...event, - version, - }); - return { - conflict: false, - version, - persistedEvent: { ...event, version }, - }; - }, - appendWorkspaceEventUsingCurrentVersionWithRetry: async ({ - workspaceId, - event, - }: any) => { - const result = await mockTransaction(async (tx: any) => { - await tx.execute(); - return tx.execute(); - }); - const raw = result?.[0]?.result as string | undefined; - const match = raw?.match(/\((\d+),(t|f|true|false)\)/i); - const version = match ? Number(match[1]) : 0; - await mockBroadcastWorkspaceEventFromServer(workspaceId, { - ...event, - version, - }); - return { - conflict: false, - version, - persistedEvent: { ...event, version }, - }; - }, -})); - -describe("workspaceWorker edit end-to-end paths", () => { - let workspaceWorker: typeof import("@/lib/ai/workers/workspace-worker").workspaceWorker; - let workspaceOperationQueues: Map>; - - beforeAll(async () => { - const workerMod = await import("@/lib/ai/workers/workspace-worker"); - workspaceWorker = workerMod.workspaceWorker; - const commonMod = await import("@/lib/ai/workers/common"); - workspaceOperationQueues = commonMod.workspaceOperationQueues; - }); - - beforeEach(() => { - vi.clearAllMocks(); - workspaceOperationQueues.clear(); - - mockHeaders.mockResolvedValue(new Headers()); - mockGetSession.mockResolvedValue({ user: { id: "user-1" } }); - mockLimit.mockResolvedValue([{ userId: "user-1" }]); // workspace owner path - mockTransaction.mockImplementation(async (callback: any) => - callback({ execute: mockExecute }), - ); - mockCreateEvent.mockImplementation( - (type: string, payload: unknown, userId: string) => ({ - id: "evt-1", - type, - payload, - timestamp: 123, - userId, - }), - ); - }); - - it("edits quiz JSON and appends question near end", async () => { - mockLoadWorkspaceState.mockResolvedValue({ - items: [ - { - id: "quiz-1", - type: "quiz", - name: "Quiz 1", - subtitle: "", - data: { - questions: [ - { - id: "q1", - type: "multiple_choice", - questionText: "Q1", - options: ["A", "B", "C", "D"], - correctIndex: 0, - }, - ], - }, - }, - ], - }); - - mockExecute - .mockResolvedValueOnce([{ version: 1 }]) // get_workspace_version - .mockResolvedValueOnce([{ result: "(2,f)" }]); // append_workspace_event - - const result = await workspaceWorker("edit", { - workspaceId: "ws-1", - itemId: "quiz-1", - itemType: "quiz", - itemName: "Quiz 1", - oldString: " ]\n}", - newString: [ - " ,", - " {", - ' "id": "q2",', - ' "type": "multiple_choice",', - ' "questionText": "Q2",', - ' "options": ["A", "B", "C", "D"],', - ' "correctIndex": 1,', - " }", - " ]", - "}", - ].join("\n"), - }); - - expect(result.success).toBe(true); - expect(result.message).toMatch(/Updated quiz/); - expect((result as any).questionCount).toBe(2); - expect(mockBroadcastWorkspaceEventFromServer).toHaveBeenCalledTimes(1); - expect(mockBroadcastWorkspaceEventFromServer).toHaveBeenCalledWith( - "ws-1", - expect.objectContaining({ - id: "evt-1", - type: "ITEM_UPDATED", - version: 2, - payload: expect.objectContaining({ - id: "quiz-1", - }), - }), - ); - }); - - it("repairs malformed appended flashcard JSON and succeeds", async () => { - mockLoadWorkspaceState.mockResolvedValue({ - items: [ - { - id: "deck-1", - type: "flashcard", - name: "Deck 1", - subtitle: "", - data: { - cards: [{ id: "c1", front: "f1", back: "b1" }], - }, - }, - ], - }); - - mockExecute - .mockResolvedValueOnce([{ version: 4 }]) // get_workspace_version - .mockResolvedValueOnce([{ result: "(5,f)" }]); // append_workspace_event - - const result = await workspaceWorker("edit", { - workspaceId: "ws-1", - itemId: "deck-1", - itemType: "flashcard", - itemName: "Deck 1", - oldString: " ]\n}", - // intentionally malformed but repairable (single quotes + trailing comma) - newString: [ - " ,", - " {'id':'c2','front':'f2','back':'b2'},", - " ]", - "}", - ].join("\n"), - }); - - expect(result.success).toBe(true); - expect(result.message).toMatch(/Updated flashcard deck/); - expect((result as any).cardCount).toBe(2); - expect(mockBroadcastWorkspaceEventFromServer).toHaveBeenCalledTimes(1); - expect(mockBroadcastWorkspaceEventFromServer).toHaveBeenCalledWith( - "ws-1", - expect.objectContaining({ - id: "evt-1", - type: "ITEM_UPDATED", - version: 5, - payload: expect.objectContaining({ - id: "deck-1", - }), - }), - ); - }); - - it("fails quiz edit when repaired JSON violates schema", async () => { - const initialQuestions = [ - { - id: "q1", - type: "multiple_choice", - questionText: "Q1", - options: ["A", "B", "C", "D"], - correctIndex: 0, - }, - ]; - - mockLoadWorkspaceState.mockResolvedValue({ - items: [ - { - id: "quiz-1", - type: "quiz", - name: "Quiz 1", - subtitle: "", - data: { - questions: initialQuestions, - }, - }, - ], - }); - - const result = await workspaceWorker("edit", { - workspaceId: "ws-1", - itemId: "quiz-1", - itemType: "quiz", - itemName: "Quiz 1", - oldString: JSON.stringify({ questions: initialQuestions }, null, 2), - // repair may parse this, but schema should reject 3 options for MC - newString: JSON.stringify( - { - questions: [ - { - ...initialQuestions[0], - options: ["A", "B", "C"], - }, - ], - }, - null, - 2, - ), - }); - - expect(result.success).toBe(false); - expect(result.message).toMatch(/multiple_choice needs 4 options/i); - }); - - it("fails flashcard edit on unrecoverable invalid JSON", async () => { - mockLoadWorkspaceState.mockResolvedValue({ - items: [ - { - id: "deck-1", - type: "flashcard", - name: "Deck 1", - subtitle: "", - data: { - cards: [{ id: "c1", front: "f1", back: "b1" }], - }, - }, - ], - }); - - const result = await workspaceWorker("edit", { - workspaceId: "ws-1", - itemId: "deck-1", - itemType: "flashcard", - itemName: "Deck 1", - oldString: "{", - newString: "{ ???", - }); - - expect(result.success).toBe(false); - expect(result.message).toMatch(/Invalid JSON after edit/i); - }); - - it("rename-only: updates document name without touching content", async () => { - const markdown = "Original document content"; - mockLoadWorkspaceState.mockResolvedValue({ - items: [ - { - id: "doc-1", - type: "document", - name: "My Document", - subtitle: "", - data: { markdown }, - }, - ], - }); - - mockExecute - .mockResolvedValueOnce([{ version: 1 }]) // get_workspace_version - .mockResolvedValueOnce([{ result: "(2,f)" }]); // append_workspace_event - - const result = await workspaceWorker("edit", { - workspaceId: "ws-1", - itemId: "doc-1", - itemType: "document", - itemName: "My Document", - oldString: "", - newString: "", - newName: "Renamed Document", - }); - - expect(result.success).toBe(true); - expect(result.message).toMatch(/Updated document successfully/); - expect(mockCreateEvent).toHaveBeenCalled(); - expect(mockBroadcastWorkspaceEventFromServer).toHaveBeenCalledTimes(1); - expect(mockBroadcastWorkspaceEventFromServer).toHaveBeenCalledWith( - "ws-1", - expect.objectContaining({ - id: "evt-1", - type: "ITEM_UPDATED", - version: 2, - payload: expect.objectContaining({ - id: "doc-1", - }), - }), - ); - const eventPayload = mockCreateEvent.mock.calls[0][1] as { - id: string; - changes: Record; - }; - expect(eventPayload.id).toBe("doc-1"); - expect(eventPayload.changes).toEqual({ name: "Renamed Document" }); - }); - - it("fails with clear message when oldString is ambiguous", async () => { - mockLoadWorkspaceState.mockResolvedValue({ - items: [ - { - id: "quiz-1", - type: "quiz", - name: "Quiz 1", - subtitle: "", - data: { - questions: [ - { - id: "q1", - type: "multiple_choice", - questionText: "Same", - options: ["A", "B", "C", "D"], - correctIndex: 0, - }, - { - id: "q2", - type: "multiple_choice", - questionText: "Same", - options: ["A", "B", "C", "D"], - correctIndex: 1, - }, - ], - }, - }, - ], - }); - - const result = await workspaceWorker("edit", { - workspaceId: "ws-1", - itemId: "quiz-1", - itemType: "quiz", - itemName: "Quiz 1", - oldString: '"questionText": "Same"', - newString: '"questionText": "Updated"', - replaceAll: false, - }); - - expect(result.success).toBe(false); - expect(result.message).toMatch(/multiple matches/i); - }); -}); diff --git a/src/lib/ai/workers/common.ts b/src/lib/ai/workers/common.ts index ffe4afa7..50fcaa8b 100644 --- a/src/lib/ai/workers/common.ts +++ b/src/lib/ai/workers/common.ts @@ -64,4 +64,4 @@ export async function executeWorkspaceOperation( return newOperation; } -// loadCurrentState removed - use loadWorkspaceState from "@/lib/workspace/state-loader" instead +// loadCurrentState removed - use loadWorkspaceState from "@/lib/workspace/workspace-state-read" instead diff --git a/src/lib/ai/workers/workspace-worker.ts b/src/lib/ai/workers/workspace-worker.ts index e5c4dac1..30dce666 100644 --- a/src/lib/ai/workers/workspace-worker.ts +++ b/src/lib/ai/workers/workspace-worker.ts @@ -1,9 +1,5 @@ import { createPatch, diffLines } from "diff"; -import { - appendWorkspaceEventOrThrow, - appendWorkspaceEventUsingCurrentVersionWithRetry, -} from "@/lib/workspace/workspace-event-store"; -import { createEvent } from "@/lib/workspace/events"; +import { db } from "@/lib/db/client"; import { generateItemId } from "@/lib/workspace-state/item-helpers"; import { getRandomCardColor } from "@/lib/workspace-state/colors"; import { logger } from "@/lib/utils/logger"; @@ -24,7 +20,6 @@ import { loadWorkspaceItemsForValidation, checkDuplicateName, } from "@/lib/workspace/mutation-helpers"; -import type { WorkspaceEvent } from "@/lib/workspace/events"; import { replace as applyReplace, trimDiff, @@ -32,6 +27,13 @@ import { } from "@/lib/utils/edit-replace"; import { parseJsonWithRepair } from "@/lib/utils/json-repair"; import { buildPdfDataFromUpload } from "@/lib/pdf/pdf-item"; +import { + deleteWorkspaceItemById, + insertWorkspaceItem, + loadWorkspaceItemRecord, + upsertWorkspaceItem, +} from "@/lib/workspace/workspace-item-write"; +import { sanitizeWorkspaceItemForPersistence } from "@/lib/workspace/workspace-item-sanitize"; /** Create params for a single item (used by create and bulkCreate). Exported for autogen. */ export type CreateItemParams = { @@ -81,7 +83,7 @@ export type CreateItemParams = { * Build an Item from create params. Used by both create and bulkCreate. */ async function buildItemFromCreateParams(p: CreateItemParams): Promise { - const itemId = p.id || generateItemId(); + const itemId = p.id || crypto.randomUUID(); const itemType = p.itemType || "document"; let itemData: any; @@ -180,27 +182,50 @@ async function buildItemFromCreateParams(p: CreateItemParams): Promise { }; } -async function persistWorkspaceEvent( - workspaceId: string, - event: WorkspaceEvent, -) { - return appendWorkspaceEventOrThrow({ - workspaceId, - event, - conflictMessage: "Workspace was modified by another user, please try again", +async function createWorkspaceItem(workspaceId: string, item: Item) { + await db.transaction(async (tx) => { + await insertWorkspaceItem(tx, { + workspaceId, + item: sanitizeWorkspaceItemForPersistence(item), + sourceVersion: 0, + }); }); } -async function persistWorkspaceEventWithRetry( +async function createWorkspaceItems(workspaceId: string, items: Item[]) { + await db.transaction(async (tx) => { + for (const item of items) { + await insertWorkspaceItem(tx, { + workspaceId, + item: sanitizeWorkspaceItemForPersistence(item), + sourceVersion: 0, + }); + } + }); +} + +async function updateWorkspaceItem( workspaceId: string, - event: WorkspaceEvent, - maxRetries = 0, + itemId: string, + updater: (item: Item) => Item, ) { - return appendWorkspaceEventUsingCurrentVersionWithRetry({ - workspaceId, - event, - maxRetries, - conflictMessage: "Workspace was modified by another user, please try again", + await db.transaction(async (tx) => { + const existing = await loadWorkspaceItemRecord(tx, { workspaceId, itemId }); + if (!existing) { + throw new Error(`Item not found with ID: ${itemId}`); + } + + await upsertWorkspaceItem(tx, { + workspaceId, + sourceVersion: existing.sourceVersion, + item: sanitizeWorkspaceItemForPersistence(updater(existing.item)), + }); + }); +} + +async function deleteWorkspaceItem(workspaceId: string, itemId: string) { + await db.transaction(async (tx) => { + await deleteWorkspaceItemById(tx, { workspaceId, itemId }); }); } @@ -291,7 +316,7 @@ export async function workspaceWorker( itemId?: string; cardsAdded?: number; cardCount?: number; - event?: WorkspaceEvent; + event?: unknown; version?: number; }> { // For "create" and "bulkCreate" operations, allow parallel execution (bypass queue) @@ -302,29 +327,26 @@ export async function workspaceWorker( params.workspaceId, async () => { try { - const { userId, userName } = await requireMutationIdentity(); + const { userId } = await requireMutationIdentity(); await requireWorkspaceEditor(params.workspaceId, userId); // Handle different actions if (action === "create") { const item = await buildItemFromCreateParams(params); - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); - const dupError = checkDuplicateName(currentState, item.name, item.type, item.folderId ?? null); - if (dupError) { - return { success: false, message: dupError }; - } - const event = createEvent( - "ITEM_CREATED", - { id: item.id, item }, + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, userId, - userName, ); - - const appendResult = await persistWorkspaceEventWithRetry( - params.workspaceId, - event, - 2, + const dupError = checkDuplicateName( + currentState, + item.name, + item.type, + item.folderId ?? null, ); + if (dupError) { + return { success: false, message: dupError }; + } + await createWorkspaceItem(params.workspaceId, item); // Include card count for flashcard decks (use created item.data.cards, not params) const flashcardCards = @@ -342,8 +364,6 @@ export async function workspaceWorker( itemId: item.id, message: `Created ${item.type} "${item.name}" successfully`, cardCount, - event, - version: appendResult.version, }; } @@ -356,32 +376,29 @@ export async function workspaceWorker( params.items.map((p) => buildItemFromCreateParams(p)), ); - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, + userId, + ); for (let i = 0; i < items.length; i++) { const item = items[i]; const preceding = [...currentState, ...items.slice(0, i)]; - const dupError = checkDuplicateName(preceding, item.name, item.type, item.folderId ?? null); + const dupError = checkDuplicateName( + preceding, + item.name, + item.type, + item.folderId ?? null, + ); if (dupError) { return { success: false, message: dupError }; } } - const event = createEvent( - "BULK_ITEMS_CREATED", - { items }, - userId, - userName, - ); - - const appendResult = await persistWorkspaceEvent( - params.workspaceId, - event, - ); + await createWorkspaceItems(params.workspaceId, items); return { success: true, message: `Bulk created ${items.length} items successfully`, - version: appendResult.version, itemIds: items.map((i) => i.id), }; } @@ -397,7 +414,10 @@ export async function workspaceWorker( throw new Error("Cards to add required for flashcard update"); } - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, + userId, + ); const existingItem = currentState.find( (i: any) => i.id === params.itemId, @@ -434,27 +454,27 @@ export async function workspaceWorker( // Handle title update if provided if (params.title) { - const dupError = checkDuplicateName(currentState, params.title, existingItem.type, existingItem.folderId ?? null, params.itemId); + const dupError = checkDuplicateName( + currentState, + params.title, + existingItem.type, + existingItem.folderId ?? null, + params.itemId, + ); if (dupError) { return { success: false, message: dupError }; } changes.name = params.title; } - const event = createEvent( - "ITEM_UPDATED", - { - id: params.itemId, - changes, - name: changes.name ?? existingItem.name, - }, - userId, - userName, - ); - - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + data: updatedData, + }), ); return { @@ -462,8 +482,6 @@ export async function workspaceWorker( itemId: params.itemId, cardsAdded: newCards.length, message: `Added ${newCards.length} card${newCards.length !== 1 ? "s" : ""} to flashcard deck${params.title ? ` and renamed to "${params.title}"` : ""}`, - event, - version: appendResult.version, }; } @@ -483,7 +501,10 @@ export async function workspaceWorker( ); } - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, + userId, + ); const existingItem = currentState.find( (i: any) => i.id === params.itemId, @@ -511,27 +532,27 @@ export async function workspaceWorker( const changes: any = hasQuestions ? { data: updatedData } : {}; if (params.title) { - const dupError = checkDuplicateName(currentState, params.title, existingItem.type, existingItem.folderId ?? null, params.itemId); + const dupError = checkDuplicateName( + currentState, + params.title, + existingItem.type, + existingItem.folderId ?? null, + params.itemId, + ); if (dupError) { return { success: false, message: dupError }; } changes.name = params.title; } - const event = createEvent( - "ITEM_UPDATED", - { - id: params.itemId, - changes, - name: changes.name ?? existingItem.name, - }, - userId, - userName, - ); - - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + ...(hasQuestions ? { data: updatedData } : {}), + }), ); return { @@ -542,8 +563,6 @@ export async function workspaceWorker( message: hasQuestions ? `Added ${questionsToAdd!.length} question${questionsToAdd!.length !== 1 ? "s" : ""} to quiz` : "Quiz title updated.", - event, - version: appendResult.version, }; } @@ -563,7 +582,10 @@ export async function workspaceWorker( ); } - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, + userId, + ); const existingItem = currentState.find( (i: any) => i.id === params.itemId, ); @@ -589,36 +611,33 @@ export async function workspaceWorker( const changes: Partial = { data: updatedData }; if (params.title) { - const dupError = checkDuplicateName(currentState, params.title, existingItem.type, existingItem.folderId ?? null, params.itemId); + const dupError = checkDuplicateName( + currentState, + params.title, + existingItem.type, + existingItem.folderId ?? null, + params.itemId, + ); if (dupError) { return { success: false, message: dupError }; } changes.name = params.title; } - const event = createEvent( - "ITEM_UPDATED", - { - id: params.itemId, - changes, - name: changes.name ?? existingItem.name, - }, - userId, - userName, - ); - - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + data: updatedData, + }), ); - return { success: true, itemId: params.itemId, message: `Cached OCR content for PDF "${existingItem.name}"`, - event, - version: appendResult.version, }; } @@ -636,7 +655,10 @@ export async function workspaceWorker( ); } - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, + userId, + ); const existingItem = currentState.find( (i: any) => i.id === params.itemId, ); @@ -664,20 +686,14 @@ export async function workspaceWorker( }; const changes: Partial = { data: updatedData }; - const event = createEvent( - "ITEM_UPDATED", - { - id: params.itemId, - changes, - name: existingItem.name, - }, - userId, - userName, - ); - - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + data: updatedData, + }), ); return { @@ -687,8 +703,6 @@ export async function workspaceWorker( params.imageOcrStatus === "failed" ? "Marked image OCR as failed" : `Cached OCR content for image "${existingItem.name}"`, - event, - version: appendResult.version, }; } @@ -707,7 +721,10 @@ export async function workspaceWorker( throw new Error("oldString and newString required for edit"); } - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, + userId, + ); const existingItem = currentState.find( (i: Item) => i.id === params.itemId, ); @@ -771,34 +788,33 @@ export async function workspaceWorker( data: { ...data, cards: newCards } as FlashcardData, }; if (rename) { - const dupError = checkDuplicateName(currentState, rename, "flashcard", existingItem.folderId ?? null, params.itemId); + const dupError = checkDuplicateName( + currentState, + rename, + "flashcard", + existingItem.folderId ?? null, + params.itemId, + ); if (dupError) { return { success: false, message: dupError }; } changes.name = rename; } - const event = createEvent( - "ITEM_UPDATED", - { - id: params.itemId, - changes, - name: changes.name ?? existingItem.name, - }, - userId, - userName, - ); - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + data: { ...data, cards: newCards } as FlashcardData, + }), ); return { success: true, itemId: params.itemId, message: `Updated flashcard deck (${newCards.length} cards)`, - event, - version: appendResult.version, cardCount: newCards.length, }; } @@ -870,38 +886,36 @@ export async function workspaceWorker( ...data, questions: validatedQuestions, }; - if (data.session) updatedData.session = data.session; const changes: Partial = { data: updatedData }; if (rename) { - const dupError = checkDuplicateName(currentState, rename, "quiz", existingItem.folderId ?? null, params.itemId); + const dupError = checkDuplicateName( + currentState, + rename, + "quiz", + existingItem.folderId ?? null, + params.itemId, + ); if (dupError) { return { success: false, message: dupError }; } changes.name = rename; } - const event = createEvent( - "ITEM_UPDATED", - { - id: params.itemId, - changes, - name: changes.name ?? existingItem.name, - }, - userId, - userName, - ); - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + data: updatedData, + }), ); return { success: true, itemId: params.itemId, message: `Updated quiz (${validatedQuestions.length} questions)`, - event, - version: appendResult.version, questionCount: validatedQuestions.length, }; } @@ -910,7 +924,13 @@ export async function workspaceWorker( const changes: Partial = {}; const docData = existingItem.data as DocumentData; if (rename) { - const dupError = checkDuplicateName(currentState, rename, "document", existingItem.folderId ?? null, params.itemId); + const dupError = checkDuplicateName( + currentState, + rename, + "document", + existingItem.folderId ?? null, + params.itemId, + ); if (dupError) { return { success: false, message: dupError }; } @@ -962,16 +982,14 @@ export async function workspaceWorker( }; } - const itemName = (changes.name ?? existingItem.name) as string; - const event = createEvent( - "ITEM_UPDATED", - { id: params.itemId, changes, name: itemName }, - userId, - userName, - ); - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + ...(changes.data ? { data: changes.data } : {}), + }), ); const diffOutput = trimDiff( @@ -992,8 +1010,6 @@ export async function workspaceWorker( success: true, itemId: params.itemId, message: "Updated document successfully", - event, - version: appendResult.version, diff: diffOutput, filediff: { additions: filediffAdditions, @@ -1010,27 +1026,29 @@ export async function workspaceWorker( "PDFs can only be renamed. Use oldString='', newString='', and newName='new name'.", }; } - const dupError = checkDuplicateName(currentState, rename, "pdf", existingItem.folderId ?? null, params.itemId); + const dupError = checkDuplicateName( + currentState, + rename, + "pdf", + existingItem.folderId ?? null, + params.itemId, + ); if (dupError) { return { success: false, message: dupError }; } const changes: Partial = { name: rename }; - const event = createEvent( - "ITEM_UPDATED", - { id: params.itemId, changes, name: rename }, - userId, - userName, - ); - const appendResult = await persistWorkspaceEvent( + await updateWorkspaceItem( params.workspaceId, - event, + params.itemId, + (item) => ({ + ...item, + ...changes, + }), ); return { success: true, itemId: params.itemId, message: `Renamed PDF to "${rename}"`, - event, - version: appendResult.version, }; } @@ -1042,28 +1060,21 @@ export async function workspaceWorker( throw new Error("Item ID required for delete"); } - const currentState = await loadWorkspaceItemsForValidation(params.workspaceId, userId); - const existingItem = currentState.find( - (i: any) => i.id === params.itemId, - ); - const event = createEvent( - "ITEM_DELETED", - { id: params.itemId, name: existingItem?.name }, + const currentState = await loadWorkspaceItemsForValidation( + params.workspaceId, userId, - userName, ); - - const appendResult = await persistWorkspaceEvent( - params.workspaceId, - event, + const existingItem = currentState.find( + (i: any) => i.id === params.itemId, ); + await deleteWorkspaceItem(params.workspaceId, params.itemId); return { success: true, itemId: params.itemId, - message: `Deleted item successfully`, - event, - version: appendResult.version, + message: existingItem + ? `Deleted \"${existingItem.name}\" successfully` + : "Deleted item successfully", }; } diff --git a/src/lib/auth.ts b/src/lib/auth.ts index 775f266e..7fe1e95f 100644 --- a/src/lib/auth.ts +++ b/src/lib/auth.ts @@ -19,9 +19,10 @@ const getBaseURL = () => { }; import { eq } from "drizzle-orm"; -import { workspaces, workspaceEvents, userProfiles } from "@/lib/db/schema"; +import { workspaces, userProfiles } from "@/lib/db/schema"; const baseURL = getBaseURL(); +const authSecret = process.env.BETTER_AUTH_SECRET || process.env.AUTH_SECRET; export const auth = betterAuth({ database: drizzleAdapter(db, { @@ -32,7 +33,10 @@ export const auth = betterAuth({ create: { after: async (user) => { try { - await db.insert(userProfiles).values({ userId: user.id }).onConflictDoNothing({ target: userProfiles.userId }); + await db + .insert(userProfiles) + .values({ userId: user.id }) + .onConflictDoNothing({ target: userProfiles.userId }); } catch (err) { console.error("[auth] Failed to create user profile:", err); } @@ -49,18 +53,24 @@ export const auth = betterAuth({ accessType: "offline", }, }, - secret: process.env.BETTER_AUTH_SECRET || process.env.AUTH_SECRET, + secret: authSecret, baseURL, trustedOrigins: [ "https://www.thinkex.app", "https://thinkex.app", "https://thinkexv2-git-dev-chakrabortyurjit-gmailcoms-projects.vercel.app", - ...(process.env.NEXT_PUBLIC_APP_URL ? [process.env.NEXT_PUBLIC_APP_URL] : []), + ...(process.env.NEXT_PUBLIC_APP_URL + ? [process.env.NEXT_PUBLIC_APP_URL] + : []), ...(process.env.VERCEL_URL ? [`https://${process.env.VERCEL_URL}`] : []), - ...(process.env.NEXT_PUBLIC_VERCEL_URL ? [`https://${process.env.NEXT_PUBLIC_VERCEL_URL}`] : []), + ...(process.env.NEXT_PUBLIC_VERCEL_URL + ? [`https://${process.env.NEXT_PUBLIC_VERCEL_URL}`] + : []), // Chrome extension: in dev accept any origin; in prod require CHROME_EXTENSION_ID ...(process.env.NODE_ENV === "development" ? ["*"] : []), - ...(process.env.CHROME_EXTENSION_ID ? [`chrome-extension://${process.env.CHROME_EXTENSION_ID}`] : []), + ...(process.env.CHROME_EXTENSION_ID + ? [`chrome-extension://${process.env.CHROME_EXTENSION_ID}`] + : []), ], // Session configuration - 30 days for better user experience session: { @@ -93,6 +103,10 @@ export const auth = betterAuth({ advanced: { // Force secure cookies (HTTPS only) - critical for preventing session hijacking useSecureCookies: process.env.NODE_ENV === "production", + crossSubDomainCookies: { + enabled: process.env.NODE_ENV === "production", + domain: process.env.ZERO_COOKIE_DOMAIN ?? ".thinkex.app", + }, // Explicitly configure cookie attributes for maximum security cookies: { session_token: { @@ -129,7 +143,7 @@ export const auth = betterAuth({ const existingSlugs = new Set( existingUserWorkspaces .map((w) => w.slug) - .filter((slug): slug is string => !!slug) + .filter((slug): slug is string => !!slug), ); // Get anonymous user's workspaces @@ -162,13 +176,6 @@ export const auth = betterAuth({ .update(workspaces) .set({ userId: newUser.user.id }) .where(eq(workspaces.userId, anonymousUser.user.id)); - - // 3. Migrate Workspace Events - // Also move the history/events to the new user so they don't get orphaned - await db - .update(workspaceEvents) - .set({ userId: newUser.user.id }) - .where(eq(workspaceEvents.userId, anonymousUser.user.id)); } catch (error) { console.error("Failed to migrate anonymous user data:", error); // We log but don't throw to allow the account linking to complete diff --git a/src/lib/db/relations.ts b/src/lib/db/relations.ts index d8e6ca04..c96a0e03 100644 --- a/src/lib/db/relations.ts +++ b/src/lib/db/relations.ts @@ -1,37 +1,19 @@ import { relations } from "drizzle-orm/relations"; import { workspaces, - workspaceEvents, workspaceItems, workspaceItemContent, workspaceItemExtracted, - workspaceItemProjectionState, - workspaceItemUserState, chatThreads, chatMessages, } from "./schema"; -// workspace_shares removed - sharing is now fork-based (users import copies) - -export const workspacesRelations = relations(workspaces, ({ many, one }) => ({ - workspaceEvents: many(workspaceEvents), +export const workspacesRelations = relations(workspaces, ({ many }) => ({ workspaceItems: many(workspaceItems), workspaceItemContent: many(workspaceItemContent), workspaceItemExtracted: many(workspaceItemExtracted), - workspaceItemUserState: many(workspaceItemUserState), - workspaceItemProjectionState: one(workspaceItemProjectionState), })); -export const workspaceEventsRelations = relations( - workspaceEvents, - ({ one }) => ({ - workspace: one(workspaces, { - fields: [workspaceEvents.workspaceId], - references: [workspaces.id], - }), - }), -); - export const workspaceItemsRelations = relations( workspaceItems, ({ one, many }) => ({ @@ -41,7 +23,6 @@ export const workspaceItemsRelations = relations( }), workspaceItemContent: many(workspaceItemContent), workspaceItemExtracted: many(workspaceItemExtracted), - workspaceItemUserState: many(workspaceItemUserState), }), ); @@ -76,33 +57,6 @@ export const workspaceItemExtractedRelations = relations( }), ); -export const workspaceItemUserStateRelations = relations( - workspaceItemUserState, - ({ one }) => ({ - workspace: one(workspaces, { - fields: [workspaceItemUserState.workspaceId], - references: [workspaces.id], - }), - workspaceItem: one(workspaceItems, { - fields: [ - workspaceItemUserState.workspaceId, - workspaceItemUserState.itemId, - ], - references: [workspaceItems.workspaceId, workspaceItems.itemId], - }), - }), -); - -export const workspaceItemProjectionStateRelations = relations( - workspaceItemProjectionState, - ({ one }) => ({ - workspace: one(workspaces, { - fields: [workspaceItemProjectionState.workspaceId], - references: [workspaces.id], - }), - }), -); - export const chatThreadsRelations = relations(chatThreads, ({ one, many }) => ({ workspace: one(workspaces, { fields: [chatThreads.workspaceId], diff --git a/src/lib/db/schema.ts b/src/lib/db/schema.ts index cc268f11..4c8d1af0 100644 --- a/src/lib/db/schema.ts +++ b/src/lib/db/schema.ts @@ -11,7 +11,6 @@ import { uniqueIndex, integer, unique, - check, bigint, primaryKey, } from "drizzle-orm/pg-core"; @@ -295,72 +294,6 @@ export const workspaceSnapshots = pgTable( ], ); -export const workspaceEvents = pgTable( - "workspace_events", - { - id: uuid().defaultRandom().primaryKey().notNull(), - workspaceId: uuid("workspace_id").notNull(), - eventId: text("event_id").notNull(), - eventType: text("event_type").notNull(), - payload: jsonb().notNull(), - // You can use { mode: "bigint" } if numbers are exceeding js number limitations - timestamp: bigint({ mode: "number" }).notNull(), - userId: text("user_id").notNull(), - version: integer().notNull(), - createdAt: timestamp("created_at", { - withTimezone: true, - mode: "string", - }).defaultNow(), - userName: text("user_name"), - }, - (table) => [ - index("idx_workspace_events_event_id").using( - "btree", - table.eventId.asc().nullsLast().op("text_ops"), - ), - index("idx_workspace_events_timestamp").using( - "btree", - table.workspaceId.asc().nullsLast().op("uuid_ops"), - table.timestamp.asc().nullsLast().op("int8_ops"), - ), - index("idx_workspace_events_user_name").using( - "btree", - table.userName.asc().nullsLast().op("text_ops"), - ), - index("idx_workspace_events_workspace").using( - "btree", - table.workspaceId.asc().nullsLast().op("uuid_ops"), - table.version.asc().nullsLast().op("int4_ops"), - ), - foreignKey({ - columns: [table.workspaceId], - foreignColumns: [workspaces.id], - name: "workspace_events_workspace_id_fkey", - }).onDelete("cascade"), - unique("workspace_events_event_id_key").on(table.eventId), - pgPolicy("Users can insert workspace events they have write access to", { - as: "permissive", - for: "insert", - to: ["public"], - withCheck: sql`(EXISTS ( SELECT 1 - FROM workspaces - WHERE ((workspaces.id = workspace_events.workspace_id) AND (workspaces.user_id = (auth.jwt() ->> 'sub'::text))))) OR (EXISTS ( SELECT 1 - FROM workspace_collaborators c - WHERE ((c.workspace_id = workspace_events.workspace_id) AND (c.user_id = (auth.jwt() ->> 'sub'::text)) AND (c.permission_level = 'editor'::text))))`, - }), - pgPolicy("Users can read workspace events they have access to", { - as: "permissive", - for: "select", - to: ["public"], - using: sql`(EXISTS ( SELECT 1 - FROM workspaces - WHERE ((workspaces.id = workspace_events.workspace_id) AND (workspaces.user_id = (auth.jwt() ->> 'sub'::text))))) OR (EXISTS ( SELECT 1 - FROM workspace_collaborators c - WHERE ((c.workspace_id = workspace_events.workspace_id) AND (c.user_id = (auth.jwt() ->> 'sub'::text)))))`, - }), - ], -); - const workspaceItemsReadAccessSql = sql`(EXISTS ( SELECT 1 FROM workspaces WHERE ((workspaces.id = workspace_items.workspace_id) AND (workspaces.user_id = (auth.jwt() ->> 'sub'::text))))) OR (EXISTS ( SELECT 1 @@ -601,106 +534,6 @@ export const workspaceItemExtracted = pgTable( ], ); -export const workspaceItemUserState = pgTable( - "workspace_item_user_state", - { - workspaceId: uuid("workspace_id").notNull(), - itemId: text("item_id").notNull(), - userId: text("user_id").notNull(), - stateKey: text("state_key").default("item").notNull(), - stateType: text("state_type").notNull(), - stateSchemaVersion: integer("state_schema_version").default(1).notNull(), - state: jsonb().notNull(), - updatedAt: timestamp("updated_at", { withTimezone: true, mode: "string" }) - .defaultNow() - .notNull(), - }, - (table) => [ - primaryKey({ - columns: [table.workspaceId, table.itemId, table.userId, table.stateKey], - name: "workspace_item_user_state_pkey", - }), - index("idx_workspace_item_user_state_workspace_user").using( - "btree", - table.workspaceId.asc().nullsLast().op("uuid_ops"), - table.userId.asc().nullsLast().op("text_ops"), - ), - index("idx_workspace_item_user_state_item").using( - "btree", - table.workspaceId.asc().nullsLast().op("uuid_ops"), - table.itemId.asc().nullsLast().op("text_ops"), - table.userId.asc().nullsLast().op("text_ops"), - ), - foreignKey({ - columns: [table.workspaceId, table.itemId], - foreignColumns: [workspaceItems.workspaceId, workspaceItems.itemId], - name: "workspace_item_user_state_workspace_item_fkey", - }).onDelete("cascade"), - pgPolicy("Users can read their workspace item user state", { - as: "permissive", - for: "select", - to: ["public"], - using: sql`((workspace_item_user_state.user_id = (auth.jwt() ->> 'sub'::text)) AND ((EXISTS ( SELECT 1 - FROM workspaces - WHERE ((workspaces.id = workspace_item_user_state.workspace_id) AND (workspaces.user_id = (auth.jwt() ->> 'sub'::text))))) OR (EXISTS ( SELECT 1 - FROM workspace_collaborators c - WHERE ((c.workspace_id = workspace_item_user_state.workspace_id) AND (c.user_id = (auth.jwt() ->> 'sub'::text)))))))`, - }), - pgPolicy("Users can write their workspace item user state", { - as: "permissive", - for: "all", - to: ["public"], - using: sql`((workspace_item_user_state.user_id = (auth.jwt() ->> 'sub'::text)) AND ((EXISTS ( SELECT 1 - FROM workspaces - WHERE ((workspaces.id = workspace_item_user_state.workspace_id) AND (workspaces.user_id = (auth.jwt() ->> 'sub'::text))))) OR (EXISTS ( SELECT 1 - FROM workspace_collaborators c - WHERE ((c.workspace_id = workspace_item_user_state.workspace_id) AND (c.user_id = (auth.jwt() ->> 'sub'::text)))))))`, - withCheck: sql`((workspace_item_user_state.user_id = (auth.jwt() ->> 'sub'::text)) AND ((EXISTS ( SELECT 1 - FROM workspaces - WHERE ((workspaces.id = workspace_item_user_state.workspace_id) AND (workspaces.user_id = (auth.jwt() ->> 'sub'::text))))) OR (EXISTS ( SELECT 1 - FROM workspace_collaborators c - WHERE ((c.workspace_id = workspace_item_user_state.workspace_id) AND (c.user_id = (auth.jwt() ->> 'sub'::text)))))))`, - }), - ], -); - -export const workspaceItemProjectionState = pgTable( - "workspace_item_projection_state", - { - workspaceId: uuid("workspace_id").primaryKey().notNull(), - lastAppliedVersion: integer("last_applied_version").notNull(), - createdAt: timestamp("created_at", { withTimezone: true, mode: "string" }) - .defaultNow() - .notNull(), - updatedAt: timestamp("updated_at", { withTimezone: true, mode: "string" }) - .defaultNow() - .notNull(), - }, - (table) => [ - index("idx_workspace_item_projection_state_version").using( - "btree", - table.lastAppliedVersion.desc().nullsFirst().op("int4_ops"), - ), - foreignKey({ - columns: [table.workspaceId], - foreignColumns: [workspaces.id], - name: "workspace_item_projection_state_workspace_id_fkey", - }).onDelete("cascade"), - pgPolicy( - "Users can read workspace item projection state they have access to", - { - as: "permissive", - for: "select", - to: ["public"], - using: sql`(EXISTS ( SELECT 1 - FROM workspaces - WHERE ((workspaces.id = workspace_item_projection_state.workspace_id) AND (workspaces.user_id = (auth.jwt() ->> 'sub'::text))))) OR (EXISTS ( SELECT 1 - FROM workspace_collaborators c - WHERE ((c.workspace_id = workspace_item_projection_state.workspace_id) AND (c.user_id = (auth.jwt() ->> 'sub'::text)))))`, - }, - ), - ], -); export const workspaceCollaborators = pgTable( "workspace_collaborators", diff --git a/src/lib/db/types.ts b/src/lib/db/types.ts index 14f83588..edcebc99 100644 --- a/src/lib/db/types.ts +++ b/src/lib/db/types.ts @@ -6,27 +6,17 @@ import type { InferSelectModel, InferInsertModel } from "drizzle-orm"; import { workspaces, - workspaceEvents, workspaceItems, workspaceItemContent, workspaceItemExtracted, - workspaceItemProjectionState, - workspaceItemUserState, userProfiles, workspaceCollaborators, } from "./schema"; import type { Item } from "@/lib/workspace-state/types"; -// Base database types (what Drizzle returns) export type Workspace = InferSelectModel; export type WorkspaceInsert = InferInsertModel; -// WorkspaceState types removed - current state lives in workspace item tables -// WorkspaceShare types removed - sharing is now fork-based (users import copies) - -export type WorkspaceEvent = InferSelectModel; -export type WorkspaceEventInsert = InferInsertModel; - export type WorkspaceItem = InferSelectModel; export type WorkspaceItemInsert = InferInsertModel; @@ -44,20 +34,6 @@ export type WorkspaceItemExtractedInsert = InferInsertModel< typeof workspaceItemExtracted >; -export type WorkspaceItemProjectionState = InferSelectModel< - typeof workspaceItemProjectionState ->; -export type WorkspaceItemProjectionStateInsert = InferInsertModel< - typeof workspaceItemProjectionState ->; - -export type WorkspaceItemUserState = InferSelectModel< - typeof workspaceItemUserState ->; -export type WorkspaceItemUserStateInsert = InferInsertModel< - typeof workspaceItemUserState ->; - export type UserProfile = InferSelectModel; export type UserProfileInsert = InferInsertModel; @@ -70,14 +46,12 @@ export type WorkspaceCollaboratorInsert = InferInsertModel< export type PermissionLevel = "viewer" | "editor"; -// Extended types for frontend use export interface WorkspaceWithState extends Workspace { state?: Item[]; isShared?: boolean; - permissionLevel?: "viewer" | "editor" | "admin"; // admin is implied for owner but good to have in types + permissionLevel?: "viewer" | "editor" | "admin"; } -// API response types export interface WorkspacesResponse { workspaces: WorkspaceWithState[]; } diff --git a/src/lib/realtime/server-broadcast.ts b/src/lib/realtime/server-broadcast.ts deleted file mode 100644 index b9831b34..00000000 --- a/src/lib/realtime/server-broadcast.ts +++ /dev/null @@ -1,75 +0,0 @@ -import "server-only"; - -import { createClient, type SupabaseClient } from "@supabase/supabase-js"; -import { logger } from "@/lib/utils/logger"; -import type { WorkspaceEvent } from "@/lib/workspace/events"; -import { toClientWorkspaceEvent } from "@/lib/workspace/workspace-event-client-payload"; - -let realtimeBroadcastClient: SupabaseClient | null = null; -let didWarnMissingEnv = false; - -function getRealtimeBroadcastClient(): SupabaseClient | null { - if (realtimeBroadcastClient) { - return realtimeBroadcastClient; - } - - const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL; - const supabaseKey = - process.env.SUPABASE_SERVICE_ROLE_KEY ?? - process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY; - - if (!supabaseUrl || !supabaseKey) { - if (!didWarnMissingEnv) { - didWarnMissingEnv = true; - logger.warn( - "[REALTIME] Missing Supabase env for server broadcasts; skipping workspace event broadcast", - ); - } - return null; - } - - realtimeBroadcastClient = createClient(supabaseUrl, supabaseKey, { - auth: { - autoRefreshToken: false, - persistSession: false, - }, - }); - - return realtimeBroadcastClient; -} - -export async function broadcastWorkspaceEventFromServer( - workspaceId: string, - event: WorkspaceEvent, -): Promise { - const supabase = getRealtimeBroadcastClient(); - if (!supabase) return; - - const channel = supabase.channel(`workspace:${workspaceId}:events`); - - try { - // REST broadcast from the server (no WebSocket). See https://supabase.com/docs/guides/realtime/broadcast - const result = await channel.httpSend( - "workspace_event", - toClientWorkspaceEvent(event), - ); - if (!result.success) { - logger.error("[REALTIME] httpSend broadcast failed", { - workspaceId, - eventId: event.id, - eventType: event.type, - status: result.status, - error: result.error, - }); - } - } catch (error) { - logger.error("[REALTIME] Failed to broadcast workspace event from server", { - workspaceId, - eventId: event.id, - eventType: event.type, - error, - }); - } finally { - await supabase.removeChannel(channel); - } -} diff --git a/src/lib/stores/workspace-store.ts b/src/lib/stores/workspace-store.ts index ba9d26ce..8e6f5c4a 100644 --- a/src/lib/stores/workspace-store.ts +++ b/src/lib/stores/workspace-store.ts @@ -1,66 +1,20 @@ -import { create } from 'zustand'; -import { devtools } from 'zustand/middleware'; +import { create } from "zustand"; +import { devtools } from "zustand/middleware"; -/** - * Workspace Store - Manages current workspace and save status - * This replaces WorkspaceContext's currentWorkspaceId and save status tracking - */ interface WorkspaceStoreState { - // Current workspace currentWorkspaceId: string | null; - - // Save status - isSaving: boolean; - lastSavedAt: Date | null; - hasUnsavedChanges: boolean; - - // Actions setCurrentWorkspaceId: (id: string | null) => void; - updateSaveStatus: (isSaving: boolean) => void; - updateLastSaved: (date: Date) => void; - updateHasUnsavedChanges: (hasChanges: boolean) => void; - - // Utility - resetSaveStatus: () => void; } export const useWorkspaceStore = create()( devtools( (set) => ({ - // Initial state currentWorkspaceId: null, - isSaving: false, - lastSavedAt: null, - hasUnsavedChanges: false, - - // Actions setCurrentWorkspaceId: (id) => set({ currentWorkspaceId: id }), - - updateSaveStatus: (isSaving) => set({ isSaving }), - - updateLastSaved: (date) => set({ - lastSavedAt: date, - hasUnsavedChanges: false, - }), - - updateHasUnsavedChanges: (hasChanges) => set({ hasUnsavedChanges: hasChanges }), - - resetSaveStatus: () => set({ - isSaving: false, - lastSavedAt: null, - hasUnsavedChanges: false, - }), }), - { name: 'Workspace Store' } - ) + { name: "Workspace Store" }, + ), ); -// Selectors -export const selectCurrentWorkspaceId = (state: WorkspaceStoreState) => state.currentWorkspaceId; - -export const selectSaveStatus = (state: WorkspaceStoreState) => ({ - isSaving: state.isSaving, - lastSavedAt: state.lastSavedAt, - hasUnsavedChanges: state.hasUnsavedChanges, -}); - +export const selectCurrentWorkspaceId = (state: WorkspaceStoreState) => + state.currentWorkspaceId; diff --git a/src/lib/utils/format-workspace-context.ts b/src/lib/utils/format-workspace-context.ts index 1449289b..d00ea2b0 100644 --- a/src/lib/utils/format-workspace-context.ts +++ b/src/lib/utils/format-workspace-context.ts @@ -692,31 +692,10 @@ function formatFlashcardDetailsFull(data: FlashcardData): string[] { /** * Formats quiz details as raw JSON (editable by item_edit). - * Session progress is shown at top (read-only); item_edit only modifies the questions JSON. */ function formatQuizDetailsFull(data: QuizData): string[] { - const questions = data.questions || []; - const session = data.session; - const lines: string[] = []; - - if (session) { - const total = questions.length; - const answered = session.answeredQuestions?.length ?? 0; - const correct = - session.answeredQuestions?.filter((a) => a.isCorrect).length ?? 0; - const completed = !!(session.completedAt && total > 0 && answered >= total); - lines.push("--- Progress (read-only) ---"); - lines.push( - `Current question: ${session.currentIndex + 1} of ${total || "?"}`, - ); - lines.push(`Answered: ${answered} | Correct: ${correct}`); - lines.push(`Completed: ${completed ? "yes" : "no"}`); - lines.push(""); - } - - const payload = { questions }; - lines.push(JSON.stringify(payload, null, 2)); - return lines; + const payload = { questions: data.questions || [] }; + return [JSON.stringify(payload, null, 2)]; } /** diff --git a/src/lib/workspace-state/item-data-schemas.ts b/src/lib/workspace-state/item-data-schemas.ts index 75ba91e9..9dfa86ad 100644 --- a/src/lib/workspace-state/item-data-schemas.ts +++ b/src/lib/workspace-state/item-data-schemas.ts @@ -1,7 +1,5 @@ import { z } from "zod"; -// ── Shared sub-schemas ── - export const ocrPageSchema = z.object({ index: z.number().int().nonnegative().default(0), markdown: z.string().default(""), @@ -17,15 +15,12 @@ export const sourceSchema = z.object({ favicon: z.string().optional(), }); -// ── Flashcard schemas ── - export const flashcardItemSchema = z.object({ id: z.string(), front: z.string().default(""), back: z.string().default(""), }); -/** Tool/API input variant — no `id`, fields required (no defaults) */ export const flashcardCardInputSchema = z.object({ front: z.string(), back: z.string(), @@ -33,11 +28,8 @@ export const flashcardCardInputSchema = z.object({ export const flashcardDataSchema = z.object({ cards: z.array(flashcardItemSchema).default([]), - currentIndex: z.number().int().nonnegative().optional(), }); -// ── Quiz schemas (slimmed down — NO hint, explanation, sourceContext) ── - export const quizQuestionSchema = z.object({ id: z.string(), type: z.enum(["multiple_choice", "true_false"]), @@ -46,7 +38,6 @@ export const quizQuestionSchema = z.object({ correctIndex: z.number().int().min(0).default(0), }); -/** Tool/API input variant — no `id`, with option-count validation */ export const quizQuestionInputSchema = quizQuestionSchema .omit({ id: true, correctIndex: true }) .extend({ @@ -65,29 +56,11 @@ export const quizQuestionInputSchema = quizQuestionSchema }, ); -export const quizSessionSchema = z.object({ - currentIndex: z.number().int().nonnegative().default(0), - answeredQuestions: z - .array( - z.object({ - questionId: z.string(), - userAnswer: z.number().int(), - isCorrect: z.boolean(), - }), - ) - .default([]), - startedAt: z.number().optional(), - completedAt: z.number().optional(), -}); - export const quizDataSchema = z.object({ title: z.string().optional(), questions: z.array(quizQuestionSchema).default([]), - session: quizSessionSchema.optional(), }); -// ── PDF schema ── - export const pdfDataSchema = z.object({ fileUrl: z.string().default(""), filename: z.string().default(""), @@ -97,8 +70,6 @@ export const pdfDataSchema = z.object({ ocrPages: z.array(ocrPageSchema).optional(), }); -// ── Image schema ── - export const imageDataSchema = z.object({ url: z.string().default(""), altText: z.string().optional(), @@ -108,8 +79,6 @@ export const imageDataSchema = z.object({ ocrPages: z.array(ocrPageSchema).optional(), }); -// ── Audio schemas ── - export const audioSegmentSchema = z.object({ speaker: z.string(), timestamp: z.string(), @@ -133,29 +102,19 @@ export const audioDataSchema = z.object({ error: z.string().optional(), }); -// ── YouTube schema ── - export const youtubeDataSchema = z.object({ url: z.string().default(""), thumbnail: z.string().optional(), - progress: z.number().nonnegative().optional(), - playbackRate: z.number().positive().optional(), }); -// ── Website schema ── - export const websiteDataSchema = z.object({ url: z.string().default(""), favicon: z.string().optional(), }); -// ── Document schema ── - export const documentDataSchema = z.object({ markdown: z.string().optional(), sources: z.array(sourceSchema).optional(), }); -// ── Folder schema ── - export const folderDataSchema = z.object({}).passthrough(); diff --git a/src/lib/workspace-state/item-helpers.ts b/src/lib/workspace-state/item-helpers.ts index 2e3b28c4..da498d7d 100644 --- a/src/lib/workspace-state/item-helpers.ts +++ b/src/lib/workspace-state/item-helpers.ts @@ -1,8 +1,5 @@ import type { CardType, ItemData, PdfData, FlashcardData, FolderData, YouTubeData, QuizData, ImageData, AudioData, WebsiteData, DocumentData } from "./types"; -/** - * Generate a unique item ID - */ export function generateItemId(): string { return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`; } @@ -20,7 +17,6 @@ export function defaultDataFor(type: CardType): ItemData { back: "", }, ], - currentIndex: 0, } as FlashcardData; case "folder": return {} as FolderData; @@ -42,4 +38,3 @@ export function defaultDataFor(type: CardType): ItemData { } } } - diff --git a/src/lib/workspace-state/state.ts b/src/lib/workspace-state/state.ts index 463b6faa..9616d18f 100644 --- a/src/lib/workspace-state/state.ts +++ b/src/lib/workspace-state/state.ts @@ -40,7 +40,6 @@ export function defaultDataFor(type: CardType): ItemData { case "flashcard": return { cards: [], - currentIndex: 0, } as FlashcardData; case "folder": return {} as FolderData; diff --git a/src/lib/workspace-state/types.ts b/src/lib/workspace-state/types.ts index e77827c2..73efed9c 100644 --- a/src/lib/workspace-state/types.ts +++ b/src/lib/workspace-state/types.ts @@ -8,7 +8,6 @@ import { youtubeDataSchema, imageDataSchema, quizQuestionSchema, - quizSessionSchema, quizDataSchema, audioSegmentSchema, audioDataSchema, @@ -36,7 +35,6 @@ export type FolderData = z.infer; export type YouTubeData = z.infer; export type ImageData = z.infer; export type QuizQuestion = z.infer; -export type QuizSessionData = z.infer; export type QuizData = z.infer; export type AudioSegment = z.infer; export type AudioData = z.infer; @@ -54,7 +52,6 @@ export type ItemData = | WebsiteData | DocumentData; -/** Layout position for a single breakpoint */ export interface LayoutPosition { x: number; y: number; @@ -62,32 +59,22 @@ export interface LayoutPosition { h: number; } -/** Responsive layouts for different breakpoints */ export interface ResponsiveLayouts { - lg?: LayoutPosition; // 4-column layout + lg?: LayoutPosition; } export interface Item { id: string; type: CardType; - name: string; // editable title - subtitle: string; // subtitle shown under the title + name: string; + subtitle: string; data: ItemData; - color?: CardColor; // background color for the card - folderId?: string; // Single folder assignment (flat structure) - /** - * Layout position for the workspace grid. - * May be responsive (`ResponsiveLayouts`) or a flat `LayoutPosition` (treated as `lg`). - */ + color?: CardColor; + folderId?: string; layout?: ResponsiveLayouts | LayoutPosition; - /** Timestamp (ms) when item was last modified. Set by event reducer. Used for AI conflict detection. */ lastModified?: number; } -// ===================================================== -// WORKSPACE TYPES -// ===================================================== - export type WorkspaceTemplate = "blank" | "getting_started"; export type PermissionLevel = "viewer" | "editor" | "admin"; diff --git a/src/lib/workspace/__tests__/event-reducer.bulk-items-patched.test.ts b/src/lib/workspace/__tests__/event-reducer.bulk-items-patched.test.ts deleted file mode 100644 index 2edce24e..00000000 --- a/src/lib/workspace/__tests__/event-reducer.bulk-items-patched.test.ts +++ /dev/null @@ -1,80 +0,0 @@ -import { describe, expect, it } from "vitest"; -import { eventReducer } from "../event-reducer"; -import type { ImageData, Item, PdfData } from "@/lib/workspace-state/types"; -import type { WorkspaceEvent } from "../events"; - -describe("eventReducer BULK_ITEMS_PATCHED", () => { - it("deep merges OCR changes across multiple items in one event", () => { - const state: Item[] = [ - { - id: "pdf-1", - type: "pdf", - name: "Doc", - subtitle: "", - data: { - fileUrl: "https://example.com/a.pdf", - filename: "a.pdf", - ocrStatus: "processing", - }, - } as Item, - { - id: "img-1", - type: "image", - name: "Image", - subtitle: "", - data: { - url: "https://example.com/b.png", - altText: "Image", - caption: "keep me", - ocrStatus: "processing", - }, - } as Item, - ]; - - const event: WorkspaceEvent = { - id: "evt-1", - type: "BULK_ITEMS_PATCHED", - timestamp: 123, - userId: "user-1", - payload: { - updates: [ - { - id: "pdf-1", - changes: { - data: ({ - ocrStatus: "complete", - ocrPages: [{ index: 0, markdown: "pdf page" }], - } satisfies Partial) as Item["data"], - }, - }, - { - id: "img-1", - changes: { - data: ({ - ocrStatus: "failed", - ocrError: "bad image", - } satisfies Partial) as Item["data"], - }, - }, - ], - }, - }; - - const next = eventReducer(state, event); - - expect(next[0]?.data).toMatchObject({ - fileUrl: "https://example.com/a.pdf", - filename: "a.pdf", - ocrStatus: "complete", - ocrPages: [{ index: 0, markdown: "pdf page" }], - }); - - expect(next[1]?.data).toMatchObject({ - url: "https://example.com/b.png", - altText: "Image", - caption: "keep me", - ocrStatus: "failed", - ocrError: "bad image", - }); - }); -}); diff --git a/src/lib/workspace/__tests__/event-reducer.lightweight-ocr.test.ts b/src/lib/workspace/__tests__/event-reducer.lightweight-ocr.test.ts deleted file mode 100644 index a0522b07..00000000 --- a/src/lib/workspace/__tests__/event-reducer.lightweight-ocr.test.ts +++ /dev/null @@ -1,105 +0,0 @@ -import { describe, expect, it } from "vitest"; -import { eventReducer } from "../event-reducer"; -import type { Item, PdfData, ImageData } from "@/lib/workspace-state/types"; -import type { WorkspaceEvent } from "../events"; - -describe("eventReducer lightweight OCR events", () => { - const basePdf: Item = { - id: "pdf-1", - type: "pdf", - name: "Doc", - subtitle: "", - data: { - fileUrl: "https://example.com/a.pdf", - filename: "a.pdf", - ocrStatus: "processing", - } as PdfData, - }; - - const baseImage: Item = { - id: "img-1", - type: "image", - name: "Image", - subtitle: "", - data: { - url: "https://example.com/b.png", - ocrStatus: "processing", - } as ImageData, - }; - - it("applies status-only BULK_ITEMS_PATCHED (no ocrPages in event)", () => { - const event: WorkspaceEvent = { - id: "evt-1", - type: "BULK_ITEMS_PATCHED", - timestamp: Date.now(), - userId: "user-1", - payload: { - updates: [ - { - id: "pdf-1", - changes: { - data: { ocrStatus: "complete" } as Item["data"], - }, - }, - { - id: "img-1", - changes: { - data: { - ocrStatus: "failed", - ocrError: "bad image", - } as Item["data"], - }, - }, - ], - }, - }; - - const next = eventReducer([basePdf, baseImage], event); - - const pdfData = next[0].data as PdfData; - expect(pdfData.ocrStatus).toBe("complete"); - expect(pdfData.fileUrl).toBe("https://example.com/a.pdf"); - expect(pdfData.filename).toBe("a.pdf"); - - const imgData = next[1].data as ImageData; - expect(imgData.ocrStatus).toBe("failed"); - expect(imgData.ocrError).toBe("bad image"); - expect(imgData.url).toBe("https://example.com/b.png"); - }); - - it("applies status-only ITEM_UPDATED for audio completion", () => { - const audioItem: Item = { - id: "audio-1", - type: "audio", - name: "Recording", - subtitle: "", - data: { - fileUrl: "https://example.com/a.mp3", - filename: "a.mp3", - processingStatus: "processing", - }, - }; - - const event: WorkspaceEvent = { - id: "evt-2", - type: "ITEM_UPDATED", - timestamp: Date.now(), - userId: "user-1", - payload: { - id: "audio-1", - changes: { - data: { - summary: "Meeting notes", - processingStatus: "complete", - } as Item["data"], - }, - }, - }; - - const next = eventReducer([audioItem], event); - const data = next[0].data as Record; - expect(data.processingStatus).toBe("complete"); - expect(data.summary).toBe("Meeting notes"); - expect(data.fileUrl).toBe("https://example.com/a.mp3"); - }); -}); diff --git a/src/lib/workspace/__tests__/version-helpers.test.ts b/src/lib/workspace/__tests__/version-helpers.test.ts deleted file mode 100644 index 05e5cc07..00000000 --- a/src/lib/workspace/__tests__/version-helpers.test.ts +++ /dev/null @@ -1,99 +0,0 @@ -import { describe, expect, it } from "vitest"; -import { - computeBaseVersion, - removeOptimisticEvent, - confirmOptimisticEvent, -} from "../version-helpers"; -import type { EventResponse } from "../events"; - -function makeCache( - version: number, - events: Array<{ id: string; version?: number }>, -): EventResponse { - return { - version, - events: events.map((e) => ({ - id: e.id, - type: "ITEM_DELETED" as const, - timestamp: Date.now(), - userId: "u", - payload: { id: "x" }, - ...(e.version !== undefined && { version: e.version }), - })), - }; -} - -describe("computeBaseVersion", () => { - it("returns 0 for undefined cache", () => { - const result = computeBaseVersion(undefined); - expect(result.baseVersion).toBe(0); - expect(result.currentVersion).toBe(0); - expect(result.optimisticCount).toBe(0); - }); - - it("returns cache version when no optimistic events", () => { - const cache = makeCache(10, [{ id: "a", version: 10 }]); - const result = computeBaseVersion(cache); - expect(result.baseVersion).toBe(10); - expect(result.currentVersion).toBe(10); - }); - - it("adjusts for optimistic events (subtracts own)", () => { - const cache = makeCache(10, [ - { id: "a", version: 10 }, - { id: "b" }, - { id: "c" }, - ]); - const result = computeBaseVersion(cache); - expect(result.optimisticCount).toBe(2); - expect(result.baseVersion).toBe(11); - }); - - it("uses max event version over cache version", () => { - const cache = makeCache(5, [ - { id: "a", version: 5 }, - { id: "b", version: 8 }, - ]); - const result = computeBaseVersion(cache); - expect(result.currentVersion).toBe(8); - expect(result.baseVersion).toBe(8); - }); -}); - -describe("removeOptimisticEvent", () => { - it("removes event by ID", () => { - const cache = makeCache(5, [ - { id: "a", version: 5 }, - { id: "b" }, - ]); - const result = removeOptimisticEvent(cache, "b"); - expect(result?.events).toHaveLength(1); - expect(result?.events[0].id).toBe("a"); - }); - - it("updates version when provided", () => { - const cache = makeCache(5, [{ id: "a", version: 5 }]); - const result = removeOptimisticEvent(cache, "x", 10); - expect(result?.version).toBe(10); - }); - - it("returns undefined for undefined input", () => { - expect(removeOptimisticEvent(undefined, "a")).toBeUndefined(); - }); -}); - -describe("confirmOptimisticEvent", () => { - it("stamps version on the matching event", () => { - const cache = makeCache(5, [ - { id: "a", version: 5 }, - { id: "b" }, - ]); - const result = confirmOptimisticEvent(cache, "b", 6); - expect(result?.events[1].version).toBe(6); - expect(result?.version).toBe(6); - }); - - it("returns undefined for undefined input", () => { - expect(confirmOptimisticEvent(undefined, "a", 1)).toBeUndefined(); - }); -}); diff --git a/src/lib/workspace/__tests__/workspace-event-client-payload.test.ts b/src/lib/workspace/__tests__/workspace-event-client-payload.test.ts deleted file mode 100644 index f446c1bf..00000000 --- a/src/lib/workspace/__tests__/workspace-event-client-payload.test.ts +++ /dev/null @@ -1,86 +0,0 @@ -import { describe, expect, it } from "vitest"; -import type { WorkspaceEvent } from "@/lib/workspace/events"; -import { toClientWorkspaceEvent } from "@/lib/workspace/workspace-event-client-payload"; - -describe("workspace-event-client-payload", () => { - it("strips per-user fields and heavy OCR payloads without mutating the original event", () => { - const event: WorkspaceEvent = { - id: "evt-1", - type: "BULK_ITEMS_CREATED", - payload: { - items: [ - { - id: "flash-1", - type: "flashcard", - name: "Deck", - subtitle: "", - data: { - cards: [{ id: "c1", front: "Q", back: "A" }], - currentIndex: 3, - }, - }, - { - id: "quiz-1", - type: "quiz", - name: "Quiz", - subtitle: "", - data: { - questions: [], - session: { currentIndex: 2, answeredQuestions: [] }, - }, - }, - { - id: "yt-1", - type: "youtube", - name: "Video", - subtitle: "", - data: { - url: "https://youtu.be/1", - progress: 88, - playbackRate: 1.5, - }, - }, - { - id: "pdf-1", - type: "pdf", - name: "PDF", - subtitle: "", - data: { - fileUrl: "https://cdn.example.com/doc.pdf", - filename: "doc.pdf", - ocrPages: [{ index: 0, markdown: "page" }], - }, - }, - ], - }, - timestamp: 1, - userId: "user-1", - version: 10, - }; - - const sanitized = toClientWorkspaceEvent(event); - const items = ( - sanitized.payload as { items: Array<{ data: Record }> } - ).items; - - expect(items[0].data.currentIndex).toBeUndefined(); - expect(items[1].data.session).toBeUndefined(); - expect(items[2].data.progress).toBeUndefined(); - expect(items[2].data.playbackRate).toBeUndefined(); - expect(items[3].data.ocrPages).toBeUndefined(); - - const originalItems = ( - event.payload as { items: Array<{ data: Record }> } - ).items; - expect(originalItems[0].data.currentIndex).toBe(3); - expect(originalItems[1].data.session).toEqual({ - currentIndex: 2, - answeredQuestions: [], - }); - expect(originalItems[2].data.progress).toBe(88); - expect(originalItems[2].data.playbackRate).toBe(1.5); - expect(originalItems[3].data.ocrPages).toEqual([ - { index: 0, markdown: "page" }, - ]); - }); -}); diff --git a/src/lib/workspace/__tests__/workspace-event-store.test.ts b/src/lib/workspace/__tests__/workspace-event-store.test.ts deleted file mode 100644 index f792ee0d..00000000 --- a/src/lib/workspace/__tests__/workspace-event-store.test.ts +++ /dev/null @@ -1,127 +0,0 @@ -import { beforeEach, describe, expect, it, vi } from "vitest"; -import type { WorkspaceEvent } from "@/lib/workspace/events"; - -const mockExecute = vi.fn(); -const mockTransaction = vi.fn(); -const mockProjectWorkspaceEvent = vi.fn(); -const mockBroadcast = vi.fn(); - -vi.mock("@/lib/db/client", () => ({ - db: { - execute: (...args: any[]) => mockExecute(...args), - transaction: (...args: any[]) => mockTransaction(...args), - }, -})); - -vi.mock("@/lib/workspace/workspace-items-projector", () => ({ - projectWorkspaceEvent: (...args: any[]) => mockProjectWorkspaceEvent(...args), -})); - -vi.mock("@/lib/realtime/server-broadcast", () => ({ - broadcastWorkspaceEventFromServer: (...args: any[]) => mockBroadcast(...args), -})); - -const event: WorkspaceEvent = { - id: "evt-1", - type: "ITEM_CREATED", - payload: { - id: "item-1", - item: { - id: "item-1", - type: "document", - name: "Doc", - subtitle: "", - data: { markdown: "hello" }, - }, - }, - timestamp: 123, - userId: "user-1", - userName: "User", -}; - -describe("workspace-event-store", () => { - beforeEach(() => { - vi.clearAllMocks(); - mockTransaction.mockImplementation(async (callback: any) => - callback({ execute: mockExecute }), - ); - mockBroadcast.mockResolvedValue(undefined); - }); - - it("projects and broadcasts persisted events on success", async () => { - mockExecute.mockResolvedValueOnce([{ result: "(7,f)" }]); - - const { appendWorkspaceEventWithBaseVersion } = - await import("@/lib/workspace/workspace-event-store"); - - const result = await appendWorkspaceEventWithBaseVersion({ - workspaceId: "ws-1", - event, - baseVersion: 6, - }); - - expect(result).toEqual({ - conflict: false, - version: 7, - persistedEvent: { - ...event, - version: 7, - }, - }); - expect(mockProjectWorkspaceEvent).toHaveBeenCalledWith( - { execute: mockExecute }, - { - workspaceId: "ws-1", - event, - version: 7, - }, - ); - expect(mockBroadcast).toHaveBeenCalledWith("ws-1", { - ...event, - version: 7, - }); - }); - - it("does not wait for realtime broadcast completion", async () => { - mockExecute.mockResolvedValueOnce([{ result: "(7,f)" }]); - mockBroadcast.mockImplementation(() => new Promise(() => undefined)); - - const { appendWorkspaceEventWithBaseVersion } = - await import("@/lib/workspace/workspace-event-store"); - - await expect( - appendWorkspaceEventWithBaseVersion({ - workspaceId: "ws-1", - event, - baseVersion: 6, - }), - ).resolves.toEqual({ - conflict: false, - version: 7, - persistedEvent: { - ...event, - version: 7, - }, - }); - }); - - it("returns conflicts without projecting or broadcasting", async () => { - mockExecute.mockResolvedValueOnce([{ result: "(9,t)" }]); - - const { appendWorkspaceEventWithBaseVersion } = - await import("@/lib/workspace/workspace-event-store"); - - const result = await appendWorkspaceEventWithBaseVersion({ - workspaceId: "ws-1", - event, - baseVersion: 8, - }); - - expect(result).toEqual({ - conflict: true, - version: 9, - }); - expect(mockProjectWorkspaceEvent).not.toHaveBeenCalled(); - expect(mockBroadcast).not.toHaveBeenCalled(); - }); -}); diff --git a/src/lib/workspace/__tests__/workspace-item-model.test.ts b/src/lib/workspace/__tests__/workspace-item-model.test.ts index 9c611a85..ca08ac0a 100644 --- a/src/lib/workspace/__tests__/workspace-item-model.test.ts +++ b/src/lib/workspace/__tests__/workspace-item-model.test.ts @@ -1,7 +1,6 @@ import { describe, expect, it } from "vitest"; import type { Item } from "@/lib/workspace-state/types"; import { - WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, buildWorkspaceItemTableRows, getWorkspaceItemCapabilities, normalizeItemData, @@ -17,7 +16,9 @@ describe("workspace item model", () => { name: "Doc", subtitle: "Research notes", data: { - markdown: "# Hello\n\nWorld", + markdown: "# Hello + +World", sources: [{ title: "Ref", url: "https://example.com" }], }, lastModified: 123, @@ -35,14 +36,15 @@ describe("workspace item model", () => { hasTranscript: false, }); expect(split.content).toEqual({ - textContent: "# Hello\n\nWorld", + textContent: "# Hello + +World", structuredData: null, assetData: null, embedData: null, sourceData: [{ title: "Ref", url: "https://example.com" }], }); expect(split.extracted.searchText).toContain("hello"); - expect(split.userStates).toEqual([]); expect( rehydrateWorkspaceItem({ @@ -105,114 +107,18 @@ describe("workspace item model", () => { ).toEqual(item); }); - it("separates flashcard user state from shared structured content", () => { - const item: Item = { + it("keeps flashcard and youtube content fully shared", () => { + const flashcard: Item = { id: "flash-1", type: "flashcard", name: "Deck", subtitle: "", data: { cards: [{ id: "card-1", front: "Front", back: "Back" }], - currentIndex: 2, - }, - }; - - const rows = buildWorkspaceItemTableRows({ - workspaceId: "workspace-1", - item, - sourceVersion: 3, - userId: "user-1", - }); - - expect(rows.content.structuredData).toEqual({ - cards: [{ id: "card-1", front: "Front", back: "Back" }], - }); - expect(rows.item.contentHash).toBeTruthy(); - expect(rows.userStates).toEqual([ - { - workspaceId: "workspace-1", - itemId: "flash-1", - userId: "user-1", - stateKey: WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, - stateType: "flashcard", - stateSchemaVersion: 1, - state: { currentIndex: 2 }, - }, - ]); - - const rehydrated = rehydrateWorkspaceItem({ - shell: rows.item, - content: rows.content, - extracted: rows.extracted, - userStates: rows.userStates, - }); - - expect(rehydrated).toEqual(item); - expect(getWorkspaceItemCapabilities("flashcard")).toContain("user_state"); - }); - - it("routes audio transcript/search data into extracted state and preserves shared processing metadata", () => { - const item: Item = { - id: "audio-1", - type: "audio", - name: "Recording", - subtitle: "", - data: { - fileUrl: "https://example.com/audio.mp3", - filename: "audio.mp3", - duration: 42, - mimeType: "audio/mpeg", - summary: "Lecture summary", - transcript: "Hello world transcript", - segments: [ - { - speaker: "Speaker 1", - timestamp: "00:00", - content: "Hello world transcript", - }, - ], - processingStatus: "complete", }, }; - const split = splitWorkspaceItem(item); - - expect(split.shell).toMatchObject({ - processingStatus: "complete", - hasTranscript: true, - hasOcr: false, - }); - expect(split.content.assetData).toEqual({ - fileUrl: "https://example.com/audio.mp3", - filename: "audio.mp3", - duration: 42, - mimeType: "audio/mpeg", - }); - expect(split.content.structuredData).toEqual({ - summary: "Lecture summary", - }); - expect(split.extracted.transcriptText).toBe("Hello world transcript"); - expect(split.extracted.transcriptSegments).toEqual([ - { - speaker: "Speaker 1", - timestamp: "00:00", - content: "Hello world transcript", - }, - ]); - expect(split.extracted.searchText).toContain("lecture summary"); - expect(split.userStates).toEqual([]); - - expect( - rehydrateWorkspaceItem({ - shell: split.shell, - content: split.content, - extracted: split.extracted, - }), - ).toEqual(item); - }); - - it("keeps youtube playback state in user-state rows instead of shared content", () => { - const item: Item = { + const youtube: Item = { id: "yt-1", type: "youtube", name: "Video", @@ -220,42 +126,18 @@ describe("workspace item model", () => { data: { url: "https://youtube.com/watch?v=abc123", thumbnail: "https://img.youtube.com/vi/abc123/default.jpg", - progress: 42, - playbackRate: 1.5, }, }; - const rows = buildWorkspaceItemTableRows({ - workspaceId: "workspace-1", - item, - sourceVersion: 9, - userId: "user-1", + expect(buildWorkspaceItemTableRows({ workspaceId: "workspace-1", item: flashcard, sourceVersion: 1 }).content.structuredData).toEqual({ + cards: [{ id: "card-1", front: "Front", back: "Back" }], }); - - expect(rows.content.embedData).toEqual({ + expect(buildWorkspaceItemTableRows({ workspaceId: "workspace-1", item: youtube, sourceVersion: 1 }).content.embedData).toEqual({ url: "https://youtube.com/watch?v=abc123", thumbnail: "https://img.youtube.com/vi/abc123/default.jpg", }); - expect(rows.userStates).toEqual([ - { - workspaceId: "workspace-1", - itemId: "yt-1", - userId: "user-1", - stateKey: WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, - stateType: "youtube", - stateSchemaVersion: 1, - state: { progress: 42, playbackRate: 1.5 }, - }, - ]); - - expect( - rehydrateWorkspaceItem({ - shell: rows.item, - content: rows.content, - extracted: rows.extracted, - userStates: rows.userStates, - }), - ).toEqual(item); + expect(getWorkspaceItemCapabilities("flashcard")).toEqual(["structured_content"]); + expect(getWorkspaceItemCapabilities("youtube")).toEqual(["embed_ref"]); }); it("round-trips the remaining item types through split and rehydrate", () => { @@ -276,12 +158,6 @@ describe("workspace item model", () => { correctIndex: 0, }, ], - session: { - currentIndex: 0, - answeredQuestions: [ - { questionId: "q-1", userAnswer: 0, isCorrect: true }, - ], - }, }, }, { @@ -321,7 +197,6 @@ describe("workspace item model", () => { workspaceId: "workspace-1", item, sourceVersion: 4, - userId: item.type === "quiz" ? "user-1" : undefined, }); expect( @@ -329,7 +204,6 @@ describe("workspace item model", () => { shell: rows.item, content: rows.content, extracted: rows.extracted, - userStates: rows.userStates, }), ).toEqual(item); } @@ -350,23 +224,4 @@ describe("workspace item model", () => { segments: "not-an-array", }); }); - - it("throws when user-scoped state exists but userId is omitted", () => { - expect(() => - buildWorkspaceItemTableRows({ - workspaceId: "workspace-1", - item: { - id: "flash-2", - type: "flashcard", - name: "Deck", - subtitle: "", - data: { - cards: [{ id: "card-1", front: "Front", back: "Back" }], - currentIndex: 1, - }, - }, - sourceVersion: 2, - }), - ).toThrow("userId is required for items with user state"); - }); }); diff --git a/src/lib/workspace/__tests__/workspace-items-projector.test.ts b/src/lib/workspace/__tests__/workspace-items-projector.test.ts deleted file mode 100644 index 708948c8..00000000 --- a/src/lib/workspace/__tests__/workspace-items-projector.test.ts +++ /dev/null @@ -1,188 +0,0 @@ -import { describe, expect, it } from "vitest"; -import type { Item } from "@/lib/workspace-state/types"; -import { eventReducer } from "@/lib/workspace/event-reducer"; -import type { WorkspaceEvent } from "@/lib/workspace/events"; -import { deriveWorkspaceProjectionChangeSet } from "@/lib/workspace/workspace-items-projector"; -import { buildWorkspaceItemTableRows } from "@/lib/workspace/workspace-item-model"; - -function applyEvents(events: WorkspaceEvent[], baseState: Item[] = []) { - let state = baseState; - - for (const event of events) { - state = deriveWorkspaceProjectionChangeSet(state, event).nextItems; - } - - return state; -} - -describe("workspace-items-projector", () => { - it("matches replay semantics across create, patch, move, bulk, and delete flows", () => { - const doc: Item = { - id: "doc-1", - type: "document", - name: "Doc", - subtitle: "", - data: { - markdown: "hello", - sources: [{ title: "A", url: "https://a.test" }], - }, - layout: { lg: { x: 0, y: 0, w: 4, h: 3 } }, - }; - const note: Item = { - id: "doc-2", - type: "document", - name: "Note", - subtitle: "", - data: { markdown: "note" }, - }; - const folder: Item = { - id: "folder-1", - type: "folder", - name: "Folder", - subtitle: "", - data: {}, - }; - - const events: WorkspaceEvent[] = [ - { - id: "evt-1", - type: "ITEM_CREATED", - payload: { id: doc.id, item: doc }, - timestamp: 1, - userId: "user-1", - }, - { - id: "evt-2", - type: "ITEM_UPDATED", - payload: { - id: doc.id, - changes: { data: { markdown: "hello world" } as Item["data"] }, - }, - timestamp: 2, - userId: "user-1", - }, - { - id: "evt-3", - type: "BULK_ITEMS_CREATED", - payload: { items: [note] }, - timestamp: 3, - userId: "user-1", - }, - { - id: "evt-4", - type: "FOLDER_CREATED_WITH_ITEMS", - payload: { folder, itemIds: [doc.id] }, - timestamp: 4, - userId: "user-1", - }, - { - id: "evt-5", - type: "BULK_ITEMS_PATCHED", - payload: { - updates: [ - { - id: note.id, - changes: { data: { markdown: "patched note" } as Item["data"] }, - }, - ], - }, - timestamp: 5, - userId: "user-1", - }, - { - id: "evt-6", - type: "ITEM_DELETED", - payload: { id: folder.id }, - timestamp: 6, - userId: "user-1", - }, - ]; - - expect(applyEvents(events)).toEqual(events.reduce(eventReducer, [])); - }); - - it("clears child folder and layout when bulk deleting folders", () => { - const current: Item[] = [ - { - id: "folder-1", - type: "folder", - name: "Folder", - subtitle: "", - data: {}, - }, - { - id: "doc-1", - type: "document", - name: "Doc", - subtitle: "", - folderId: "folder-1", - layout: { lg: { x: 1, y: 1, w: 4, h: 3 } }, - data: { markdown: "doc" }, - }, - ]; - - const changeSet = deriveWorkspaceProjectionChangeSet(current, { - id: "evt-1", - type: "BULK_ITEMS_UPDATED", - payload: { deletedIds: ["folder-1"] }, - timestamp: 10, - userId: "user-1", - }); - - expect(changeSet.deletedItemIds).toEqual(["folder-1"]); - expect(changeSet.nextItems).toEqual([ - { - id: "doc-1", - type: "document", - name: "Doc", - subtitle: "", - data: { markdown: "doc" }, - }, - ]); - }); - - it("routes OCR payloads into content and extracted projection rows", () => { - const current: Item[] = [ - { - id: "pdf-1", - type: "pdf", - name: "PDF", - subtitle: "", - data: { fileUrl: "https://a.test/a.pdf", filename: "a.pdf" }, - }, - ]; - - const changeSet = deriveWorkspaceProjectionChangeSet(current, { - id: "evt-1", - type: "ITEM_UPDATED", - payload: { - id: "pdf-1", - changes: { - data: { - ocrStatus: "complete", - ocrPages: [{ index: 0, markdown: "page body" }], - } as Item["data"], - }, - }, - timestamp: 20, - userId: "user-1", - }); - - const rows = buildWorkspaceItemTableRows({ - workspaceId: "ws-1", - item: changeSet.upsertedItems[0], - sourceVersion: 3, - userId: "user-1", - }); - - expect(rows.content.assetData).toEqual({ - fileUrl: "https://a.test/a.pdf", - filename: "a.pdf", - }); - expect(rows.extracted.ocrPages).toEqual([ - { index: 0, markdown: "page body" }, - ]); - expect(rows.extracted.ocrText).toBe("page body"); - expect(rows.item.ocrStatus).toBe("complete"); - }); -}); diff --git a/src/lib/workspace/event-reducer.ts b/src/lib/workspace/event-reducer.ts deleted file mode 100644 index d8061252..00000000 --- a/src/lib/workspace/event-reducer.ts +++ /dev/null @@ -1,181 +0,0 @@ -import type { Item } from "@/lib/workspace-state/types"; -import type { WorkspaceEvent } from "./events"; - -/** Shared reducer for projection writes and client-side optimistic delta overlays. */ -export function eventReducer(state: Item[], event: WorkspaceEvent): Item[] { - switch (event.type) { - case "ITEM_CREATED": { - const item = event.payload.item; - const now = event.timestamp || Date.now(); - return [...state, { ...item, lastModified: now }]; - } - - case "ITEM_UPDATED": { - const now = event.timestamp || Date.now(); - return state.map((item) => - item.id === event.payload.id - ? { - ...item, - ...event.payload.changes, - // Deep merge data field to preserve existing properties like sources - data: event.payload.changes.data - ? { - ...item.data, // Preserve existing data properties - ...event.payload.changes.data, // Apply new data updates - } - : item.data, - lastModified: now, - } - : item, - ); - } - - case "BULK_ITEMS_PATCHED": { - const now = event.timestamp || Date.now(); - const updateMap = new Map( - event.payload.updates.map((update) => [update.id, update]), - ); - - return state.map((item) => { - const update = updateMap.get(item.id); - if (!update) return item; - - return { - ...item, - ...update.changes, - data: update.changes.data - ? { - ...item.data, - ...update.changes.data, - } - : item.data, - lastModified: now, - }; - }); - } - - case "ITEM_DELETED": { - const deletedItemId = event.payload.id; - const deletedItem = state.find((item) => item.id === deletedItemId); - const isFolder = deletedItem?.type === "folder"; - - return ( - state - .filter((item) => item.id !== deletedItemId) - // If deleting a folder-type item, clear folderId and layout from items that were in it - // Layout is cleared so items get fresh positioning in root (same as when moving to folder) - .map((item) => - isFolder && item.folderId === deletedItemId - ? { ...item, folderId: undefined, layout: undefined } - : item, - ) - ); - } - - case "BULK_ITEMS_UPDATED": { - const p = event.payload; - const now = event.timestamp || Date.now(); - - // Bulk delete: send only deletedIds – no item data - if (p.deletedIds && p.deletedIds.length > 0) { - const deletedSet = new Set(p.deletedIds); - const deletedFolderIds = new Set( - state - .filter((i) => deletedSet.has(i.id) && i.type === "folder") - .map((i) => i.id), - ); - const remaining = state - .filter((i) => !deletedSet.has(i.id)) - .map((item) => - item.folderId && deletedFolderIds.has(item.folderId) - ? { ...item, folderId: undefined, layout: undefined } - : item, - ); - return remaining; - } - - // Items added: send only addedItems - if (p.addedItems && p.addedItems.length > 0) { - const added = p.addedItems.map((item) => ({ - ...item, - lastModified: now, - })); - return [...state, ...added]; - } - - const layoutUpdates = p.layoutUpdates ?? []; - if (layoutUpdates.length > 0) { - const layoutMap = new Map(layoutUpdates.map((u) => [u.id, u])); - return state.map((item) => { - const u = layoutMap.get(item.id); - return u - ? { ...item, layout: { x: u.x, y: u.y, w: u.w, h: u.h } } - : item; - }); - } - - return state; - } - - case "BULK_ITEMS_CREATED": { - const now = event.timestamp || Date.now(); - const itemsWithModified = event.payload.items.map((item: Item) => ({ - ...item, - lastModified: now, - })); - return [...state, ...itemsWithModified]; - } - - case "ITEM_MOVED_TO_FOLDER": { - return state.map((item) => - item.id === event.payload.itemId - ? { - ...item, - folderId: event.payload.folderId ?? undefined, - layout: undefined, - } - : item, - ); - } - - case "ITEMS_MOVED_TO_FOLDER": { - const itemIdsSet = new Set(event.payload.itemIds); - const targetFolderId = event.payload.folderId ?? undefined; - const updatedItems = state.map((item) => - itemIdsSet.has(item.id) - ? { - ...item, - folderId: targetFolderId, - layout: undefined, - } - : item, - ); - return updatedItems; - } - - case "FOLDER_CREATED_WITH_ITEMS": { - const now = event.timestamp || Date.now(); - const folder = { ...event.payload.folder, lastModified: now }; - const itemIdsSet = new Set(event.payload.itemIds); - const folderId = folder.id; - - const updatedItems = state.map((item) => - itemIdsSet.has(item.id) - ? { - ...item, - folderId: folderId, - layout: undefined, - lastModified: now, - } - : item, - ); - - updatedItems.push(folder); - - return updatedItems; - } - - default: - return state; - } -} diff --git a/src/lib/workspace/events.ts b/src/lib/workspace/events.ts deleted file mode 100644 index b1664232..00000000 --- a/src/lib/workspace/events.ts +++ /dev/null @@ -1,158 +0,0 @@ -import type { Item } from "@/lib/workspace-state/types"; - -/** - * Workspace mutations persisted for conflict resolution and realtime confirmation. - * Current state is loaded from projection tables, not reconstructed from this log. - */ - -type WorkspaceEventBase = - | { - type: "ITEM_CREATED"; - payload: { id: string; item: Item }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "ITEM_UPDATED"; - payload: { id: string; changes: Partial; name?: string }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "BULK_ITEMS_PATCHED"; - payload: { - updates: Array<{ - id: string; - changes: Partial; - name?: string; - }>; - }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "ITEM_DELETED"; - payload: { id: string; name?: string }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "BULK_ITEMS_UPDATED"; - payload: { - layoutUpdates?: Array<{ - id: string; - x: number; - y: number; - w: number; - h: number; - }>; - previousItemCount?: number; - deletedIds?: string[]; - addedItems?: Item[]; - }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "BULK_ITEMS_CREATED"; - // Create multiple items atomically in a single event - payload: { items: Item[] }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "ITEM_MOVED_TO_FOLDER"; - payload: { itemId: string; folderId: string | null; itemName?: string }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "ITEMS_MOVED_TO_FOLDER"; - payload: { - itemIds: string[]; - folderId: string | null; - itemNames?: string[]; - }; - timestamp: number; - userId: string; - userName?: string; - id: string; - } - | { - type: "FOLDER_CREATED_WITH_ITEMS"; - payload: { folder: Item; itemIds: string[] }; - timestamp: number; - userId: string; - userName?: string; - id: string; - }; - -/** - * WorkspaceEvent with optional version field (populated from database) - */ -export type WorkspaceEvent = WorkspaceEventBase & { - version?: number; -}; - -const CLIENT_VISIBLE_WORKSPACE_EVENT_TYPES = new Set([ - "ITEM_CREATED", - "ITEM_UPDATED", - "BULK_ITEMS_PATCHED", - "ITEM_DELETED", - "BULK_ITEMS_UPDATED", - "BULK_ITEMS_CREATED", - "ITEM_MOVED_TO_FOLDER", - "ITEMS_MOVED_TO_FOLDER", - "FOLDER_CREATED_WITH_ITEMS", -]); - -export type ClientWorkspaceEvent = WorkspaceEvent; - -export function isClientVisibleWorkspaceEvent(event: { - type: string; -}): event is ClientWorkspaceEvent { - return CLIENT_VISIBLE_WORKSPACE_EVENT_TYPES.has( - event.type as WorkspaceEvent["type"], - ); -} - -/** - * Response from event API - */ -export interface EventResponse { - events: ClientWorkspaceEvent[]; - version: number; -} - -/** - * Helper to create a new event with required fields - */ -export function createEvent( - type: T, - payload: Extract["payload"], - userId: string, - userName?: string, -): Extract { - return { - type, - payload, - timestamp: Date.now(), - userId, - userName, - id: crypto.randomUUID(), - } as Extract; -} diff --git a/src/lib/workspace/mutation-helpers.ts b/src/lib/workspace/mutation-helpers.ts index 4b958956..e135fcfd 100644 --- a/src/lib/workspace/mutation-helpers.ts +++ b/src/lib/workspace/mutation-helpers.ts @@ -3,7 +3,7 @@ import { auth } from "@/lib/auth"; import { db, workspaces } from "@/lib/db/client"; import { workspaceCollaborators } from "@/lib/db/schema"; import { eq, and } from "drizzle-orm"; -import { loadWorkspaceState } from "@/lib/workspace/state-loader"; +import { loadWorkspaceState } from "@/lib/workspace/workspace-state-read"; import { hasDuplicateName } from "@/lib/workspace/unique-name"; import { normalizeWorkspaceItems } from "@/lib/workspace-state/state"; import type { Item } from "@/lib/workspace-state/types"; diff --git a/src/lib/workspace/state-loader.ts b/src/lib/workspace/state-loader.ts deleted file mode 100644 index b4966094..00000000 --- a/src/lib/workspace/state-loader.ts +++ /dev/null @@ -1,38 +0,0 @@ -import { db } from "@/lib/db/client"; -import { logger } from "@/lib/utils/logger"; -import type { Item } from "@/lib/workspace-state/types"; -import { loadWorkspaceProjectionState } from "./workspace-items-projector"; - -export interface LoadWorkspaceStateOptions { - userId?: string | null; -} - -export interface WorkspaceStatePayload { - state: Item[]; - version: number; -} - -export async function loadWorkspaceStatePayload( - workspaceId: string, - options: LoadWorkspaceStateOptions = {}, -): Promise { - return db.transaction(async (tx: any) => { - const projection = await loadWorkspaceProjectionState(tx, { - workspaceId, - userId: options.userId, - }); - - return { - state: projection.items, - version: projection.version, - }; - }); -} - -export async function loadWorkspaceState( - workspaceId: string, - options: LoadWorkspaceStateOptions = {}, -): Promise { - const statePayload = await loadWorkspaceStatePayload(workspaceId, options); - return statePayload.state; -} diff --git a/src/lib/workspace/version-helpers.ts b/src/lib/workspace/version-helpers.ts deleted file mode 100644 index 7df54ba4..00000000 --- a/src/lib/workspace/version-helpers.ts +++ /dev/null @@ -1,61 +0,0 @@ -import type { EventResponse } from "./events"; - -/** - * Compute the effective base version for a new mutation, accounting for: - * 1. The cache's stored version field - * 2. The max version from individual events (may be higher after tool events) - * 3. Pending optimistic events that will increment the server version - */ -export function computeBaseVersion( - cacheData: EventResponse | undefined, -): { baseVersion: number; currentVersion: number; optimisticCount: number } { - const events = cacheData?.events ?? []; - - const optimisticCount = events.filter( - (e) => typeof e.version !== "number", - ).length; - - const maxEventVersion = events - .filter((e) => typeof e.version === "number") - .reduce((max, e) => Math.max(max, e.version!), cacheData?.version ?? 0); - - const currentVersion = Math.max(cacheData?.version ?? 0, maxEventVersion); - - const baseVersion = currentVersion + Math.max(0, optimisticCount - 1); - - return { baseVersion, currentVersion, optimisticCount }; -} - -/** - * Remove a single optimistic event from the cache by ID. - */ -export function removeOptimisticEvent( - cache: EventResponse | undefined, - eventId: string, - newVersion?: number, -): EventResponse | undefined { - if (!cache) return cache; - return { - ...cache, - events: cache.events.filter((e) => e.id !== eventId), - ...(newVersion !== undefined && { version: newVersion }), - }; -} - -/** - * Confirm an optimistic event by stamping its server-assigned version. - */ -export function confirmOptimisticEvent( - cache: EventResponse | undefined, - eventId: string, - serverVersion: number, -): EventResponse | undefined { - if (!cache) return cache; - return { - ...cache, - events: cache.events.map((e) => - e.id === eventId ? { ...e, version: serverVersion } : e, - ), - version: serverVersion, - }; -} diff --git a/src/lib/workspace/workspace-event-client-payload.ts b/src/lib/workspace/workspace-event-client-payload.ts deleted file mode 100644 index ac08f9ec..00000000 --- a/src/lib/workspace/workspace-event-client-payload.ts +++ /dev/null @@ -1,117 +0,0 @@ -import type { Item } from "@/lib/workspace-state/types"; -import type { WorkspaceEvent } from "./events"; - -function stripOcrPagesFromItem(item: Item): void { - if ( - (item.type === "pdf" || item.type === "image") && - item.data && - typeof item.data === "object" - ) { - const data = item.data as Record; - delete data.ocrPages; - } -} - -function stripPerUserStateFromItem(item: Item): void { - if (!item.data || typeof item.data !== "object") { - return; - } - - const data = item.data as Record; - - switch (item.type) { - case "flashcard": - delete data.currentIndex; - break; - case "quiz": - delete data.session; - break; - case "youtube": - delete data.progress; - delete data.playbackRate; - break; - default: - break; - } -} - -function stripPerUserStateFromItemChanges( - changes: Record, -): void { - if (!changes.data || typeof changes.data !== "object") { - return; - } - - const data = changes.data as Record; - delete data.currentIndex; - delete data.session; - delete data.progress; - delete data.playbackRate; -} - -export function toClientWorkspaceEvent(event: WorkspaceEvent): WorkspaceEvent { - const sanitized = structuredClone(event); - const payload = sanitized.payload as Record; - - switch (sanitized.type) { - case "ITEM_CREATED": - if (payload.item) { - stripOcrPagesFromItem(payload.item as Item); - stripPerUserStateFromItem(payload.item as Item); - } - break; - case "ITEM_UPDATED": - if (payload.changes && typeof payload.changes === "object") { - stripPerUserStateFromItemChanges( - payload.changes as Record, - ); - const changes = payload.changes as Record; - if (changes.data && typeof changes.data === "object") { - const data = changes.data as Record; - delete data.ocrPages; - } - } - break; - case "BULK_ITEMS_CREATED": - (payload.items as Item[] | undefined)?.forEach((item) => { - stripOcrPagesFromItem(item); - stripPerUserStateFromItem(item); - }); - break; - case "BULK_ITEMS_PATCHED": - ( - payload.updates as - | Array<{ changes?: Record }> - | undefined - )?.forEach((update) => { - if (update.changes) { - stripPerUserStateFromItemChanges(update.changes); - const data = update.changes.data; - if (data && typeof data === "object") { - delete (data as Record).ocrPages; - } - } - }); - break; - case "BULK_ITEMS_UPDATED": - (payload.addedItems as Item[] | undefined)?.forEach((item) => { - stripOcrPagesFromItem(item); - stripPerUserStateFromItem(item); - }); - (payload.items as Item[] | undefined)?.forEach((item) => { - stripOcrPagesFromItem(item); - stripPerUserStateFromItem(item); - }); - break; - default: - break; - } - - return sanitized; -} - -export function toClientWorkspaceEvents( - events: WorkspaceEvent[], -): WorkspaceEvent[] { - return events.map((event) => toClientWorkspaceEvent(event)); -} diff --git a/src/lib/workspace/workspace-event-store.ts b/src/lib/workspace/workspace-event-store.ts deleted file mode 100644 index 5baf5d46..00000000 --- a/src/lib/workspace/workspace-event-store.ts +++ /dev/null @@ -1,226 +0,0 @@ -import { db } from "@/lib/db/client"; -import { sql } from "drizzle-orm"; -import { broadcastWorkspaceEventFromServer } from "@/lib/realtime/server-broadcast"; -import { logger } from "@/lib/utils/logger"; -import type { WorkspaceEvent } from "./events"; -import { projectWorkspaceEvent } from "./workspace-items-projector"; - -const APPEND_RESULT_REGEX = /\(\s*(\d+)\s*,\s*(t|f|true|false)\s*\)/i; - -export interface WorkspaceEventAppendSuccess { - conflict: false; - persistedEvent: WorkspaceEvent & { version: number }; - version: number; -} - -export interface WorkspaceEventAppendConflict { - conflict: true; - version: number; -} - -export type WorkspaceEventAppendResult = - | WorkspaceEventAppendSuccess - | WorkspaceEventAppendConflict; - -export function parseWorkspaceAppendResult(rawResult: unknown): { - version: number; - conflict: boolean; -} { - if (typeof rawResult === "object" && rawResult !== null) { - const rawVersion = (rawResult as { version?: unknown }).version; - const version = Number(rawVersion); - const rawConflict = (rawResult as { conflict?: unknown }).conflict; - const conflict = - rawConflict === true || - (typeof rawConflict === "string" && - ["t", "true"].includes(rawConflict.toLowerCase().trim())); - - if (rawVersion === undefined || !Number.isFinite(version)) { - throw new Error( - `append_workspace_event returned unexpected object format: ${JSON.stringify(rawResult)}`, - ); - } - - return { - version, - conflict, - }; - } - - const resultString = - typeof rawResult === "string" ? rawResult : String(rawResult); - const match = resultString.match(APPEND_RESULT_REGEX); - - if (!match) { - throw new Error( - `append_workspace_event returned unexpected format: ${resultString}`, - ); - } - - return { - version: Number.parseInt(match[1], 10), - conflict: ["t", "true"].includes(match[2].toLowerCase()), - }; -} - -export async function getWorkspaceVersion( - workspaceId: string, -): Promise { - const result = await db.execute(sql` - SELECT get_workspace_version(${workspaceId}::uuid) as version - `); - return Number(result[0]?.version ?? 0); -} - -async function appendWorkspaceEventInTransaction( - workspaceId: string, - event: WorkspaceEvent, - baseVersion: number, -): Promise { - const result = await db.transaction(async (tx: any) => { - const appendResultRows = await tx.execute(sql` - SELECT append_workspace_event( - ${workspaceId}::uuid, - ${event.id}::text, - ${event.type}::text, - ${JSON.stringify(event.payload)}::jsonb, - ${event.timestamp}::bigint, - ${event.userId}::text, - ${baseVersion}::integer, - ${event.userName ?? null}::text - ) as result - `); - - if (!appendResultRows?.length || !appendResultRows[0]) { - throw new Error("append_workspace_event returned no result"); - } - - const parsed = parseWorkspaceAppendResult(appendResultRows[0].result); - - if (parsed.conflict) { - return { - conflict: true, - version: parsed.version, - } satisfies WorkspaceEventAppendConflict; - } - - await projectWorkspaceEvent(tx, { - workspaceId, - event, - version: parsed.version, - }); - - return { - conflict: false, - version: parsed.version, - persistedEvent: { - ...event, - version: parsed.version, - }, - } satisfies WorkspaceEventAppendSuccess; - }); - - if (!result.conflict) { - void broadcastWorkspaceEventFromServer( - workspaceId, - result.persistedEvent, - ).catch((error) => { - logger.error("Failed to broadcast persisted workspace event", { - workspaceId, - eventId: result.persistedEvent.id, - version: result.persistedEvent.version, - error, - }); - }); - } - - return result; -} - -export async function appendWorkspaceEventWithBaseVersion(params: { - workspaceId: string; - event: WorkspaceEvent; - baseVersion: number; -}): Promise { - return appendWorkspaceEventInTransaction( - params.workspaceId, - params.event, - params.baseVersion, - ); -} - -export async function appendWorkspaceEventUsingCurrentVersion(params: { - workspaceId: string; - event: WorkspaceEvent; -}): Promise { - const baseVersion = await getWorkspaceVersion(params.workspaceId); - return appendWorkspaceEventWithBaseVersion({ - workspaceId: params.workspaceId, - event: params.event, - baseVersion, - }); -} - -export async function appendWorkspaceEventUsingCurrentVersionWithRetry(params: { - workspaceId: string; - event: WorkspaceEvent; - maxRetries?: number; - conflictMessage?: string; -}): Promise { - let baseVersion = await getWorkspaceVersion(params.workspaceId); - const maxRetries = params.maxRetries ?? 0; - let attempt = 0; - - while (attempt <= maxRetries) { - const result = await appendWorkspaceEventWithBaseVersion({ - workspaceId: params.workspaceId, - event: params.event, - baseVersion, - }); - - if (!result.conflict) { - return result; - } - - logger.warn("[EVENT-STORE] Conflict, retrying", { - workspaceId: params.workspaceId, - attempt: attempt + 1, - nextBaseVersion: result.version, - }); - baseVersion = result.version; - attempt += 1; - } - - throw new Error( - params.conflictMessage ?? - `Version conflict appending event ${params.event.id} to workspace ${params.workspaceId}`, - ); -} - -export async function appendWorkspaceEventOrThrow(params: { - workspaceId: string; - event: WorkspaceEvent; - baseVersion?: number; - conflictMessage?: string; -}): Promise { - const result = - typeof params.baseVersion === "number" - ? await appendWorkspaceEventWithBaseVersion({ - workspaceId: params.workspaceId, - event: params.event, - baseVersion: params.baseVersion, - }) - : await appendWorkspaceEventUsingCurrentVersion({ - workspaceId: params.workspaceId, - event: params.event, - }); - - if (result.conflict) { - throw new Error( - params.conflictMessage ?? - `Version conflict appending event ${params.event.id} to workspace ${params.workspaceId}`, - ); - } - - return result; -} diff --git a/src/lib/workspace/workspace-item-model-schemas.ts b/src/lib/workspace/workspace-item-model-schemas.ts index 15d0e0a9..9a0314fe 100644 --- a/src/lib/workspace/workspace-item-model-schemas.ts +++ b/src/lib/workspace/workspace-item-model-schemas.ts @@ -13,8 +13,6 @@ import { documentDataSchema, } from "@/lib/workspace-state/item-data-schemas"; -export { quizSessionSchema } from "@/lib/workspace-state/item-data-schemas"; - export const itemDataSchemas: Record> = { pdf: pdfDataSchema as z.ZodType, flashcard: flashcardDataSchema as z.ZodType, @@ -29,10 +27,10 @@ export const itemDataSchemas: Record> = { export const itemCapabilities: Record = { pdf: ["asset_ref", "ocr_content"], - flashcard: ["structured_content", "user_state"], + flashcard: ["structured_content"], folder: [], - youtube: ["embed_ref", "user_state"], - quiz: ["structured_content", "user_state"], + youtube: ["embed_ref"], + quiz: ["structured_content"], image: ["asset_ref", "ocr_content"], audio: ["asset_ref", "structured_content", "transcript_content"], website: ["embed_ref"], diff --git a/src/lib/workspace/workspace-item-model-shared.ts b/src/lib/workspace/workspace-item-model-shared.ts index 59f72bf2..043f7847 100644 --- a/src/lib/workspace/workspace-item-model-shared.ts +++ b/src/lib/workspace/workspace-item-model-shared.ts @@ -15,11 +15,7 @@ import type { YouTubeData, } from "@/lib/workspace-state/types"; import { itemCapabilities } from "./workspace-item-model-schemas"; -import { - WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, - type WorkspaceItemCapability, - type WorkspaceItemUserStateProjection, -} from "./workspace-item-model-types"; +import type { WorkspaceItemCapability } from "./workspace-item-model-types"; export function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); @@ -81,10 +77,7 @@ function formatQuizQuestions( ): string { const questionText = questions .map((question) => - [ - question.questionText, - question.options.join("\n"), - ] + [question.questionText, question.options.join("\n")] .filter(Boolean) .join("\n"), ) @@ -135,19 +128,6 @@ function getDomain(url: string | undefined): string { } } -export function findPrimaryUserState( - userStates: WorkspaceItemUserStateProjection[] | null | undefined, - type: CardType, -): Record | null { - const match = userStates?.find( - (userState) => - userState.stateKey === WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY && - userState.stateType === type, - ); - - return match?.state ?? null; -} - export function nullIfEmptyString(value: string | undefined): string | null { if (!value) { return null; diff --git a/src/lib/workspace/workspace-item-model-types.ts b/src/lib/workspace/workspace-item-model-types.ts index 710c86fd..12d608fb 100644 --- a/src/lib/workspace/workspace-item-model-types.ts +++ b/src/lib/workspace/workspace-item-model-types.ts @@ -10,8 +10,6 @@ import type { } from "@/lib/workspace-state/types"; export const WORKSPACE_ITEM_DATA_SCHEMA_VERSION = 1; -export const WORKSPACE_ITEM_USER_STATE_SCHEMA_VERSION = 1; -export const WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY = "item"; export type WorkspaceItemCapability = | "asset_ref" @@ -20,8 +18,7 @@ export type WorkspaceItemCapability = | "sources" | "structured_content" | "text_content" - | "transcript_content" - | "user_state"; + | "transcript_content"; export interface WorkspaceItemShellProjection { itemId: string; @@ -59,18 +56,10 @@ export interface WorkspaceItemExtractedProjection { transcriptSegments: AudioSegment[] | null; } -export interface WorkspaceItemUserStateProjection { - stateKey: string; - stateType: CardType; - stateSchemaVersion: number; - state: Record; -} - export interface WorkspaceItemSplitResult { shell: WorkspaceItemShellProjection; content: WorkspaceItemContentProjection; extracted: WorkspaceItemExtractedProjection; - userStates: WorkspaceItemUserStateProjection[]; } export interface WorkspaceItemTableRows { @@ -88,11 +77,4 @@ export interface WorkspaceItemTableRows { workspaceId: string; itemId: string; }; - userStates: Array< - WorkspaceItemUserStateProjection & { - workspaceId: string; - itemId: string; - userId: string; - } - >; } diff --git a/src/lib/workspace/workspace-item-model.ts b/src/lib/workspace/workspace-item-model.ts index ae85a284..e6304775 100644 --- a/src/lib/workspace/workspace-item-model.ts +++ b/src/lib/workspace/workspace-item-model.ts @@ -10,18 +10,12 @@ import type { PdfData, QuizData, QuizQuestion, - QuizSessionData, WebsiteData, YouTubeData, } from "@/lib/workspace-state/types"; import { getOcrPagesTextContent } from "@/lib/utils/ocr-pages"; +import { emptyDataForType, itemDataSchemas } from "./workspace-item-model-schemas"; import { - emptyDataForType, - itemDataSchemas, - quizSessionSchema, -} from "./workspace-item-model-schemas"; -import { - findPrimaryUserState, getItemContentPreview, getItemSearchIndex, getWorkspaceItemCapabilities, @@ -32,14 +26,11 @@ import { } from "./workspace-item-model-shared"; import { WORKSPACE_ITEM_DATA_SCHEMA_VERSION, - WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, - WORKSPACE_ITEM_USER_STATE_SCHEMA_VERSION, type WorkspaceItemContentProjection, type WorkspaceItemExtractedProjection, type WorkspaceItemShellProjection, type WorkspaceItemSplitResult, type WorkspaceItemTableRows, - type WorkspaceItemUserStateProjection, } from "./workspace-item-model-types"; export * from "./workspace-item-model-types"; @@ -73,67 +64,6 @@ export function normalizeItem(item: Item): Item { }; } -export function extractWorkspaceItemUserStates( - item: Item, -): WorkspaceItemUserStateProjection[] { - const normalized = normalizeItem(item); - - switch (normalized.type) { - case "flashcard": { - const data = normalized.data as FlashcardData; - if (data.currentIndex == null) { - return []; - } - - return [ - { - stateKey: WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, - stateType: normalized.type, - stateSchemaVersion: WORKSPACE_ITEM_USER_STATE_SCHEMA_VERSION, - state: { currentIndex: data.currentIndex }, - }, - ]; - } - case "quiz": { - const data = normalized.data as QuizData; - if (!data.session) { - return []; - } - - return [ - { - stateKey: WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, - stateType: normalized.type, - stateSchemaVersion: WORKSPACE_ITEM_USER_STATE_SCHEMA_VERSION, - state: { session: data.session }, - }, - ]; - } - case "youtube": { - const data = normalized.data as YouTubeData; - if (data.progress == null && data.playbackRate == null) { - return []; - } - - return [ - { - stateKey: WORKSPACE_ITEM_PRIMARY_USER_STATE_KEY, - stateType: normalized.type, - stateSchemaVersion: WORKSPACE_ITEM_USER_STATE_SCHEMA_VERSION, - state: { - ...(data.progress != null ? { progress: data.progress } : {}), - ...(data.playbackRate != null - ? { playbackRate: data.playbackRate } - : {}), - }, - }, - ]; - } - default: - return []; - } -} - export function rehydrateWorkspaceItemData( type: CardType, shell: Partial< @@ -141,11 +71,9 @@ export function rehydrateWorkspaceItemData( >, content: Partial | null | undefined, extracted: Partial | null | undefined, - userStates: WorkspaceItemUserStateProjection[] | null | undefined = [], ): ItemData { const contentRecord = content ?? {}; const extractedRecord = extracted ?? {}; - const primaryUserState = findPrimaryUserState(userStates, type); let merged: ItemData; @@ -256,9 +184,6 @@ export function rehydrateWorkspaceItemData( cards: Array.isArray(structuredData.cards) ? (structuredData.cards as FlashcardItem[]) : [], - ...(typeof primaryUserState?.currentIndex === "number" - ? { currentIndex: primaryUserState.currentIndex } - : {}), } satisfies FlashcardData; break; } @@ -266,9 +191,6 @@ export function rehydrateWorkspaceItemData( const structuredData = isRecord(contentRecord.structuredData) ? contentRecord.structuredData : {}; - const parsedSession = quizSessionSchema.safeParse( - primaryUserState?.session, - ); merged = { ...(typeof structuredData.title === "string" ? { title: structuredData.title } @@ -276,9 +198,6 @@ export function rehydrateWorkspaceItemData( questions: Array.isArray(structuredData.questions) ? (structuredData.questions as QuizQuestion[]) : [], - ...(parsedSession.success - ? { session: parsedSession.data as QuizSessionData } - : {}), } satisfies QuizData; break; } @@ -291,12 +210,6 @@ export function rehydrateWorkspaceItemData( ...(typeof embedData.thumbnail === "string" ? { thumbnail: embedData.thumbnail } : {}), - ...(typeof primaryUserState?.progress === "number" - ? { progress: primaryUserState.progress } - : {}), - ...(typeof primaryUserState?.playbackRate === "number" - ? { playbackRate: primaryUserState.playbackRate } - : {}), } satisfies YouTubeData; break; } @@ -327,12 +240,11 @@ function normalizeSharedItemData( extracted: WorkspaceItemExtractedProjection, shell?: Pick, ): ItemData { - return rehydrateWorkspaceItemData(type, shell ?? {}, content, extracted, []); + return rehydrateWorkspaceItemData(type, shell ?? {}, content, extracted); } export function splitWorkspaceItem(item: Item): WorkspaceItemSplitResult { const normalized = normalizeItem(item); - const userStates = extractWorkspaceItemUserStates(normalized); const content: WorkspaceItemContentProjection = { textContent: null, @@ -482,7 +394,6 @@ export function splitWorkspaceItem(item: Item): WorkspaceItemSplitResult { }, content, extracted, - userStates, }; } @@ -490,16 +401,9 @@ export function buildWorkspaceItemTableRows(params: { workspaceId: string; item: Item; sourceVersion: number; - userId?: string; }): WorkspaceItemTableRows { const split = splitWorkspaceItem(params.item); - if (split.userStates.length > 0 && !params.userId) { - throw new Error("userId is required for items with user state"); - } - - const userId = params.userId; - return { item: { workspaceId: params.workspaceId, @@ -518,14 +422,6 @@ export function buildWorkspaceItemTableRows(params: { itemId: split.shell.itemId, ...split.extracted, }, - userStates: userId - ? split.userStates.map((userState) => ({ - workspaceId: params.workspaceId, - itemId: split.shell.itemId, - userId, - ...userState, - })) - : [], }; } @@ -545,9 +441,8 @@ export function rehydrateWorkspaceItem(params: { >; content?: Partial | null; extracted?: Partial | null; - userStates?: WorkspaceItemUserStateProjection[] | null; }): Item { - const { shell, content, extracted, userStates } = params; + const { shell, content, extracted } = params; return { id: shell.itemId, @@ -562,7 +457,6 @@ export function rehydrateWorkspaceItem(params: { }, content, extracted, - userStates, ), ...(shell.color ? { color: shell.color } : {}), ...(shell.folderId ? { folderId: shell.folderId } : {}), diff --git a/src/lib/workspace/workspace-item-sanitize.ts b/src/lib/workspace/workspace-item-sanitize.ts new file mode 100644 index 00000000..28f4e203 --- /dev/null +++ b/src/lib/workspace/workspace-item-sanitize.ts @@ -0,0 +1,11 @@ +import type { Item } from "@/lib/workspace-state/types"; + +export function sanitizeWorkspaceItemForPersistence(item: Item): Item { + return item; +} + +export function sanitizeWorkspaceItemChanges( + changes: Partial, +): Partial { + return changes; +} diff --git a/src/lib/workspace/workspace-item-write.ts b/src/lib/workspace/workspace-item-write.ts new file mode 100644 index 00000000..0c108180 --- /dev/null +++ b/src/lib/workspace/workspace-item-write.ts @@ -0,0 +1,303 @@ +import { and, eq } from "drizzle-orm"; +import { + db, + workspaceItemContent, + workspaceItemExtracted, + workspaceItems, +} from "@/lib/db/client"; +import type { Item } from "@/lib/workspace-state/types"; +import { + buildWorkspaceItemTableRows, + rehydrateWorkspaceItem, +} from "./workspace-item-model"; +import { sanitizeWorkspaceItemForPersistence } from "./workspace-item-sanitize"; + +type DbExecutor = typeof db | any; + +export async function loadWorkspaceItemRecord( + tx: DbExecutor, + params: { workspaceId: string; itemId: string }, +): Promise<{ item: Item; sourceVersion: number } | null> { + const [shell] = await tx + .select() + .from(workspaceItems) + .where( + and( + eq(workspaceItems.workspaceId, params.workspaceId), + eq(workspaceItems.itemId, params.itemId), + ), + ) + .limit(1); + + if (!shell) { + return null; + } + + const [content] = await tx + .select() + .from(workspaceItemContent) + .where( + and( + eq(workspaceItemContent.workspaceId, params.workspaceId), + eq(workspaceItemContent.itemId, params.itemId), + ), + ) + .limit(1); + + const [extracted] = await tx + .select() + .from(workspaceItemExtracted) + .where( + and( + eq(workspaceItemExtracted.workspaceId, params.workspaceId), + eq(workspaceItemExtracted.itemId, params.itemId), + ), + ) + .limit(1); + + return { + item: rehydrateWorkspaceItem({ + shell: { + itemId: shell.itemId, + type: shell.type as Item["type"], + name: shell.name, + subtitle: shell.subtitle, + color: (shell.color as Item["color"]) ?? null, + folderId: shell.folderId ?? null, + layout: (shell.layout as Item["layout"]) ?? null, + lastModified: shell.lastModified ?? null, + ocrStatus: shell.ocrStatus ?? null, + processingStatus: shell.processingStatus ?? null, + }, + content: content + ? { + textContent: content.textContent ?? null, + structuredData: + (content.structuredData as Record | null) ?? + null, + assetData: + (content.assetData as Record | null) ?? null, + embedData: + (content.embedData as Record | null) ?? null, + sourceData: (content.sourceData as never[] | null) ?? null, + } + : null, + extracted: extracted + ? { + searchText: extracted.searchText ?? "", + contentPreview: extracted.contentPreview ?? null, + ocrText: extracted.ocrText ?? null, + transcriptText: extracted.transcriptText ?? null, + ocrPages: (extracted.ocrPages as any) ?? null, + transcriptSegments: (extracted.transcriptSegments as any) ?? null, + } + : null, + }), + sourceVersion: shell.sourceVersion, + }; +} + +export async function insertWorkspaceItem( + tx: DbExecutor, + params: { + workspaceId: string; + item: Item; + sourceVersion?: number; + }, +): Promise { + const rows = buildWorkspaceItemTableRows({ + workspaceId: params.workspaceId, + item: sanitizeWorkspaceItemForPersistence(params.item), + sourceVersion: params.sourceVersion ?? 0, + }); + + await tx.insert(workspaceItems).values(rows.item); + await tx.insert(workspaceItemContent).values(rows.content); + await tx + .insert(workspaceItemExtracted) + .values(rows.extracted) + .onConflictDoUpdate({ + target: [ + workspaceItemExtracted.workspaceId, + workspaceItemExtracted.itemId, + ], + set: { + searchText: rows.extracted.searchText, + contentPreview: rows.extracted.contentPreview, + ocrText: rows.extracted.ocrText, + transcriptText: rows.extracted.transcriptText, + ocrPages: rows.extracted.ocrPages, + transcriptSegments: rows.extracted.transcriptSegments, + updatedAt: new Date().toISOString(), + }, + }); +} + +export async function upsertWorkspaceItem( + tx: DbExecutor, + params: { + workspaceId: string; + item: Item; + sourceVersion: number; + }, +): Promise { + const rows = buildWorkspaceItemTableRows({ + workspaceId: params.workspaceId, + item: sanitizeWorkspaceItemForPersistence(params.item), + sourceVersion: params.sourceVersion, + }); + + await tx + .update(workspaceItems) + .set({ + type: rows.item.type, + name: rows.item.name, + subtitle: rows.item.subtitle, + color: rows.item.color, + folderId: rows.item.folderId, + layout: rows.item.layout, + lastModified: rows.item.lastModified, + sourceVersion: rows.item.sourceVersion, + dataSchemaVersion: rows.item.dataSchemaVersion, + contentHash: rows.item.contentHash, + processingStatus: rows.item.processingStatus, + hasOcr: rows.item.hasOcr, + ocrStatus: rows.item.ocrStatus, + ocrPageCount: rows.item.ocrPageCount, + hasTranscript: rows.item.hasTranscript, + sourceCount: rows.item.sourceCount, + updatedAt: new Date().toISOString(), + }) + .where( + and( + eq(workspaceItems.workspaceId, params.workspaceId), + eq(workspaceItems.itemId, rows.item.itemId), + ), + ); + + await tx + .insert(workspaceItemContent) + .values(rows.content) + .onConflictDoUpdate({ + target: [workspaceItemContent.workspaceId, workspaceItemContent.itemId], + set: { + dataSchemaVersion: rows.content.dataSchemaVersion, + contentHash: rows.content.contentHash, + textContent: rows.content.textContent, + structuredData: rows.content.structuredData, + assetData: rows.content.assetData, + embedData: rows.content.embedData, + sourceData: rows.content.sourceData, + updatedAt: new Date().toISOString(), + }, + }); + + await tx + .insert(workspaceItemExtracted) + .values(rows.extracted) + .onConflictDoUpdate({ + target: [ + workspaceItemExtracted.workspaceId, + workspaceItemExtracted.itemId, + ], + set: { + searchText: rows.extracted.searchText, + contentPreview: rows.extracted.contentPreview, + ocrText: rows.extracted.ocrText, + transcriptText: rows.extracted.transcriptText, + ocrPages: rows.extracted.ocrPages, + transcriptSegments: rows.extracted.transcriptSegments, + updatedAt: new Date().toISOString(), + }, + }); +} + +export async function deleteWorkspaceItemById( + tx: DbExecutor, + params: { + workspaceId: string; + itemId: string; + }, +): Promise { + const [shell] = await tx + .select({ + type: workspaceItems.type, + }) + .from(workspaceItems) + .where( + and( + eq(workspaceItems.workspaceId, params.workspaceId), + eq(workspaceItems.itemId, params.itemId), + ), + ) + .limit(1); + + if (!shell) { + return; + } + + await tx + .delete(workspaceItemExtracted) + .where( + and( + eq(workspaceItemExtracted.workspaceId, params.workspaceId), + eq(workspaceItemExtracted.itemId, params.itemId), + ), + ); + await tx + .delete(workspaceItemContent) + .where( + and( + eq(workspaceItemContent.workspaceId, params.workspaceId), + eq(workspaceItemContent.itemId, params.itemId), + ), + ); + await tx + .delete(workspaceItems) + .where( + and( + eq(workspaceItems.workspaceId, params.workspaceId), + eq(workspaceItems.itemId, params.itemId), + ), + ); + + if (shell.type !== "folder") { + return; + } + + const children = await tx + .select({ + itemId: workspaceItems.itemId, + }) + .from(workspaceItems) + .where( + and( + eq(workspaceItems.workspaceId, params.workspaceId), + eq(workspaceItems.folderId, params.itemId), + ), + ); + + const now = Date.now(); + + for (const child of children) { + const loadedChild = await loadWorkspaceItemRecord(tx, { + workspaceId: params.workspaceId, + itemId: child.itemId, + }); + + if (!loadedChild) { + continue; + } + + await upsertWorkspaceItem(tx, { + workspaceId: params.workspaceId, + sourceVersion: loadedChild.sourceVersion, + item: { + ...loadedChild.item, + folderId: undefined, + layout: undefined, + lastModified: now, + }, + }); + } +} diff --git a/src/lib/workspace/workspace-items-projector.ts b/src/lib/workspace/workspace-items-projector.ts deleted file mode 100644 index b01624d4..00000000 --- a/src/lib/workspace/workspace-items-projector.ts +++ /dev/null @@ -1,787 +0,0 @@ -import { - db, - workspaceItemContent, - workspaceItemExtracted, - workspaceItemProjectionState, - workspaceItemUserState, - workspaceItems, -} from "@/lib/db/client"; -import { and, asc, eq, inArray } from "drizzle-orm"; -import type { Item } from "@/lib/workspace-state/types"; -import { eventReducer } from "./event-reducer"; -import type { WorkspaceEvent } from "./events"; -import { - buildWorkspaceItemTableRows, - normalizeItem, - rehydrateWorkspaceItem, -} from "./workspace-item-model"; -import { stableStringify } from "./workspace-item-model-shared"; - -export type WorkspaceProjectionClient = Pick< - typeof db, - "delete" | "execute" | "insert" | "select" | "update" ->; - -export interface WorkspaceProjectionStatePayload { - items: Item[]; - version: number; -} - -function toIsoTimestamp(timestamp: number | undefined): string { - return new Date(timestamp ?? Date.now()).toISOString(); -} - -async function getWorkspaceProjectionCheckpoint( - client: WorkspaceProjectionClient, - workspaceId: string, -): Promise { - const [row] = await client - .select({ - lastAppliedVersion: workspaceItemProjectionState.lastAppliedVersion, - }) - .from(workspaceItemProjectionState) - .where(eq(workspaceItemProjectionState.workspaceId, workspaceId)) - .limit(1); - - return row?.lastAppliedVersion ?? 0; -} - -async function upsertProjectionCheckpoint( - client: WorkspaceProjectionClient, - workspaceId: string, - version: number, -): Promise { - await client - .insert(workspaceItemProjectionState) - .values({ - workspaceId, - lastAppliedVersion: version, - createdAt: new Date().toISOString(), - updatedAt: new Date().toISOString(), - }) - .onConflictDoUpdate({ - target: workspaceItemProjectionState.workspaceId, - set: { - lastAppliedVersion: version, - updatedAt: new Date().toISOString(), - }, - }); -} - -function rehydrateProjectedItems(params: { - shellRows: Array; - contentRows: Array; - extractedRows: Array; - userStateRows: Array; -}): Item[] { - const contentByItemId = new Map( - params.contentRows.map((row) => [row.itemId, row]), - ); - const extractedByItemId = new Map( - params.extractedRows.map((row) => [row.itemId, row]), - ); - const userStatesByItemId = new Map(); - - for (const row of params.userStateRows) { - const rows = userStatesByItemId.get(row.itemId) ?? []; - rows.push(row); - userStatesByItemId.set(row.itemId, rows); - } - - return params.shellRows.map((shellRow) => - rehydrateWorkspaceItem({ - shell: shellRow as any, - content: contentByItemId.get(shellRow.itemId) as any, - extracted: extractedByItemId.get(shellRow.itemId) as any, - userStates: userStatesByItemId.get(shellRow.itemId)?.map((row) => ({ - stateKey: row.stateKey, - stateType: row.stateType as Item["type"], - stateSchemaVersion: row.stateSchemaVersion, - state: row.state as Record, - })), - }), - ); -} - -async function loadProjectedItemsByShellRows( - client: WorkspaceProjectionClient, - workspaceId: string, - shellRows: Array, - userId?: string | null, -): Promise { - if (shellRows.length === 0) { - return []; - } - - const itemIds = shellRows.map((row) => row.itemId); - - const [contentRows, extractedRows, userStateRows] = await Promise.all([ - client - .select() - .from(workspaceItemContent) - .where( - and( - eq(workspaceItemContent.workspaceId, workspaceId), - inArray(workspaceItemContent.itemId, itemIds), - ), - ), - client - .select() - .from(workspaceItemExtracted) - .where( - and( - eq(workspaceItemExtracted.workspaceId, workspaceId), - inArray(workspaceItemExtracted.itemId, itemIds), - ), - ), - userId - ? client - .select() - .from(workspaceItemUserState) - .where( - and( - eq(workspaceItemUserState.workspaceId, workspaceId), - eq(workspaceItemUserState.userId, userId), - inArray(workspaceItemUserState.itemId, itemIds), - ), - ) - : Promise.resolve( - [] as Array, - ), - ]); - - return rehydrateProjectedItems({ - shellRows, - contentRows: contentRows as Array, - extractedRows: extractedRows as Array< - typeof workspaceItemExtracted.$inferSelect - >, - userStateRows: userStateRows as Array< - typeof workspaceItemUserState.$inferSelect - >, - }); -} - -async function loadProjectedItemsByIds( - client: WorkspaceProjectionClient, - workspaceId: string, - itemIds: string[], - userId?: string | null, -): Promise { - if (itemIds.length === 0) { - return []; - } - - const shellRows = (await client - .select() - .from(workspaceItems) - .where( - and( - eq(workspaceItems.workspaceId, workspaceId), - inArray(workspaceItems.itemId, itemIds), - ), - )) as Array; - - const shellRowOrder = new Map(shellRows.map((row) => [row.itemId, row])); - const orderedShellRows = itemIds - .map((itemId) => shellRowOrder.get(itemId)) - .filter((row): row is typeof workspaceItems.$inferSelect => Boolean(row)); - - return loadProjectedItemsByShellRows( - client, - workspaceId, - orderedShellRows, - userId, - ); -} - -async function readProjectedWorkspaceState( - client: WorkspaceProjectionClient, - workspaceId: string, - userId?: string | null, -): Promise { - const [shellRows, version] = await Promise.all([ - client - .select() - .from(workspaceItems) - .where(eq(workspaceItems.workspaceId, workspaceId)) - .orderBy(asc(workspaceItems.createdAt), asc(workspaceItems.itemId)), - getWorkspaceProjectionCheckpoint(client, workspaceId), - ]); - - const items = await loadProjectedItemsByShellRows( - client, - workspaceId, - shellRows as Array, - userId, - ); - - return { - items, - version, - }; -} - -function diffProjectedItems(previousItems: Item[], nextItems: Item[]) { - const previousById = new Map(previousItems.map((item) => [item.id, item])); - const nextIds = new Set(nextItems.map((item) => item.id)); - - const deletedItemIds = previousItems - .filter((item) => !nextIds.has(item.id)) - .map((item) => item.id); - - const upsertedItems = nextItems.filter((item) => { - const previous = previousById.get(item.id); - if (!previous) { - return true; - } - - return ( - stableStringify(normalizeItem(previous)) !== - stableStringify(normalizeItem(item)) - ); - }); - - return { deletedItemIds, upsertedItems }; -} - -async function deleteProjectedItems( - client: WorkspaceProjectionClient, - workspaceId: string, - itemIds: string[], -): Promise { - if (itemIds.length === 0) { - return; - } - - await client - .delete(workspaceItems) - .where( - and( - eq(workspaceItems.workspaceId, workspaceId), - inArray(workspaceItems.itemId, itemIds), - ), - ); -} - -async function replaceProjectedUserState( - client: WorkspaceProjectionClient, - workspaceId: string, - itemId: string, - userId: string, - rows: ReturnType["userStates"], -): Promise { - await client - .delete(workspaceItemUserState) - .where( - and( - eq(workspaceItemUserState.workspaceId, workspaceId), - eq(workspaceItemUserState.itemId, itemId), - eq(workspaceItemUserState.userId, userId), - ), - ); - - if (rows.length === 0) { - return; - } - - for (const row of rows) { - await client.insert(workspaceItemUserState).values({ - workspaceId: row.workspaceId, - itemId: row.itemId, - userId: row.userId, - stateKey: row.stateKey, - stateType: row.stateType, - stateSchemaVersion: row.stateSchemaVersion, - state: row.state, - updatedAt: new Date().toISOString(), - }); - } -} - -async function upsertProjectedItem( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - item: Item; - version: number; - timestamp: number; - userId?: string | null; - }, -): Promise { - const rows = buildWorkspaceItemTableRows({ - workspaceId: params.workspaceId, - item: params.item, - sourceVersion: params.version, - userId: params.userId ?? undefined, - }); - const timestamp = toIsoTimestamp(params.timestamp); - - await client - .insert(workspaceItems) - .values({ - ...rows.item, - createdAt: timestamp, - updatedAt: timestamp, - }) - .onConflictDoUpdate({ - target: [workspaceItems.workspaceId, workspaceItems.itemId], - set: { - type: rows.item.type, - name: rows.item.name, - subtitle: rows.item.subtitle, - color: rows.item.color, - folderId: rows.item.folderId, - layout: rows.item.layout, - lastModified: rows.item.lastModified, - sourceVersion: rows.item.sourceVersion, - dataSchemaVersion: rows.item.dataSchemaVersion, - contentHash: rows.item.contentHash, - processingStatus: rows.item.processingStatus, - hasOcr: rows.item.hasOcr, - ocrStatus: rows.item.ocrStatus, - ocrPageCount: rows.item.ocrPageCount, - hasTranscript: rows.item.hasTranscript, - sourceCount: rows.item.sourceCount, - updatedAt: timestamp, - }, - }); - - await client - .insert(workspaceItemContent) - .values({ - ...rows.content, - updatedAt: timestamp, - }) - .onConflictDoUpdate({ - target: [workspaceItemContent.workspaceId, workspaceItemContent.itemId], - set: { - dataSchemaVersion: rows.content.dataSchemaVersion, - contentHash: rows.content.contentHash, - textContent: rows.content.textContent, - structuredData: rows.content.structuredData, - assetData: rows.content.assetData, - embedData: rows.content.embedData, - sourceData: rows.content.sourceData, - updatedAt: timestamp, - }, - }); - - await client - .insert(workspaceItemExtracted) - .values({ - ...rows.extracted, - updatedAt: timestamp, - }) - .onConflictDoUpdate({ - target: [ - workspaceItemExtracted.workspaceId, - workspaceItemExtracted.itemId, - ], - set: { - searchText: rows.extracted.searchText, - contentPreview: rows.extracted.contentPreview, - ocrText: rows.extracted.ocrText, - transcriptText: rows.extracted.transcriptText, - ocrPages: rows.extracted.ocrPages, - transcriptSegments: rows.extracted.transcriptSegments, - updatedAt: timestamp, - }, - }); - - if (params.userId) { - await replaceProjectedUserState( - client, - params.workspaceId, - params.item.id, - params.userId, - rows.userStates, - ); - } -} - -async function upsertProjectedItems( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - items: Item[]; - version: number; - timestamp: number; - userId?: string | null; - }, -): Promise { - for (const item of params.items) { - await upsertProjectedItem(client, { - workspaceId: params.workspaceId, - item, - version: params.version, - timestamp: params.timestamp, - userId: params.userId, - }); - } -} - -async function getFolderIds( - client: WorkspaceProjectionClient, - workspaceId: string, - itemIds: string[], -): Promise { - if (itemIds.length === 0) { - return []; - } - - const rows = await client - .select({ - itemId: workspaceItems.itemId, - type: workspaceItems.type, - }) - .from(workspaceItems) - .where( - and( - eq(workspaceItems.workspaceId, workspaceId), - inArray(workspaceItems.itemId, itemIds), - ), - ); - - return rows.filter((row) => row.type === "folder").map((row) => row.itemId); -} - -async function clearProjectedFolderMembership( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - folderIds: string[]; - version: number; - timestamp: number; - }, -): Promise { - if (params.folderIds.length === 0) { - return; - } - - await client - .update(workspaceItems) - .set({ - folderId: null, - layout: null, - sourceVersion: params.version, - updatedAt: toIsoTimestamp(params.timestamp), - }) - .where( - and( - eq(workspaceItems.workspaceId, params.workspaceId), - inArray(workspaceItems.folderId, params.folderIds), - ), - ); -} - -async function moveProjectedItemsToFolder( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - itemIds: string[]; - folderId: string | null; - version: number; - timestamp: number; - touchLastModified?: boolean; - }, -): Promise { - if (params.itemIds.length === 0) { - return; - } - - await client - .update(workspaceItems) - .set({ - folderId: params.folderId, - layout: null, - sourceVersion: params.version, - ...(params.touchLastModified ? { lastModified: params.timestamp } : {}), - updatedAt: toIsoTimestamp(params.timestamp), - }) - .where( - and( - eq(workspaceItems.workspaceId, params.workspaceId), - inArray(workspaceItems.itemId, params.itemIds), - ), - ); -} - -async function updateProjectedLayouts( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - layoutUpdates: NonNullable< - Extract< - WorkspaceEvent, - { type: "BULK_ITEMS_UPDATED" } - >["payload"]["layoutUpdates"] - >; - version: number; - timestamp: number; - }, -): Promise { - for (const layoutUpdate of params.layoutUpdates) { - await client - .update(workspaceItems) - .set({ - layout: { - x: layoutUpdate.x, - y: layoutUpdate.y, - w: layoutUpdate.w, - h: layoutUpdate.h, - }, - sourceVersion: params.version, - updatedAt: toIsoTimestamp(params.timestamp), - }) - .where( - and( - eq(workspaceItems.workspaceId, params.workspaceId), - eq(workspaceItems.itemId, layoutUpdate.id), - ), - ); - } -} - -async function applyReducerProjectionForItemIds( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - itemIds: string[]; - event: WorkspaceEvent; - version: number; - }, -): Promise { - if (params.itemIds.length === 0) { - return; - } - - const currentItems = await loadProjectedItemsByIds( - client, - params.workspaceId, - params.itemIds, - params.event.userId, - ); - const projectedEvent = { ...params.event, version: params.version }; - const nextItems = eventReducer(currentItems, projectedEvent); - const { deletedItemIds, upsertedItems } = diffProjectedItems( - currentItems, - nextItems, - ); - - await deleteProjectedItems(client, params.workspaceId, deletedItemIds); - await upsertProjectedItems(client, { - workspaceId: params.workspaceId, - items: upsertedItems, - version: params.version, - timestamp: params.event.timestamp, - userId: params.event.userId, - }); -} - -export function deriveWorkspaceProjectionChangeSet( - currentItems: Item[], - event: WorkspaceEvent, -) { - const nextItems = eventReducer(currentItems, event); - const { deletedItemIds, upsertedItems } = diffProjectedItems( - currentItems, - nextItems, - ); - - return { - nextItems, - deletedItemIds, - upsertedItems, - }; -} - -async function applyWorkspaceEventProjectionInternal( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - event: WorkspaceEvent; - version: number; - }, -): Promise { - const eventWithVersion = { - ...params.event, - version: params.version, - } as WorkspaceEvent; - - switch (eventWithVersion.type) { - case "ITEM_CREATED": { - await upsertProjectedItem(client, { - workspaceId: params.workspaceId, - item: { - ...eventWithVersion.payload.item, - lastModified: eventWithVersion.timestamp, - }, - version: params.version, - timestamp: eventWithVersion.timestamp, - userId: eventWithVersion.userId, - }); - break; - } - - case "BULK_ITEMS_CREATED": { - await upsertProjectedItems(client, { - workspaceId: params.workspaceId, - items: eventWithVersion.payload.items.map((item) => ({ - ...item, - lastModified: eventWithVersion.timestamp, - })), - version: params.version, - timestamp: eventWithVersion.timestamp, - userId: eventWithVersion.userId, - }); - break; - } - - case "ITEM_UPDATED": { - await applyReducerProjectionForItemIds(client, { - workspaceId: params.workspaceId, - itemIds: [eventWithVersion.payload.id], - event: eventWithVersion, - version: params.version, - }); - break; - } - - case "BULK_ITEMS_PATCHED": { - await applyReducerProjectionForItemIds(client, { - workspaceId: params.workspaceId, - itemIds: eventWithVersion.payload.updates.map((update) => update.id), - event: eventWithVersion, - version: params.version, - }); - break; - } - - case "ITEM_DELETED": { - const folderIds = await getFolderIds(client, params.workspaceId, [ - eventWithVersion.payload.id, - ]); - await clearProjectedFolderMembership(client, { - workspaceId: params.workspaceId, - folderIds, - version: params.version, - timestamp: eventWithVersion.timestamp, - }); - await deleteProjectedItems(client, params.workspaceId, [ - eventWithVersion.payload.id, - ]); - break; - } - - case "BULK_ITEMS_UPDATED": { - if (eventWithVersion.payload.deletedIds?.length) { - const deletedIds = eventWithVersion.payload.deletedIds; - const folderIds = await getFolderIds( - client, - params.workspaceId, - deletedIds, - ); - await clearProjectedFolderMembership(client, { - workspaceId: params.workspaceId, - folderIds, - version: params.version, - timestamp: eventWithVersion.timestamp, - }); - await deleteProjectedItems(client, params.workspaceId, deletedIds); - break; - } - - if (eventWithVersion.payload.addedItems?.length) { - await upsertProjectedItems(client, { - workspaceId: params.workspaceId, - items: eventWithVersion.payload.addedItems.map((item) => ({ - ...item, - lastModified: eventWithVersion.timestamp, - })), - version: params.version, - timestamp: eventWithVersion.timestamp, - userId: eventWithVersion.userId, - }); - break; - } - - if (eventWithVersion.payload.layoutUpdates?.length) { - await updateProjectedLayouts(client, { - workspaceId: params.workspaceId, - layoutUpdates: eventWithVersion.payload.layoutUpdates, - version: params.version, - timestamp: eventWithVersion.timestamp, - }); - } - break; - } - - case "ITEM_MOVED_TO_FOLDER": { - await moveProjectedItemsToFolder(client, { - workspaceId: params.workspaceId, - itemIds: [eventWithVersion.payload.itemId], - folderId: eventWithVersion.payload.folderId, - version: params.version, - timestamp: eventWithVersion.timestamp, - }); - break; - } - - case "ITEMS_MOVED_TO_FOLDER": { - await moveProjectedItemsToFolder(client, { - workspaceId: params.workspaceId, - itemIds: eventWithVersion.payload.itemIds, - folderId: eventWithVersion.payload.folderId, - version: params.version, - timestamp: eventWithVersion.timestamp, - }); - break; - } - - case "FOLDER_CREATED_WITH_ITEMS": { - await upsertProjectedItem(client, { - workspaceId: params.workspaceId, - item: { - ...eventWithVersion.payload.folder, - lastModified: eventWithVersion.timestamp, - }, - version: params.version, - timestamp: eventWithVersion.timestamp, - userId: eventWithVersion.userId, - }); - await moveProjectedItemsToFolder(client, { - workspaceId: params.workspaceId, - itemIds: eventWithVersion.payload.itemIds, - folderId: eventWithVersion.payload.folder.id, - version: params.version, - timestamp: eventWithVersion.timestamp, - touchLastModified: true, - }); - break; - } - } - - await upsertProjectionCheckpoint(client, params.workspaceId, params.version); -} - -export async function projectWorkspaceEvent( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - event: WorkspaceEvent; - version: number; - }, -): Promise { - await applyWorkspaceEventProjectionInternal(client, params); -} - -export async function loadWorkspaceProjectionState( - client: WorkspaceProjectionClient, - params: { - workspaceId: string; - userId?: string | null; - }, -): Promise { - return readProjectedWorkspaceState(client, params.workspaceId, params.userId); -} diff --git a/src/lib/workspace/workspace-state-read.ts b/src/lib/workspace/workspace-state-read.ts new file mode 100644 index 00000000..fdd501ba --- /dev/null +++ b/src/lib/workspace/workspace-state-read.ts @@ -0,0 +1,108 @@ +import { and, asc, eq, inArray } from "drizzle-orm"; +import { + db, + workspaceItemContent, + workspaceItemExtracted, + workspaceItems, +} from "@/lib/db/client"; +import { rehydrateWorkspaceItem } from "./workspace-item-model"; +import type { Item } from "@/lib/workspace-state/types"; + +type DbExecutor = typeof db | any; + +async function readWorkspaceState( + tx: DbExecutor, + workspaceId: string, +): Promise { + const shellRows = await tx + .select() + .from(workspaceItems) + .where(eq(workspaceItems.workspaceId, workspaceId)) + .orderBy(asc(workspaceItems.createdAt), asc(workspaceItems.itemId)); + + if (shellRows.length === 0) { + return []; + } + + const itemIds = shellRows.map((row: typeof workspaceItems.$inferSelect) => row.itemId); + const [contentRows, extractedRows] = await Promise.all([ + tx + .select() + .from(workspaceItemContent) + .where( + and( + eq(workspaceItemContent.workspaceId, workspaceId), + inArray(workspaceItemContent.itemId, itemIds), + ), + ), + tx + .select() + .from(workspaceItemExtracted) + .where( + and( + eq(workspaceItemExtracted.workspaceId, workspaceId), + inArray(workspaceItemExtracted.itemId, itemIds), + ), + ), + ]); + + const contentByItemId = new Map( + contentRows.map((row: typeof workspaceItemContent.$inferSelect) => [row.itemId, row]), + ); + const extractedByItemId = new Map( + extractedRows.map((row: typeof workspaceItemExtracted.$inferSelect) => [row.itemId, row]), + ); + + return shellRows.map((shell: typeof workspaceItems.$inferSelect) => { + const content = contentByItemId.get(shell.itemId) as + | typeof workspaceItemContent.$inferSelect + | undefined; + const extracted = extractedByItemId.get(shell.itemId) as + | typeof workspaceItemExtracted.$inferSelect + | undefined; + + return rehydrateWorkspaceItem({ + shell: { + itemId: shell.itemId, + type: shell.type as Item["type"], + name: shell.name, + subtitle: shell.subtitle, + color: (shell.color as Item["color"]) ?? null, + folderId: shell.folderId ?? null, + layout: (shell.layout as Item["layout"]) ?? null, + lastModified: shell.lastModified ?? null, + ocrStatus: shell.ocrStatus ?? null, + processingStatus: shell.processingStatus ?? null, + }, + content: content + ? { + textContent: content.textContent ?? null, + structuredData: + (content.structuredData as Record | null) ?? null, + assetData: + (content.assetData as Record | null) ?? null, + embedData: + (content.embedData as Record | null) ?? null, + sourceData: (content.sourceData as never[] | null) ?? null, + } + : null, + extracted: extracted + ? { + searchText: extracted.searchText ?? "", + contentPreview: extracted.contentPreview ?? null, + ocrText: extracted.ocrText ?? null, + transcriptText: extracted.transcriptText ?? null, + ocrPages: (extracted.ocrPages as any) ?? null, + transcriptSegments: (extracted.transcriptSegments as any) ?? null, + } + : null, + }); + }); +} + +export async function loadWorkspaceState( + workspaceId: string, + _options?: { userId?: string | null }, +): Promise { + return db.transaction((tx) => readWorkspaceState(tx, workspaceId)); +} diff --git a/src/lib/zero/client.ts b/src/lib/zero/client.ts index 87201822..7b4a4030 100644 --- a/src/lib/zero/client.ts +++ b/src/lib/zero/client.ts @@ -3,16 +3,14 @@ import { mutators } from "./mutators"; import { schema } from "./zero-schema.gen"; export interface ZeroContext { - userId: string | null; + userId: string; } -function createZeroInstance(params: { userId: string; auth: string }) { +function createZeroInstance(params: { userId: string }) { return new Zero({ schema, cacheURL: process.env.NEXT_PUBLIC_ZERO_SERVER!, - mutateURL: "/api/zero/mutate", userID: params.userId, - auth: params.auth, context: { userId: params.userId, }, @@ -22,7 +20,6 @@ function createZeroInstance(params: { userId: string; auth: string }) { let zeroInstance: ReturnType | null = null; let zeroUserId: string | null = null; -let zeroAuthToken: string | null = null; export function destroyZero() { if (!zeroInstance) { @@ -32,23 +29,16 @@ export function destroyZero() { void zeroInstance.close(); zeroInstance = null; zeroUserId = null; - zeroAuthToken = null; } -export function getZero(params: { userId: string; auth: string }) { +export function getZero(params: { userId: string }) { if (!zeroInstance || zeroUserId !== params.userId) { destroyZero(); zeroInstance = createZeroInstance(params); zeroUserId = params.userId; - zeroAuthToken = params.auth; return zeroInstance; } - if (zeroAuthToken !== params.auth) { - zeroAuthToken = params.auth; - void zeroInstance.connection.connect({ auth: params.auth }); - } - return zeroInstance; } diff --git a/src/lib/zero/mutators.ts b/src/lib/zero/mutators.ts index 39f4498a..eb14e7ef 100644 --- a/src/lib/zero/mutators.ts +++ b/src/lib/zero/mutators.ts @@ -1,8 +1,8 @@ import { ApplicationError, type Transaction, - defineMutatorWithType, - defineMutatorsWithType, + defineMutator, + defineMutators, } from "@rocicorp/zero"; import { z } from "zod"; import type { Item } from "@/lib/workspace-state/types"; @@ -10,11 +10,12 @@ import { buildWorkspaceItemTableRows, rehydrateWorkspaceItem, } from "@/lib/workspace/workspace-item-model"; +import { + sanitizeWorkspaceItemChanges, + sanitizeWorkspaceItemForPersistence, +} from "@/lib/workspace/workspace-item-sanitize"; import { schema, zql } from "./zero-schema.gen"; -import type { ZeroContext } from "./client"; -const defineZeroMutator = defineMutatorWithType(); -const defineZeroMutators = defineMutatorsWithType(); type ZeroTx = Transaction; const cardTypeSchema = z.enum([ @@ -37,30 +38,52 @@ type JsonValue = | JsonValue[] | { [key: string]: JsonValue }; -const jsonValueSchema: z.ZodType = z.lazy(() => - z.union([ - z.string(), - z.number(), - z.boolean(), - z.null(), - z.array(jsonValueSchema), - z.record(z.string(), jsonValueSchema), - ]), -); - -const jsonObjectSchema: z.ZodType<{ [key: string]: JsonValue }> = z.record( - z.string(), - jsonValueSchema, -); +type JsonObject = { [key: string]: JsonValue }; + +function isJsonValue(value: unknown): value is JsonValue { + if (value === null) { + return true; + } + + if ( + typeof value === "string" || + typeof value === "number" || + typeof value === "boolean" + ) { + return true; + } + + if (Array.isArray(value)) { + return value.every(isJsonValue); + } + + if (typeof value === "object") { + return Object.values(value as Record).every(isJsonValue); + } + + return false; +} + +function isJsonObject(value: unknown): value is JsonObject { + return ( + typeof value === "object" && + value !== null && + !Array.isArray(value) && + isJsonValue(value) + ); +} + +const jsonValueSchema = z.custom(isJsonValue); +const jsonObjectSchema = z.custom(isJsonObject); const itemSchema = z.object({ - id: z.string().uuid(), + id: z.string(), type: cardTypeSchema, name: z.string(), subtitle: z.string().default(""), data: jsonObjectSchema, color: z.string().nullable().optional(), - folderId: z.string().uuid().nullable().optional(), + folderId: z.string().nullable().optional(), layout: jsonObjectSchema.nullable().optional(), lastModified: z.number().int().optional(), }); @@ -74,13 +97,13 @@ const itemChangesSchema = z.object({ subtitle: z.string().optional(), data: jsonObjectSchema.optional(), color: z.string().nullable().optional(), - folderId: z.string().uuid().nullable().optional(), + folderId: z.string().nullable().optional(), layout: jsonObjectSchema.nullable().optional(), lastModified: z.number().int().optional(), }); const layoutUpdateSchema = z.object({ - id: z.string().uuid(), + id: z.string(), x: z.number(), y: z.number(), w: z.number(), @@ -91,18 +114,18 @@ export const zeroMutatorSchemas = { item: { create: z.object({ workspaceId: z.string().uuid(), - id: z.string().uuid(), + id: z.string(), item: itemSchema, }), update: z.object({ workspaceId: z.string().uuid(), - id: z.string().uuid(), + id: z.string(), changes: itemChangesSchema, name: z.string().optional(), }), delete: z.object({ workspaceId: z.string().uuid(), - id: z.string().uuid(), + id: z.string(), name: z.string().optional(), }), createMany: z.object({ @@ -113,7 +136,7 @@ export const zeroMutatorSchemas = { workspaceId: z.string().uuid(), updates: z.array( z.object({ - id: z.string().uuid(), + id: z.string(), changes: itemChangesSchema, name: z.string().optional(), }), @@ -123,19 +146,19 @@ export const zeroMutatorSchemas = { workspaceId: z.string().uuid(), layoutUpdates: z.array(layoutUpdateSchema).optional(), previousItemCount: z.number().int().optional(), - deletedIds: z.array(z.string().uuid()).optional(), + deletedIds: z.array(z.string()).optional(), addedItems: z.array(itemSchema).optional(), }), move: z.object({ workspaceId: z.string().uuid(), - itemId: z.string().uuid(), - folderId: z.string().uuid().nullable(), + itemId: z.string(), + folderId: z.string().nullable(), itemName: z.string().optional(), }), moveMany: z.object({ workspaceId: z.string().uuid(), - itemIds: z.array(z.string().uuid()), - folderId: z.string().uuid().nullable(), + itemIds: z.array(z.string()), + folderId: z.string().nullable(), itemNames: z.array(z.string()).optional(), }), }, @@ -143,13 +166,13 @@ export const zeroMutatorSchemas = { createWithItems: z.object({ workspaceId: z.string().uuid(), folder: folderItemSchema, - itemIds: z.array(z.string().uuid()), + itemIds: z.array(z.string()), }), }, } as const; function toItem(input: z.infer): Item { - return { + return sanitizeWorkspaceItemForPersistence({ id: input.id, type: input.type, name: input.name, @@ -161,11 +184,13 @@ function toItem(input: z.infer): Item { ...(input.folderId !== undefined ? { folderId: input.folderId ?? undefined } : {}), - ...(input.layout !== undefined ? { layout: input.layout ?? undefined } : {}), + ...(input.layout !== undefined + ? { layout: input.layout ?? undefined } + : {}), ...(input.lastModified !== undefined ? { lastModified: input.lastModified } : {}), - }; + }); } function mergeItemChanges( @@ -173,30 +198,39 @@ function mergeItemChanges( changes: z.infer, lastModified: number, ): Item { + const sanitizedChanges = sanitizeWorkspaceItemChanges( + changes as Partial, + ) as z.infer; const next: Item = { ...existing, - ...(changes.name !== undefined ? { name: changes.name } : {}), - ...(changes.subtitle !== undefined ? { subtitle: changes.subtitle } : {}), - ...(changes.color !== undefined - ? { color: (changes.color ?? undefined) as Item["color"] } + ...(sanitizedChanges.name !== undefined + ? { name: sanitizedChanges.name } + : {}), + ...(sanitizedChanges.subtitle !== undefined + ? { subtitle: sanitizedChanges.subtitle } : {}), - ...(changes.folderId !== undefined - ? { folderId: changes.folderId ?? undefined } + ...(sanitizedChanges.color !== undefined + ? { color: (sanitizedChanges.color ?? undefined) as Item["color"] } : {}), - ...(changes.layout !== undefined ? { layout: changes.layout ?? undefined } : {}), - ...(changes.lastModified !== undefined - ? { lastModified: changes.lastModified } + ...(sanitizedChanges.folderId !== undefined + ? { folderId: sanitizedChanges.folderId ?? undefined } + : {}), + ...(sanitizedChanges.layout !== undefined + ? { layout: sanitizedChanges.layout ?? undefined } + : {}), + ...(sanitizedChanges.lastModified !== undefined + ? { lastModified: sanitizedChanges.lastModified } : { lastModified }), data: - changes.data !== undefined + sanitizedChanges.data !== undefined ? ({ ...(existing.data as Record), - ...changes.data, + ...sanitizedChanges.data, } as Item["data"]) : existing.data, }; - return next; + return sanitizeWorkspaceItemForPersistence(next); } function toMutateShellRow( @@ -223,13 +257,10 @@ function toMutateContentRow( async function loadItem( tx: ZeroTx, params: { workspaceId: string; itemId: string }, -): Promise< - | { - item: Item; - sourceVersion: number; - } - | null -> { +): Promise<{ + item: Item; + sourceVersion: number; +} | null> { const shell = await tx.run( zql.workspace_items .where("workspaceId", params.workspaceId) @@ -266,7 +297,8 @@ async function loadItem( ? { textContent: content.textContent ?? null, structuredData: - (content.structuredData as Record | null) ?? null, + (content.structuredData as Record | null) ?? + null, assetData: (content.assetData as Record | null) ?? null, embedData: @@ -274,7 +306,6 @@ async function loadItem( sourceData: (content.sourceData as never[] | null) ?? null, } : null, - userStates: null, }), sourceVersion: shell.sourceVersion, }; @@ -293,11 +324,12 @@ async function insertItem( workspaceId: params.workspaceId, item: params.item, sourceVersion: params.sourceVersion ?? 0, - userId: params.userId ?? undefined, }); await tx.mutate.workspace_items.insert(toMutateShellRow(rows.item)); - await tx.mutate.workspace_item_content.insert(toMutateContentRow(rows.content)); + await tx.mutate.workspace_item_content.insert( + toMutateContentRow(rows.content), + ); } async function upsertItem( @@ -313,11 +345,12 @@ async function upsertItem( workspaceId: params.workspaceId, item: params.item, sourceVersion: params.sourceVersion, - userId: params.userId ?? undefined, }); await tx.mutate.workspace_items.update(toMutateShellRow(rows.item)); - await tx.mutate.workspace_item_content.upsert(toMutateContentRow(rows.content)); + await tx.mutate.workspace_item_content.upsert( + toMutateContentRow(rows.content), + ); } async function deleteItemById( @@ -381,110 +414,67 @@ async function deleteItemById( } } -export const mutators = defineZeroMutators({ +export const mutators = defineMutators({ item: { - create: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.create.parse(args); - const now = Date.now(); - const item = toItem({ - ...parsed.item, - id: parsed.id, - lastModified: now, - }); - - await insertItem(tx, { - workspaceId: parsed.workspaceId, - item, - userId: ctx.userId, - sourceVersion: 0, - }); - }), - update: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.update.parse(args); - const existing = await loadItem(tx, { - workspaceId: parsed.workspaceId, - itemId: parsed.id, - }); - - if (!existing) { - throw new ApplicationError(`Workspace item ${parsed.id} was not found.`); - } - - const next = mergeItemChanges(existing.item, parsed.changes, Date.now()); - - await upsertItem(tx, { - workspaceId: parsed.workspaceId, - item: next, - sourceVersion: existing.sourceVersion, - userId: ctx.userId, - }); - }), - delete: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.delete.parse(args); - await deleteItemById(tx, { - workspaceId: parsed.workspaceId, - itemId: parsed.id, - }); - }), - createMany: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.createMany.parse(args); - const now = Date.now(); + create: defineMutator( + zeroMutatorSchemas.item.create, + async ({ tx, ctx, args }) => { + const now = Date.now(); + const item = toItem({ + ...args.item, + id: args.id, + lastModified: now, + }); - for (const rawItem of parsed.items) { await insertItem(tx, { - workspaceId: parsed.workspaceId, - item: toItem({ - ...rawItem, - lastModified: now, - }), + workspaceId: args.workspaceId, + item, userId: ctx.userId, sourceVersion: 0, }); - } - }), - patchMany: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.patchMany.parse(args); - const now = Date.now(); - - for (const update of parsed.updates) { + }, + ), + update: defineMutator( + zeroMutatorSchemas.item.update, + async ({ tx, ctx, args }) => { const existing = await loadItem(tx, { - workspaceId: parsed.workspaceId, - itemId: update.id, + workspaceId: args.workspaceId, + itemId: args.id, }); if (!existing) { throw new ApplicationError( - `Workspace item ${update.id} was not found.`, + `Workspace item ${args.id} was not found.`, ); } - const next = mergeItemChanges(existing.item, update.changes, now); + const next = mergeItemChanges(existing.item, args.changes, Date.now()); await upsertItem(tx, { - workspaceId: parsed.workspaceId, + workspaceId: args.workspaceId, item: next, sourceVersion: existing.sourceVersion, userId: ctx.userId, }); - } - }), - updateMany: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.updateMany.parse(args); - if (parsed.deletedIds?.length) { - for (const itemId of parsed.deletedIds) { - await deleteItemById(tx, { - workspaceId: parsed.workspaceId, - itemId, - }); - } - } - - if (parsed.addedItems?.length) { + }, + ), + delete: defineMutator( + zeroMutatorSchemas.item.delete, + async ({ tx, ctx, args }) => { + await deleteItemById(tx, { + workspaceId: args.workspaceId, + itemId: args.id, + }); + }, + ), + createMany: defineMutator( + zeroMutatorSchemas.item.createMany, + async ({ tx, ctx, args }) => { const now = Date.now(); - for (const rawItem of parsed.addedItems) { + for (const rawItem of args.items) { await insertItem(tx, { - workspaceId: parsed.workspaceId, + workspaceId: args.workspaceId, item: toItem({ ...rawItem, lastModified: now, @@ -493,131 +483,198 @@ export const mutators = defineZeroMutators({ sourceVersion: 0, }); } - } - - if (parsed.layoutUpdates?.length) { + }, + ), + patchMany: defineMutator( + zeroMutatorSchemas.item.patchMany, + async ({ tx, ctx, args }) => { const now = Date.now(); - for (const layoutUpdate of parsed.layoutUpdates) { + for (const update of args.updates) { const existing = await loadItem(tx, { - workspaceId: parsed.workspaceId, - itemId: layoutUpdate.id, + workspaceId: args.workspaceId, + itemId: update.id, }); if (!existing) { throw new ApplicationError( - `Workspace item ${layoutUpdate.id} was not found.`, + `Workspace item ${update.id} was not found.`, ); } + const next = mergeItemChanges(existing.item, update.changes, now); + await upsertItem(tx, { - workspaceId: parsed.workspaceId, - userId: ctx.userId, + workspaceId: args.workspaceId, + item: next, sourceVersion: existing.sourceVersion, - item: { - ...existing.item, - layout: { - x: layoutUpdate.x, - y: layoutUpdate.y, - w: layoutUpdate.w, - h: layoutUpdate.h, - }, - lastModified: now, - }, + userId: ctx.userId, }); } - } - }), - move: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.move.parse(args); - const existing = await loadItem(tx, { - workspaceId: parsed.workspaceId, - itemId: parsed.itemId, - }); - - if (!existing) { - throw new ApplicationError( - `Workspace item ${parsed.itemId} was not found.`, - ); - } + }, + ), + updateMany: defineMutator( + zeroMutatorSchemas.item.updateMany, + async ({ tx, ctx, args }) => { + if (args.deletedIds?.length) { + for (const itemId of args.deletedIds) { + await deleteItemById(tx, { + workspaceId: args.workspaceId, + itemId, + }); + } + } - await upsertItem(tx, { - workspaceId: parsed.workspaceId, - userId: ctx.userId, - sourceVersion: existing.sourceVersion, - item: { - ...existing.item, - folderId: parsed.folderId ?? undefined, - layout: undefined, - lastModified: Date.now(), - }, - }); - }), - moveMany: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.moveMany.parse(args); - const now = Date.now(); + if (args.addedItems?.length) { + const now = Date.now(); + + for (const rawItem of args.addedItems) { + await insertItem(tx, { + workspaceId: args.workspaceId, + item: toItem({ + ...rawItem, + lastModified: now, + }), + userId: ctx.userId, + sourceVersion: 0, + }); + } + } - for (const itemId of parsed.itemIds) { + if (args.layoutUpdates?.length) { + const now = Date.now(); + + for (const layoutUpdate of args.layoutUpdates) { + const existing = await loadItem(tx, { + workspaceId: args.workspaceId, + itemId: layoutUpdate.id, + }); + + if (!existing) { + throw new ApplicationError( + `Workspace item ${layoutUpdate.id} was not found.`, + ); + } + + await upsertItem(tx, { + workspaceId: args.workspaceId, + userId: ctx.userId, + sourceVersion: existing.sourceVersion, + item: { + ...existing.item, + layout: { + x: layoutUpdate.x, + y: layoutUpdate.y, + w: layoutUpdate.w, + h: layoutUpdate.h, + }, + lastModified: now, + }, + }); + } + } + }, + ), + move: defineMutator( + zeroMutatorSchemas.item.move, + async ({ tx, ctx, args }) => { const existing = await loadItem(tx, { - workspaceId: parsed.workspaceId, - itemId, + workspaceId: args.workspaceId, + itemId: args.itemId, }); if (!existing) { - throw new ApplicationError(`Workspace item ${itemId} was not found.`); + throw new ApplicationError( + `Workspace item ${args.itemId} was not found.`, + ); } await upsertItem(tx, { - workspaceId: parsed.workspaceId, + workspaceId: args.workspaceId, userId: ctx.userId, sourceVersion: existing.sourceVersion, item: { ...existing.item, - folderId: parsed.folderId ?? undefined, + folderId: args.folderId ?? undefined, layout: undefined, - lastModified: now, + lastModified: Date.now(), }, }); - } - }), - }, - folder: { - createWithItems: defineZeroMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.folder.createWithItems.parse(args); - const now = Date.now(); - - await insertItem(tx, { - workspaceId: parsed.workspaceId, - item: toItem({ - ...parsed.folder, - lastModified: now, - }), - userId: ctx.userId, - sourceVersion: 0, - }); + }, + ), + moveMany: defineMutator( + zeroMutatorSchemas.item.moveMany, + async ({ tx, ctx, args }) => { + const now = Date.now(); - for (const itemId of parsed.itemIds) { - const existing = await loadItem(tx, { - workspaceId: parsed.workspaceId, - itemId, - }); + for (const itemId of args.itemIds) { + const existing = await loadItem(tx, { + workspaceId: args.workspaceId, + itemId, + }); - if (!existing) { - throw new ApplicationError(`Workspace item ${itemId} was not found.`); + if (!existing) { + throw new ApplicationError( + `Workspace item ${itemId} was not found.`, + ); + } + + await upsertItem(tx, { + workspaceId: args.workspaceId, + userId: ctx.userId, + sourceVersion: existing.sourceVersion, + item: { + ...existing.item, + folderId: args.folderId ?? undefined, + layout: undefined, + lastModified: now, + }, + }); } + }, + ), + }, + folder: { + createWithItems: defineMutator( + zeroMutatorSchemas.folder.createWithItems, + async ({ tx, ctx, args }) => { + const now = Date.now(); - await upsertItem(tx, { - workspaceId: parsed.workspaceId, - userId: ctx.userId, - sourceVersion: existing.sourceVersion, - item: { - ...existing.item, - folderId: parsed.folder.id, - layout: undefined, + await insertItem(tx, { + workspaceId: args.workspaceId, + item: toItem({ + ...args.folder, lastModified: now, - }, + }), + userId: ctx.userId, + sourceVersion: 0, }); - } - }), + + for (const itemId of args.itemIds) { + const existing = await loadItem(tx, { + workspaceId: args.workspaceId, + itemId, + }); + + if (!existing) { + throw new ApplicationError( + `Workspace item ${itemId} was not found.`, + ); + } + + await upsertItem(tx, { + workspaceId: args.workspaceId, + userId: ctx.userId, + sourceVersion: existing.sourceVersion, + item: { + ...existing.item, + folderId: args.folder.id, + layout: undefined, + lastModified: now, + }, + }); + } + }, + ), }, }); diff --git a/src/lib/zero/provider.tsx b/src/lib/zero/provider.tsx index ce856a6f..95def528 100644 --- a/src/lib/zero/provider.tsx +++ b/src/lib/zero/provider.tsx @@ -2,57 +2,13 @@ import { ZeroProvider as BaseZeroProvider } from "@rocicorp/zero/react"; import type { ReactNode } from "react"; -import { useEffect, useMemo, useState } from "react"; +import { useEffect, useMemo } from "react"; import { useSession } from "@/lib/auth-client"; import { destroyZero, getZero } from "./client"; export function ZeroProvider({ children }: { children: ReactNode }) { const { data: session, isPending } = useSession(); const userId = session?.user?.id ?? null; - const [token, setToken] = useState(null); - - useEffect(() => { - setToken(null); - - if (!userId) { - return; - } - - const controller = new AbortController(); - let refreshTimer: ReturnType | null = null; - - const fetchToken = async () => { - try { - const response = await fetch("/api/zero/token", { - credentials: "include", - signal: controller.signal, - }); - - if (!response.ok) { - throw new Error(`Failed to fetch Zero token: ${response.status}`); - } - - const data = (await response.json()) as { token?: string }; - setToken(data.token ?? null); - - refreshTimer = setTimeout(fetchToken, 55 * 60 * 1000); - } catch (error) { - if (!controller.signal.aborted) { - console.error("[zero] Failed to fetch token", error); - setToken(null); - } - } - }; - - void fetchToken(); - - return () => { - controller.abort(); - if (refreshTimer) { - clearTimeout(refreshTimer); - } - }; - }, [userId]); useEffect(() => { if (!userId) { @@ -61,12 +17,12 @@ export function ZeroProvider({ children }: { children: ReactNode }) { }, [userId]); const zero = useMemo(() => { - if (!userId || !token) { + if (!userId) { return null; } - return getZero({ userId, auth: token }); - }, [token, userId]); + return getZero({ userId }); + }, [userId]); if (isPending) { return null; diff --git a/src/lib/zero/queries.ts b/src/lib/zero/queries.ts new file mode 100644 index 00000000..0af7b178 --- /dev/null +++ b/src/lib/zero/queries.ts @@ -0,0 +1,15 @@ +import { defineQueries, defineQuery } from "@rocicorp/zero"; +import { z } from "zod"; +import { zql } from "./zero-schema.gen"; + +export const queries = defineQueries({ + workspace: { + items: defineQuery( + z.object({ workspaceId: z.string() }), + ({ args: { workspaceId } }) => + zql.workspace_items + .where("workspaceId", workspaceId) + .related("workspaceItemContent"), + ), + }, +}); diff --git a/src/lib/zero/server-mutators.ts b/src/lib/zero/server-mutators.ts index 1707fe8e..e9672f37 100644 --- a/src/lib/zero/server-mutators.ts +++ b/src/lib/zero/server-mutators.ts @@ -1,11 +1,12 @@ import { ApplicationError, type Transaction, - defineMutatorWithType, - defineMutatorsWithType, + defineMutator, + defineMutators, } from "@rocicorp/zero"; import type { DrizzleTransaction } from "@rocicorp/zero/server/adapters/drizzle"; import { and, eq } from "drizzle-orm"; +import { z } from "zod"; import { db } from "@/lib/db/client"; import { workspaceCollaborators, @@ -18,18 +19,17 @@ import { buildWorkspaceItemTableRows, rehydrateWorkspaceItem, } from "@/lib/workspace/workspace-item-model"; -import { mutators, zeroMutatorSchemas } from "./mutators"; -import type { ZeroContext } from "./client"; +import { mutators as sharedMutators, zeroMutatorSchemas } from "./mutators"; import { schema } from "./zero-schema.gen"; -const defineServerMutator = defineMutatorWithType< - typeof schema, - ZeroContext, - DrizzleTransaction ->(); -const defineServerMutators = defineMutatorsWithType(); type ServerZeroTx = Transaction>; +type WorkspaceArgs = { workspaceId: string }; + +type SharedServerMutator = { + fn: (params: { tx: any; ctx: any; args: any }) => Promise; +}; + async function assertWorkspaceWriteAccess( wrappedTx: DrizzleTransaction, workspaceId: string, @@ -140,14 +140,12 @@ async function syncExtractedRow( sourceData: (content.sourceData as never[] | null) ?? null, } : null, - userStates: null, }); const rows = buildWorkspaceItemTableRows({ workspaceId: params.workspaceId, item, sourceVersion: shell.sourceVersion, - userId: params.userId ?? undefined, }); await wrappedTx @@ -164,7 +162,10 @@ async function syncExtractedRow( updatedAt: new Date().toISOString(), }) .onConflictDoUpdate({ - target: [workspaceItemExtracted.workspaceId, workspaceItemExtracted.itemId], + target: [ + workspaceItemExtracted.workspaceId, + workspaceItemExtracted.itemId, + ], set: { searchText: rows.extracted.searchText, contentPreview: rows.extracted.contentPreview, @@ -194,9 +195,7 @@ async function syncExtractedRows( } } -function getWrappedTransaction( - tx: ServerZeroTx, -) { +function getWrappedTransaction(tx: ServerZeroTx) { if (tx.location !== "server") { throw new ApplicationError("Server-only mutator"); } @@ -204,140 +203,144 @@ function getWrappedTransaction( return tx.dbTransaction.wrappedTransaction; } -export const serverMutators = defineServerMutators(mutators, { - item: { - create: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.create.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.item.create.fn({ tx, ctx, args: parsed }); - await syncExtractedRows(wrappedTx, { - workspaceId: parsed.workspaceId, - itemIds: [parsed.id], - userId: ctx.userId, - }); - }), - update: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.update.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.item.update.fn({ tx, ctx, args: parsed }); +function withAuth( + schema: z.ZodType, + sharedMutator: SharedServerMutator, + getItemIds: (args: TArgs) => string[], +) { + return defineMutator(schema as any, async ({ tx, ctx, args }) => { + const validatedArgs = args as unknown as TArgs; + const wrappedTx = getWrappedTransaction(tx as ServerZeroTx); + await assertWorkspaceWriteAccess( + wrappedTx, + validatedArgs.workspaceId, + ctx.userId, + ); + await sharedMutator.fn({ tx, ctx, args: validatedArgs }); + + const itemIds = [...new Set(getItemIds(validatedArgs))]; + if (itemIds.length > 0) { await syncExtractedRows(wrappedTx, { - workspaceId: parsed.workspaceId, - itemIds: [parsed.id], + workspaceId: validatedArgs.workspaceId, + itemIds, userId: ctx.userId, }); - }), - delete: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.delete.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); + } + }); +} + +function withAuthOnly( + schema: z.ZodType, + sharedMutator: SharedServerMutator, +) { + return defineMutator(schema as any, async ({ tx, ctx, args }) => { + const validatedArgs = args as unknown as TArgs; + const wrappedTx = getWrappedTransaction(tx as ServerZeroTx); + await assertWorkspaceWriteAccess( + wrappedTx, + validatedArgs.workspaceId, + ctx.userId, + ); + await sharedMutator.fn({ tx, ctx, args: validatedArgs }); + }); +} - const [shell] = await wrappedTx - .select({ type: workspaceItems.type }) - .from(workspaceItems) - .where( - and( - eq(workspaceItems.workspaceId, parsed.workspaceId), - eq(workspaceItems.itemId, parsed.id), - ), - ) - .limit(1); +export const serverMutators = defineMutators(sharedMutators, { + item: { + create: withAuth( + zeroMutatorSchemas.item.create, + sharedMutators.item.create, + (args) => [args.id], + ), + update: withAuth( + zeroMutatorSchemas.item.update, + sharedMutators.item.update, + (args) => [args.id], + ), + delete: defineMutator( + zeroMutatorSchemas.item.delete, + async ({ tx, ctx, args }) => { + const wrappedTx = getWrappedTransaction(tx as ServerZeroTx); + await assertWorkspaceWriteAccess( + wrappedTx, + args.workspaceId, + ctx.userId, + ); - let childIds: string[] = []; - if (shell?.type === "folder") { - const children = await wrappedTx - .select({ itemId: workspaceItems.itemId }) + const [shell] = await wrappedTx + .select({ type: workspaceItems.type }) .from(workspaceItems) .where( and( - eq(workspaceItems.workspaceId, parsed.workspaceId), - eq(workspaceItems.folderId, parsed.id), + eq(workspaceItems.workspaceId, args.workspaceId), + eq(workspaceItems.itemId, args.id), ), - ); - childIds = children.map((child) => child.itemId); - } + ) + .limit(1); - await wrappedTx - .delete(workspaceItemExtracted) - .where( - and( - eq(workspaceItemExtracted.workspaceId, parsed.workspaceId), - eq(workspaceItemExtracted.itemId, parsed.id), - ), - ); - await mutators.item.delete.fn({ tx, ctx, args: parsed }); + let childIds: string[] = []; + if (shell?.type === "folder") { + const children = await wrappedTx + .select({ itemId: workspaceItems.itemId }) + .from(workspaceItems) + .where( + and( + eq(workspaceItems.workspaceId, args.workspaceId), + eq(workspaceItems.folderId, args.id), + ), + ); + childIds = children.map((child) => child.itemId); + } - if (childIds.length > 0) { - await syncExtractedRows(wrappedTx, { - workspaceId: parsed.workspaceId, - itemIds: childIds, - userId: ctx.userId, - }); - } - }), - createMany: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.createMany.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.item.createMany.fn({ tx, ctx, args: parsed }); - await syncExtractedRows(wrappedTx, { - workspaceId: parsed.workspaceId, - itemIds: parsed.items.map((item) => item.id), - userId: ctx.userId, - }); - }), - patchMany: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.patchMany.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.item.patchMany.fn({ tx, ctx, args: parsed }); - await syncExtractedRows(wrappedTx, { - workspaceId: parsed.workspaceId, - itemIds: parsed.updates.map((update) => update.id), - userId: ctx.userId, - }); - }), - updateMany: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.updateMany.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.item.updateMany.fn({ tx, ctx, args: parsed }); - const affectedIds = [ - ...(parsed.deletedIds ?? []), - ...(parsed.addedItems ?? []).map((item) => item.id), - ...(parsed.layoutUpdates ?? []).map((update) => update.id), - ]; - await syncExtractedRows(wrappedTx, { - workspaceId: parsed.workspaceId, - itemIds: [...new Set(affectedIds)], - userId: ctx.userId, - }); - }), - move: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.move.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.item.move.fn({ tx, ctx, args: parsed }); - }), - moveMany: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.item.moveMany.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.item.moveMany.fn({ tx, ctx, args: parsed }); - }), + await wrappedTx + .delete(workspaceItemExtracted) + .where( + and( + eq(workspaceItemExtracted.workspaceId, args.workspaceId), + eq(workspaceItemExtracted.itemId, args.id), + ), + ); + await sharedMutators.item.delete.fn({ tx, ctx, args }); + + if (childIds.length > 0) { + await syncExtractedRows(wrappedTx, { + workspaceId: args.workspaceId, + itemIds: childIds, + userId: ctx.userId, + }); + } + }, + ), + createMany: withAuth( + zeroMutatorSchemas.item.createMany, + sharedMutators.item.createMany, + (args) => args.items.map((item) => item.id), + ), + patchMany: withAuth( + zeroMutatorSchemas.item.patchMany, + sharedMutators.item.patchMany, + (args) => args.updates.map((update) => update.id), + ), + updateMany: withAuth( + zeroMutatorSchemas.item.updateMany, + sharedMutators.item.updateMany, + (args) => [ + ...(args.deletedIds ?? []), + ...(args.addedItems ?? []).map((item) => item.id), + ...(args.layoutUpdates ?? []).map((update) => update.id), + ], + ), + move: withAuthOnly(zeroMutatorSchemas.item.move, sharedMutators.item.move), + moveMany: withAuthOnly( + zeroMutatorSchemas.item.moveMany, + sharedMutators.item.moveMany, + ), }, folder: { - createWithItems: defineServerMutator(async ({ tx, ctx, args }) => { - const parsed = zeroMutatorSchemas.folder.createWithItems.parse(args); - const wrappedTx = getWrappedTransaction(tx); - await assertWorkspaceWriteAccess(wrappedTx, parsed.workspaceId, ctx.userId); - await mutators.folder.createWithItems.fn({ tx, ctx, args: parsed }); - await syncExtractedRows(wrappedTx, { - workspaceId: parsed.workspaceId, - itemIds: [parsed.folder.id, ...parsed.itemIds], - userId: ctx.userId, - }); - }), + createWithItems: withAuth( + zeroMutatorSchemas.folder.createWithItems, + sharedMutators.folder.createWithItems, + (args) => [args.folder.id, ...args.itemIds], + ), }, }); diff --git a/src/lib/zero/zero-schema.gen.ts b/src/lib/zero/zero-schema.gen.ts index 77e82ce7..41877afb 100644 --- a/src/lib/zero/zero-schema.gen.ts +++ b/src/lib/zero/zero-schema.gen.ts @@ -32,7 +32,7 @@ const workspaceItems = table("workspace_items") ocrPageCount: number().from("ocr_page_count"), hasTranscript: boolean().from("has_transcript"), sourceCount: number().from("source_count"), - createdAt: string().from("created_at").optional(), + createdAt: number().from("created_at").optional(), }) .primaryKey("workspaceId", "itemId"); @@ -75,14 +75,22 @@ const workspaceItemContentRelationships = relationships( export const schema = createSchema({ tables: [workspaceItems, workspaceItemContent], - relationships: [workspaceItemsRelationships, workspaceItemContentRelationships], + relationships: [ + workspaceItemsRelationships, + workspaceItemContentRelationships, + ], + enableLegacyQueries: false, + enableLegacyMutators: false, }); export type ZeroSchema = typeof schema; -export type WorkspaceItemsRow = Row<(typeof schema)["tables"]["workspace_items"]>; -export type WorkspaceItemContentRow = - Row<(typeof schema)["tables"]["workspace_item_content"]>; +export type WorkspaceItemsRow = Row< + (typeof schema)["tables"]["workspace_items"] +>; +export type WorkspaceItemContentRow = Row< + (typeof schema)["tables"]["workspace_item_content"] +>; export const zql = createBuilder(schema); export const builder = zql; diff --git a/src/workflows/audio-transcribe/steps/persist-result.ts b/src/workflows/audio-transcribe/steps/persist-result.ts index ec42b8fd..ee5f6494 100644 --- a/src/workflows/audio-transcribe/steps/persist-result.ts +++ b/src/workflows/audio-transcribe/steps/persist-result.ts @@ -1,95 +1,144 @@ -import { createEvent } from "@/lib/workspace/events"; -import { appendWorkspaceEventOrThrow } from "@/lib/workspace/workspace-event-store"; -import { db, workspaceItemExtracted } from "@/lib/db/client"; -import type { AudioData, Item } from "@/lib/workspace-state/types"; +import { + db, + workspaceItemContent, + workspaceItemExtracted, + workspaceItems, +} from "@/lib/db/client"; +import { and, eq } from "drizzle-orm"; import type { TranscribeResult } from "./transcribe"; -async function appendAudioEvent( - workspaceId: string, - event: ReturnType, -) { - await appendWorkspaceEventOrThrow({ - workspaceId, - event, - conflictMessage: `Version conflict appending event ${event.id} to workspace ${workspaceId}. Workflow will retry automatically.`, - }); -} - export async function persistAudioResult( workspaceId: string, itemId: string, - userId: string, + _userId: string, result: TranscribeResult, ): Promise { "use step"; - const transcriptText = result.segments - ?.map((s) => s.content) - .join("\n") || null; + const transcriptText = + result.segments?.map((s) => s.content).join("\n") || null; + const updatedAt = new Date().toISOString(); - await db - .insert(workspaceItemExtracted) - .values({ - workspaceId, - itemId, - searchText: transcriptText ?? "", - transcriptText, - transcriptSegments: result.segments as unknown as Record, - updatedAt: new Date().toISOString(), - }) - .onConflictDoUpdate({ - target: [ - workspaceItemExtracted.workspaceId, - workspaceItemExtracted.itemId, - ], - set: { - transcriptText, - transcriptSegments: result.segments as unknown as Record, + await db.transaction(async (tx) => { + await tx + .insert(workspaceItemExtracted) + .values({ + workspaceId, + itemId, searchText: transcriptText ?? "", - updatedAt: new Date().toISOString(), - }, - }); + transcriptText, + transcriptSegments: result.segments as unknown as Record< + string, + unknown + >, + updatedAt, + }) + .onConflictDoUpdate({ + target: [ + workspaceItemExtracted.workspaceId, + workspaceItemExtracted.itemId, + ], + set: { + transcriptText, + transcriptSegments: result.segments as unknown as Record< + string, + unknown + >, + searchText: transcriptText ?? "", + updatedAt, + }, + }); - const event = createEvent( - "ITEM_UPDATED", - { - id: itemId, - changes: { - data: { - summary: result.summary, - ...(typeof result.duration === "number" && - result.duration > 0 && { duration: result.duration }), - processingStatus: "complete" as const, - } satisfies Partial as Item["data"], - }, - }, - userId, - ); + await tx + .update(workspaceItems) + .set({ + processingStatus: "complete", + hasTranscript: true, + lastModified: Date.now(), + }) + .where( + and( + eq(workspaceItems.workspaceId, workspaceId), + eq(workspaceItems.itemId, itemId), + ), + ); - await appendAudioEvent(workspaceId, event); + const [contentRow] = await tx + .select({ + assetData: workspaceItemContent.assetData, + }) + .from(workspaceItemContent) + .where( + and( + eq(workspaceItemContent.workspaceId, workspaceId), + eq(workspaceItemContent.itemId, itemId), + ), + ) + .limit(1); + + const currentAssetData = + (contentRow?.assetData as Record | null) ?? {}; + + await tx + .update(workspaceItemContent) + .set({ + structuredData: { + summary: result.summary, + }, + ...(typeof result.duration === "number" && result.duration > 0 + ? { + assetData: { + ...currentAssetData, + duration: result.duration, + }, + } + : {}), + updatedAt, + }) + .where( + and( + eq(workspaceItemContent.workspaceId, workspaceId), + eq(workspaceItemContent.itemId, itemId), + ), + ); + }); } export async function persistAudioFailure( workspaceId: string, itemId: string, - userId: string, + _userId: string, error: string, ): Promise { "use step"; - const event = createEvent( - "ITEM_UPDATED", - { - id: itemId, - changes: { - data: { - processingStatus: "failed" as const, - error, - } satisfies Partial as Item["data"], - }, - }, - userId, - ); + const updatedAt = new Date().toISOString(); + + await db.transaction(async (tx) => { + await tx + .update(workspaceItems) + .set({ + processingStatus: "failed", + lastModified: Date.now(), + }) + .where( + and( + eq(workspaceItems.workspaceId, workspaceId), + eq(workspaceItems.itemId, itemId), + ), + ); - await appendAudioEvent(workspaceId, event); + await tx + .update(workspaceItemContent) + .set({ + structuredData: { error }, + updatedAt, + }) + .where( + and( + eq(workspaceItemContent.workspaceId, workspaceId), + eq(workspaceItemContent.itemId, itemId), + ), + ); + }); } diff --git a/src/workflows/ocr-dispatch/steps/persist-results.ts b/src/workflows/ocr-dispatch/steps/persist-results.ts index 8b599ba8..f95efa2e 100644 --- a/src/workflows/ocr-dispatch/steps/persist-results.ts +++ b/src/workflows/ocr-dispatch/steps/persist-results.ts @@ -1,13 +1,16 @@ -import { createEvent } from "@/lib/workspace/events"; -import { appendWorkspaceEventOrThrow } from "@/lib/workspace/workspace-event-store"; -import { db, workspaceItemExtracted } from "@/lib/db/client"; +import { + db, + workspaceItemContent, + workspaceItemExtracted, + workspaceItems, +} from "@/lib/db/client"; +import { and, eq } from "drizzle-orm"; import { getOcrPagesTextContent } from "@/lib/utils/ocr-pages"; import type { OcrItemResult } from "@/lib/ocr/types"; -import type { ImageData, Item, PdfData } from "@/lib/workspace-state/types"; export async function persistOcrResults( workspaceId: string, - userId: string, + _userId: string, results: OcrItemResult[], ): Promise { "use step"; @@ -15,61 +18,84 @@ export async function persistOcrResults( for (const result of results) { const ocrPages = result.ok ? result.pages : []; const ocrText = getOcrPagesTextContent(ocrPages) || null; + const updatedAt = new Date().toISOString(); - await db - .insert(workspaceItemExtracted) - .values({ - workspaceId, - itemId: result.itemId, - searchText: ocrText ?? "", - ocrText, - ocrPages: ocrPages as unknown as Record, - updatedAt: new Date().toISOString(), - }) - .onConflictDoUpdate({ - target: [ - workspaceItemExtracted.workspaceId, - workspaceItemExtracted.itemId, - ], - set: { + await db.transaction(async (tx) => { + await tx + .insert(workspaceItemExtracted) + .values({ + workspaceId, + itemId: result.itemId, + searchText: ocrText ?? "", ocrText, ocrPages: ocrPages as unknown as Record, - searchText: ocrText ?? "", - updatedAt: new Date().toISOString(), - }, - }); - } + updatedAt, + }) + .onConflictDoUpdate({ + target: [ + workspaceItemExtracted.workspaceId, + workspaceItemExtracted.itemId, + ], + set: { + ocrText, + ocrPages: ocrPages as unknown as Record, + searchText: ocrText ?? "", + updatedAt, + }, + }); - const event = createEvent( - "BULK_ITEMS_PATCHED", - { - updates: results.map((result) => { - const statusPatch = ( - result.ok - ? { - ocrStatus: "complete" as const, - ocrError: undefined, - } - : { - ocrStatus: "failed" as const, - ocrError: result.error, - } - ) satisfies Partial | Partial; + await tx + .update(workspaceItems) + .set({ + ocrStatus: result.ok ? "complete" : "failed", + hasOcr: result.ok && ocrPages.length > 0, + ocrPageCount: ocrPages.length, + lastModified: Date.now(), + }) + .where( + and( + eq(workspaceItems.workspaceId, workspaceId), + eq(workspaceItems.itemId, result.itemId), + ), + ); - return { - id: result.itemId, - changes: { - data: statusPatch as Item["data"], - }, - }; - }), - }, - userId, - ); + const [contentRow] = await tx + .select({ + assetData: workspaceItemContent.assetData, + }) + .from(workspaceItemContent) + .where( + and( + eq(workspaceItemContent.workspaceId, workspaceId), + eq(workspaceItemContent.itemId, result.itemId), + ), + ) + .limit(1); + + const currentAssetData = + (contentRow?.assetData as Record | null) ?? {}; + const nextAssetData = result.ok + ? (() => { + const { ocrError: _ocrError, ...rest } = currentAssetData; + return rest; + })() + : { + ...currentAssetData, + ocrError: result.error, + }; - await appendWorkspaceEventOrThrow({ - workspaceId, - event, - conflictMessage: `Version conflict appending event ${event.id} to workspace ${workspaceId}. Workflow will retry automatically.`, - }); + await tx + .update(workspaceItemContent) + .set({ + assetData: nextAssetData, + updatedAt, + }) + .where( + and( + eq(workspaceItemContent.workspaceId, workspaceId), + eq(workspaceItemContent.itemId, result.itemId), + ), + ); + }); + } }