@manta-eu/horns-server 0.2.0 → 0.2.1

package/dist/horn-routes.js

@@ -484,6 +484,83 @@ export function hornRoutes(deps = {}) {
      * Two segments because one would not be safe: `about` is a legal slug, so `/horns/about` is a Horn
      * somebody may have saved, and `/horns/:slug` would answer for it either way.
      */
+    // Three fit beside a thing without pushing it off the screen; ten is where the reading cost stops being
+    // one query and starts being a page of them.
+    const defaultAboutLimit = 3;
+    const maxAboutLimit = 10;
+    /**
+     * Every Horn about a thing, for a host that has room for more than one.
+     *
+     * The singular route answers with one and counts the rest, which is what a panel beside a plan wants.
+     * A host showing a thing's whole story wants them all: `?limit=` caps how many come back whole, and
+     * `total` says how many there are. Nothing kept falls back the same way the singular route does, so an
+     * IRI nobody has made a Horn for still draws.
+     */
+    routes.get("/api/d/:datastoreId/horns/by/about/list", async (c) => {
+        const datastoreId = c.req.param("datastoreId");
+        const authorized = await authorize(c.req.raw, c.env, datastoreId);
+        if (!authorized.ok)
+            return authorized.response;
+        const realm = c.env.VITE_KEYCLOAK_REALM;
+        if (!isPresent(realm) || !isRealm(realm))
+            return refuse(500, "This deployment has no realm configured.").response;
+        const about = c.req.query("iri");
+        if (!isPresent(about))
+            return refuse(400, "Ask with ?iri=<the thing's IRI>.").response;
+        if (!isAbsoluteIri(about))
+            return refuse(400, `"${about}" is not an IRI.`).response;
+        const asked = Number(c.req.query("limit") ?? defaultAboutLimit);
+        if (!Number.isInteger(asked) || asked < 1 || asked > maxAboutLimit) {
+            return refuse(400, `limit is a whole number from 1 to ${maxAboutLimit}.`).response;
+        }
+        const select = agentsSparqlSelect({
+            agentsUrl: c.env.MANTA_AGENTS_URL,
+            upstream: c.env.UPSTREAM,
+            session: authorized.session,
+            datastoreId,
+        });
+        try {
+            const found = await select(hornsAboutQuery(realm, about), undefined);
+            // One row per revision, and a Horn can bring two of those, so the Horn is what is counted and the
+            // first row for each is the one read.
+            const firstRows = new Map();
+            for (const row of found.results.bindings) {
+                const hornIri = row["horn"]?.value;
+                if (isPresent(hornIri) && !firstRows.has(hornIri))
+                    firstRows.set(hornIri, row);
+            }
+            if (firstRows.size === 0) {
+                const made = (await hornForRule({ select, realm, datastoreId, about })) ??
+                    (await hornForPlan({ select, realm, datastoreId, about }));
+                return made === undefined
+                    ? Response.json({ horns: [], total: 0 }, { headers: noStore })
+                    : Response.json({ horns: [{ horn: made, kept: false }], total: 0 }, { headers: noStore });
+            }
+            const wanted = [...firstRows.entries()].slice(0, asked);
+            const read = await Promise.all(wanted.map(async ([hornIri, row]) => {
+                const revision = row["revision"]?.value;
+                if (!isPresent(revision))
+                    return undefined;
+                const one = await hornAtRevision({ select, realm, hornIri, revision, number: Number(row["number"]?.value) });
+                if (one === undefined)
+                    return undefined;
+                const slug = row["slug"]?.value;
+                return {
+                    horn: one.horn,
+                    kept: true,
+                    revision,
+                    contentHash: await contentHash(one.stored),
+                    ...(isPresent(slug) ? { slug } : {}),
+                };
+            }));
+            // A revision that no longer reads as a Horn is left out rather than failing the lot: the others are
+            // still worth drawing, and `total` already says more exist.
+            return Response.json({ horns: read.filter(isPresent), total: firstRows.size }, { headers: noStore });
+        }
+        catch (caught) {
+            return refuse(502, caught instanceof Error ? caught.message : String(caught)).response;
+        }
+    });
     routes.get("/api/d/:datastoreId/horns/by/about", async (c) => {
         const datastoreId = c.req.param("datastoreId");
         const authorized = await authorize(c.req.raw, c.env, datastoreId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manta-eu/horns-server",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The Manta Horns worker as a library: Hono routes a Cloudflare host mounts on its own app.",
   "license": "MIT",
   "repository": {
@@ -70,8 +70,8 @@
     "sparqljs": "^3.7.4",
     "typescript": "^5.9.0",
     "zod": "^4.5.4",
-    "@manta-eu/horns": "0.2.0",
-    "@manta-eu/horns-kit": "0.2.0"
+    "@manta-eu/horns": "0.2.1",
+    "@manta-eu/horns-kit": "0.2.1"
   },
   "devDependencies": {
     "@cloudflare/vite-plugin": "1.47.0",