@carlonicora/nextjs-jsonapi 6.13.1 → 6.14.1

package/src/hooks/usePageTracker.ts

@@ -10,18 +10,28 @@ import { getTrackablePages } from "../client/config";
 const EXCLUDED_ROUTES = ["/", "/login", "/register", "/forgot-password", "/reset-password", "/activate"];
 
 /**
- * Detail pages title themselves `[Entity type] Entity name | App name`. Returns
- * the entity name, or null when the document title is not (yet) a detail-page
- * title — the normal state for the first tick after a client-side navigation,
- * before the route's streamed metadata replaces the <title>.
+ * Detail pages title themselves in one of two shapes:
+ *
+ *   `[Entity type] Entity name | App name`        (bracketed)
+ *   `Entity name · Entity type · Context | App name` (most-specific-first)
+ *
+ * Returns the entity name, or null when the document title carries no page
+ * name — just the bare app name. Whether the title belongs to THIS route (and
+ * not the page we left) is decided by the caller, not here.
  */
 function readEntityTitle(): string | null {
   if (typeof document === "undefined") return null;
 
-  const afterEntityType = document.title.split("]")[1];
-  if (!afterEntityType) return null;
+  const title = document.title;
 
-  return afterEntityType.split("|")[0]?.trim() || null;
+  if (title.includes("]")) {
+    const afterEntityType = title.split("]")[1];
+    return afterEntityType?.split("|")[0]?.trim() || null;
+  }
+
+  if (!title.includes("|")) return null;
+
+  return title.split("|")[0].split("·")[0]?.trim() || null;
 }
 
 export function usePageTracker() {

package/src/offline/__tests__/generic-answers.spec.ts

@@ -1,10 +1,10 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { buildGenericRoutes, linksOfKind, listAnswer } from "../generic-answers";
 import { matchRoute } from "../router";
 import { setOfflineState } from "../state";
 import type { DeviceStore } from "../store/DeviceStore";
-import type { OfflineAnswer, OfflineConfig, OfflineMethod } from "../types";
-import { npc, offlineConfig, seededStore } from "./offline-fixtures";
+import type { OfflineAnswer, OfflineConfig, OfflineLocalWriteContext, OfflineMethod } from "../types";
+import { bookConfig, npc, offlineConfig, page, seededStore } from "./offline-fixtures";
 
 const API = "http://api.test/";
 
@@ -377,4 +377,147 @@ describe("generic answers", () => {
     expect(post.status).toBe(503);
     expect(await store.queue()).toEqual([]);
   });
+
+  describe("extra root kinds", () => {
+    it("POST of an extra-kind root type roots the record at its own id", async () => {
+      const body = { data: { type: "books", id: "b9", attributes: { name: "Book" } } };
+
+      const result = await answer(store, "POST", "books", body, bookConfig());
+
+      expect(result.status).toBe(201);
+      expect(await store.getRecord("books", "b9")).toMatchObject({ rootId: "b9", localOnly: true });
+      const [entry] = await store.queue();
+      expect(entry).toMatchObject({ rootId: "b9", method: "POST", path: "books" });
+    });
+
+    it("POST of a child with a relationship to an extra-kind root roots it there", async () => {
+      const body = { data: page("p9", "Page", "b9") };
+
+      const result = await answer(store, "POST", "pages", body, bookConfig());
+
+      expect(result.status).toBe(201);
+      expect(await store.getRecord("pages", "p9")).toMatchObject({ rootId: "b9" });
+      const [entry] = await store.queue();
+      expect(entry).toMatchObject({ rootId: "b9", method: "POST", path: "pages" });
+    });
+
+    it("GET {extraModule}/:rootId/{type} lists the root's records", async () => {
+      await store.putRecord({
+        type: "books",
+        id: "b1",
+        rootId: "b1",
+        resource: { type: "books", id: "b1", attributes: { name: "Book" } },
+        updatedAt: null,
+      });
+      await store.putRecord({
+        type: "pages",
+        id: "p1",
+        rootId: "b1",
+        resource: page("p1", "One", "b1"),
+        updatedAt: null,
+      });
+      await store.putRecord({
+        type: "pages",
+        id: "p2",
+        rootId: "b2",
+        resource: page("p2", "Two", "b2"),
+        updatedAt: null,
+      });
+
+      const result = await answer(store, "GET", "books/b1/pages?fetchAll=true", undefined, bookConfig());
+      const missing = await answer(store, "GET", "books/b2/pages", undefined, bookConfig());
+
+      expect(result.status).toBe(200);
+      expect(result.body.data.map((resource: any) => resource.id)).toEqual(["p1"]);
+      expect(missing.status).toBe(503);
+    });
+  });
+
+  describe("afterLocalWrite", () => {
+    const hookConfig = (hook: (ctx: OfflineLocalWriteContext) => Promise<void>): OfflineConfig => {
+      const config = offlineConfig();
+      return {
+        ...config,
+        types: config.types.map((typeConfig) =>
+          typeConfig.module.name === "npcs" ? { ...typeConfig, afterLocalWrite: hook } : typeConfig,
+        ),
+      };
+    };
+
+    it("afterLocalWrite runs in the write's transaction with method, resource and previous", async () => {
+      const seen: any[] = [];
+      const hook = vi.fn(async (ctx: OfflineLocalWriteContext) => {
+        seen.push({
+          method: ctx.method,
+          module: ctx.module.name,
+          id: ctx.id,
+          resource: ctx.resource,
+          previous: ctx.previous,
+          stored: (await ctx.store.getRecord("npcs", ctx.id))?.resource ?? null,
+          queued: (await ctx.store.queue()).length,
+        });
+      });
+      const config = hookConfig(hook);
+
+      await answer(store, "POST", "npcs", { data: npc("n9", "New", "C") }, config);
+      await answer(
+        store,
+        "PUT",
+        "npcs/n1",
+        { data: { type: "npcs", id: "n1", attributes: { name: "Alda II" } } },
+        config,
+      );
+      await answer(store, "DELETE", "npcs/n2", undefined, config);
+
+      const alda2 = { ...npc("n1", "Alda", "C"), attributes: { name: "Alda II", description: "Alda text" } };
+      expect(seen).toEqual([
+        {
+          method: "POST",
+          module: "npcs",
+          id: "n9",
+          resource: npc("n9", "New", "C"),
+          previous: null,
+          stored: npc("n9", "New", "C"),
+          queued: 1,
+        },
+        {
+          method: "PUT",
+          module: "npcs",
+          id: "n1",
+          resource: alda2,
+          previous: npc("n1", "Alda", "C"),
+          stored: alda2,
+          queued: 2,
+        },
+        {
+          method: "DELETE",
+          module: "npcs",
+          id: "n2",
+          resource: null,
+          previous: npc("n2", "brom", "C"),
+          stored: null,
+          queued: 3,
+        },
+      ]);
+    });
+
+    it("a hook that throws rolls back the write and the enqueue", async () => {
+      const config = hookConfig(async () => {
+        throw new Error("hook failed");
+      });
+
+      await expect(answer(store, "POST", "npcs", { data: npc("n9", "New", "C") }, config)).rejects.toThrow(
+        "hook failed",
+      );
+      await expect(
+        answer(store, "PUT", "npcs/n1", { data: { type: "npcs", id: "n1", attributes: { name: "X" } } }, config),
+      ).rejects.toThrow("hook failed");
+      await expect(answer(store, "DELETE", "npcs/n2", undefined, config)).rejects.toThrow("hook failed");
+
+      expect(await store.getRecord("npcs", "n9")).toBeUndefined();
+      expect((await store.getRecord("npcs", "n1"))?.resource).toEqual(npc("n1", "Alda", "C"));
+      expect(await store.getRecord("npcs", "n2")).toBeDefined();
+      expect(await store.queue()).toEqual([]);
+    });
+  });
 });

package/src/offline/__tests__/local-transport.spec.ts

@@ -5,7 +5,7 @@ import { getOfflineState, setOfflineState } from "../state";
 import type { DeviceStore } from "../store/DeviceStore";
 import { NeedsConnectionError, type OfflineRoute } from "../types";
 import { setDeviceStoreOpener } from "../config";
-import { Roots, Npcs, setUpOffline, tearDownOffline } from "./offline-fixtures";
+import { bookConfig, Books, Roots, Npcs, setUpOffline, tearDownOffline } from "./offline-fixtures";
 
 const API = "http://api.test/";
 
@@ -147,4 +147,18 @@ describe("localTransport", () => {
 
     expect(response.data.errors[0].code).toBe("needs-connection");
   });
+
+  it("a queued custom write under an extra-kind module segment takes that root", async () => {
+    const answer = vi.fn(async () => ({ status: 200, body: { data: { type: "books", id: "b7" } } }));
+    store = await setUpOffline(
+      [{ method: "POST", pattern: [Books, ":bookId", "reorder"], answer, queue: true }],
+      bookConfig,
+    );
+
+    const response = await localTransport({ method: "POST", url: `${API}books/b7/reorder`, body: {} });
+
+    expect(response.status).toBe(200);
+    const [entry] = await store.queue();
+    expect(entry).toMatchObject({ rootId: "b7", method: "POST", path: "books/b7/reorder" });
+  });
 });

package/src/offline/__tests__/offline-fixtures.ts

@@ -18,6 +18,16 @@ export const Roots = { name: "roots", model: TestModel };
 export const Npcs = { name: "npcs", model: TestModel };
 export const Factions = { name: "factions", model: TestModel };
 export const Characters = { name: "characters", model: TestModel };
+/** A second kind of root record (`extraRootKinds`) and its child type. */
+export const Books = { name: "books", model: TestModel };
+export const Pages = { name: "pages", model: TestModel };
+
+export const page = (id: string, name: string, bookId: string) => ({
+  type: "pages",
+  id,
+  attributes: { name },
+  relationships: { book: { data: { type: "books", id: bookId } } },
+});
 
 export const npc = (id: string, name: string, rootId: string) => ({
   type: "npcs",
@@ -43,6 +53,20 @@ export function offlineConfig(routes: OfflineRoute[] = []): OfflineConfig {
   };
 }
 
+/** `offlineConfig` with the books root kind and its types. */
+export function bookConfig(routes: OfflineRoute[] = []): OfflineConfig {
+  const config = offlineConfig(routes);
+  return {
+    ...config,
+    types: [
+      ...config.types,
+      { module: Books, fetch: "by-id", readOnly: false, serverOwnedFields: [] },
+      { module: Pages, fetch: "root-list", readOnly: false, serverOwnedFields: [] },
+    ],
+    extraRootKinds: [{ module: Books, listSyncRoots: async () => ["b1"] }],
+  };
+}
+
 /** Two NPCs and a faction in root record C, one NPC in D; the faction is linked to n1. */
 export async function seededStore(): Promise<DeviceStore> {
   const store = await openMemoryDeviceStore();
@@ -74,11 +98,14 @@ export async function seededStore(): Promise<DeviceStore> {
   return store;
 }
 
-export async function setUpOffline(routes: OfflineRoute[] = []): Promise<DeviceStore> {
+export async function setUpOffline(
+  routes: OfflineRoute[] = [],
+  buildConfig: (routes: OfflineRoute[]) => OfflineConfig = offlineConfig,
+): Promise<DeviceStore> {
   resetOfflineState();
   resetOfflineConfig();
   const store = await seededStore();
-  configureOffline(offlineConfig(routes));
+  configureOffline(buildConfig(routes));
   setDeviceStoreOpener(async () => store);
   return store;
 }

package/src/offline/__tests__/write-through.spec.ts

@@ -1,6 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { DeviceStore } from "../store/DeviceStore";
-import { artwork, fakeCacheStorage, npc, setUpSync, tearDownSync } from "../sync/__tests__/sync-fixtures";
+import {
+  artwork,
+  book,
+  bookTypes,
+  Books,
+  fakeCacheStorage,
+  npc,
+  setUpSync,
+  syncTestConfig,
+  tearDownSync,
+} from "../sync/__tests__/sync-fixtures";
 import { markOfflineUnavailable, OfflineUnavailableError } from "../config";
 import { writeThrough } from "../write-through";
 
@@ -134,4 +144,20 @@ describe("writeThrough", () => {
 
     expect(images.has("http://api.test/artworks/a1/image?v=1")).toBe(false);
   });
+
+  it("an online write under an extra-kind root is stored", async () => {
+    tearDownSync();
+    store = await setUpSync({
+      types: [...syncTestConfig().types, ...bookTypes],
+      extraRootKinds: [{ module: Books, listSyncRoots: async () => ["b1"] }],
+    });
+    await store.putRecord({ type: "books", id: "b1", rootId: "b1", resource: book("b1"), updatedAt: null });
+
+    await writeThrough(
+      { method: "POST", url: "http://api.test/books/b1/pages" },
+      ok({ data: { type: "pages", id: "p5", attributes: { name: "No relationship" } } }),
+    );
+
+    expect(await store.getRecord("pages", "p5")).toMatchObject({ rootId: "b1" });
+  });
 });

package/src/offline/config.ts

@@ -5,6 +5,7 @@ import {
   DEFAULT_SQLITE_MODULE_URL,
   NeedsConnectionError,
   type OfflineConfig,
+  type OfflineRootKind,
 } from "./types";
 
 // Kept free of store, worker and React imports: `directFetch` reads `isOfflineConfigured()` on
@@ -159,6 +160,14 @@ export function refreshOfflineDeviceState(): void {
   });
 }
 
+/**
+ * Every kind of root record: the primary one (`rootModule` + `listSyncRoots`) first, then
+ * `extraRootKinds`. Library-internal (not exported from the entry).
+ */
+export function rootKinds(config: OfflineConfig): OfflineRootKind[] {
+  return [{ module: config.rootModule, listSyncRoots: config.listSyncRoots }, ...(config.extraRootKinds ?? [])];
+}
+
 export function getOfflineConfig(): OfflineConfig {
   if (!_config) throw new Error("Offline mode is not configured. Call configureOffline() first.");
   return _config;

package/src/offline/generic-answers.ts

@@ -1,5 +1,5 @@
 import { CURRENT_USER_STORAGE_KEY } from "../features/user/data/user.storage";
-import { getOfflineConfig } from "./config";
+import { getOfflineConfig, rootKinds } from "./config";
 import { getOfflineState } from "./state";
 import type { DeviceStore, StoredLink, StoredRecord } from "./store/DeviceStore";
 import type {
@@ -7,6 +7,7 @@ import type {
   OfflineAnswer,
   OfflineConfig,
   OfflineMethod,
+  OfflineRootKind,
   OfflineRoute,
   OfflineTypeConfig,
 } from "./types";
@@ -402,10 +403,10 @@ async function getOne(ctx: LocalAnswerContext, type: string): Promise<OfflineAns
 
 async function rootList(
   ctx: LocalAnswerContext,
-  config: OfflineConfig,
+  kind: OfflineRootKind,
   typeConfig: OfflineTypeConfig,
 ): Promise<OfflineAnswer> {
-  const rootType = config.rootModule.name;
+  const rootType = kind.module.name;
   const rootId = ctx.params.rootId;
   if (!(await ctx.store.getRecord(rootType, rootId))) return notOnDeviceAnswer(rootType, rootId);
   const records = await ctx.store.listRecords({ type: typeConfig.module.name, rootId });
@@ -463,17 +464,20 @@ async function relatedList(
 // Writes
 // ---------------------------------------------------------------------------------------------
 
-/** The root record a record belongs to: itself (root type), a relationship to the root, or a related stored record. */
+/**
+ * The root record a record belongs to: itself (the type of any root kind), a relationship to a
+ * root of any kind, or a related stored record.
+ */
 export async function rootIdForResource(
   store: DeviceStore,
   config: OfflineConfig,
   resource: any,
 ): Promise<string | undefined> {
-  const rootType = config.rootModule.name;
-  if (resource?.type === rootType && resource.id) return resource.id;
+  const rootTypes = new Set(rootKinds(config).map((kind) => kind.module.name));
+  if (rootTypes.has(resource?.type) && resource.id) return resource.id;
 
   const identifiers = Object.values(resource?.relationships ?? {}).flatMap(identifiersOf);
-  const root = identifiers.find((identifier) => identifier.type === rootType);
+  const root = identifiers.find((identifier) => rootTypes.has(identifier.type));
   if (root) return root.id;
 
   for (const identifier of identifiers) {
@@ -582,6 +586,17 @@ async function create(ctx: LocalAnswerContext, config: OfflineConfig, type: stri
       body: ctx.request.body,
       base: null,
     });
+    // The type's hook, inside the write's transaction: a throw rolls the write and the enqueue back.
+    if (typeConfig?.afterLocalWrite) {
+      await typeConfig.afterLocalWrite({
+        store,
+        module: typeConfig.module,
+        id,
+        method: "POST",
+        resource,
+        previous: null,
+      });
+    }
   });
 
   return singleAnswer(ctx.store, record, 201);
@@ -599,16 +614,12 @@ async function update(ctx: LocalAnswerContext, config: OfflineConfig, type: stri
   // A record created on this device has no server version to merge against.
   const base = existing.localOnly ? null : (existing.base ?? before);
 
+  const typeConfig = typeConfigOf(config, type);
+  const method = ctx.request.method === "PATCH" ? "PATCH" : "PUT";
   const record: StoredRecord = { ...existing, resource, base, localOnly: existing.localOnly };
   await ctx.store.transaction(async (store) => {
     await store.putRecord(record);
-    await linkRelationships(
-      store,
-      typeConfigOf(config, type),
-      { type, id },
-      before.relationships ?? {},
-      data.relationships ?? {},
-    );
+    await linkRelationships(store, typeConfig, { type, id }, before.relationships ?? {}, data.relationships ?? {});
     await store.enqueue({
       rootId: existing.rootId,
       method: ctx.request.method,
@@ -618,12 +629,15 @@ async function update(ctx: LocalAnswerContext, config: OfflineConfig, type: stri
       recordId: id,
       base,
     });
+    if (typeConfig?.afterLocalWrite) {
+      await typeConfig.afterLocalWrite({ store, module: typeConfig.module, id, method, resource, previous: before });
+    }
   });
 
   return singleAnswer(ctx.store, record);
 }
 
-async function remove(ctx: LocalAnswerContext, type: string): Promise<OfflineAnswer> {
+async function remove(ctx: LocalAnswerContext, config: OfflineConfig, type: string): Promise<OfflineAnswer> {
   const id = ctx.params.id;
   const existing = await ctx.store.getRecord(type, id);
   if (!existing) return notOnDeviceAnswer(type, id);
@@ -643,6 +657,17 @@ async function remove(ctx: LocalAnswerContext, type: string): Promise<OfflineAns
       recordId: id,
       base,
     });
+    const typeConfig = typeConfigOf(config, type);
+    if (typeConfig?.afterLocalWrite) {
+      await typeConfig.afterLocalWrite({
+        store,
+        module: typeConfig.module,
+        id,
+        method: "DELETE",
+        resource: null,
+        previous: existing.resource,
+      });
+    }
   });
 
   return { status: 204, body: undefined };
@@ -676,7 +701,9 @@ export function buildGenericRoutes(config: OfflineConfig): OfflineRoute[] {
   for (const typeConfig of config.types) {
     const type = typeConfig.module.name;
     route("GET", [typeConfig.module, ":id"], (ctx) => getOne(ctx, type));
-    route("GET", [config.rootModule, ":rootId", typeConfig.module], (ctx) => rootList(ctx, config, typeConfig));
+    for (const kind of rootKinds(config)) {
+      route("GET", [kind.module, ":rootId", typeConfig.module], (ctx) => rootList(ctx, kind, typeConfig));
+    }
     route(
       "POST",
       [typeConfig.module],
@@ -695,7 +722,7 @@ export function buildGenericRoutes(config: OfflineConfig): OfflineRoute[] {
     route(
       "DELETE",
       [typeConfig.module, ":id"],
-      readOnlyGuard(typeConfig, (ctx) => remove(ctx, type)),
+      readOnlyGuard(typeConfig, (ctx) => remove(ctx, config, type)),
     );
   }
   for (const typeConfig of config.types) {

package/src/offline/index.ts

@@ -42,6 +42,8 @@ export {
   type ResourceDocumentData,
 } from "./generic-answers";
 export type { OfflineChangeResolution } from "./sync/models/OfflineChangeSetInterface";
+// The sync answer's model: an app reads an extra root kind's sync answer (`OfflineRootKind.syncModule`) with it.
+export { RootSync } from "./sync/models/RootSync";
 
 // Device store (Task 5)
 export type * from "./store/DeviceStore";

package/src/offline/local-transport.ts

@@ -1,7 +1,7 @@
 import { getClientApiUrl } from "../client/JsonApiClient";
 import type { ApiData } from "../core/interfaces/ApiData";
 import { getApiUrl } from "../unified/JsonApiRequest";
-import { getOfflineConfig, getOfflineStore } from "./config";
+import { getOfflineConfig, getOfflineStore, rootKinds } from "./config";
 import {
   buildGenericRoutes,
   rootIdForResource,
@@ -132,10 +132,12 @@ export async function localTransport(request: LocalTransportRequest): Promise<Ap
     }
     const ctx = { request: offlineRequest, params: match.params, store };
 
-    // The root record of a custom write (a `<root>/:param` capture, a stored record, or the body).
+    // The root record of a custom write (a `<root>/:param` capture of any root kind's module, a
+    // stored record, or the body).
+    const rootTypes = new Set(rootKinds(config).map((kind) => kind.module.name));
     const customRootId = async (route: OfflineRoute): Promise<string | undefined> => {
       const rootIndex = route.pattern.findIndex(
-        (segment) => typeof segment !== "string" && segment.name === config.rootModule.name,
+        (segment) => typeof segment !== "string" && rootTypes.has(segment.name),
       );
       const next = rootIndex >= 0 ? route.pattern[rootIndex + 1] : undefined;
       const rootParam = typeof next === "string" && next.startsWith(":") ? next.slice(1) : undefined;

package/src/offline/sync/__tests__/runtime.spec.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { getOfflineState, isReconnecting, setOfflineState } from "../../state";
 import { markOfflineUnavailable, OfflineUnavailableError } from "../../config";
 import type { DeviceStore } from "../../store/DeviceStore";
-import { setUpSync, tearDownSync } from "./sync-fixtures";
+import { book, bookTypes, Books, setUpSync, syncTestConfig, tearDownSync } from "./sync-fixtures";
 
 const { drainQueue, syncAll } = vi.hoisted(() => ({ drainQueue: vi.fn(), syncAll: vi.fn() }));
 vi.mock("../drain-queue", () => ({ drainQueue }));
@@ -168,6 +168,35 @@ describe("startOfflineRuntime", () => {
     vi.unstubAllGlobals();
   });
 
+  it("probeApi ignores extra-kind roots", async () => {
+    tearDownSync();
+    store = await setUpSync({
+      syncIntervalMs: 300000,
+      types: [...syncTestConfig().types, ...bookTypes],
+      extraRootKinds: [{ module: Books, listSyncRoots: async () => ["A1"] }],
+    });
+    await store.putRecord({ type: "books", id: "A1", rootId: "A1", resource: book("A1"), updatedAt: null });
+    await store.enqueue({ rootId: "A1", method: "PATCH", path: "books/A1", body: { data: book("A1") }, base: null });
+    await store.putRecord({
+      type: "roots",
+      id: "C",
+      rootId: "C",
+      resource: { type: "roots", id: "C" },
+      updatedAt: null,
+    });
+    setOfflineState({ online: false });
+    vi.stubGlobal("navigator", { ...navigator, onLine: true });
+    directFetch.mockResolvedValue({ ok: false, status: 503, statusText: "", data: undefined, networkError: true });
+
+    stop = startOfflineRuntime();
+    await vi.advanceTimersByTimeAsync(30000);
+    await flush();
+
+    expect(directFetch).toHaveBeenCalledTimes(1);
+    expect(directFetch.mock.calls[0][0].url).toBe("http://api.test/roots/C/sync");
+    vi.unstubAllGlobals();
+  });
+
   it("a change queued while the reconnect attempt ran (a resolved conflict) is sent as soon as the session goes online", async () => {
     await store.putRecord({
       type: "roots",

package/src/offline/sync/__tests__/sync-fixtures.ts

@@ -19,6 +19,28 @@ export const Roots = { name: "roots", model: TestModel };
 export const Npcs = { name: "npcs", model: TestModel };
 export const Artworks = { name: "artworks", model: TestModel };
 export const Templates = { name: "templates", model: TestModel };
+/** A second kind of root record (`extraRootKinds`) and its child type. */
+export const Books = { name: "books", model: TestModel };
+export const Pages = { name: "pages", model: TestModel };
+
+/** The types of the second root kind, appended to `syncTestConfig().types` by the specs that use it. */
+export const bookTypes: OfflineConfig["types"] = [
+  { module: Books, fetch: "by-id", readOnly: false, serverOwnedFields: [] },
+  { module: Pages, fetch: "root-list", readOnly: false, serverOwnedFields: [] },
+];
+
+export const book = (id: string, attributes: Record<string, unknown> = {}) => ({
+  type: "books",
+  id,
+  attributes: { name: id, ...attributes },
+});
+
+export const page = (id: string, name: string, bookId = "b1") => ({
+  type: "pages",
+  id,
+  attributes: { name },
+  relationships: { book: { data: { type: "books", id: bookId } } },
+});
 
 const moduleFactory: ModuleFactory = (params) =>
   ({ pageUrl: params.pageUrl, name: params.name, model: params.model }) as ModuleWithPermissions;