@tuturuuu/utils 0.25.2 → 0.25.4

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.25.4](https://github.com/tutur3u/platform/compare/utils-v0.25.3...utils-v0.25.4) (2026-08-21)
+
+
+### Bug Fixes
+
+* **ci:** complete dependency and Rust validation ([61e4c12](https://github.com/tutur3u/platform/commit/61e4c12ec3c90707dde63ed7469854519b3688c8))
+* **tasks:** repair resource CRUD and sorting ([de345a4](https://github.com/tutur3u/platform/commit/de345a40e2948415eaec6f2965dfd83154d83935))
+
+## [0.25.3](https://github.com/tutur3u/platform/compare/utils-v0.25.2...utils-v0.25.3) (2026-08-20)
+
+
+### Bug Fixes
+
+* **tasks:** keep optimistic creates at top ([fed3be6](https://github.com/tutur3u/platform/commit/fed3be688b954ebae8153647609cf8710b99171a))
+* **tasks:** preserve cached ticket prefixes ([59a4b31](https://github.com/tutur3u/platform/commit/59a4b3109046f910bd586aee8af3200afffcd65f))
+
 ## [0.25.2](https://github.com/tutur3u/platform/compare/utils-v0.25.1...utils-v0.25.2) (2026-08-16)
 
 

package/biome.json

@@ -1,5 +1,5 @@
 {
   "root": false,
-  "$schema": "https://biomejs.dev/schemas/2.5.8/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.5.9/schema.json",
   "extends": "//"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuturuuu/utils",
   "license": "MIT",
-  "version": "0.25.2",
+  "version": "0.25.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/tutur3u/platform",
@@ -20,40 +20,40 @@
     "@noble/ciphers": "^2.3.0",
     "@noble/hashes": "^2.3.0",
     "@tanstack/react-query": "^5.101.4",
-    "@tiptap/core": "3.30.0",
-    "@tiptap/react": "3.30.0",
+    "@tiptap/core": "3.30.2",
+    "@tiptap/react": "3.30.2",
     "@tuturuuu/google": "0.1.0",
     "@tuturuuu/icons": "0.1.0",
-    "@tuturuuu/internal-api": "0.31.0",
-    "@tuturuuu/supabase": "0.5.0",
+    "@tuturuuu/internal-api": "0.31.1",
+    "@tuturuuu/supabase": "0.5.1",
     "@upstash/ratelimit": "^2.0.8",
     "@upstash/redis": "^1.38.2",
     "clsx": "^2.1.1",
     "date-fns": "^4.4.0",
-    "dayjs": "^1.11.21",
+    "dayjs": "^1.11.23",
     "diff": "^9.0.0",
     "effect": "^3.22.1",
     "moment": "^2.30.1",
-    "next": "^16.3.1",
+    "next": "^16.3.2",
     "prosemirror-model": "^1.25.11",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "tailwind-merge": "^3.6.0",
-    "uuid": "^14.0.1",
+    "uuid": "^14.0.2",
     "y-prosemirror": "^1.3.7",
     "yjs": "^13.6.32",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@tuturuuu/types": "0.27.0",
-    "@tuturuuu/typescript-config": "0.1.1",
+    "@tuturuuu/typescript-config": "0.1.2",
     "@types/diff": "^8.0.0",
     "@types/node": "^26.2.0",
     "@types/react": "^19.2.18",
-    "@vitejs/plugin-react": "^6.0.5",
+    "@vitejs/plugin-react": "^6.1.0",
     "typescript": "7.0.2",
-    "vite": "^8.2.1",
-    "vitest": "^4.1.10"
+    "vite": "^8.2.2",
+    "vitest": "^4.1.11"
   },
   "exports": {
     "./timezones": "./src/timezones.json",
@@ -77,5 +77,5 @@
     "./encryption": "./src/encryption/index.ts",
     "./finance": "./src/finance/index.ts"
   },
-  "packageManager": "bun@1.3.14"
+  "packageManager": "bun@1.4.0"
 }

package/src/__tests__/optimistic-task-cache.test.ts

@@ -7,7 +7,11 @@ import {
   removeOptimisticTaskFromBoardCaches,
 } from '../task-helper/optimistic-task-cache';
 
-function task(id: string, listId = 'list-1'): Task {
+function task(
+  id: string,
+  listId = 'list-1',
+  overrides: Partial<Task> = {}
+): Task {
   return {
     assignees: [],
     created_at: '2026-08-14T00:00:00.000Z',
@@ -16,6 +20,7 @@ function task(id: string, listId = 'list-1'): Task {
     list_id: listId,
     name: id,
     projects: [],
+    ...overrides,
   } as unknown as Task;
 }
 
@@ -23,7 +28,7 @@ describe('optimistic task creation cache lifecycle', () => {
   it('inserts the pending task into the board and every mounted full-task variant', () => {
     const queryClient = new QueryClient();
     const boardId = 'board-1';
-    const existingTask = task('existing');
+    const existingTask = task('existing', 'list-1', { sort_key: 1_000_000 });
     const optimisticTask = {
       ...task('optimistic-1'),
       _isOptimistic: true,
@@ -40,21 +45,78 @@ describe('optimistic task creation cache lifecycle', () => {
     insertOptimisticTaskIntoBoardCaches(queryClient, boardId, optimisticTask);
 
     expect(queryClient.getQueryData(['tasks', boardId])).toEqual([
+      expect.objectContaining({
+        id: optimisticTask.id,
+        sort_key: expect.any(Number),
+      }),
       existingTask,
-      optimisticTask,
     ]);
     expect(queryClient.getQueryData(['tasks-full', boardId])).toEqual([
+      expect.objectContaining({
+        id: optimisticTask.id,
+        sort_key: expect.any(Number),
+      }),
       existingTask,
-      optimisticTask,
     ]);
     expect(
       queryClient.getQueryData(['tasks-full', boardId, 'filtered'])
-    ).toEqual([existingTask, optimisticTask]);
+    ).toEqual([
+      expect.objectContaining({
+        id: optimisticTask.id,
+        sort_key: expect.any(Number),
+      }),
+      existingTask,
+    ]);
     expect(queryClient.getQueryData(['tasks-full', 'another-board'])).toEqual([
       existingTask,
     ]);
   });
 
+  it('orders consecutive optimistic creates above mixed local and placed external tasks', () => {
+    const queryClient = new QueryClient();
+    const boardId = 'board-1';
+    const localTask = task('local', 'list-1', { sort_key: 1_000_000 });
+    const externalTask = task('external', 'list-1', {
+      is_personal_external: true,
+      is_personal_external_default: false,
+      personal_sort_key: 500_000,
+      sort_key: 9_000_000,
+    });
+    const firstOptimisticTask = {
+      ...task('optimistic-1'),
+      _isOptimistic: true,
+    } as Task;
+    const secondOptimisticTask = {
+      ...task('optimistic-2'),
+      _isOptimistic: true,
+    } as Task;
+
+    queryClient.setQueryData(['tasks', boardId], [externalTask, localTask]);
+
+    insertOptimisticTaskIntoBoardCaches(
+      queryClient,
+      boardId,
+      firstOptimisticTask
+    );
+    insertOptimisticTaskIntoBoardCaches(
+      queryClient,
+      boardId,
+      secondOptimisticTask
+    );
+
+    const tasks = queryClient.getQueryData<Task[]>(['tasks', boardId]);
+    expect(tasks?.map(({ id }) => id)).toEqual([
+      'optimistic-2',
+      'optimistic-1',
+      'external',
+      'local',
+    ]);
+    expect(tasks?.[0]?.sort_key).toBeLessThan(tasks?.[1]?.sort_key ?? 0);
+    expect(tasks?.[1]?.sort_key).toBeLessThan(
+      externalTask.personal_sort_key ?? 0
+    );
+  });
+
   it('replaces the pending task without duplicating a realtime server task', () => {
     const queryClient = new QueryClient();
     const boardId = 'board-1';

package/src/platform-release.test.ts

@@ -7,7 +7,7 @@ import {
 
 describe('platform release metadata', () => {
   it('uses the centralized shared browser app version', () => {
-    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.39.0'); // x-release-please-version
+    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.40.2'); // x-release-please-version
   });
 
   it('preserves the source timestamp in builtAt and derives a short hash', () => {

package/src/platform-release.ts

@@ -1,6 +1,6 @@
 import { PLATFORM_BUILD_METADATA } from './generated/platform-build-metadata';
 
-export const TUTURUUU_PLATFORM_VERSION = '0.39.0'; // x-release-please-version
+export const TUTURUUU_PLATFORM_VERSION = '0.40.2'; // x-release-please-version
 
 export type PlatformBuildMetadataInput = {
   /** ISO timestamp of the source commit used for the build, not deployment time. */

package/src/task-helper/board.test.ts

@@ -0,0 +1,54 @@
+import { QueryClient } from '@tanstack/react-query';
+import type { WorkspaceTaskBoard } from '@tuturuuu/types';
+import { describe, expect, it } from 'vitest';
+import { getCachedBoardConfig, toBoardConfig } from './board';
+
+function board(overrides: Partial<WorkspaceTaskBoard> = {}) {
+  return {
+    id: 'board-1',
+    name: 'Roadmap',
+    ws_id: 'workspace-1',
+    ticket_prefix: 'VHP',
+    ...overrides,
+  } as WorkspaceTaskBoard;
+}
+
+describe('board config cache', () => {
+  it('derives the ticket prefix and estimation defaults from cached board metadata', () => {
+    expect(toBoardConfig(board())).toEqual({
+      id: 'board-1',
+      name: 'Roadmap',
+      ws_id: 'workspace-1',
+      ticket_prefix: 'VHP',
+      estimation_type: null,
+      extended_estimation: false,
+      allow_zero_estimates: false,
+      count_unestimated_issues: false,
+    });
+  });
+
+  it('finds a cached personal board by board id when its query scope uses an alias', () => {
+    const queryClient = new QueryClient();
+    queryClient.setQueryData(
+      ['task-board', 'personal', 'board-1'],
+      board({ ws_id: 'user-workspace-id' })
+    );
+
+    expect(
+      getCachedBoardConfig(queryClient, 'board-1', 'user-workspace-id')
+        ?.ticket_prefix
+    ).toBe('VHP');
+  });
+
+  it('does not reuse metadata from another board', () => {
+    const queryClient = new QueryClient();
+    queryClient.setQueryData(
+      ['task-board', 'workspace-1', 'board-2'],
+      board({ id: 'board-2' })
+    );
+
+    expect(
+      getCachedBoardConfig(queryClient, 'board-1', 'workspace-1')
+    ).toBeUndefined();
+  });
+});

package/src/task-helper/board.ts

@@ -1,4 +1,9 @@
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  type QueryClient,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query';
 import type { InternalApiClientOptions } from '@tuturuuu/internal-api/client';
 import {
   createWorkspaceTaskBoard,
@@ -162,10 +167,41 @@ export interface BoardConfig {
   ticket_prefix: string | null;
 }
 
+export function toBoardConfig(board: WorkspaceTaskBoard): BoardConfig {
+  return {
+    id: board.id,
+    name: board.name ?? null,
+    estimation_type: board.estimation_type ?? null,
+    extended_estimation: board.extended_estimation ?? false,
+    allow_zero_estimates: board.allow_zero_estimates ?? false,
+    count_unestimated_issues: board.count_unestimated_issues ?? false,
+    ws_id: board.ws_id,
+    ticket_prefix: board.ticket_prefix ?? null,
+  };
+}
+
+export function getCachedBoardConfig(
+  queryClient: Pick<QueryClient, 'getQueriesData'>,
+  boardId: string,
+  wsId: string
+): BoardConfig | undefined {
+  const boards = queryClient
+    .getQueriesData<WorkspaceTaskBoard>({ queryKey: ['task-board'] })
+    .map(([, cachedBoard]) => cachedBoard);
+  const board =
+    boards.find(
+      (cachedBoard) => cachedBoard?.id === boardId && cachedBoard.ws_id === wsId
+    ) ?? boards.find((cachedBoard) => cachedBoard?.id === boardId);
+
+  return board ? toBoardConfig(board) : undefined;
+}
+
 export function useBoardConfig(
   boardId: string | null | undefined,
   wsId: string | null | undefined
 ) {
+  const queryClient = useQueryClient();
+
   return useQuery({
     queryKey: ['board-config', wsId, boardId],
     queryFn: async () => {
@@ -179,18 +215,13 @@ export function useBoardConfig(
         return null;
       }
 
-      return {
-        id: board.id,
-        name: board.name ?? null,
-        estimation_type: board.estimation_type ?? null,
-        extended_estimation: board.extended_estimation ?? false,
-        allow_zero_estimates: board.allow_zero_estimates ?? false,
-        count_unestimated_issues: board.count_unestimated_issues ?? false,
-        ws_id: board.ws_id,
-        ticket_prefix: board.ticket_prefix ?? null,
-      } as BoardConfig;
+      return toBoardConfig(board);
     },
     enabled: Boolean(boardId && wsId),
+    placeholderData: () =>
+      boardId && wsId
+        ? getCachedBoardConfig(queryClient, boardId, wsId)
+        : undefined,
     staleTime: 10 * 60 * 1000,
     refetchOnWindowFocus: false,
   });

package/src/task-helper/optimistic-task-cache.ts

@@ -3,6 +3,58 @@ import type { Task } from '@tuturuuu/types/primitives/Task';
 
 export type OptimisticTask = Task & { _isOptimistic: true };
 
+const EMPTY_LIST_OPTIMISTIC_SORT_KEY = 1_000_000_000;
+
+function getEffectiveTaskSortKey(task: Task) {
+  if (
+    task.is_personal_external === true &&
+    task.is_personal_external_default !== true &&
+    typeof task.personal_sort_key === 'number' &&
+    Number.isFinite(task.personal_sort_key)
+  ) {
+    return task.personal_sort_key;
+  }
+
+  return typeof task.sort_key === 'number' && Number.isFinite(task.sort_key)
+    ? task.sort_key
+    : null;
+}
+
+function getOptimisticTopSortKey(
+  queryClient: QueryClient,
+  boardId: string,
+  optimisticTask: Task
+) {
+  const cachedTaskSets = queryClient.getQueriesData<Task[]>({
+    predicate: ({ queryKey }) =>
+      (queryKey[0] === 'tasks' || queryKey[0] === 'tasks-full') &&
+      queryKey[1] === boardId,
+  });
+  let minimumSortKey: number | null = null;
+
+  for (const [, tasks] of cachedTaskSets) {
+    for (const task of tasks ?? []) {
+      if (
+        task.id === optimisticTask.id ||
+        task.list_id !== optimisticTask.list_id
+      ) {
+        continue;
+      }
+
+      const sortKey = getEffectiveTaskSortKey(task);
+      if (
+        sortKey !== null &&
+        (minimumSortKey === null || sortKey < minimumSortKey)
+      ) {
+        minimumSortKey = sortKey;
+      }
+    }
+  }
+
+  if (minimumSortKey === null) return EMPTY_LIST_OPTIMISTIC_SORT_KEY;
+  return Math.max(Number.MIN_SAFE_INTEGER, minimumSortKey - 1);
+}
+
 function updateOptimisticTaskCaches(
   queryClient: QueryClient,
   boardId: string,
@@ -53,12 +105,17 @@ export function insertOptimisticTaskIntoBoardCaches(
     { revert: false }
   );
 
+  const taskAtTop = {
+    ...optimisticTask,
+    sort_key: getOptimisticTopSortKey(queryClient, boardId, optimisticTask),
+  };
+
   updateOptimisticTaskCaches(queryClient, boardId, (tasks) => {
     const currentTasks = tasks ?? [];
     if (currentTasks.some((task) => task.id === optimisticTask.id)) {
       return currentTasks;
     }
-    return [...currentTasks, optimisticTask];
+    return [taskAtTop, ...currentTasks];
   });
 }
 

package/src/task-helper/task-sort.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import {
+  parseTaskSortBy,
+  type SortableTask,
+  sortTasksByCriterion,
+} from './task-sort';
+
+const task = (
+  id: string,
+  values: Partial<SortableTask> = {}
+): SortableTask => ({
+  id,
+  name: id,
+  created_at: '2026-01-01T00:00:00.000Z',
+  ...values,
+});
+
+describe('sortTasksByCriterion', () => {
+  it('accepts only supported server and client sort criteria', () => {
+    expect(parseTaskSortBy('priority-high')).toBe('priority-high');
+    expect(parseTaskSortBy('unknown')).toBeUndefined();
+    expect(parseTaskSortBy(null)).toBeUndefined();
+  });
+
+  it('sorts every priority direction with unset priorities last', () => {
+    const tasks = [
+      task('none'),
+      task('high', { priority: 'high' }),
+      task('low', { priority: 'low' }),
+      task('critical', { priority: 'critical' }),
+      task('normal', { priority: 'normal' }),
+    ];
+
+    expect(
+      sortTasksByCriterion(tasks, 'priority-high').map(({ id }) => id)
+    ).toEqual(['critical', 'high', 'normal', 'low', 'none']);
+    expect(
+      sortTasksByCriterion(tasks, 'priority-low').map(({ id }) => id)
+    ).toEqual(['low', 'normal', 'high', 'critical', 'none']);
+  });
+
+  it('keeps missing due dates and estimations last in both directions', () => {
+    const tasks = [
+      task('none'),
+      task('invalid', { end_date: 'not-a-date' }),
+      task('early', {
+        end_date: '2026-01-02T00:00:00.000Z',
+        estimation_points: 1,
+      }),
+      task('late', {
+        end_date: '2026-01-03T00:00:00.000Z',
+        estimation_points: 8,
+      }),
+    ];
+
+    expect(
+      sortTasksByCriterion(tasks, 'due-date-desc').map(({ id }) => id)
+    ).toEqual(['late', 'early', 'invalid', 'none']);
+    expect(
+      sortTasksByCriterion(tasks, 'estimation-low').map(({ id }) => id)
+    ).toEqual(['early', 'late', 'invalid', 'none']);
+  });
+
+  it('uses newest creation time and then id as stable tie-breakers', () => {
+    const tasks = [
+      task('b', { priority: 'high' }),
+      task('c', {
+        priority: 'high',
+        created_at: '2026-01-02T00:00:00.000Z',
+      }),
+      task('a', { priority: 'high' }),
+    ];
+
+    expect(
+      sortTasksByCriterion(tasks, 'priority-high').map(({ id }) => id)
+    ).toEqual(['c', 'a', 'b']);
+  });
+});

package/src/task-helper/task-sort.ts

@@ -0,0 +1,162 @@
+import type { TaskPriority } from '@tuturuuu/types/primitives/Priority';
+
+export type TaskSortBy =
+  | 'name-asc'
+  | 'name-desc'
+  | 'priority-high'
+  | 'priority-low'
+  | 'due-date-asc'
+  | 'due-date-desc'
+  | 'created-date-desc'
+  | 'created-date-asc'
+  | 'estimation-high'
+  | 'estimation-low';
+
+export type SortableTask = {
+  id: string;
+  name: string;
+  priority?: TaskPriority | null;
+  end_date?: string | null;
+  created_at?: string | null;
+  estimation_points?: number | null;
+};
+
+export function parseTaskSortBy(value: string | null) {
+  switch (value) {
+    case 'name-asc':
+    case 'name-desc':
+    case 'priority-high':
+    case 'priority-low':
+    case 'due-date-asc':
+    case 'due-date-desc':
+    case 'created-date-desc':
+    case 'created-date-asc':
+    case 'estimation-high':
+    case 'estimation-low':
+      return value satisfies TaskSortBy;
+    default:
+      return undefined;
+  }
+}
+
+const PRIORITY_RANK: Record<TaskPriority, number> = {
+  critical: 0,
+  high: 1,
+  normal: 2,
+  low: 3,
+};
+
+function compareNullable<T>(
+  a: T | null | undefined,
+  b: T | null | undefined,
+  compare: (left: T, right: T) => number
+) {
+  if (a == null && b == null) return 0;
+  if (a == null) return 1;
+  if (b == null) return -1;
+  return compare(a, b);
+}
+
+function compareText(a: string, b: string) {
+  const left = a.toLowerCase();
+  const right = b.toLowerCase();
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function getTimestamp(value: string | null | undefined) {
+  if (!value) return null;
+  const timestamp = new Date(value).getTime();
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function compareCreatedFallback(a: SortableTask, b: SortableTask) {
+  const created = compareNullable(
+    getTimestamp(a.created_at),
+    getTimestamp(b.created_at),
+    (left, right) => right - left
+  );
+  return created || a.id.localeCompare(b.id);
+}
+
+export function compareTasksByCriterion(
+  a: SortableTask,
+  b: SortableTask,
+  sortBy: TaskSortBy
+) {
+  let result = 0;
+
+  switch (sortBy) {
+    case 'name-asc':
+      result = compareText(a.name, b.name);
+      break;
+    case 'name-desc':
+      result = compareText(b.name, a.name);
+      break;
+    case 'priority-high':
+      result = compareNullable(
+        a.priority,
+        b.priority,
+        (left, right) => PRIORITY_RANK[left] - PRIORITY_RANK[right]
+      );
+      break;
+    case 'priority-low':
+      result = compareNullable(
+        a.priority,
+        b.priority,
+        (left, right) => PRIORITY_RANK[right] - PRIORITY_RANK[left]
+      );
+      break;
+    case 'due-date-asc':
+      result = compareNullable(
+        getTimestamp(a.end_date),
+        getTimestamp(b.end_date),
+        (left, right) => left - right
+      );
+      break;
+    case 'due-date-desc':
+      result = compareNullable(
+        getTimestamp(a.end_date),
+        getTimestamp(b.end_date),
+        (left, right) => right - left
+      );
+      break;
+    case 'created-date-asc':
+      result = compareNullable(
+        getTimestamp(a.created_at),
+        getTimestamp(b.created_at),
+        (left, right) => left - right
+      );
+      break;
+    case 'created-date-desc':
+      result = compareNullable(
+        getTimestamp(a.created_at),
+        getTimestamp(b.created_at),
+        (left, right) => right - left
+      );
+      break;
+    case 'estimation-high':
+      result = compareNullable(
+        a.estimation_points,
+        b.estimation_points,
+        (left, right) => right - left
+      );
+      break;
+    case 'estimation-low':
+      result = compareNullable(
+        a.estimation_points,
+        b.estimation_points,
+        (left, right) => left - right
+      );
+      break;
+  }
+
+  return result || compareCreatedFallback(a, b);
+}
+
+export function sortTasksByCriterion<T extends SortableTask>(
+  tasks: readonly T[],
+  sortBy: TaskSortBy | null | undefined
+) {
+  if (!sortBy) return [...tasks];
+  return [...tasks].sort((a, b) => compareTasksByCriterion(a, b, sortBy));
+}

package/src/task-helper.ts

@@ -11,3 +11,4 @@ export * from './task-helper/sort-keys';
 export * from './task-helper/task-hooks-basic';
 export * from './task-helper/task-hooks-move';
 export * from './task-helper/task-operations';
+export * from './task-helper/task-sort';