feat: client/server ID split — Phase 1 (DB shim + API)

apps/expo/features/packs/utils/__tests__/computeCategories.test.ts

@@ -0,0 +1,131 @@
+import type { Pack, PackItem } from 'expo-app/features/packs/types';
+import { describe, expect, it, vi } from 'vitest';
+import { computeCategorySummaries } from '../computeCategories';
+
+vi.mock('expo-app/features/auth/store', () => ({
+  userStore: {
+    preferredWeightUnit: {
+      peek: vi.fn().mockReturnValue('g'),
+    },
+  },
+}));
+
+function makeItem(
+  overrides: Partial<PackItem> & Pick<PackItem, 'weight' | 'weightUnit'>,
+): PackItem {
+  return {
+    id: 'item-1',
+    name: 'Test Item',
+    quantity: 1,
+    category: 'Shelter',
+    consumable: false,
+    worn: false,
+    packId: 'pack-1',
+    deleted: false,
+    isAIGenerated: false,
+    ...overrides,
+  };
+}
+
+function makePack(items: PackItem[]): Pack {
+  return {
+    id: 'pack-1',
+    name: 'Test Pack',
+    category: 'hiking',
+    isPublic: false,
+    deleted: false,
+    items,
+    baseWeight: 0,
+    totalWeight: 0,
+  };
+}
+
+describe('computeCategorySummaries', () => {
+  it('returns empty array for a pack with no items', () => {
+    expect(computeCategorySummaries(makePack([]))).toEqual([]);
+  });
+
+  it('groups items under the correct category name', () => {
+    const items = [
+      makeItem({ id: 'i1', weight: 200, weightUnit: 'g', category: 'Shelter' }),
+      makeItem({ id: 'i2', weight: 300, weightUnit: 'g', category: 'Food' }),
+    ];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result).toHaveLength(2);
+    const names = result.map((c) => c.name);
+    expect(names).toContain('Shelter');
+    expect(names).toContain('Food');
+  });
+
+  it('falls back to "Other" for empty category string', () => {
+    const items = [makeItem({ id: 'i1', weight: 100, weightUnit: 'g', category: '' })];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.name).toBe('Other');
+  });
+
+  it('falls back to "Other" for whitespace-only category', () => {
+    const items = [makeItem({ id: 'i1', weight: 100, weightUnit: 'g', category: '   ' })];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.name).toBe('Other');
+  });
+
+  it('computes weight in preferred unit (grams)', () => {
+    const items = [makeItem({ weight: 500, weightUnit: 'g', category: 'Pack' })];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.weight).toBe(500);
+  });
+
+  it('converts weight units before computing (kg → g)', () => {
+    const items = [makeItem({ weight: 1, weightUnit: 'kg', category: 'Pack' })];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.weight).toBe(1000);
+  });
+
+  it('multiplies weight by quantity', () => {
+    const items = [makeItem({ weight: 100, weightUnit: 'g', quantity: 3, category: 'Food' })];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.weight).toBe(300);
+  });
+
+  it('sets percentage to 100 for a single-category pack', () => {
+    const items = [makeItem({ weight: 300, weightUnit: 'g', category: 'Electronics' })];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.percentage).toBe(100);
+  });
+
+  it('splits percentage evenly across equal-weight categories', () => {
+    const items = [
+      makeItem({ id: 'i1', weight: 500, weightUnit: 'g', category: 'Shelter' }),
+      makeItem({ id: 'i2', weight: 500, weightUnit: 'g', category: 'Food' }),
+    ];
+    const result = computeCategorySummaries(makePack(items));
+    for (const cat of result) {
+      expect(cat.percentage).toBe(50);
+    }
+  });
+
+  it('counts item rows (not total quantity) in each category', () => {
+    const items = [
+      makeItem({ id: 'i1', weight: 100, weightUnit: 'g', quantity: 5, category: 'Food' }),
+      makeItem({ id: 'i2', weight: 200, weightUnit: 'g', quantity: 2, category: 'Food' }),
+    ];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.items).toBe(2);
+  });
+
+  it('merges multiple items in the same category', () => {
+    const items = [
+      makeItem({ id: 'i1', weight: 300, weightUnit: 'g', category: 'Shelter' }),
+      makeItem({ id: 'i2', weight: 200, weightUnit: 'g', category: 'Shelter' }),
+    ];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result).toHaveLength(1);
+    expect(result[0]?.weight).toBe(500);
+  });
+
+  it('sets percentage to 0 when total weight is zero', () => {
+    const items = [makeItem({ weight: 0, weightUnit: 'g', category: 'Empty' })];
+    const result = computeCategorySummaries(makePack(items));
+    expect(result[0]?.percentage).toBe(0);
+  });
+});

apps/expo/features/trips/store/trips.ts

@@ -7,10 +7,17 @@ import { apiClient } from 'expo-app/lib/api/packrat';
 import { persistPlugin } from 'expo-app/lib/persist-plugin';
 import type { TripInStore } from '../types';
 
+// The mobile `Trip` / `TripInStore` interface (apps/expo/features/trips/types.ts)
+// pre-dates the @packrat/schemas TripSchema and drifts from it (description is
+// not-nullable locally, nullable in schema). Aligning the two is part of PR 3
+// of the client-uuid-split (docs/design/client-uuid-split.md §9). For now, the
+// schema-parsed return is `unknown`-cast through `TripInStore[]` to keep
+// syncedCrud's generic happy.
 const listTrips = async () => {
   const { data, error } = await apiClient.trips.get({ query: { includePublic: 0 } });
   if (error) throw new Error(`Failed to list trips: ${error.value}`);
-  return TripSchema.array().parse(data);
+  // safe-cast: mobile TripInStore drifts from TripSchema (description nullability); aligned in PR 3.
+  return TripSchema.array().parse(data) as unknown as TripInStore[];
 };
 
 const createTrip = async (tripData: TripInStore) => {
@@ -30,7 +37,8 @@ const createTrip = async (tripData: TripInStore) => {
     localUpdatedAt: tripData.localUpdatedAt ?? new Date().toISOString(),
   });
   if (error) throw new Error(`Failed to create trip: ${error.value}`);
-  return TripSchema.parse(data);
+  // safe-cast: mobile TripInStore drifts from TripSchema; aligned in PR 3.
+  return TripSchema.parse(data) as unknown as TripInStore;
 };
 
 const updateTrip = async ({ id, ...data }: Partial<TripInStore>) => {
@@ -45,7 +53,8 @@ const updateTrip = async ({ id, ...data }: Partial<TripInStore>) => {
     ...(data.localUpdatedAt ? { localUpdatedAt: data.localUpdatedAt } : {}),
   });
   if (error) throw new Error(`Failed to update trip: ${error.value}`);
-  return TripSchema.parse(result);
+  // safe-cast: mobile TripInStore drifts from TripSchema; aligned in PR 3.
+  return TripSchema.parse(result) as unknown as TripInStore;
 };
 
 // Observable trips store

apps/expo/lib/utils/__tests__/compute-pack.test.ts

@@ -12,6 +12,7 @@ function makePackItem(
 ): PackItem {
   return {
     id: 'item-1',
+    clientUuid: 'item-1',
     name: 'Test Item',
     description: null,
     quantity: overrides.quantity ?? 1,
@@ -36,6 +37,7 @@ function makePackItem(
 function makePack(items: PackItem[] = [], overrides: Partial<PackWithItems> = {}): PackWithItems {
   return {
     id: 'pack-1',
+    clientUuid: 'pack-1',
     name: 'Test Pack',
     description: null,
     category: 'hiking',

apps/expo/lib/utils/__tests__/dateUtils.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import { formatLocalDate, parseLocalDate } from '../dateUtils';
+
+describe('parseLocalDate', () => {
+  it('returns null for undefined', () => {
+    expect(parseLocalDate(undefined)).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(parseLocalDate('')).toBeNull();
+  });
+
+  it('parses YYYY-MM-DD as a local date with correct year, month, and day', () => {
+    const result = parseLocalDate('2024-01-15');
+    expect(result).not.toBeNull();
+    expect(result?.getFullYear()).toBe(2024);
+    expect(result?.getMonth()).toBe(0); // January
+    expect(result?.getDate()).toBe(15);
+  });
+
+  it('parses end-of-year date correctly', () => {
+    const result = parseLocalDate('2023-12-31');
+    expect(result).not.toBeNull();
+    expect(result?.getFullYear()).toBe(2023);
+    expect(result?.getMonth()).toBe(11); // December
+    expect(result?.getDate()).toBe(31);
+  });
+
+  it('returns null for an invalid YYYY-MM-DD date (month 13)', () => {
+    expect(parseLocalDate('2024-13-01')).toBeNull();
+  });
+
+  it('returns null for an invalid YYYY-MM-DD date (day 32)', () => {
+    expect(parseLocalDate('2024-01-32')).toBeNull();
+  });
+
+  it('parses ISO datetime strings', () => {
+    const result = parseLocalDate('2024-06-15T10:30:00Z');
+    expect(result).not.toBeNull();
+    expect(result?.getUTCFullYear()).toBe(2024);
+    expect(result?.getUTCMonth()).toBe(5); // June
+  });
+
+  it('returns null for completely invalid input', () => {
+    expect(parseLocalDate('not-a-date')).toBeNull();
+  });
+
+  it('returns null for a non-standard pattern that looks date-like', () => {
+    expect(parseLocalDate('foo-bar-baz')).toBeNull();
+  });
+
+  it('YYYY-MM-DD parses as local time (not UTC)', () => {
+    const result = parseLocalDate('2024-03-10');
+    expect(result).not.toBeNull();
+    // date-fns parse() with 'yyyy-MM-dd' sets hours to 0 in local time
+    expect(result?.getHours()).toBe(0);
+    expect(result?.getMinutes()).toBe(0);
+  });
+});
+
+describe('formatLocalDate', () => {
+  it('returns em dash for undefined', () => {
+    expect(formatLocalDate(undefined)).toBe('—');
+  });
+
+  it('returns em dash for empty string', () => {
+    expect(formatLocalDate('')).toBe('—');
+  });
+
+  it('returns a non-empty locale string for a valid YYYY-MM-DD date', () => {
+    const result = formatLocalDate('2024-01-15');
+    expect(result).not.toBe('—');
+    expect(typeof result).toBe('string');
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  it('returns em dash for a completely invalid date string', () => {
+    expect(formatLocalDate('not-a-date')).toBe('—');
+  });
+
+  it('returns a formatted string for ISO datetime', () => {
+    const result = formatLocalDate('2024-06-15T10:30:00Z');
+    expect(result).not.toBe('—');
+    expect(typeof result).toBe('string');
+  });
+
+  it('returns a formatted string for end-of-year date', () => {
+    const result = formatLocalDate('2023-12-31');
+    expect(result).not.toBe('—');
+    expect(typeof result).toBe('string');
+  });
+});