jacobh2/F-r-ldraledigplannerare
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Separate user intent from planner output via day assertions

Browse Source 
The calendar mixed two kinds of truth in one table. `planned_leave_day` was
simultaneously the allocator's output cache, the user's override store
(`is_pinned`, plus ad-hoc rows with no `wish_id`), and the resource ledger that
analytics and the age-4 maths read. The planner therefore had to ask "am I
allowed to touch this row?" on every sync, and got it wrong at the edges.

Every user assertion is now one `day_assertion` row — a concrete `day_type`
replaces a pinned day, a row with no `wish_id` replaces an ad-hoc day, and
`day_type='none'` replaces `planned_day_exclusion`. `planned_leave_day` becomes
purely derived with a single writer, and `PlanningService.pinned_keys()` is the
single answer to "is this day pinned", used by the allocator's loader, by
`sync_plan` and by the read router alike.

On top of that, every calendar band is now a real event: an ad-hoc band opens
the same full editor as a wish-backed one and saving it promotes it to a
`LeaveWish`, so it can be named, repeated yearly, assigned to either or both
parents, and handed to the planner. "Planering" is a `moveable` toggle plus a
from/to month bound plus a separate lock/unlock action on the days themselves,
replacing a three-rung ladder whose "planner decides" rung set a search window
equal to the drawn dates and so could never move anything.

Bugs found and fixed along the way:

- The plan erased its own history. Fixed windows clip to today, so an elapsed
  auto-placed day fell into `stale_keys` and was deleted on the next sync —
  and a background sync runs on every workspace load. Past rows are now frozen
  and counted as spent.
- Migration 010's downgrade silently destroyed every pinned day and exclusion
  (`is_pinned` returned as DEFAULT 0, the exclusion table came back empty,
  exit 0, no warning). It now reconstructs both from `day_assertion`, and 009
  itemises what it cannot recover before dropping the table.
- Deleting a period left its assertions behind, locking those dates forever
  with no UI path to clear them. Wish deletion now clears them by `wish_id`.
- `DayAssertionService` and `LeaveWishService` committed multi-statement writes
  without a transaction; a crash mid-write diverged the tables or half-deleted
  a series. Both now run in a unit of work.
- A sibling year's shortfall was never surfaced: the toast only inspected the
  edited occurrence's outcome, so a fully unfunded later year rendered as an
  empty band with no warning.
- A flexible window whose bound had entirely elapsed was dropped from the
  proposal with no outcome at all. It now reports as `unplaced`.
- Unlocking a period deleted its days instead of returning them to the planner.
- The e2e global setup posted to a route deleted in this change, which would
  have failed the whole suite before its first test.

Gates: backend 938 tests / 91% coverage, frontend 1351 / 97.4 | 92.2 | 94.37 |
97.4. Migrations 009 and 010 audited against a hand-built realistic database:
the upgrade reconciles exactly and a constraint violation fails safe, leaving
the schema at 008.

Not complete. Step 4's toggle, month picker and lock/unlock action are verified
by browser walk and unit tests, but the partial-lock readout was not exercised.
`ideas.md` §7 adds a full plan for the vacation-forfeiture defect (the planner
detects expiring days and then does nothing about them) — not implemented here.
Remaining smaller items are listed in the session's restructure notes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01T4wjgbVL4HAC5Rdaw75VbV
This commit is contained in:
Jacob Hagstedt
2026-09-21 07:20:14 +02:00
parent fc90cf9a5f
commit 782415122d
101 changed files with 9542 additions and 3930 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frontend/src/hooks/usePlannedDays.test.ts
+2 -321
View File
@@ -57,43 +57,6 @@ describe('usePlannedDays', () => {
expect(api.getPlannedDays).not.toHaveBeenCalled()
})
it('adds planned day and refreshes', async () => {
const mockAdded = makePlannedLeaveDay({
id: '2',
workspaceId: 'ws1',
childId: 'child1',
parentPersonalDataUuid: 'parent1',
date: '2026-06-16',
dayType: 'vacation',
isDubbeldag: false,
})
vi.mocked(api.createPlannedDay).mockResolvedValue(mockAdded)
vi.mocked(api.getPlannedDays).mockResolvedValue([mockAdded])
renderHook(() => usePlannedDays('child1'))
await act(async () => {
// just test that add can be called; mocks handle the result
})
expect(api.createPlannedDay).not.toHaveBeenCalled() // won't be called without user action
})
it('removes planned day and refreshes', async () => {
vi.mocked(api.deletePlannedDay).mockResolvedValue(undefined)
vi.mocked(api.getPlannedDays).mockResolvedValue([])
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await result.current.remove('pd1')
})
expect(api.deletePlannedDay).toHaveBeenCalledWith('pd1')
expect(api.getPlannedDays).toHaveBeenCalled()
})
it('handles fetch error and sets error state', async () => {
const errorMessage = 'Network error'
vi.mocked(api.getPlannedDays).mockRejectedValue(new Error(errorMessage))
@@ -122,113 +85,6 @@ describe('usePlannedDays', () => {
expect(result.current.data).toBeNull()
})
it('updates planned day and refreshes', async () => {
const mockUpdated = makePlannedLeaveDay({
id: '1',
workspaceId: 'ws1',
childId: 'child1',
parentPersonalDataUuid: 'parent1',
date: '2026-06-16',
dayType: 'lagsta',
isDubbeldag: false,
})
vi.mocked(api.updatePlannedDay).mockResolvedValue(mockUpdated)
vi.mocked(api.getPlannedDays).mockResolvedValue([mockUpdated])
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await result.current.update('1', { day_type: 'lagsta' })
})
expect(api.updatePlannedDay).toHaveBeenCalledWith('1', { day_type: 'lagsta' })
expect(api.getPlannedDays).toHaveBeenCalled()
})
it('updates data after successful add', async () => {
const initialData = [
makePlannedLeaveDay({
id: '1',
workspaceId: 'ws1',
childId: 'child1',
parentPersonalDataUuid: 'parent1',
date: '2026-06-15',
dayType: 'vacation',
isDubbeldag: false,
}),
]
const newData = makePlannedLeaveDay({
id: '2',
workspaceId: 'ws1',
childId: 'child1',
parentPersonalDataUuid: 'parent1',
date: '2026-06-16',
dayType: 'vacation',
isDubbeldag: false,
})
vi.mocked(api.getPlannedDays).mockResolvedValueOnce(initialData)
vi.mocked(api.createPlannedDay).mockResolvedValue(newData)
vi.mocked(api.getPlannedDays).mockResolvedValueOnce([...initialData, newData])
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await new Promise(resolve => setTimeout(resolve, 0))
})
expect(result.current.data).toEqual(initialData)
await act(async () => {
await result.current.add({ workspace_id: 'ws1', child_id: 'child1', date: '2026-06-16', day_type: 'vacation', parent_personal_data_uuid: 'parent1' })
})
expect(result.current.data).toEqual([...initialData, newData])
})
it('updates data after successful remove', async () => {
const initialData = [
makePlannedLeaveDay({
id: '1',
workspaceId: 'ws1',
childId: 'child1',
parentPersonalDataUuid: 'parent1',
date: '2026-06-15',
dayType: 'vacation',
isDubbeldag: false,
}),
makePlannedLeaveDay({
id: '2',
workspaceId: 'ws1',
childId: 'child1',
parentPersonalDataUuid: 'parent1',
date: '2026-06-16',
dayType: 'vacation',
isDubbeldag: false,
}),
]
vi.mocked(api.getPlannedDays).mockResolvedValueOnce(initialData)
vi.mocked(api.deletePlannedDay).mockResolvedValue(undefined)
vi.mocked(api.getPlannedDays).mockResolvedValueOnce([initialData[0]!])
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await new Promise(resolve => setTimeout(resolve, 0))
})
expect(result.current.data).toEqual(initialData)
await act(async () => {
await result.current.remove('2')
})
expect(result.current.data).toEqual([initialData[0]])
})
it('refreshes data explicitly', async () => {
const mockData = [
makePlannedLeaveDay({
@@ -303,50 +159,6 @@ describe('usePlannedDays', () => {
expect(result.current.error).toBeNull()
})
it('handles add error gracefully', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.createPlannedDay).mockRejectedValue(new Error('Create failed'))
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await new Promise(resolve => setTimeout(resolve, 0))
})
let addError: Error | undefined
await act(async () => {
try {
await result.current.add({ workspace_id: 'ws1', child_id: 'child1', date: '2026-06-16', day_type: 'vacation', parent_personal_data_uuid: 'parent1' })
} catch (err) {
addError = err as Error
}
})
expect(addError?.message).toBe('Create failed')
})
it('handles update error gracefully', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.updatePlannedDay).mockRejectedValue(new Error('Update failed'))
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await new Promise(resolve => setTimeout(resolve, 0))
})
let updateError: Error | undefined
await act(async () => {
try {
await result.current.update('1', { day_type: 'lagsta' })
} catch (err) {
updateError = err as Error
}
})
expect(updateError?.message).toBe('Update failed')
})
it('discards a stale response for a previous childId (P1 stale-response guard)', async () => {
let resolveFirst: (value: ReturnType<typeof makePlannedLeaveDay>[]) => void = () => {}
let resolveSecond: (value: ReturnType<typeof makePlannedLeaveDay>[]) => void = () => {}
@@ -406,96 +218,8 @@ describe('usePlannedDays', () => {
expect(result.current.data).toEqual(child2Data)
})
it('handles remove error gracefully', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.deletePlannedDay).mockRejectedValue(new Error('Delete failed'))
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await new Promise(resolve => setTimeout(resolve, 0))
})
let removeError: Error | undefined
await act(async () => {
try {
await result.current.remove('1')
} catch (err) {
removeError = err as Error
}
})
expect(removeError?.message).toBe('Delete failed')
})
describe('plan-version invalidation', () => {
it('bumps planVersion after a successful add', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.createPlannedDay).mockResolvedValue(
makePlannedLeaveDay({ id: '1', date: '2026-06-16' }),
)
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await result.current.add({
workspace_id: 'ws1',
child_id: 'child1',
date: '2026-06-16',
day_type: 'vacation',
parent_personal_data_uuid: 'parent1',
})
})
expect(bumpPlanVersion).toHaveBeenCalledTimes(1)
})
it('bumps planVersion after a successful update', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.updatePlannedDay).mockResolvedValue(makePlannedLeaveDay({ id: '1' }))
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await result.current.update('1', { day_type: 'lagsta' })
})
expect(bumpPlanVersion).toHaveBeenCalledTimes(1)
})
it('bumps planVersion after a successful remove', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.deletePlannedDay).mockResolvedValue(undefined)
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await result.current.remove('1')
})
expect(bumpPlanVersion).toHaveBeenCalledTimes(1)
})
it('does not bump planVersion when a mutation fails', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.createPlannedDay).mockRejectedValue(new Error('boom'))
const { result } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
try {
await result.current.add({
workspace_id: 'ws1',
child_id: 'child1',
date: '2026-06-16',
day_type: 'vacation',
parent_personal_data_uuid: 'parent1',
})
} catch {
// expected
}
})
expect(bumpPlanVersion).not.toHaveBeenCalled()
})
it('refetches when planVersion changes, even without a local mutation (invalidation from another instance)', async () => {
it('refetches when planVersion changes, even without a local mutation (invalidation from another hook, e.g. useDayAssertions or usePlanSync)', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
const { rerender } = renderHook(() => usePlannedDays('child1'))
@@ -504,7 +228,7 @@ describe('usePlannedDays', () => {
})
const callCountBefore = vi.mocked(api.getPlannedDays).mock.calls.length
// Simulate another usePlannedDays instance bumping the shared counter.
// Simulate another hook (e.g. useDayAssertions) bumping the shared counter.
vi.mocked(useWorkspace).mockReturnValue(
makeWorkspaceContextValue({ planVersion: 1, bumpPlanVersion }),
)
@@ -516,48 +240,5 @@ describe('usePlannedDays', () => {
expect(vi.mocked(api.getPlannedDays).mock.calls.length).toBeGreaterThan(callCountBefore)
})
it('does not loop: bumping its own planVersion after a mutation causes one extra refetch, not repeated ones', async () => {
vi.mocked(api.getPlannedDays).mockResolvedValue([])
vi.mocked(api.createPlannedDay).mockResolvedValue(
makePlannedLeaveDay({ id: '1', date: '2026-06-16' }),
)
// bumpPlanVersion actually bumps a real counter here (rather than a
// no-op mock) so the effect's dependency genuinely changes once, the
// same way the real WorkspaceProvider would.
let planVersion = 0
vi.mocked(useWorkspace).mockImplementation(() =>
makeWorkspaceContextValue({
planVersion,
bumpPlanVersion: () => {
planVersion += 1
},
}),
)
const { result, rerender } = renderHook(() => usePlannedDays('child1'))
await act(async () => {
await result.current.add({
workspace_id: 'ws1',
child_id: 'child1',
date: '2026-06-16',
day_type: 'vacation',
parent_personal_data_uuid: 'parent1',
})
})
rerender()
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 0))
})
// Own direct fetch() after add, plus one effect-triggered refetch from
// its own bump — not an unbounded/growing number of calls.
const callCountAfterFirstSettle = vi.mocked(api.getPlannedDays).mock.calls.length
rerender()
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 0))
})
expect(vi.mocked(api.getPlannedDays).mock.calls.length).toBe(callCountAfterFirstSettle)
})
})
})