@tuturuuu/utils 0.28.0 → 0.29.0

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

@@ -22,7 +22,7 @@ describe('sortTasksByCriterion', () => {
     expect(parseTaskSortBy(null)).toBeUndefined();
   });
 
-  it('sorts every priority direction with unset priorities last', () => {
+  it('sorts every priority direction with unset priorities first by default', () => {
     const tasks = [
       task('none'),
       task('high', { priority: 'high' }),
@@ -33,12 +33,31 @@ describe('sortTasksByCriterion', () => {
 
     expect(
       sortTasksByCriterion(tasks, 'priority-high').map(({ id }) => id)
-    ).toEqual(['critical', 'high', 'normal', 'low', 'none']);
+    ).toEqual(['none', 'critical', 'high', 'normal', 'low']);
     expect(
       sortTasksByCriterion(tasks, 'priority-low').map(({ id }) => id)
-    ).toEqual(['low', 'normal', 'high', 'critical', 'none']);
+    ).toEqual(['none', 'low', 'normal', 'high', 'critical']);
   });
 
+  it.each(['priority-high', 'priority-low'] as const)(
+    'keeps null and undefined priorities last when requested: %s',
+    (sortBy) => {
+      const tasks = [
+        task('null', { priority: null }),
+        task('set', { priority: 'high' }),
+        task('undefined'),
+      ];
+      expect(
+        sortTasksByCriterion(tasks, sortBy, 'last').map((t) => t.id)
+      ).toEqual(['set', 'null', 'undefined']);
+      expect(sortTasksByCriterion(tasks, sortBy).map((t) => t.id)).toEqual([
+        'null',
+        'undefined',
+        'set',
+      ]);
+    }
+  );
+
   it('keeps missing due dates and estimations last in both directions', () => {
     const tasks = [
       task('none'),

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

@@ -1,5 +1,14 @@
 import type { TaskPriority } from '@tuturuuu/types/primitives/Priority';
 
+export const TASK_UNPRIORITIZED_POSITION_CONFIG_ID =
+  'TASK_UNPRIORITIZED_POSITION';
+export type UnprioritizedPosition = 'first' | 'last';
+export function normalizeUnprioritizedPosition(
+  value: unknown
+): UnprioritizedPosition {
+  return value === 'last' ? 'last' : 'first';
+}
+
 export type TaskSortBy =
   | 'name-asc'
   | 'name-desc'
@@ -78,11 +87,29 @@ function compareCreatedFallback(a: SortableTask, b: SortableTask) {
   return created || a.id.localeCompare(b.id);
 }
 
+export function compareUnprioritizedPlacement(
+  a: TaskPriority | null | undefined,
+  b: TaskPriority | null | undefined,
+  position: UnprioritizedPosition = 'first'
+) {
+  if ((a == null) === (b == null)) return 0;
+  return (a == null ? -1 : 1) * (position === 'first' ? 1 : -1);
+}
+
 export function compareTasksByCriterion(
   a: SortableTask,
   b: SortableTask,
-  sortBy: TaskSortBy
+  sortBy: TaskSortBy,
+  unprioritizedPosition: UnprioritizedPosition = 'first'
 ) {
+  if (sortBy === 'priority-high' || sortBy === 'priority-low') {
+    const placement = compareUnprioritizedPlacement(
+      a.priority,
+      b.priority,
+      unprioritizedPosition
+    );
+    if (placement) return placement;
+  }
   let result = 0;
 
   switch (sortBy) {
@@ -155,8 +182,11 @@ export function compareTasksByCriterion(
 
 export function sortTasksByCriterion<T extends SortableTask>(
   tasks: readonly T[],
-  sortBy: TaskSortBy | null | undefined
+  sortBy: TaskSortBy | null | undefined,
+  unprioritizedPosition: UnprioritizedPosition = 'first'
 ) {
   if (!sortBy) return [...tasks];
-  return [...tasks].sort((a, b) => compareTasksByCriterion(a, b, sortBy));
+  return [...tasks].sort((a, b) =>
+    compareTasksByCriterion(a, b, sortBy, unprioritizedPosition)
+  );
 }

package/src/workspace-helper.ts

@@ -702,7 +702,6 @@ export async function resolveWorkspaceIdForPrincipal({
   if (wsId.trim().toLowerCase() !== PERSONAL_WORKSPACE_SLUG) {
     return normalizeWorkspaceId(wsId, authorizationClient);
   }
-
   const { data: creatorWorkspace, error: creatorWorkspaceError } =
     await authorizationClient
       .from('workspaces')
@@ -710,7 +709,6 @@ export async function resolveWorkspaceIdForPrincipal({
       .eq('personal', true)
       .eq('creator_id', principal.id)
       .maybeSingle();
-
   if (!creatorWorkspaceError && creatorWorkspace?.id) {
     return creatorWorkspace.id;
   }
@@ -725,7 +723,9 @@ export async function resolveWorkspaceIdForPrincipal({
       .maybeSingle();
 
   if (memberWorkspaceError || !memberWorkspace?.id) {
-    throw new Error('Personal workspace not found');
+    throw creatorWorkspaceError || memberWorkspaceError
+      ? new WorkspaceResolutionError('Personal workspace lookup failed')
+      : new WorkspaceNotFoundError('Personal workspace not found');
   }
 
   return memberWorkspace.id;

package/src/workspace-limits.ts

@@ -55,7 +55,7 @@ export async function checkWorkspaceCreationLimit(
       canCreate: false,
       currentCount,
       limit: MAX_WORKSPACES_FOR_FREE_USERS,
-      errorMessage: `You have reached the maximum limit of ${MAX_WORKSPACES_FOR_FREE_USERS} workspaces. Please upgrade to a paid plan or contact the Tuturuuu team for more information.`,
+      errorMessage: `You have reached the maximum limit of ${MAX_WORKSPACES_FOR_FREE_USERS} workspaces. Upgrading does not increase this account limit. Contact the Tuturuuu team if you need more workspaces.`,
       errorCode: WORKSPACE_LIMIT_ERROR_CODE,
     };
   }