@sixb/core 0.1.20 → 0.1.22

package/src/testing/object-query-contract.ts

@@ -1,13 +1,11 @@
 import { describe, expect, test } from "bun:test"
 import type { JsonValue } from "../json"
 import {
-  collectObjectQueryValidationIssues,
   countObjects,
   executeObjectQuery,
   executeObjectQueryLinks,
   existsObjects,
   facetObjects,
-  normalizeObjectQuery,
   type ObjectQuery,
   ObjectQueryPlanningError,
   type ObjectQueryPredicate,
@@ -155,10 +153,53 @@ const Task = defineObjectType({
   ],
 })
 
+const Meeting = defineObjectType({
+  id: "ContractMeeting",
+  name: "Contract Meeting",
+  properties: [
+    prop("id", "string", { required: true, primary: true }),
+    prop("startsAt", "timestamp", { query: { searchable: true, filterable: true } }),
+    prop("day", "date", { query: { searchable: true, filterable: true } }),
+    prop(
+      "reminders",
+      { type: "array", items: "timestamp" },
+      { query: { searchable: true, filterable: true } }
+    ),
+  ],
+})
+
+const Label = defineObjectType({
+  id: "ContractLabel",
+  name: "Contract Label",
+  properties: [
+    prop("id", "string", { required: true, primary: true }),
+    prop("code", "string", {
+      nullable: true,
+      query: { searchable: true, filterable: true, exact: true, sortable: true },
+    }),
+  ],
+})
+
 export const objectQueryContractOntology = new OntologyRegistry({
-  sources: [Room, Device, Zone, Asset, LaptopAsset, DefaultTextBase, DefaultTextChild, Task],
+  sources: [
+    Room,
+    Device,
+    Zone,
+    Asset,
+    LaptopAsset,
+    DefaultTextBase,
+    DefaultTextChild,
+    Task,
+    Meeting,
+    Label,
+  ],
 })
 
+// Ascending code-point order: what SQLite's BINARY and PostgreSQL's "C" collation compare.
+// Any linguistic collation reorders case and accents; UTF-16 code units put the emoji
+// (a surrogate pair) before the fullwidth letter.
+const codePointOrder = ["", "B", "a", "b", "z", "Á", "á", "é", "Ａ", "😀"]
+
 /**
  * Runs the shared object-query provider contract against any ObjectStorage.
  *
@@ -195,73 +236,6 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
   }
 
   describe(label, () => {
-    test("normalizes query shape and resolves search profile defaults", () => {
-      const normalized = normalizeObjectQuery({
-        kind: "limit",
-        limit: 10,
-        input: {
-          kind: "limit",
-          limit: 3,
-          input: {
-            kind: "project",
-            properties: ["id", "name", "id"],
-            input: {
-              kind: "text",
-              query: "alpha",
-              fields: ["name", "description", "name"],
-              input: { kind: "start", objectTypeId: Room.id },
-            },
-          },
-        },
-      })
-
-      expect(normalized.kind).toBe("limit")
-      if (normalized.kind !== "limit") return
-      expect(normalized.limit).toBe(3)
-      expect(normalized.input.kind).toBe("project")
-      if (normalized.input.kind !== "project") return
-      expect(normalized.input.properties).toEqual(["id", "name"])
-      expect(normalized.input.input.kind).toBe("text")
-      if (normalized.input.input.kind !== "text") return
-      expect(normalized.input.input.fields).toEqual(["name", "description"])
-
-      const validated = validateObjectQuery(
-        { kind: "text", query: "alpha", input: { kind: "start", objectTypeId: Room.id } },
-        { ontology: objectQueryContractOntology }
-      )
-      expect(validated.query.kind).toBe("text")
-      if (validated.query.kind === "text") {
-        expect(validated.query.fields).toBeUndefined()
-        expect(validated.query.fieldsByObjectType).toEqual({
-          [Room.id]: ["name", "description"],
-        })
-      }
-    })
-
-    test("collects validation failures before provider planning", () => {
-      const issues = collectObjectQueryValidationIssues(
-        {
-          kind: "filter",
-          predicate: { op: "eq", propertyId: "missing", value: "x" },
-          input: {
-            kind: "text",
-            query: "alpha",
-            fields: ["capacity"],
-            input: { kind: "start", objectTypeId: Room.id },
-          },
-        },
-        { ontology: objectQueryContractOntology }
-      )
-
-      expect(issues.map((issue) => issue.code)).toEqual(
-        expect.arrayContaining([
-          "unknown_property",
-          "query_field_not_enabled",
-          "text_field_not_string_like",
-        ])
-      )
-    })
-
     test("declares the portable V1 query capability surface", async () => {
       await withStorage(async ({ objects: storage }) => {
         const capabilities = storage.queryCapabilities()
@@ -296,6 +270,7 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
           "in",
           "exists",
           "contains",
+          "constant",
         ] as const) {
           expect(capabilities.predicateOps?.[op]).toBe(true)
         }
@@ -661,6 +636,59 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
       })
     })
 
+    test("orders and compares strings by code point, whatever the database collation", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await seedLabels(fixture)
+
+        const run = (query: ObjectQuery) =>
+          executeObjectQuery(
+            { projectId, query },
+            { ontology: objectQueryContractOntology, storage }
+          )
+        const start: ObjectQuery = { kind: "start", objectTypeId: Label.id }
+        const byCode = (direction: "asc" | "desc", input: ObjectQuery = start): ObjectQuery => ({
+          kind: "sort",
+          fields: [{ kind: "property", propertyId: "code", direction }],
+          input,
+        })
+        const where = (predicate: ObjectQueryPredicate) =>
+          run(byCode("asc", { kind: "filter", predicate, input: start }))
+
+        const ascending = await run(byCode("asc"))
+        const descending = await run(byCode("desc"))
+
+        expect(ascending.plan.mode).toBe("pushdown")
+        expect(codes(ascending)).toEqual([...codePointOrder, null])
+        expect(codes(descending)).toEqual([...[...codePointOrder].reverse(), null])
+
+        // A page token resumes in the order that produced it.
+        const paged: unknown[] = []
+        let pageToken: string | undefined
+        do {
+          const page = await run({ kind: "page", pageSize: 3, pageToken, input: byCode("asc") })
+          paged.push(...codes(page))
+          pageToken = page.nextPageToken
+        } while (pageToken)
+
+        expect(paged).toEqual([...codePointOrder, null])
+
+        const range = await where({
+          op: "and",
+          items: [
+            { op: "gte", propertyId: "code", value: "a" },
+            { op: "lt", propertyId: "code", value: "é" },
+          ],
+        })
+
+        expect(codes(range)).toEqual(["a", "b", "z", "Á", "á"])
+        expect(codes(await where({ op: "gt", propertyId: "code", value: "" }))).toEqual(
+          codePointOrder.slice(1)
+        )
+        expect(codes(await where({ op: "lte", propertyId: "code", value: "B" }))).toEqual(["", "B"])
+        expect(codes(await where({ op: "gt", propertyId: "code", value: "Ａ" }))).toEqual(["😀"])
+      })
+    })
+
     test("keeps page tokens stable when projection hides sorted cursor fields", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture)
@@ -756,80 +784,21 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
       })
     })
 
-    test("counts matching objects without returning rows", async () => {
-      await withStorage(async ({ objects: storage, fixture }) => {
-        await seedObjectQueryContractData(fixture)
-
-        const active = await countObjects(
-          {
-            projectId,
-            query: {
-              kind: "filter",
-              predicate: { op: "eq", propertyId: "status", value: "active" },
-              input: { kind: "start", objectTypeId: Room.id },
-            },
-          },
-          { ontology: objectQueryContractOntology, storage }
-        )
-        const limited = await countObjects(
-          {
-            projectId,
-            query: { kind: "limit", limit: 2, input: { kind: "start", objectTypeId: Room.id } },
-          },
-          { ontology: objectQueryContractOntology, storage }
-        )
-
-        expect(active.plan.mode).toBe("pushdown")
-        expect(active.count).toBe(2)
-        expect(limited.count).toBe(5)
-      })
-    })
-
-    test("checks existence without returning rows", async () => {
-      await withStorage(async ({ objects: storage, fixture }) => {
-        await seedObjectQueryContractData(fixture)
-
-        const active = await existsObjects(
-          {
-            projectId,
-            query: {
-              kind: "filter",
-              predicate: { op: "eq", propertyId: "status", value: "active" },
-              input: { kind: "start", objectTypeId: Room.id },
-            },
-          },
-          { ontology: objectQueryContractOntology, storage }
-        )
-        const missing = await existsObjects(
-          {
-            projectId,
-            query: {
-              kind: "filter",
-              predicate: { op: "eq", propertyId: "name", value: "No Such Room" },
-              input: { kind: "start", objectTypeId: Room.id },
-            },
-          },
-          { ontology: objectQueryContractOntology, storage }
-        )
-        const limited = await existsObjects(
-          {
-            projectId,
-            query: { kind: "limit", limit: 0, input: { kind: "start", objectTypeId: Room.id } },
-          },
-          { ontology: objectQueryContractOntology, storage }
-        )
-
-        expect(active.plan.mode).toBe("pushdown")
-        expect(active.exists).toBe(true)
-        expect(missing.exists).toBe(false)
-        expect(limited.exists).toBe(true)
-      })
-    })
-
-    test("plans aggregate operations without outer row-shaping requirements", async () => {
+    test("counts and checks existence without returning rows or applying outer row shaping", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture)
-        const query: ObjectQuery = {
+        const context = { ontology: objectQueryContractOntology, storage }
+        const active: ObjectQuery = {
+          kind: "filter",
+          predicate: { op: "eq", propertyId: "status", value: "active" },
+          input: { kind: "start", objectTypeId: Room.id },
+        }
+        const missing: ObjectQuery = {
+          kind: "filter",
+          predicate: { op: "eq", propertyId: "name", value: "No Such Room" },
+          input: { kind: "start", objectTypeId: Room.id },
+        }
+        const relevance: ObjectQuery = {
           kind: "sort",
           fields: [{ kind: "relevance" }],
           input: {
@@ -839,23 +808,32 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
           },
         }
 
-        const count = await countObjects(
-          { projectId, query },
-          { ontology: objectQueryContractOntology, storage }
-        )
-        const exists = await existsObjects(
-          { projectId, query },
-          { ontology: objectQueryContractOntology, storage }
-        )
+        const activeCount = await countObjects({ projectId, query: active }, context)
+        expect(activeCount.plan.mode).toBe("pushdown")
+        expect(activeCount.count).toBe(2)
+        const activeExists = await existsObjects({ projectId, query: active }, context)
+        expect(activeExists.plan.mode).toBe("pushdown")
+        expect(activeExists.exists).toBe(true)
+        expect((await existsObjects({ projectId, query: missing }, context)).exists).toBe(false)
 
-        expect(count.plan.mode).toBe("pushdown")
-        if (count.plan.mode !== "pushdown") return
-        expect(count.plan.query.kind).toBe("text")
-        expect(count.count).toBe(1)
-        expect(exists.plan.mode).toBe("pushdown")
-        if (exists.plan.mode !== "pushdown") return
-        expect(exists.plan.query.kind).toBe("text")
-        expect(exists.exists).toBe(true)
+        // Limits and relevance sorts shape rows; aggregate terminals ignore them.
+        const limited = (limit: number): ObjectQuery => ({
+          kind: "limit",
+          limit,
+          input: { kind: "start", objectTypeId: Room.id },
+        })
+        expect((await countObjects({ projectId, query: limited(2) }, context)).count).toBe(5)
+        expect((await existsObjects({ projectId, query: limited(0) }, context)).exists).toBe(true)
+        const relevanceCount = await countObjects({ projectId, query: relevance }, context)
+        const relevanceExists = await existsObjects({ projectId, query: relevance }, context)
+        expect(relevanceCount.plan.mode).toBe("pushdown")
+        if (relevanceCount.plan.mode !== "pushdown") return
+        expect(relevanceCount.plan.query.kind).toBe("text")
+        expect(relevanceCount.count).toBe(1)
+        expect(relevanceExists.plan.mode).toBe("pushdown")
+        if (relevanceExists.plan.mode !== "pushdown") return
+        expect(relevanceExists.plan.query.kind).toBe("text")
+        expect(relevanceExists.exists).toBe(true)
       })
     })
 
@@ -954,6 +932,220 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
       })
     })
 
+    // Guard: the `bindCurrentUser` call in the executor's `validateExecutableQuery`. Without it,
+    // the provider receives the placeholder and these assertions fail.
+    test("binds currentUser() to the reading user before the provider sees the query", async () => {
+      await withStorage(async ({ storage: complete, objects: storage, fixture }) => {
+        const auth = complete.auth
+        if (!auth) throw new Error("The object query contract requires auth storage.")
+        for (const id of ["usr_alice", "usr_bob"]) {
+          await auth.users.create({ projectId, id, email: `${id}@example.com` })
+        }
+        const alice = { type: "user" as const, id: "usr_alice" }
+        const bob = { type: "user" as const, id: "usr_bob" }
+        await fixture.seed({
+          objects: [
+            objectSeed(Task.id, "t1", { assignee: alice, reviewers: [bob] }),
+            objectSeed(Task.id, "t2", { assignee: bob, reviewers: [alice] }),
+            objectSeed(Task.id, "t3", { assignee: null }),
+            objectSeed(Task.id, "t4", { reviewers: [alice, bob] }),
+          ],
+        })
+
+        const received: string[] = []
+        const spy = recordingCalls(storage, received)
+        const ids = async (predicate: ObjectQueryPredicate, user?: typeof alice) => {
+          const result = await executeObjectQuery(
+            {
+              projectId,
+              query: {
+                kind: "sort",
+                fields: [{ kind: "property", propertyId: "id" }],
+                input: {
+                  kind: "filter",
+                  predicate,
+                  input: { kind: "start", objectTypeId: Task.id },
+                },
+              },
+            },
+            { ontology: objectQueryContractOntology, storage: spy, requestingUser: user }
+          )
+          expect(result.plan.mode).toBe("pushdown")
+          return result.objects.map((object) => object.primaryId)
+        }
+
+        const me = { type: "currentUser" }
+        const eq: ObjectQueryPredicate = { op: "eq", propertyId: "assignee", value: me }
+        const neq: ObjectQueryPredicate = { op: "neq", propertyId: "assignee", value: me }
+        const inMeOrBob: ObjectQueryPredicate = {
+          op: "in",
+          propertyId: "assignee",
+          values: [me, bob],
+        }
+        const inMe: ObjectQueryPredicate = { op: "in", propertyId: "assignee", values: [me] }
+        const reviewing: ObjectQueryPredicate = {
+          op: "contains",
+          propertyId: "reviewers",
+          value: me,
+        }
+        const notMine: ObjectQueryPredicate = { op: "not", item: eq }
+        const notReviewing: ObjectQueryPredicate = { op: "not", item: reviewing }
+
+        expect(await ids(eq, alice)).toEqual(["t1"])
+        expect(await ids(neq, alice)).toEqual(["t2", "t3", "t4"])
+        expect(await ids(inMeOrBob, alice)).toEqual(["t1", "t2"])
+        expect(await ids(inMe, alice)).toEqual(["t1"])
+        expect(await ids(reviewing, alice)).toEqual(["t2", "t4"])
+        expect(await ids(notMine, alice)).toEqual(["t2", "t3", "t4"])
+        expect(await ids(notReviewing, alice)).toEqual(["t1", "t3"])
+
+        // A reader that is not a user matches no one, and `neq` stays the complement of `eq`.
+        expect(await ids(eq)).toEqual([])
+        expect(await ids(neq)).toEqual(["t1", "t2", "t3", "t4"])
+        expect(await ids(inMeOrBob)).toEqual(["t2"])
+        expect(await ids(inMe)).toEqual([])
+        expect(await ids(reviewing)).toEqual([])
+        expect(await ids(notMine)).toEqual(["t1", "t2", "t3", "t4"])
+        expect(await ids(notReviewing)).toEqual(["t1", "t2", "t3", "t4"])
+
+        expect(received.length).toBeGreaterThan(0)
+        expect(received.filter((call) => call.includes('"currentUser"'))).toEqual([])
+      })
+    })
+
+    test("matches every object on a constant true and none on a constant false", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await fixture.seed({
+          objects: [
+            objectSeed(Device.id, "d1", { id: "d1", name: "Lamp" }),
+            objectSeed(Device.id, "d2", { id: "d2", name: "Fan" }),
+          ],
+        })
+
+        const context = { ontology: objectQueryContractOntology, storage }
+        const matching = async (predicate: ObjectQueryPredicate) => {
+          const query: ObjectQuery = {
+            kind: "filter",
+            predicate,
+            input: { kind: "start", objectTypeId: Device.id },
+          }
+
+          const listed = await executeObjectQuery(
+            {
+              projectId,
+              query: {
+                kind: "sort",
+                fields: [{ kind: "property", propertyId: "id" }],
+                input: query,
+              },
+            },
+            context
+          )
+          const counted = await countObjects({ projectId, query }, context)
+          const exists = await existsObjects({ projectId, query }, context)
+
+          expect([listed.plan.mode, counted.plan.mode, exists.plan.mode]).toEqual([
+            "pushdown",
+            "pushdown",
+            "pushdown",
+          ])
+          expect(counted.count).toBe(listed.objects.length)
+          expect(exists.exists).toBe(listed.objects.length > 0)
+
+          return listed.objects.map((object) => object.primaryId)
+        }
+
+        const all: ObjectQueryPredicate = { op: "constant", value: true }
+        const none: ObjectQueryPredicate = { op: "constant", value: false }
+        const lamp: ObjectQueryPredicate = { op: "eq", propertyId: "name", value: "Lamp" }
+
+        expect(await matching(all)).toEqual(["d1", "d2"])
+        expect(await matching(none)).toEqual([])
+
+        expect(await matching({ op: "and", items: [all, lamp] })).toEqual(["d1"])
+        expect(await matching({ op: "and", items: [none, lamp] })).toEqual([])
+        expect(await matching({ op: "or", items: [none, lamp] })).toEqual(["d1"])
+        expect(await matching({ op: "or", items: [all, lamp] })).toEqual(["d1", "d2"])
+
+        expect(await matching({ op: "not", item: none })).toEqual(["d1", "d2"])
+        expect(await matching({ op: "not", item: all })).toEqual([])
+      })
+    })
+
+    test("compares dates and timestamps as instants, whatever offset or precision", async () => {
+      await withStorage(async ({ objects: storage, fixture }) => {
+        await fixture.seed({
+          objects: [
+            objectSeed(Meeting.id, "m1", {
+              id: "m1",
+              startsAt: "2026-01-01T00:00:00.000Z",
+              day: "2026-01-01",
+              reminders: ["2025-12-31T23:00:00.000Z"],
+            }),
+            objectSeed(Meeting.id, "m2", {
+              id: "m2",
+              startsAt: "2026-01-01T01:00:00.000Z",
+              day: "2026-01-02",
+              reminders: [],
+            }),
+            objectSeed(Meeting.id, "m3", {
+              id: "m3",
+              startsAt: "2026-01-01T02:00:00.000Z",
+              day: "2026-01-03",
+              reminders: [],
+            }),
+          ],
+        })
+
+        const context = { ontology: objectQueryContractOntology, storage }
+        const matching = async (predicate: ObjectQueryPredicate) => {
+          const query: ObjectQuery = {
+            kind: "filter",
+            predicate,
+            input: { kind: "start", objectTypeId: Meeting.id },
+          }
+
+          const listed = await executeObjectQuery({ projectId, query }, context)
+          expect(listed.plan.mode).toBe("pushdown")
+
+          return listed.objects.map((object) => object.primaryId).sort()
+        }
+
+        // Each value names a stored instant in another offset, or without milliseconds.
+        const startsAt = (op: "eq" | "neq" | "lt" | "lte" | "gt" | "gte", value: string) =>
+          matching({ op, propertyId: "startsAt", value })
+
+        expect(await startsAt("eq", "2026-01-01T01:00:00Z")).toEqual(["m2"])
+        expect(await startsAt("neq", "2026-01-01T00:00:00Z")).toEqual(["m2", "m3"])
+        expect(await startsAt("lt", "2026-01-01T02:00:00+02:00")).toEqual([])
+        expect(await startsAt("lte", "2026-01-01T02:00:00+02:00")).toEqual(["m1"])
+        expect(await startsAt("gt", "2026-01-01T02:30:00+01:30")).toEqual(["m3"])
+        expect(await startsAt("gte", "2026-01-01T02:30:00+01:30")).toEqual(["m2", "m3"])
+        expect(
+          await matching({
+            op: "in",
+            propertyId: "startsAt",
+            values: ["2026-01-01T03:00:00+01:00", "2026-01-01T00:00:00Z"],
+          })
+        ).toEqual(["m1", "m3"])
+        expect(
+          await matching({
+            op: "contains",
+            propertyId: "reminders",
+            value: "2026-01-01T00:00:00+01:00",
+          })
+        ).toEqual(["m1"])
+
+        // A date is the calendar day of its instant in UTC, as storage writes it.
+        expect(
+          await matching({ op: "lt", propertyId: "day", value: "2026-01-02T00:00:00+05:00" })
+        ).toEqual([])
+        expect(
+          await matching({ op: "eq", propertyId: "day", value: "2026-01-02T12:00:00Z" })
+        ).toEqual(["m2"])
+      })
+    })
+
     test("counts matching objects by facetable properties without returning rows", async () => {
       await withStorage(async ({ objects: storage, fixture }) => {
         await seedObjectQueryContractData(fixture)
@@ -1369,37 +1561,10 @@ export function runObjectQueryProviderContractSuite<TStorage extends Storage>(
         expect(ids(result)).toEqual(["room-alpha", "room-beta"])
       })
     })
-
-    test("rejects fallback for unsupported query nodes when pushdown is disabled", async () => {
-      await withStorage(async ({ objects: storage, fixture }) => {
-        await seedObjectQueryContractData(fixture)
-        const fallbackStorage = withoutQueryPushdown(storage)
-
-        await expectPlanningIssue(
-          executeObjectQuery(
-            {
-              projectId,
-              query: {
-                kind: "limit",
-                limit: 5,
-                input: {
-                  kind: "traverse",
-                  direction: "outgoing",
-                  linkId: "hasDevice",
-                  input: { kind: "start", objectTypeId: Room.id },
-                },
-              },
-            },
-            { ontology: objectQueryContractOntology, storage: fallbackStorage, maxFallbackRows: 20 }
-          ),
-          "fallback_node_not_supported"
-        )
-      })
-    })
   })
 }
 
-export async function seedObjectQueryContractData(fixture: MaterializerTestFixture): Promise<void> {
+async function seedObjectQueryContractData(fixture: MaterializerTestFixture): Promise<void> {
   await fixture.seed({
     objects: [
       objectSeed(Room.id, "room-alpha", {
@@ -1476,6 +1641,37 @@ export async function seedObjectQueryContractData(fixture: MaterializerTestFixtu
   })
 }
 
+// Primary ids run against the code order, so only a sort by code can produce it.
+async function seedLabels(fixture: MaterializerTestFixture): Promise<void> {
+  await fixture.seed({
+    objects: [
+      ...codePointOrder.map((code, index) =>
+        objectSeed(Label.id, `label-${codePointOrder.length - index}`, {
+          id: `label-${codePointOrder.length - index}`,
+          code,
+        })
+      ),
+      objectSeed(Label.id, "label-null", { id: "label-null", code: null }),
+    ],
+    links: [],
+  })
+}
+
+/** Wrap storage so every call's arguments are recorded as JSON before it runs. */
+function recordingCalls<TStorage extends object>(storage: TStorage, received: string[]): TStorage {
+  return new Proxy(storage, {
+    get(target, key) {
+      const value = Reflect.get(target, key, target)
+      if (typeof value !== "function") return value
+
+      return (...args: unknown[]) => {
+        received.push(JSON.stringify(args))
+        return value.apply(target, args)
+      }
+    },
+  })
+}
+
 function objectSeed(
   objectTypeId: string,
   primaryId: string,
@@ -1507,6 +1703,10 @@ function ids(result: QueryObjectsResult): string[] {
   return result.objects.map((row) => row.primaryId)
 }
 
+function codes(result: QueryObjectsResult): unknown[] {
+  return result.objects.map((row) => row.properties.code)
+}
+
 // Sorted primaryIds of the objects hydrated under `linkId` on the parent row.
 function expandedIds(result: QueryObjectsResult, parentId: string, linkId: string): string[] {
   const parent = result.objects.find((row) => row.primaryId === parentId)