trails/apps/journal/app/routes/api.v1.activities._index.ts
Ullrich Schäfer 61a2d0085b
one source of truth for Route/Activity shapes; enforce api contracts
Route and Activity existed three times: hand-written interfaces in
packages/types, Zod contracts in packages/api, and Drizzle columns in
packages/db — each with different fields and nullability. The
hand-written ones had drifted so far they had zero importers; the Zod
contracts were advisory because v1 handlers hand-rolled Response.json
shapes nothing validated.

- packages/types keeps only what both apps actually share (Waypoint,
  WaypointPoiTags) and documents where row types and wire contracts
  live; the dead Route/RouteMetadata/RouteVersion/Activity interfaces
  are gone
- packages/db exports canonical inferred row types (RouteRow,
  ActivityRow, RouteVersionRow, UserRow)
- packages/api contracts are reconciled with the real wire format
  (RouteVersionSchema gains the id and createdBy fields the endpoint
  has always returned) and gain Create*ResponseSchemas
- apiJson(schema, payload) in api-guard parses every v1 response
  through its contract: drift is now a thrown ZodError in tests/CI,
  unknown keys are stripped, and payloads are compile-checked as
  z.input of the schema

Enforcement immediately caught two real drifts: nullable DB
descriptions could ship null where the contract promises string (now
coalesced at the boundary), and GET /api/v1/activities/:id was missing
the routeName and photos fields its contract declares.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-06-10 07:39:50 +02:00

73 lines
2.5 KiB
TypeScript

import type { Route } from "./+types/api.v1.activities._index";
import { requireApiUser, apiError, apiJson } from "~/lib/api-guard.server";
import { listActivities, createActivity } from "~/lib/activities.server";
import {
PaginationQuerySchema,
CreateActivityRequestSchema,
ERROR_CODES,
zodIssuesToFieldErrors,
ActivityListResponseSchema,
CreateActivityResponseSchema,
} from "@trails-cool/api";
/** GET /api/v1/activities — paginated activity list */
export async function loader({ request }: Route.LoaderArgs) {
const user = await requireApiUser(request);
const url = new URL(request.url);
const query = PaginationQuerySchema.safeParse({
cursor: url.searchParams.get("cursor") ?? undefined,
limit: url.searchParams.get("limit") ?? undefined,
});
if (!query.success) {
return apiError(400, ERROR_CODES.VALIDATION_ERROR, "Invalid pagination params");
}
const allActivities = await listActivities(user.id);
const { cursor, limit } = query.data;
let startIdx = 0;
if (cursor) {
const idx = allActivities.findIndex((a) => a.id === cursor);
startIdx = idx >= 0 ? idx + 1 : 0;
}
const page = allActivities.slice(startIdx, startIdx + limit);
const nextCursor = startIdx + limit < allActivities.length ? page[page.length - 1]?.id ?? null : null;
return apiJson(ActivityListResponseSchema, {
activities: page.map((a) => ({
id: a.id,
name: a.name,
description: a.description ?? "",
routeId: a.routeId,
routeName: null, // TODO: join route name
distance: a.distance,
duration: a.duration,
elevationGain: a.elevationGain,
elevationLoss: a.elevationLoss,
startedAt: a.startedAt?.toISOString() ?? null,
geojson: a.geojson,
createdAt: a.createdAt.toISOString(),
})),
nextCursor,
});
}
/** POST /api/v1/activities — create a new activity */
export async function action({ request }: Route.ActionArgs) {
if (request.method !== "POST") return new Response(null, { status: 405 });
const user = await requireApiUser(request);
const body = await request.json().catch(() => null);
const parsed = CreateActivityRequestSchema.safeParse(body);
if (!parsed.success) {
return apiError(400, ERROR_CODES.VALIDATION_ERROR, "Validation failed",
zodIssuesToFieldErrors(parsed.error));
}
const id = await createActivity(user.id, {
...parsed.data,
startedAt: parsed.data.startedAt ? new Date(parsed.data.startedAt) : null,
});
return apiJson(CreateActivityResponseSchema, { id }, { status: 201 });
}