@tuturuuu/ui 0.6.1 → 0.7.0

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/task-api.test.ts

@@ -0,0 +1,171 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const internalApiMocks = vi.hoisted(() => ({
+  abortWorkspaceTaskDescriptionChunks: vi.fn(),
+  appendWorkspaceTaskDescriptionChunk: vi.fn(),
+  beginWorkspaceTaskDescriptionChunks: vi.fn(),
+  commitWorkspaceTaskDescriptionChunks: vi.fn(),
+  createWorkspaceTaskProject: vi.fn(),
+  getWorkspaceTask: vi.fn(),
+  getWorkspaceTaskDescription: vi.fn(),
+  updateWorkspaceTask: vi.fn(),
+  updateWorkspaceTaskDescription: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/internal-api/tasks', () => internalApiMocks);
+
+import {
+  shouldChunkTaskDescriptionPayload,
+  updateWorkspaceTaskDescription,
+} from './task-api';
+
+describe('task-api description persistence', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    internalApiMocks.abortWorkspaceTaskDescriptionChunks.mockResolvedValue({
+      success: true,
+    });
+    internalApiMocks.appendWorkspaceTaskDescriptionChunk.mockResolvedValue({
+      success: true,
+    });
+    internalApiMocks.beginWorkspaceTaskDescriptionChunks.mockResolvedValue({
+      session_id: 'chunk-session-1',
+    });
+    internalApiMocks.commitWorkspaceTaskDescriptionChunks.mockResolvedValue({
+      description: 'persisted',
+      description_yjs_state: [1, 2, 3],
+    });
+    internalApiMocks.updateWorkspaceTaskDescription.mockResolvedValue({
+      description: 'small',
+      description_yjs_state: [1, 2, 3],
+    });
+  });
+
+  it('uses the direct description update for small payloads', async () => {
+    const payload = {
+      description: JSON.stringify({
+        type: 'doc',
+        content: [{ type: 'paragraph', content: [{ text: 'Small' }] }],
+      }),
+      description_yjs_state: [1, 2, 3],
+    };
+
+    await expect(
+      updateWorkspaceTaskDescription('ws-1', 'task-1', payload)
+    ).resolves.toEqual({
+      description: 'small',
+      description_yjs_state: [1, 2, 3],
+    });
+
+    expect(
+      internalApiMocks.updateWorkspaceTaskDescription
+    ).toHaveBeenCalledWith('ws-1', 'task-1', payload);
+    expect(
+      internalApiMocks.beginWorkspaceTaskDescriptionChunks
+    ).not.toHaveBeenCalled();
+  });
+
+  it('uploads large description updates through ordered chunks', async () => {
+    const yjsState = Array.from({ length: 220_000 }, (_, index) => index % 256);
+    const payload = {
+      description: JSON.stringify({
+        type: 'doc',
+        content: [
+          {
+            type: 'paragraph',
+            content: [{ type: 'text', text: 'Large paste' }],
+          },
+        ],
+      }),
+      description_yjs_state: yjsState,
+    };
+
+    expect(shouldChunkTaskDescriptionPayload(payload)).toBe(true);
+
+    await updateWorkspaceTaskDescription('ws-1', 'task-1', payload);
+
+    expect(
+      internalApiMocks.updateWorkspaceTaskDescription
+    ).not.toHaveBeenCalled();
+    expect(
+      internalApiMocks.beginWorkspaceTaskDescriptionChunks
+    ).toHaveBeenCalledWith(
+      'ws-1',
+      'task-1',
+      expect.objectContaining({
+        description: expect.objectContaining({
+          chunk_count: 1,
+        }),
+        description_yjs_state: expect.objectContaining({
+          chunk_count: expect.any(Number),
+        }),
+      })
+    );
+
+    const appendCalls =
+      internalApiMocks.appendWorkspaceTaskDescriptionChunk.mock.calls;
+    expect(appendCalls.length).toBeGreaterThan(2);
+    expect(appendCalls[0]).toEqual([
+      'ws-1',
+      'task-1',
+      expect.objectContaining({
+        chunk_index: 0,
+        field: 'description',
+        session_id: 'chunk-session-1',
+      }),
+    ]);
+    expect(
+      appendCalls
+        .filter((call) => call[2].field === 'description_yjs_state')
+        .map((call) => call[2].chunk_index)
+    ).toEqual(
+      appendCalls
+        .filter((call) => call[2].field === 'description_yjs_state')
+        .map((_, index) => index)
+    );
+    expect(
+      internalApiMocks.commitWorkspaceTaskDescriptionChunks
+    ).toHaveBeenCalledWith('ws-1', 'task-1', 'chunk-session-1');
+  });
+
+  it('falls back to chunked upload when a direct save hits the proxy body limit', async () => {
+    internalApiMocks.updateWorkspaceTaskDescription.mockRejectedValueOnce({
+      status: 413,
+    });
+
+    await updateWorkspaceTaskDescription('ws-1', 'task-1', {
+      description: 'small enough to try directly',
+      description_yjs_state: [1, 2, 3],
+    });
+
+    expect(
+      internalApiMocks.beginWorkspaceTaskDescriptionChunks
+    ).toHaveBeenCalled();
+    expect(
+      internalApiMocks.commitWorkspaceTaskDescriptionChunks
+    ).toHaveBeenCalled();
+  });
+
+  it('aborts the chunk session when an append fails', async () => {
+    internalApiMocks.appendWorkspaceTaskDescriptionChunk.mockRejectedValueOnce(
+      new Error('network down')
+    );
+
+    await expect(
+      updateWorkspaceTaskDescription('ws-1', 'task-1', {
+        description: 'x'.repeat(10),
+        description_yjs_state: Array.from(
+          { length: 220_000 },
+          (_, index) => index % 256
+        ),
+      })
+    ).rejects.toThrow('network down');
+
+    expect(
+      internalApiMocks.abortWorkspaceTaskDescriptionChunks
+    ).toHaveBeenCalledWith('ws-1', 'task-1', 'chunk-session-1');
+    expect(
+      internalApiMocks.commitWorkspaceTaskDescriptionChunks
+    ).not.toHaveBeenCalled();
+  });
+});

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/task-api.ts

@@ -1,11 +1,27 @@
 import {
+  abortWorkspaceTaskDescriptionChunks,
+  appendWorkspaceTaskDescriptionChunk,
+  beginWorkspaceTaskDescriptionChunks,
+  commitWorkspaceTaskDescriptionChunks,
   createWorkspaceTaskProject,
   getWorkspaceTask,
+  getWorkspaceTaskDescription,
+  updateWorkspaceTaskDescription as updateWorkspaceTaskDescriptionViaApi,
   updateWorkspaceTask as updateWorkspaceTaskViaApi,
+  type WorkspaceTaskDescriptionChunkField,
+  type WorkspaceTaskDescriptionChunkFields,
+  type WorkspaceTaskDescriptionResponse,
+  type WorkspaceTaskDescriptionUpdatePayload,
   type WorkspaceTaskUpdatePayload,
 } from '@tuturuuu/internal-api/tasks';
 import type { WorkspaceTaskLabel } from '../types';
 
+const TASK_DESCRIPTION_DIRECT_BODY_LIMIT_BYTES = 192 * 1024;
+const TASK_DESCRIPTION_CHUNK_TEXT_LENGTH = 96 * 1024;
+const TASK_DESCRIPTION_TOO_LARGE_MESSAGE =
+  'Description content is too large. Please shorten it or split it into smaller documents.';
+const textEncoder = new TextEncoder();
+
 async function getErrorMessage(
   response: Response,
   fallback: string,
@@ -38,59 +54,207 @@ export async function fetchWorkspaceTask(wsId: string, taskId: string) {
   return getWorkspaceTask(wsId, taskId);
 }
 
-interface TaskDescriptionResponse {
-  description: string | null;
-  description_yjs_state: number[] | null;
-}
-
 export async function fetchWorkspaceTaskDescription(
   wsId: string,
   taskId: string
 ) {
-  const requestPath = `/api/v1/workspaces/${wsId}/tasks/${taskId}/description`;
-  const response = await fetch(requestPath, {
-    method: 'GET',
-    cache: 'no-store',
-  });
+  return getWorkspaceTaskDescription(wsId, taskId);
+}
 
-  if (!response.ok) {
-    throw new Error(
-      await getErrorMessage(response, 'Failed to fetch task description', {
-        requestPath,
-      })
+export async function updateWorkspaceTaskDescription(
+  wsId: string,
+  taskId: string,
+  payload: WorkspaceTaskDescriptionUpdatePayload
+) {
+  if (shouldChunkTaskDescriptionPayload(payload)) {
+    return updateWorkspaceTaskDescriptionChunked(wsId, taskId, payload);
+  }
+
+  try {
+    return await updateWorkspaceTaskDescriptionViaApi(wsId, taskId, payload);
+  } catch (error) {
+    if (isPayloadTooLargeError(error)) {
+      return updateWorkspaceTaskDescriptionChunked(wsId, taskId, payload);
+    }
+
+    throw normalizeTaskDescriptionError(
+      error,
+      'Failed to update task description'
     );
   }
+}
 
-  return (await response.json()) as TaskDescriptionResponse;
+export function shouldChunkTaskDescriptionPayload(
+  payload: WorkspaceTaskDescriptionUpdatePayload
+) {
+  return getJsonByteLength(payload) > TASK_DESCRIPTION_DIRECT_BODY_LIMIT_BYTES;
 }
 
-export async function updateWorkspaceTaskDescription(
+export async function updateWorkspaceTaskDescriptionChunked(
   wsId: string,
   taskId: string,
-  payload: {
-    description?: string | null;
-    description_yjs_state?: number[] | null;
+  payload: WorkspaceTaskDescriptionUpdatePayload
+): Promise<WorkspaceTaskDescriptionResponse> {
+  const chunksByField = buildTaskDescriptionChunks(payload);
+  const fields = buildTaskDescriptionChunkFields(chunksByField);
+
+  if (Object.keys(fields).length === 0) {
+    return updateWorkspaceTaskDescriptionViaApi(wsId, taskId, payload);
   }
-) {
-  const requestPath = `/api/v1/workspaces/${wsId}/tasks/${taskId}/description`;
-  const response = await fetch(requestPath, {
-    method: 'PATCH',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(payload),
-    cache: 'no-store',
-  });
 
-  if (!response.ok) {
-    throw new Error(
-      await getErrorMessage(response, 'Failed to update task description', {
-        requestPath,
-      })
+  const { session_id: sessionId } = await beginWorkspaceTaskDescriptionChunks(
+    wsId,
+    taskId,
+    fields
+  );
+
+  try {
+    for (const field of ['description', 'description_yjs_state'] as const) {
+      const chunks = chunksByField[field];
+      if (!chunks) continue;
+
+      for (let index = 0; index < chunks.length; index += 1) {
+        await appendWorkspaceTaskDescriptionChunk(wsId, taskId, {
+          chunk: chunks[index] ?? '',
+          chunk_index: index,
+          field,
+          session_id: sessionId,
+        });
+      }
+    }
+
+    return await commitWorkspaceTaskDescriptionChunks(wsId, taskId, sessionId);
+  } catch (error) {
+    await abortWorkspaceTaskDescriptionChunks(wsId, taskId, sessionId).catch(
+      () => undefined
+    );
+
+    throw normalizeTaskDescriptionError(
+      error,
+      'Failed to update task description'
     );
   }
+}
+
+function getJsonByteLength(value: unknown) {
+  return textEncoder.encode(JSON.stringify(value)).byteLength;
+}
+
+function isPayloadTooLargeError(error: unknown) {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'status' in error &&
+    (error as { status?: unknown }).status === 413
+  );
+}
+
+function normalizeTaskDescriptionError(error: unknown, fallback: string) {
+  if (isPayloadTooLargeError(error)) {
+    return new Error(TASK_DESCRIPTION_TOO_LARGE_MESSAGE);
+  }
+
+  return error instanceof Error ? error : new Error(fallback);
+}
+
+function splitStringIntoChunks(value: string) {
+  const chunks: string[] = [];
+
+  for (
+    let index = 0;
+    index < value.length;
+    index += TASK_DESCRIPTION_CHUNK_TEXT_LENGTH
+  ) {
+    chunks.push(value.slice(index, index + TASK_DESCRIPTION_CHUNK_TEXT_LENGTH));
+  }
+
+  return chunks.length > 0 ? chunks : [''];
+}
+
+function bytesToBase64(bytes: number[]) {
+  const byteArray = Uint8Array.from(bytes);
+
+  if (typeof btoa === 'function') {
+    let binary = '';
+    const step = 0x8000;
+
+    for (let index = 0; index < byteArray.length; index += step) {
+      binary += String.fromCharCode(...byteArray.subarray(index, index + step));
+    }
+
+    return btoa(binary);
+  }
+
+  const nodeBuffer = (
+    globalThis as typeof globalThis & {
+      Buffer?: {
+        from: (value: Uint8Array) => {
+          toString: (encoding: 'base64') => string;
+        };
+      };
+    }
+  ).Buffer;
+
+  if (!nodeBuffer) {
+    throw new Error('Unable to encode task description state.');
+  }
+
+  return nodeBuffer.from(byteArray).toString('base64');
+}
+
+function buildTaskDescriptionChunks(
+  payload: WorkspaceTaskDescriptionUpdatePayload
+): Partial<Record<WorkspaceTaskDescriptionChunkField, string[] | null>> {
+  const chunks: Partial<
+    Record<WorkspaceTaskDescriptionChunkField, string[] | null>
+  > = {};
+
+  if ('description' in payload) {
+    chunks.description =
+      payload.description === null
+        ? null
+        : splitStringIntoChunks(payload.description ?? '');
+  }
+
+  if ('description_yjs_state' in payload) {
+    chunks.description_yjs_state =
+      payload.description_yjs_state === null
+        ? null
+        : splitStringIntoChunks(
+            bytesToBase64(payload.description_yjs_state ?? [])
+          );
+  }
+
+  return chunks;
+}
+
+function buildTaskDescriptionChunkFields(
+  chunksByField: Partial<
+    Record<WorkspaceTaskDescriptionChunkField, string[] | null>
+  >
+) {
+  const fields: WorkspaceTaskDescriptionChunkFields = {};
+
+  for (const field of ['description', 'description_yjs_state'] as const) {
+    const chunks = chunksByField[field];
+    if (chunks === undefined) continue;
+
+    if (chunks === null) {
+      fields[field] = {
+        chunk_count: 0,
+        is_null: true,
+        total_length: 0,
+      };
+      continue;
+    }
+
+    fields[field] = {
+      chunk_count: chunks.length,
+      total_length: chunks.join('').length,
+    };
+  }
 
-  return (await response.json()) as TaskDescriptionResponse;
+  return fields;
 }
 
 export async function createWorkspaceLabel(

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-save.ts

@@ -34,6 +34,7 @@ import {
   updateTaskDescriptionCaches,
 } from '../utils';
 import {
+  shouldChunkTaskDescriptionPayload,
   updateWorkspaceTask,
   updateWorkspaceTaskDescription,
 } from './task-api';
@@ -945,9 +946,17 @@ export async function handleCreateTask({
       ];
     }
 
+    const createDescriptionPayload = {
+      description: descriptionString || '',
+      description_yjs_state: descriptionYjsState ?? undefined,
+    };
+    const shouldDeferDescription = shouldChunkTaskDescriptionPayload(
+      createDescriptionPayload
+    );
+
     const taskData: Partial<Task> = {
       name: name.trim(),
-      description: descriptionString || '',
+      description: shouldDeferDescription ? '' : descriptionString || '',
       priority: priority,
       start_date: startDate ? startDate.toISOString() : undefined,
       end_date: endDate ? endDate.toISOString() : undefined,
@@ -957,7 +966,9 @@ export async function handleCreateTask({
     };
     const newTask = await createTask(wsId, selectedListId, {
       ...taskData,
-      description_yjs_state: descriptionYjsState ?? undefined,
+      description_yjs_state: shouldDeferDescription
+        ? undefined
+        : (descriptionYjsState ?? undefined),
       label_ids: selectedLabels.map((label) => label.id),
       assignee_ids: desiredAssignees
         .map((assignee) => assignee.user_id || assignee.id)
@@ -965,6 +976,14 @@ export async function handleCreateTask({
       project_ids: selectedProjects.map((project) => project.id),
     });
 
+    if (shouldDeferDescription) {
+      await updateWorkspaceTaskDescription(wsId, newTask.id, {
+        description: descriptionString,
+        description_yjs_state: descriptionYjsState,
+      });
+      newTask.description = descriptionString ?? undefined;
+    }
+
     // Save per-user scheduling settings for the creator (if any were provided)
     const hasAnySchedulingValue =
       totalDuration != null ||