Files
TREK/server/tests/integration/broadcast-parity/plan.cases.ts
T
Maurice 3f38621024 feat(server): let a trip owner switch trip addons for one trip
A trip can now turn a trip addon (lists, costs, documents, collab, road
trip, tours) on or off for itself, whatever the instance switch says. No
row in the new trip_addon_overrides table means the trip follows the
instance; a row is the owner's choice. Going back to the instance setting
deletes the row, and no addon data is touched either way.

- GET/PUT /api/trips/:tripId/addons[/:addonId] (every member reads, the
  owner writes) and the MCP tools get_trip_addons and set_trip_addon, on
  the shared tripAddons contract; tripAddons:changed tells the members.
- Every trip-scoped addon surface asks the trip: REST through
  TripAddonGuard, MCP through a per-call gate on the named or pinned trip,
  plugin RPC and events, the share link, the offline bundle, reminders,
  doc sync, the assistant (tools, keep_attached_file), booking costs, the
  trip summary prompt, and the cross-trip tour reads (library, Atlas
  stats, collection save).
- Routes without a trip open while the addon is on in any of the user's
  trips. Switching an addon on that the instance has off ends the members'
  MCP sessions so they reconnect with its tools.
- A copied trip takes its owner's choices along.

Behaviour changes: an anonymous call to an addon route that is off now
gets 401 instead of 404, and with an instance switch off the packing,
todo and files plugin RPC methods, the files MCP tools, todo reminder
mails, core plugin events, plugin view contributions, the share link's
lists, costs and chat sections and the offline bundle's lists follow it.
2026-11-21 13:23:09 +01:00

490 lines
19 KiB
TypeScript

import { DayAssignments } from '../../../src/db/entities/DayAssignments.entity';
import { RoadtripDayBoundaries } from '../../../src/db/entities/RoadtripDayBoundaries.entity';
import { TripFiles } from '../../../src/db/entities/TripFiles.entity';
import type { ListImportResult } from '../../../src/nest/places/places.helpers';
import { PlacesService } from '../../../src/nest/places/places.service';
import { StorageService } from '../../../src/nest/storage/storage.service';
import { makeDayAssignment } from '../../helpers/factories/itinerary';
import { makeTag } from '../../helpers/factories/places';
import { insertRow, updateRows } from '../../helpers/factories/rows';
import type { CaseGroup, Scene } from './types';
import { MikroORM } from '@mikro-orm/core';
import type { INestApplication } from '@nestjs/common';
import { Readable } from 'node:stream';
import { vi } from 'vitest';
const CATALOG = "the admin's category catalog is global: no trip room, and the registry has no event for it";
const placesPath = (s: Scene) => `/api/trips/${s.trip.id}/places`;
const daysPath = (s: Scene) => `/api/trips/${s.trip.id}/days`;
/** The assignments of one of the scene's days. */
const dayPlanPath = (s: Scene, day: 0 | 1 | 2) => `/api/trips/${s.trip.id}/days/${s.days[day].id}/assignments`;
/** The per-assignment routes of the scene's assignment. */
const assignmentPath = (s: Scene) => `/api/trips/${s.trip.id}/assignments/${s.assignment.id}`;
const dayNotesPath = (s: Scene) => `/api/trips/${s.trip.id}/days/${s.days[0].id}/notes`;
/** The tags the scene's trip owns. */
const tripTagsPath = (s: Scene) => `/api/trips/${s.trip.id}/tags`;
const onAssignment = (s: Scene) => ({ tripId: s.trip.id, assignmentId: s.assignment.id });
/** One waypoint, the smallest file the importer turns into a place. */
const GPX = [
'<?xml version="1.0" encoding="UTF-8"?>',
'<gpx version="1.1" creator="TREK parity" xmlns="http://www.topografix.com/GPX/1/1">',
'<wpt lat="48.8583" lon="2.3375"><name>Pont des Arts</name></wpt>',
'</gpx>',
].join('');
/**
* A shared Google Maps list without the network: the list reader answers with
* one place, written the way the importer writes it, so the route and the tool
* announce a real row.
*/
function stubGoogleList(app: INestApplication): () => void {
const places = app.get(PlacesService);
const spy = vi
.spyOn(places, 'importGoogleList')
.mockImplementation(async (tripId: string): Promise<ListImportResult> => {
const place = await places.create(tripId, { name: 'Shakespeare and Company', lat: 48.8526, lng: 2.3471 });
return { places: [place], listName: 'Left bank', skipped: 0 };
});
return () => spy.mockRestore();
}
/** The scene's file becomes a picture, with its bytes in storage, so a place can take it as its image. */
async function fileIsPicture(s: Scene, app: INestApplication): Promise<void> {
const name = `poster-${s.n}.jpg`;
await app.get(StorageService).put('files', name, Readable.from(Buffer.from('jpg')), { contentType: 'image/jpeg' });
await updateRows(
app.get(MikroORM),
TripFiles,
{ id: s.file.id },
{ filename: name, original_name: name, mime_type: 'image/jpeg', file_size: 3 },
);
}
/** A second stop on the first day, behind the scene's assignment. */
async function secondStop(s: Scene, app: INestApplication): Promise<void> {
await makeDayAssignment(app.get(MikroORM), s.days[0].id, s.place2.id);
}
/**
* The first day in time order, 07:00 then 08:00, with the scene's via after
* the first stop: moving the first stop to 09:00 sorts the day and moves the
* via with its stop.
*/
async function timedDay(s: Scene, app: INestApplication): Promise<void> {
const orm = app.get(MikroORM);
await updateRows(orm, DayAssignments, { id: s.assignment.id }, { assignment_time: '07:00' });
await makeDayAssignment(orm, s.days[0].id, s.place2.id, { assignment_time: '08:00' });
}
/** A road trip day boundary on the second day, after a stop of its own there. */
async function boundaryOnSecondDay(s: Scene, app: INestApplication): Promise<void> {
const orm = app.get(MikroORM);
const stop = await makeDayAssignment(orm, s.days[1].id, s.place.id);
await insertRow(orm, RoadtripDayBoundaries, {
trip: s.trip.id,
day_number: 2,
fromAssignment: stop.id,
fraction: 0.5,
});
}
/** The tag a setup gave a scene's trip, by the scene's number. */
const tripTagOf = new Map<number, number>();
/** A tag of the scene's trip, for the cases that rename or delete one. */
async function tripTag(s: Scene, app: INestApplication): Promise<void> {
const tag = await makeTag(app.get(MikroORM), s.owner.id, { trip: s.trip.id, name: 'Monument' });
tripTagOf.set(s.n, tag.id);
}
const tripTagId = (s: Scene): number => {
const id = tripTagOf.get(s.n);
if (id === undefined) throw new Error(`scene ${s.n} has no trip tag from its setup`);
return id;
};
/**
* The planner: places and the tags their trip owns, the day plan, days, day
* notes, categories, the collection places copied into a trip, and the trip
* addons its owner switches for it.
*/
export const plan: CaseGroup = {
name: 'plan',
prefix: 'BCP-PLAN',
cases: [
{
tool: 'create_place',
args: (s) => ({ tripId: s.trip.id, name: 'Sacré-Cœur', lat: 48.8867, lng: 2.3431 }),
rest: {
method: 'post',
path: placesPath,
body: () => ({ name: 'Sacré-Cœur', lat: 48.8867, lng: 2.3431 }),
},
expect: ['place:created'],
},
{
// The assistant's way to book a hotel the trip does not have yet (handoff
// section 8): every tab, the asking one included, gets the new place, the
// stay with its partner booking and the check-in stop.
tool: 'create_place_accommodation',
args: (s) => ({
tripId: s.trip.id,
name: 'Mercure Hotel Berlin City',
lat: 52.5306,
lng: 13.3846,
start_day_id: s.days[0].id,
end_day_id: s.days[2].id,
check_in: '15:00',
check_out: '11:00',
}),
twin: 'POST /api/trips/:tripId/places, then POST /api/trips/:tripId/accommodations',
// The place goes out once, already typed as lodging: the stamp the stay
// puts on it is not sent again as place:updated.
expect: [
'place:created',
'accommodation:created',
'reservation:created',
{ event: 'assignment:created', all: true },
{ event: 'assignment:reordered', all: true },
],
},
{
tool: 'create_and_assign_place',
args: (s) => ({ tripId: s.trip.id, dayId: s.days[1].id, name: 'Café de Flore', lat: 48.854, lng: 2.3326 }),
twin: 'POST /api/trips/:tripId/places, then POST /api/trips/:tripId/days/:dayId/assignments',
expect: ['place:created', 'assignment:created'],
},
{
tool: 'update_place',
needs: ['place'],
args: (s) => ({ tripId: s.trip.id, placeId: s.place.id, name: 'Musée du Louvre' }),
rest: { method: 'put', path: (s) => `${placesPath(s)}/${s.place.id}`, body: () => ({ name: 'Musée du Louvre' }) },
expect: ['place:updated'],
},
{
tool: 'set_place_image_from_file',
needs: ['place', 'file'],
setup: fileIsPicture,
args: (s) => ({ tripId: s.trip.id, placeId: s.place.id, fileId: s.file.id }),
rest: {
method: 'put',
path: (s) => `${placesPath(s)}/${s.place.id}/image/from-file`,
body: (s) => ({ file_id: s.file.id }),
},
expect: ['place:updated'],
},
{
tool: 'rate_place',
needs: ['place'],
args: (s) => ({ tripId: s.trip.id, placeId: s.place.id, rating: 4 }),
rest: { method: 'put', path: (s) => `${placesPath(s)}/${s.place.id}/rating`, body: () => ({ rating: 4 }) },
expect: ['place:updated'],
},
{
// The hotel of a stay: the night and its partner booking go with the place,
// and the deleting tab hears that too, since it only removed the place.
tool: 'delete_place',
needs: ['stay'],
args: (s) => ({ tripId: s.trip.id, placeId: s.stay.placeId }),
rest: { method: 'delete', path: (s) => `${placesPath(s)}/${s.stay.placeId}` },
expect: ['place:deleted', { event: 'reservation:deleted', all: true }],
},
{
tool: 'import_places_from_url',
args: (s) => ({ tripId: s.trip.id, url: 'https://maps.app.goo.gl/parityList', source: 'google-list' }),
rest: {
method: 'post',
path: (s) => `${placesPath(s)}/import/google-list`,
body: () => ({ url: 'https://maps.app.goo.gl/parityList' }),
},
stub: stubGoogleList,
expect: ['place:created'],
},
{
tool: 'import_trip_gpx',
args: (s) => ({ tripId: s.trip.id, gpx: GPX, name: 'Paris walk', importRoutes: false, importTracks: false }),
twin: 'POST /api/trips/:tripId/places/import/gpx, a multipart upload of the same file',
expect: ['place:created'],
},
{
tool: 'bulk_delete_places',
needs: ['place', 'place2'],
args: (s) => ({ tripId: s.trip.id, placeIds: [s.place.id, s.place2.id] }),
rest: {
method: 'post',
path: (s) => `${placesPath(s)}/bulk-delete`,
body: (s) => ({ ids: [s.place.id, s.place2.id] }),
},
expect: ['place:deleted', 'place:deleted'],
},
{
// REST takes the category alone; the tool's other fields are not a difference in events.
tool: 'bulk_update_places',
needs: ['place', 'place2', 'category'],
args: (s) => ({ tripId: s.trip.id, placeIds: [s.place.id, s.place2.id], category_id: s.category.id }),
rest: {
method: 'post',
path: (s) => `${placesPath(s)}/bulk-update`,
body: (s) => ({ ids: [s.place.id, s.place2.id], category_id: s.category.id }),
},
expect: ['place:updated', 'place:updated'],
},
{
tool: 'create_trip_tag',
args: (s) => ({ tripId: s.trip.id, name: 'Monument' }),
rest: { method: 'post', path: tripTagsPath, body: () => ({ name: 'Monument' }) },
expect: ['tripTags:changed'],
},
{
tool: 'update_trip_tag',
setup: tripTag,
args: (s) => ({ tripId: s.trip.id, tagId: tripTagId(s), name: 'Landmark' }),
rest: {
method: 'put',
path: (s) => `${tripTagsPath(s)}/${tripTagId(s)}`,
body: () => ({ name: 'Landmark' }),
},
expect: ['tripTags:changed'],
},
{
tool: 'delete_trip_tag',
setup: tripTag,
args: (s) => ({ tripId: s.trip.id, tagId: tripTagId(s) }),
rest: { method: 'delete', path: (s) => `${tripTagsPath(s)}/${tripTagId(s)}` },
expect: ['tripTags:changed'],
},
{
tool: 'assign_place_to_day',
needs: ['place'],
args: (s) => ({ tripId: s.trip.id, dayId: s.days[1].id, placeId: s.place.id }),
rest: { method: 'post', path: (s) => dayPlanPath(s, 1), body: (s) => ({ place_id: s.place.id }) },
expect: ['assignment:created'],
},
{
tool: 'set_assignment_end_day',
needs: ['assignment'],
args: (s) => ({ ...onAssignment(s), end_day: true }),
rest: { method: 'put', path: (s) => `${assignmentPath(s)}/end-day`, body: () => ({ end_day: true }) },
expect: ['assignment:updated'],
},
{
tool: 'set_assignment_stay',
needs: ['assignment'],
args: (s) => ({ ...onAssignment(s), stay_minutes: 15 }),
rest: { method: 'put', path: (s) => `${assignmentPath(s)}/stay`, body: () => ({ stay_minutes: 15 }) },
expect: ['assignment:updated'],
},
{
tool: 'unassign_place',
needs: ['assignment'],
args: (s) => ({ ...onAssignment(s), dayId: s.days[0].id }),
rest: { method: 'delete', path: (s) => `${dayPlanPath(s, 0)}/${s.assignment.id}` },
expect: ['assignment:deleted'],
},
{
tool: 'clear_day_assignments',
needs: ['assignment', 'place2'],
setup: secondStop,
args: (s) => ({ tripId: s.trip.id, dayId: s.days[0].id }),
rest: { method: 'delete', path: (s) => dayPlanPath(s, 0) },
expect: ['assignment:deleted', 'assignment:deleted'],
},
{
// A start that moves sorts the day: the new order and the vias pinned to it
// reach the writing tab too, which routes on them before its reload.
tool: 'update_assignment_time',
needs: ['assignment', 'place2', 'via'],
setup: timedDay,
args: (s) => ({ ...onAssignment(s), place_time: '09:00' }),
rest: { method: 'put', path: (s) => `${assignmentPath(s)}/time`, body: () => ({ place_time: '09:00' }) },
expect: [
'assignment:updated',
{ event: 'assignment:reordered', all: true },
{ event: 'roadtripVia:changed', all: true },
],
},
{
tool: 'update_assignment_notes',
needs: ['assignment'],
args: (s) => ({ ...onAssignment(s), notes: 'Tickets at the side door' }),
rest: {
method: 'put',
path: (s) => `${assignmentPath(s)}/notes`,
body: () => ({ notes: 'Tickets at the side door' }),
},
expect: ['assignment:updated'],
},
{
tool: 'set_leg_transport_mode',
needs: ['assignment'],
args: (s) => ({ ...onAssignment(s), transport_mode: 'walking' }),
rest: {
method: 'put',
path: (s) => `${assignmentPath(s)}/transport`,
body: () => ({ transport_mode: 'walking' }),
},
expect: ['assignment:updated'],
},
{
tool: 'set_assignment_route_excluded',
needs: ['assignment'],
args: (s) => ({ ...onAssignment(s), excluded: true }),
rest: { method: 'put', path: (s) => `${assignmentPath(s)}/route`, body: () => ({ excluded: true }) },
expect: ['assignment:updated'],
},
{
tool: 'move_assignment',
needs: ['assignment'],
args: (s) => ({ ...onAssignment(s), newDayId: s.days[1].id }),
rest: {
method: 'put',
path: (s) => `${assignmentPath(s)}/move`,
body: (s) => ({ new_day_id: s.days[1].id, order_index: 0 }),
},
expect: ['assignment:moved'],
},
{
tool: 'set_assignment_participants',
needs: ['assignment', 'member'],
args: (s) => ({ ...onAssignment(s), userIds: [s.member.id] }),
rest: {
method: 'put',
path: (s) => `${assignmentPath(s)}/participants`,
body: (s) => ({ user_ids: [s.member.id] }),
},
expect: ['assignment:participants'],
},
{
tool: 'reorder_day_assignments',
needs: ['assignment'],
args: (s) => ({ tripId: s.trip.id, dayId: s.days[0].id, assignmentIds: [s.assignment.id] }),
rest: {
method: 'put',
path: (s) => `${dayPlanPath(s, 0)}/reorder`,
body: (s) => ({ orderedIds: [s.assignment.id] }),
},
expect: ['assignment:reordered'],
},
{
// Closed gap G3: the copies used to reach no open planner, on any surface.
tool: 'copy_collection_places_to_trip',
needs: ['collection'],
args: (s) => ({ trip_id: s.trip.id, place_ids: [s.collectionPlace.id] }),
rest: {
method: 'post',
path: () => '/api/addons/collections/copy-to-trip',
body: (s) => ({ trip_id: s.trip.id, place_ids: [s.collectionPlace.id] }),
},
expect: ['place:created'],
},
{
tool: 'create_day_note',
args: (s) => ({ tripId: s.trip.id, dayId: s.days[0].id, text: 'Bring the museum pass' }),
rest: { method: 'post', path: dayNotesPath, body: () => ({ text: 'Bring the museum pass' }) },
expect: ['dayNote:created'],
},
{
tool: 'update_day_note',
needs: ['dayNote'],
args: (s) => ({ tripId: s.trip.id, dayId: s.days[0].id, noteId: s.dayNote.id, text: 'Pass in the blue bag' }),
rest: {
method: 'put',
path: (s) => `${dayNotesPath(s)}/${s.dayNote.id}`,
body: () => ({ text: 'Pass in the blue bag' }),
},
expect: ['dayNote:updated'],
},
{
tool: 'delete_day_note',
needs: ['dayNote'],
args: (s) => ({ tripId: s.trip.id, dayId: s.days[0].id, noteId: s.dayNote.id }),
rest: { method: 'delete', path: (s) => `${dayNotesPath(s)}/${s.dayNote.id}` },
expect: ['dayNote:deleted'],
},
{
tool: 'update_day',
args: (s) => ({ tripId: s.trip.id, dayId: s.days[1].id, title: 'Montmartre' }),
rest: { method: 'put', path: (s) => `${daysPath(s)}/${s.days[1].id}`, body: () => ({ title: 'Montmartre' }) },
expect: ['day:updated'],
},
{
// The calendar day after the last date: the list and the longer trip. Every
// day of the scene has a date, so no undated day moves back with a road
// trip boundary on it, and no boundary event follows.
tool: 'create_day',
args: (s) => ({ tripId: s.trip.id, dated: true }),
rest: { method: 'post', path: daysPath, body: () => ({ dated: true }) },
expect: ['day:reordered', 'trip:updated'],
},
{
tool: 'reorder_days',
args: (s) => ({ tripId: s.trip.id, orderedIds: [s.days[1].id, s.days[0].id, s.days[2].id] }),
rest: {
method: 'put',
path: (s) => `${daysPath(s)}/reorder`,
body: (s) => ({ orderedIds: [s.days[1].id, s.days[0].id, s.days[2].id] }),
},
expect: ['day:reordered'],
},
{
// The check-in day of a stay: the stay and its booking go with it, and the
// boundary on the second day moves up with its day, for every tab.
tool: 'delete_day',
needs: ['stay', 'place'],
setup: boundaryOnSecondDay,
args: (s) => ({ tripId: s.trip.id, dayId: s.days[0].id }),
rest: { method: 'delete', path: (s) => `${daysPath(s)}/${s.days[0].id}` },
expect: [
'day:deleted',
'day:reordered',
{ event: 'reservation:deleted', all: true },
'accommodation:deleted',
{ event: 'roadtripBoundary:changed', all: true },
'trip:updated',
],
},
{
tool: 'set_day_default_transport_mode',
args: (s) => ({ tripId: s.trip.id, dayId: s.days[0].id, transport_mode: 'walking' }),
rest: {
method: 'put',
path: (s) => `${daysPath(s)}/${s.days[0].id}/transport`,
body: () => ({ transport_mode: 'walking' }),
},
expect: ['day:updated'],
},
{
// The owner switches costs off for the trip: every tab gets the trip's addon list.
tool: 'set_trip_addon',
args: (s) => ({ tripId: s.trip.id, addonId: 'budget', enabled: false }),
rest: { method: 'put', path: (s) => `/api/trips/${s.trip.id}/addons/budget`, body: () => ({ enabled: false }) },
expect: ['tripAddons:changed'],
},
],
exempt: [
{
tool: 'create_category',
reason: CATALOG,
actor: 'admin',
args: (s) => ({ name: `Rooftop bars ${s.n}` }),
},
{
tool: 'update_category',
reason: CATALOG,
actor: 'admin',
needs: ['category'],
args: (s) => ({ categoryId: s.category.id, name: `Night markets ${s.n}` }),
},
{
tool: 'delete_category',
reason: CATALOG,
actor: 'admin',
needs: ['category'],
args: (s) => ({ categoryId: s.category.id }),
},
],
};