Reorder whole days and insert a day (#589) (#1148)

* feat(days): reorder whole days and insert a day at a position

Adds reorderDays + insertDay to the day service and a PUT /days/reorder route
(plus an optional position on create). Day rows stay stable so a day's
assignments, notes, bookings and accommodations ride along by id; on a dated
trip the calendar dates stay pinned to their slots while the content moves
across them, and each booking's date is re-stamped onto its day's new date
(time-of-day preserved) so day_id stays consistent. Renumbering uses the
two-phase write to avoid the UNIQUE(trip_id, day_number) collision, and a move
that would invert an accommodation's check-in/out span is rejected.

* feat(planner): reorder days from a toolbar popup, and add days

A new toolbar button opens a popup listing the days; drag a row by its grip or
use the up/down arrows to reorder, and add a day from there. Reorders apply
optimistically with rollback and sync over WebSocket; the day headers are left
untouched, so the existing place drop-targets are unaffected.

* i18n: add day-reorder strings across all languages

server/src/nest/days/days.controller.ts

@@ -12,6 +12,7 @@ import {
 } from '@nestjs/common';
 import type { User } from '../../types';
 import { DaysService } from './days.service';
+import { DayReorderError } from '../../services/dayService';
 import { JwtAuthGuard } from '../auth/jwt-auth.guard';
 import { CurrentUser } from '../auth/current-user.decorator';
 
@@ -52,16 +53,47 @@ export class DaysController {
   create(
     @CurrentUser() user: User,
     @Param('tripId') tripId: string,
-    @Body() body: { date?: string; notes?: string },
+    @Body() body: { date?: string; notes?: string; position?: number },
     @Headers('x-socket-id') socketId?: string,
   ) {
     const trip = this.requireTrip(tripId, user);
     this.requireEdit(trip, user);
-    const day = this.days.create(tripId, body.date, body.notes);
-    this.days.broadcast(tripId, 'day:created', { day }, socketId);
+    // A `position` means "insert a new empty day here" (which on a dated trip
+    // extends the trip and re-pins dates); without it, the legacy append.
+    const day = body.position !== undefined
+      ? this.days.insert(tripId, body.position)
+      : this.days.create(tripId, body.date, body.notes);
+    // An insert can shuffle dates/positions of other days, so collaborators
+    // refetch the whole list; a plain append only needs the new day.
+    const event = body.position !== undefined ? 'day:reordered' : 'day:created';
+    this.days.broadcast(tripId, event, { day }, socketId);
     return { day };
   }
 
+  @Put('reorder')
+  reorder(
+    @CurrentUser() user: User,
+    @Param('tripId') tripId: string,
+    @Body() body: { orderedIds?: number[] },
+    @Headers('x-socket-id') socketId?: string,
+  ) {
+    const trip = this.requireTrip(tripId, user);
+    this.requireEdit(trip, user);
+    if (!Array.isArray(body.orderedIds)) {
+      throw new HttpException({ error: 'orderedIds must be an array' }, 400);
+    }
+    try {
+      this.days.reorder(tripId, body.orderedIds);
+    } catch (err) {
+      if (err instanceof DayReorderError) {
+        throw new HttpException({ error: err.message }, 400);
+      }
+      throw err;
+    }
+    this.days.broadcast(tripId, 'day:reordered', { orderedIds: body.orderedIds }, socketId);
+    return { success: true };
+  }
+
   @Put(':id')
   update(
     @CurrentUser() user: User,

server/src/nest/days/days.service.ts

@@ -39,6 +39,14 @@ export class DaysService {
     return dayService.createDay(tripId, date, notes);
   }
 
+  insert(tripId: string, position?: number) {
+    return dayService.insertDay(tripId, position);
+  }
+
+  reorder(tripId: string, orderedIds: number[]) {
+    return dayService.reorderDays(tripId, orderedIds);
+  }
+
   update(id: string, current: Parameters<typeof dayService.updateDay>[1], fields: { notes?: string; title?: string | null }) {
     return dayService.updateDay(id, current, fields);
   }

server/src/services/dayService.ts

@@ -157,6 +157,220 @@ export function deleteDay(id: string | number) {
   db.prepare('DELETE FROM days WHERE id = ?').run(id);
 }
 
+// ---------------------------------------------------------------------------
+// Day reorder / insert (#589)
+//
+// Reordering keeps every day ROW stable (so assignments, notes, accommodations,
+// photos and multi-day reservation positions ride along by id) and only changes
+// each row's day_number — its position. On a dated trip the calendar dates stay
+// pinned to their slots (position i keeps the i-th date) and the day's content
+// moves across them. Because a booking's day is derived from the date part of
+// reservation_time, every booking on a day whose date changed gets that date
+// re-stamped onto the day's new date (time-of-day preserved), so day_id stays
+// consistent and the booking moves with its day.
+// ---------------------------------------------------------------------------
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+function addDays(date: string, n: number): string {
+  const [y, m, d] = date.split('-').map(Number);
+  const t = Date.UTC(y, m - 1, d) + n * MS_PER_DAY;
+  const dt = new Date(t);
+  const yyyy = dt.getUTCFullYear();
+  const mm = String(dt.getUTCMonth() + 1).padStart(2, '0');
+  const dd = String(dt.getUTCDate()).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd}`;
+}
+
+function dayDelta(from: string, to: string): number {
+  const [fy, fm, fd] = from.split('-').map(Number);
+  const [ty, tm, td] = to.split('-').map(Number);
+  return Math.round((Date.UTC(ty, tm - 1, td) - Date.UTC(fy, fm - 1, fd)) / MS_PER_DAY);
+}
+
+/** Replace the date part of an ISO-ish timestamp, keeping any time suffix. */
+function withDatePart(timestamp: string, date: string): string {
+  return date + (timestamp.length > 10 ? timestamp.slice(10) : '');
+}
+
+/**
+ * After day dates have been re-pinned, re-stamp the date of every booking on a
+ * moved day so reservation_time/reservation_end_time follow their day's new
+ * date (time-of-day preserved). Transport endpoints (flight legs) shift by the
+ * same per-booking day delta so multi-leg timing stays internally consistent.
+ */
+function restampReservationDates(
+  tripId: string | number,
+  oldDateById: Map<number, string | null>,
+  newDateById: Map<number, string | null>,
+): void {
+  const reservations = db.prepare(
+    'SELECT id, day_id, end_day_id, reservation_time, reservation_end_time FROM reservations WHERE trip_id = ?'
+  ).all(tripId) as {
+    id: number; day_id: number | null; end_day_id: number | null;
+    reservation_time: string | null; reservation_end_time: string | null;
+  }[];
+
+  const setTime = db.prepare('UPDATE reservations SET reservation_time = ? WHERE id = ?');
+  const setEndTime = db.prepare('UPDATE reservations SET reservation_end_time = ? WHERE id = ?');
+  const endpoints = db.prepare('SELECT id, local_date FROM reservation_endpoints WHERE reservation_id = ?');
+  const setEndpointDate = db.prepare('UPDATE reservation_endpoints SET local_date = ? WHERE id = ?');
+
+  for (const r of reservations) {
+    if (r.day_id != null && r.reservation_time) {
+      const oldDate = oldDateById.get(r.day_id);
+      const newDate = newDateById.get(r.day_id);
+      if (oldDate && newDate && oldDate !== newDate) {
+        setTime.run(withDatePart(r.reservation_time, newDate), r.id);
+        // Shift each transport leg's local_date by the same number of days.
+        const delta = dayDelta(oldDate, newDate);
+        if (delta !== 0) {
+          for (const ep of endpoints.all(r.id) as { id: number; local_date: string | null }[]) {
+            if (ep.local_date) setEndpointDate.run(addDays(ep.local_date, delta), ep.id);
+          }
+        }
+      }
+    }
+    if (r.end_day_id != null && r.reservation_end_time) {
+      const oldDate = oldDateById.get(r.end_day_id);
+      const newDate = newDateById.get(r.end_day_id);
+      if (oldDate && newDate && oldDate !== newDate) {
+        setEndTime.run(withDatePart(r.reservation_end_time, newDate), r.id);
+      }
+    }
+  }
+}
+
+/** A stay must not end before it begins after a reorder/insert. */
+function assertNoInvertedAccommodation(tripId: string | number): void {
+  const spans = db.prepare(`
+    SELECT a.id, s.day_number AS start_no, e.day_number AS end_no
+    FROM day_accommodations a
+    JOIN days s ON a.start_day_id = s.id
+    JOIN days e ON a.end_day_id = e.id
+    WHERE a.trip_id = ?
+  `).all(tripId) as { id: number; start_no: number; end_no: number }[];
+  for (const span of spans) {
+    if (span.start_no > span.end_no) {
+      throw new DayReorderError('This move would make an accommodation end before it starts.');
+    }
+  }
+}
+
+/** Thrown for invalid reorder/insert requests; mapped to HTTP 400 by the controller. */
+export class DayReorderError extends Error {}
+
+/**
+ * Reorder whole days. `orderedIds` is the desired full sequence of this trip's
+ * day ids (a permutation of the current ids).
+ */
+export function reorderDays(tripId: string | number, orderedIds: number[]) {
+  const rows = db.prepare(
+    'SELECT id, day_number, date FROM days WHERE trip_id = ? ORDER BY day_number'
+  ).all(tripId) as { id: number; day_number: number; date: string | null }[];
+
+  const existingIds = new Set(rows.map(r => r.id));
+  if (orderedIds.length !== rows.length || !orderedIds.every(id => existingIds.has(id))) {
+    throw new DayReorderError('orderedIds must be a permutation of the trip day ids.');
+  }
+
+  const oldDateById = new Map(rows.map(r => [r.id, r.date]));
+  // Dates stay pinned to slots: position i keeps the i-th date (ascending).
+  const sortedDates = rows.map(r => r.date).filter((d): d is string => !!d).sort();
+  const isDated = sortedDates.length > 0;
+
+  const setDayNumber = db.prepare('UPDATE days SET day_number = ? WHERE id = ?');
+  const setDayNumberAndDate = db.prepare('UPDATE days SET day_number = ?, date = ? WHERE id = ?');
+
+  db.exec('BEGIN');
+  try {
+    // Two-phase renumber to dodge UNIQUE(trip_id, day_number) collisions.
+    orderedIds.forEach((id, i) => setDayNumber.run(-(i + 1), id));
+    const newDateById = new Map<number, string | null>();
+    orderedIds.forEach((id, i) => {
+      const date = isDated ? (sortedDates[i] ?? null) : null;
+      setDayNumberAndDate.run(i + 1, date, id);
+      newDateById.set(id, date);
+    });
+
+    if (isDated) restampReservationDates(tripId, oldDateById, newDateById);
+    assertNoInvertedAccommodation(tripId);
+
+    db.exec('COMMIT');
+  } catch (e) {
+    db.exec('ROLLBACK');
+    throw e;
+  }
+
+  return listDays(tripId);
+}
+
+/**
+ * Insert a new empty day at a 1-based position (default: append at the end).
+ * On a dated trip the trip gains one calendar day: dates re-pin so the slots
+ * stay contiguous, the trip's end_date extends by one day, and bookings on
+ * shifted days have their dates re-stamped (same rules as reorderDays).
+ */
+export function insertDay(tripId: string | number, position?: number) {
+  const rows = db.prepare(
+    'SELECT id, day_number, date FROM days WHERE trip_id = ? ORDER BY day_number'
+  ).all(tripId) as { id: number; day_number: number; date: string | null }[];
+  const n = rows.length;
+  const pos = Math.min(Math.max(position ?? n + 1, 1), n + 1);
+  const datedRows = rows.filter(r => r.date) as { id: number; day_number: number; date: string }[];
+  const isDated = datedRows.length > 0;
+
+  const setDayNumber = db.prepare('UPDATE days SET day_number = ? WHERE id = ?');
+
+  if (!isDated) {
+    db.exec('BEGIN');
+    try {
+      const toShift = rows.filter(r => r.day_number >= pos);
+      toShift.forEach(r => setDayNumber.run(-r.day_number, r.id));
+      const result = db.prepare('INSERT INTO days (trip_id, day_number, date) VALUES (?, ?, NULL)').run(tripId, pos);
+      toShift.forEach(r => setDayNumber.run(r.day_number + 1, r.id));
+      db.exec('COMMIT');
+      const day = db.prepare('SELECT * FROM days WHERE id = ?').get(result.lastInsertRowid) as Day;
+      return { ...day, assignments: [], notes_items: [] };
+    } catch (e) {
+      db.exec('ROLLBACK');
+      throw e;
+    }
+  }
+
+  // Dated trip: rebuild N+1 contiguous dates from the earliest date.
+  const start = datedRows.map(r => r.date).sort()[0];
+  const dates = Array.from({ length: n + 1 }, (_, i) => addDays(start, i));
+  const oldDateById = new Map(rows.map(r => [r.id, r.date]));
+  const setDayNumberAndDate = db.prepare('UPDATE days SET day_number = ?, date = ? WHERE id = ?');
+
+  db.exec('BEGIN');
+  try {
+    rows.forEach((r, i) => setDayNumber.run(-(i + 1), r.id));
+    const result = db.prepare('INSERT INTO days (trip_id, day_number, date) VALUES (?, ?, ?)').run(tripId, pos, dates[pos - 1]);
+    const newId = Number(result.lastInsertRowid);
+
+    const orderedIds = rows.map(r => r.id);
+    orderedIds.splice(pos - 1, 0, newId);
+    const newDateById = new Map<number, string | null>();
+    orderedIds.forEach((id, i) => {
+      setDayNumberAndDate.run(i + 1, dates[i], id);
+      newDateById.set(id, dates[i]);
+    });
+
+    restampReservationDates(tripId, oldDateById, newDateById);
+    assertNoInvertedAccommodation(tripId);
+    db.prepare('UPDATE trips SET end_date = ? WHERE id = ?').run(dates[dates.length - 1], tripId);
+
+    db.exec('COMMIT');
+    const day = db.prepare('SELECT * FROM days WHERE id = ?').get(newId) as Day;
+    return { ...day, assignments: [], notes_items: [] };
+  } catch (e) {
+    db.exec('ROLLBACK');
+    throw e;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Accommodation helpers
 // ---------------------------------------------------------------------------

server/tests/integration/dayReorder.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Day reorder + insert integration tests (#589) — exercises the real
+ * dayService against the real schema. Covers: position renumber, dates pinned
+ * to slots while content rides along by id, booking-date re-stamp, permutation
+ * validation, the accommodation-inversion guard, and insert (dated + dateless).
+ */
+import { describe, it, expect, vi, beforeAll, beforeEach, afterAll } from 'vitest';
+
+const { testDb, dbMock } = vi.hoisted(() => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const Database = require('better-sqlite3');
+  const db = new Database(':memory:');
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec('PRAGMA foreign_keys = ON');
+  db.exec('PRAGMA busy_timeout = 5000');
+  return { testDb: db, dbMock: { db, closeDb: () => {}, reinitialize: () => {}, canAccessTrip: vi.fn() } };
+});
+
+vi.mock('../../src/db/database', () => dbMock);
+vi.mock('../../src/config', () => ({
+  JWT_SECRET: 'test-jwt-secret-for-trek-testing-only',
+  ENCRYPTION_KEY: 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6a7b8c9d0e1f2a3b4c5d6a7b8c9d0e1f2',
+  updateJwtSecret: () => {},
+  DEFAULT_LANGUAGE: 'en',
+}));
+
+import { createTables } from '../../src/db/schema';
+import { runMigrations } from '../../src/db/migrations';
+import { resetTestDb } from '../helpers/test-db';
+import { createUser, createTrip, createPlace, createDay, createDayAssignment, createReservation, createDayAccommodation } from '../helpers/factories';
+import { reorderDays, insertDay, DayReorderError } from '../../src/services/dayService';
+
+let userId: number;
+
+beforeAll(() => {
+  createTables(testDb);
+  runMigrations(testDb);
+});
+
+beforeEach(() => {
+  resetTestDb(testDb);
+  userId = createUser(testDb).user.id;
+});
+
+afterAll(() => testDb.close());
+
+const orderedDays = (tripId: number) =>
+  testDb.prepare('SELECT id, day_number, date FROM days WHERE trip_id = ? ORDER BY day_number').all(tripId) as
+    { id: number; day_number: number; date: string | null }[];
+
+describe('reorderDays', () => {
+  it('permutes positions, pins dates to slots, and content rides along by id', () => {
+    const trip = createTrip(testDb, userId, { start_date: '2026-03-01', end_date: '2026-03-03' });
+    const [d1, d2, d3] = orderedDays(trip.id);
+    const place = createPlace(testDb, trip.id);
+    createDayAssignment(testDb, d2.id, place.id); // place sits on day 2
+
+    // Move day 2 to the front: [d2, d1, d3]
+    reorderDays(trip.id, [d2.id, d1.id, d3.id]);
+
+    const after = orderedDays(trip.id);
+    expect(after.map(d => d.id)).toEqual([d2.id, d1.id, d3.id]);
+    // Dates stay pinned to their calendar slots
+    expect(after.map(d => d.date)).toEqual(['2026-03-01', '2026-03-02', '2026-03-03']);
+    // The place rides along with its day row (still attached to d2.id, now at slot 1)
+    const onD2 = testDb.prepare('SELECT * FROM day_assignments WHERE day_id = ?').all(d2.id);
+    expect(onD2).toHaveLength(1);
+  });
+
+  it('re-stamps a booking\'s date onto its day\'s new date, keeping the time', () => {
+    const trip = createTrip(testDb, userId, { start_date: '2026-03-01', end_date: '2026-03-03' });
+    const [d1, d2, d3] = orderedDays(trip.id);
+    const res = createReservation(testDb, trip.id, { day_id: d2.id, type: 'restaurant' });
+    testDb.prepare('UPDATE reservations SET reservation_time = ? WHERE id = ?').run('2026-03-02T19:00', res.id);
+
+    reorderDays(trip.id, [d2.id, d1.id, d3.id]); // d2 moves to the 2026-03-01 slot
+
+    const r = testDb.prepare('SELECT reservation_time FROM reservations WHERE id = ?').get(res.id) as { reservation_time: string };
+    expect(r.reservation_time).toBe('2026-03-01T19:00');
+  });
+
+  it('rejects an orderedIds list that is not a permutation of the trip days', () => {
+    const trip = createTrip(testDb, userId, { start_date: '2026-03-01', end_date: '2026-03-03' });
+    const [d1, d2] = orderedDays(trip.id);
+    expect(() => reorderDays(trip.id, [d1.id, d2.id])).toThrow(DayReorderError);
+  });
+
+  it('blocks a move that would make an accommodation end before it starts, and rolls back', () => {
+    const trip = createTrip(testDb, userId, { start_date: '2026-03-01', end_date: '2026-03-03' });
+    const [d1, d2, d3] = orderedDays(trip.id);
+    const place = createPlace(testDb, trip.id);
+    createDayAccommodation(testDb, trip.id, place.id, d1.id, d2.id); // stay spans day 1 -> day 2
+
+    // Put the start day (d1) after the end day (d2): [d2, d3, d1]
+    expect(() => reorderDays(trip.id, [d2.id, d3.id, d1.id])).toThrow(DayReorderError);
+
+    // Transaction rolled back: original order intact
+    expect(orderedDays(trip.id).map(d => d.id)).toEqual([d1.id, d2.id, d3.id]);
+  });
+});
+
+describe('insertDay', () => {
+  it('inserts an empty day at a position on a dateless trip and shifts the rest', () => {
+    const trip = createTrip(testDb, userId);
+    const d1 = createDay(testDb, trip.id);
+    const d2 = createDay(testDb, trip.id);
+    const d3 = createDay(testDb, trip.id);
+
+    const created = insertDay(trip.id, 1);
+
+    const after = orderedDays(trip.id);
+    expect(after).toHaveLength(4);
+    expect(after[0].id).toBe(created.id);
+    expect(after[0].date).toBeNull();
+    expect(after.slice(1).map(d => d.id)).toEqual([d1.id, d2.id, d3.id]);
+  });
+
+  it('inserts at the front of a dated trip: dates stay contiguous and the trip extends', () => {
+    const trip = createTrip(testDb, userId, { start_date: '2026-03-01', end_date: '2026-03-03' });
+    const [d1, d2, d3] = orderedDays(trip.id);
+
+    const created = insertDay(trip.id, 1);
+
+    const after = orderedDays(trip.id);
+    expect(after).toHaveLength(4);
+    expect(after[0].id).toBe(created.id);
+    expect(after.map(d => d.date)).toEqual(['2026-03-01', '2026-03-02', '2026-03-03', '2026-03-04']);
+    // Old content shifted down a slot
+    expect(after.slice(1).map(d => d.id)).toEqual([d1.id, d2.id, d3.id]);
+    // Trip range extended by one day
+    const t = testDb.prepare('SELECT end_date FROM trips WHERE id = ?').get(trip.id) as { end_date: string };
+    expect(t.end_date).toBe('2026-03-04');
+  });
+});