@wrenautomation/vireo 0.11.0 → 0.13.0

package/dist/store.js

@@ -7,12 +7,15 @@ import { PgTransaction } from "drizzle-orm/pg-core";
 import { collect } from "./collect.js";
 import { atomic, VireoError } from "./db.js";
 import { live } from "./live.js";
-import { batches, guides, lineage, notes, samples, ships, steers, subjects, TAP, VERDICTS, verdictOf, } from "./schema.js";
+import { batches, calls, guides, lineage, notes, samples, ships, steers, subjects, TAP, VERDICTS, verdictOf, } from "./schema.js";
 import { fitPlackettLuce, rateSplit, tiersToChoices } from "./stats.js";
 import { isSource } from "./sync.js";
 /** `s3://` (the bucket signs it) or `https://` (served as is: a live page on its own origin). */
 export const isMediaUri = (uri) => /^(s3|https):\/\/[^\s/]+/i.test(uri);
 const parentOf = (p) => typeof p === "number" ? { id: p, took: null } : { id: p.id, took: p.took?.trim() || null };
+/** `by` of calls made before calls had a judge (migration 0008); a host may name them after. */
+export const EARLIER_JUDGE = "person";
+export const BATCH_SORTS = ["waiting", "newest", "oldest", "subject", "good"];
 /** `roots` and every sample that grew from them, over any parent edge. */
 function grownFrom(roots, edges) {
     const kids = new Map();
@@ -47,26 +50,72 @@ const shuffled = (xs) => {
     return a;
 };
 /**
- * Strength per judged sample: each judged batch is a partial ranking by score, 10 down to 1, ties
- * unordered. Wins from 9 and up count double.
+ * One sheet per (batch, person) who called in it: each sample of the batch with that person's
+ * call, or none (unmarked). The unit of every rank and rate (D11).
  */
-export function strengths(rows) {
-    const byBatch = new Map();
+export function sheets(rows, cs) {
+    const inBatch = new Map();
     for (const r of rows)
-        byBatch.set(r.batchId, [...(byBatch.get(r.batchId) ?? []), r]);
-    const judged = [...byBatch.values()].filter((b) => b.some((r) => r.score != null));
-    const ids = judged.flat().map((r) => String(r.id));
+        inBatch.set(r.batchId, [...(inBatch.get(r.batchId) ?? []), r.id]);
+    const batchOf = new Map(rows.map((r) => [r.id, r.batchId]));
+    const out = new Map();
+    for (const c of cs) {
+        const b = batchOf.get(c.sampleId);
+        if (b == null)
+            continue;
+        const k = `${b}\u0000${c.by}`;
+        const sheet = out.get(k) ?? { batchId: b, by: c.by, got: new Map() };
+        sheet.got.set(c.sampleId, c);
+        out.set(k, sheet);
+    }
+    return [...out.values()].map((x) => ({
+        batchId: x.batchId,
+        by: x.by,
+        marks: (inBatch.get(x.batchId) ?? []).map((id) => ({ id, call: x.got.get(id) ?? null })),
+    }));
+}
+/**
+ * Strength per judged sample: each sheet is a partial ranking by score, 10 down to 1, ties
+ * unordered; unmarked reads as 5. Wins from 9 and up count double.
+ */
+export function strengths(rows, cs) {
+    const ss = sheets(rows, cs);
+    const ids = [...new Set(ss.flatMap((x) => x.marks.map((m) => String(m.id))))];
     const scores = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
-    const choices = judged.flatMap((b) => tiersToChoices(scores.map((n) => b.filter((r) => (r.score ?? UNMARKED) === n).map((r) => String(r.id))), scores.map((n) => (n >= TAP.amazing ? 2 : 1))));
+    const choices = ss.flatMap((x) => tiersToChoices(scores.map((n) => x.marks.filter((m) => (m.call?.score ?? UNMARKED) === n).map((m) => String(m.id))), scores.map((n) => (n >= TAP.amazing ? 2 : 1))));
     return fitPlackettLuce(ids, choices);
 }
-/** With-vs-without good rate per guide, over judged samples. */
-export function guideStats(guideRows, judged) {
+/** Good or better over every (sample, person) mark of these sheets; null with none. */
+export function goodRateOf(ss) {
+    const marks = ss.flatMap((x) => x.marks);
+    return marks.length
+        ? marks.filter((m) => GOOD.includes(m.call?.verdict ?? null)).length / marks.length
+        : null;
+}
+/** With-vs-without good rate per guide, over every mark in judged batches. */
+export function guideStats(guideRows, judged, cs) {
+    const guidesOf = new Map(judged.map((r) => [r.id, r.guides]));
+    const marks = sheets(judged, cs).flatMap((x) => x.marks);
     return guideRows.map((g) => ({
         ...g,
-        effect: rateSplit(judged.map((s) => ({ has: s.guides.includes(g.id), good: GOOD.includes(s.verdict) }))),
+        effect: rateSplit(marks.map((m) => ({
+            has: (guidesOf.get(m.id) ?? []).includes(g.id),
+            good: GOOD.includes(m.call?.verdict ?? null),
+        }))),
     }));
 }
+/** Mean of the calls a reader may see, and its zone; null with none. */
+const pooled = (cs) => {
+    if (!cs.length)
+        return { score: null, verdict: null };
+    const mean = cs.reduce((a, c) => a + c.score, 0) / cs.length;
+    return { score: Math.round(mean * 10) / 10, verdict: verdictOf(Math.round(mean)) };
+};
+/**
+ * What a reader may see of an open batch (D11). `viewer` = a person: while open, only their own
+ * calls and notes, and none of the agent's words. Null = the agent: everything.
+ */
+const blindFor = (viewer, open) => viewer != null && open;
 /** Waits on the person: open and its subject's newest. A newer batch replaces an unmarked one. */
 const WAITS = and(eq(batches.state, "open"), sql `${batches.n} = (select max(b.n) from vireo.batches b where b.subject_id = ${batches.subjectId})`);
 /** How people and agents name a batch: its number within the subject. The id is secondary. */
@@ -243,6 +292,12 @@ export class Vireo {
     async addBatch(ref, b) {
         if (!b.why.trim())
             throw new VireoError("say why: what changed and what it tests");
+        const title = b.title?.trim() || null;
+        // appending keeps the batch's title
+        if (b.into == null && !title)
+            throw new VireoError("a title: one line, what this batch is");
+        if (title && title.length > 120)
+            throw new VireoError("a title is 120 characters at most");
         if (!b.samples.length)
             throw new VireoError("a batch needs samples");
         for (const s of b.samples)
@@ -319,6 +374,7 @@ export class Vireo {
                     .values({
                     subjectId: subject.id,
                     n: (top?.n ?? 0) + 1,
+                    title,
                     why: b.why,
                     agent: b.agent ?? null,
                 })
@@ -493,8 +549,11 @@ export class Vireo {
         const pruned = await this.prunedIn(this.db, s.id, live);
         return { steers: live, pruned: [...pruned.keys()].sort((a, b) => a - b) };
     }
-    /** Batches that wait on the person, oldest first, with samples and notes: what they have to pick. */
-    async queue(ref) {
+    /**
+     * Batches that wait on the person, oldest first, with samples and notes: what they have to pick.
+     * `viewer`: a person sees only their own calls and notes (D11).
+     */
+    async queue(ref, viewer = null) {
         // a subject, or one batch as `<subject>:<n>`
         const one = typeof ref === "string" && /:\d+$/.test(ref) ? await this.batchOf(ref) : null;
         const subjectId = ref == null || one ? null : (await this.subjectOf(ref)).id;
@@ -511,15 +570,30 @@ export class Vireo {
             .from(samples)
             .where(inArray(samples.batchId, open.map((o) => o.batch.id)))
             .orderBy(asc(samples.position));
-        const ns = await this.notesOf(rows.map((r) => r.id));
+        const ids = rows.map((r) => r.id);
+        const mine = (x) => viewer == null || x.by === viewer;
+        const ns = (await this.notesOf(ids)).filter(mine);
+        const cs = (await this.callsOf(ids)).filter(mine);
         return open.map((o) => ({
             batch: { ref: refOf(o.subject.slug, o.batch.n), ...o.batch },
             subject: o.subject,
             samples: rows
                 .filter((r) => r.batchId === o.batch.id)
-                .map((r) => ({ ...r, notes: ns.filter((n) => n.sampleId === r.id) })),
+                .map((r) => {
+                const own = cs.filter((c) => c.sampleId === r.id);
+                return { ...r, ...pooled(own), calls: own, notes: ns.filter((n) => n.sampleId === r.id) };
+            }),
         }));
     }
+    async callsOf(sampleIds) {
+        if (!sampleIds.length)
+            return [];
+        return this.db
+            .select()
+            .from(calls)
+            .where(inArray(calls.sampleId, sampleIds))
+            .orderBy(asc(calls.at));
+    }
     async notesOf(sampleIds) {
         if (!sampleIds.length)
             return [];
@@ -539,20 +613,37 @@ export class Vireo {
             .where(inArray(lineage.childId, childIds))
             .orderBy(asc(lineage.childId), asc(lineage.position));
     }
-    /** A call: a 1-10 score, a verdict (its tap score) or null to clear. The verdict follows. */
+    /**
+     * `by`'s call: a 1-10 score, a verdict (its tap score) or null to clear. The verdict follows.
+     * One call per person per sample (D11).
+     */
     async judge(sampleId, call, by) {
+        if (!by)
+            throw new VireoError("a call needs who made it", 400);
         const score = typeof call === "string" ? TAP[call] : call;
         if (score != null && !(Number.isInteger(score) && score >= 1 && score <= 10))
             throw new VireoError(`score ${score}: 1-10, or ${VERDICTS.join("|")}`, 400);
         return this.write(by, async (tx) => {
             const [row] = await tx
-                .update(samples)
-                .set({ score, verdict: score == null ? null : verdictOf(score) })
-                .where(eq(samples.id, sampleId))
-                .returning({ id: samples.id, score: samples.score, verdict: samples.verdict });
+                .select({ id: samples.id })
+                .from(samples)
+                .where(eq(samples.id, sampleId));
             if (!row)
                 throw new VireoError(`no sample ${sampleId}`, 404);
-            return row;
+            const mine = and(eq(calls.sampleId, sampleId), eq(calls.by, by));
+            if (score == null) {
+                await tx.delete(calls).where(mine);
+                return { id: sampleId, by, score: null, verdict: null };
+            }
+            const verdict = verdictOf(score);
+            await tx
+                .insert(calls)
+                .values({ sampleId, by, score, verdict })
+                .onConflictDoUpdate({
+                target: [calls.sampleId, calls.by],
+                set: { score, verdict, at: sql `now()` },
+            });
+            return { id: sampleId, by, score, verdict };
         });
     }
     async addNote(sampleId, n, by) {
@@ -620,6 +711,25 @@ export class Vireo {
             return row;
         });
     }
+    /** A batch's title (id or `<subject>:<n>`); blank refused. */
+    async renameBatch(ref, title, by) {
+        const to = title.trim();
+        if (!to)
+            throw new VireoError("a title, not blank");
+        if (to.length > 120)
+            throw new VireoError("a title is 120 characters at most");
+        return this.write(by, async (tx) => {
+            const id = await this.batchOf(ref, tx);
+            const [row] = await tx
+                .update(batches)
+                .set({ title: to })
+                .where(eq(batches.id, id))
+                .returning({ id: batches.id, n: batches.n, title: batches.title });
+            if (!row)
+                throw new VireoError(`no batch ${ref}`, 404);
+            return row;
+        });
+    }
     /** A sample's short name; blank clears it. */
     async renameSample(sampleId, name, by) {
         const to = name?.trim() || null;
@@ -690,10 +800,11 @@ export class Vireo {
             .orderBy(asc(samples.batchId), asc(samples.position));
         const ns = await this.notesOf(ss.map((r) => r.id));
         const es = await this.lineageOf(ss.map((r) => r.id));
+        const cs = await this.callsOf(ss.map((r) => r.id));
         const judgedBatches = new Set(bs.filter((b) => b.state === "closed").map((b) => b.id));
         const judged = ss.filter((r) => judgedBatches.has(r.batchId));
-        const strength = new Map(strengths(ss).map((x) => [Number(x.id), x]));
-        const gs = guideStats(await this.guidesFor(s), judged);
+        const strength = new Map(strengths(ss, cs).map((x) => [Number(x.id), x]));
+        const gs = guideStats(await this.guidesFor(s), judged, cs);
         return {
             subject: s,
             guides: gs,
@@ -702,11 +813,14 @@ export class Vireo {
                 return {
                     ref: refOf(s.slug, b.n),
                     ...b,
-                    goodRate: mine.length
-                        ? mine.filter((r) => GOOD.includes(r.verdict)).length / mine.length
-                        : null,
+                    goodRate: goodRateOf(sheets(mine, cs)),
+                    judges: [
+                        ...new Set(cs.filter((c) => mine.some((r) => r.id === c.sampleId)).map((c) => c.by)),
+                    ],
                     samples: mine.map((r) => ({
                         ...r,
+                        ...pooled(cs.filter((c) => c.sampleId === r.id)),
+                        calls: cs.filter((c) => c.sampleId === r.id),
                         strength: strength.get(r.id) ?? null,
                         notes: ns.filter((n) => n.sampleId === r.id),
                         parents: es
@@ -779,6 +893,165 @@ export class Vireo {
         return out;
     }
     /** Kept samples, newest first, with their subject. */
+    /**
+     * Batches as a page: filters, a sort and an offset (D11). `viewer` = the person reading: an open
+     * batch shows only their own marks, and none of the agent's words.
+     */
+    async batches(q = {}, viewer = null) {
+        const limit = Math.min(Math.max(q.limit ?? 30, 1), 100);
+        const after = Math.max(q.after ?? 0, 0);
+        const subjectId = q.subject == null ? null : (await this.subjectOf(q.subject)).id;
+        const good = sql `${calls.verdict} in ('good', 'amazing')`;
+        const n = sql `count(distinct ${samples.id})::int`;
+        const judges = sql `count(distinct ${calls.by})::int`;
+        // an open batch has no rate: partial, and a sort on it would show others' marks
+        const rate = sql `case when ${batches.state} = 'closed' then (count(${calls.id}) filter (where ${good}))::float / nullif((${judges}) * (${n}), 0) end`;
+        const waits = sql `(${WAITS})`;
+        const tally = (v) => sql `(count(${calls.id}) filter (where ${calls.verdict} = ${v}))::int`;
+        const where = and(q.subjects
+            ? inArray(batches.subjectId, q.subjects.length ? [...q.subjects] : [-1])
+            : undefined, subjectId ? eq(batches.subjectId, subjectId) : undefined, q.kind ? eq(subjects.kind, q.kind) : undefined, q.state === "waits" ? WAITS : q.state ? eq(batches.state, q.state) : undefined, q.who
+            ? sql `exists (select 1 from vireo.calls c join vireo.samples x on x.id = c.sample_id where x.batch_id = ${batches.id} and c.by = ${q.who})`
+            : undefined);
+        const order = {
+            newest: [desc(batches.createdAt), desc(batches.id)],
+            oldest: [asc(batches.createdAt), asc(batches.id)],
+            waiting: [desc(waits), desc(batches.createdAt), desc(batches.id)],
+            subject: [asc(subjects.name), desc(batches.n)],
+            good: [sql `${rate} desc nulls last`, desc(batches.createdAt), desc(batches.id)],
+        }[q.sort ?? "waiting"];
+        const got = await this.db
+            .select({
+            batch: batches,
+            subject: subjects,
+            samples: n,
+            kept: sql `(count(distinct ${samples.id}) filter (where ${samples.keptAt} is not null))::int`,
+            judges,
+            mine: viewer
+                ? sql `(count(${calls.id}) filter (where ${calls.by} = ${viewer}))::int`
+                : sql `0`,
+            rate,
+            waits,
+            amazing: tally("amazing"),
+            good: tally("good"),
+            okay: tally("okay"),
+            bad: tally("bad"),
+        })
+            .from(batches)
+            .innerJoin(subjects, eq(subjects.id, batches.subjectId))
+            .leftJoin(samples, eq(samples.batchId, batches.id))
+            .leftJoin(calls, eq(calls.sampleId, samples.id))
+            .where(where)
+            .groupBy(batches.id, subjects.id)
+            .orderBy(...order)
+            .limit(limit + 1)
+            .offset(after);
+        const page = got.slice(0, limit);
+        const [count] = await this.db
+            .select({ waiting: sql `(count(*) filter (where ${WAITS}))::int` })
+            .from(batches)
+            .innerJoin(subjects, eq(subjects.id, batches.subjectId))
+            .where(where);
+        // thumbs: each batch's posters in made order, with the calls a reader may see
+        const thumbs = page.length
+            ? await this.db
+                .select({ id: samples.id, batchId: samples.batchId, poster: samples.poster })
+                .from(samples)
+                .where(and(inArray(samples.batchId, page.map((r) => r.batch.id)), isNotNull(samples.poster)))
+                .orderBy(asc(samples.id))
+            : [];
+        const cs = await this.callsOf(thumbs.map((t) => t.id));
+        return {
+            rows: page.map((r) => {
+                const blind = blindFor(viewer, r.batch.state === "open");
+                const tallied = r.judges * r.samples;
+                return {
+                    ref: refOf(r.subject.slug, r.batch.n),
+                    id: r.batch.id,
+                    n: r.batch.n,
+                    title: r.batch.title,
+                    state: r.batch.state,
+                    note: r.batch.note,
+                    why: blind ? null : r.batch.why,
+                    createdAt: r.batch.createdAt,
+                    subject: r.subject,
+                    waits: r.waits,
+                    samples: r.samples,
+                    kept: r.kept,
+                    // while open a person sees only their own count
+                    marked: blind ? r.mine : r.amazing + r.good + r.okay + r.bad,
+                    judges: blind ? null : r.judges,
+                    goodRate: blind ? null : r.rate,
+                    tally: blind
+                        ? null
+                        : {
+                            amazing: r.amazing,
+                            good: r.good,
+                            okay: r.okay,
+                            bad: r.bad,
+                            unmarked: tallied ? tallied - (r.amazing + r.good + r.okay + r.bad) : r.samples,
+                        },
+                    thumbs: thumbs
+                        .filter((t) => t.batchId === r.batch.id)
+                        .map((t) => ({
+                        id: t.id,
+                        poster: t.poster,
+                        verdict: blind ? null : pooled(cs.filter((c) => c.sampleId === t.id)).verdict,
+                    })),
+                };
+            }),
+            next: got.length > limit ? after + limit : null,
+            waiting: count?.waiting ?? 0,
+        };
+    }
+    /** One batch whole, for `viewer` (see `batches`); `newer` = the subject's newer open batch. */
+    async batch(ref, viewer = null) {
+        const id = await this.batchOf(ref);
+        const [o] = await this.db
+            .select({ batch: batches, subject: subjects })
+            .from(batches)
+            .innerJoin(subjects, eq(subjects.id, batches.subjectId))
+            .where(eq(batches.id, id));
+        if (!o)
+            throw new VireoError(`no batch ${ref}`, 404);
+        const blind = blindFor(viewer, o.batch.state === "open");
+        const rows = await this.db
+            .select()
+            .from(samples)
+            .where(eq(samples.batchId, id))
+            .orderBy(asc(samples.id));
+        const ids = rows.map((r) => r.id);
+        const seen = (x) => !blind || x.by === viewer;
+        const ns = (await this.notesOf(ids)).filter(seen);
+        const cs = (await this.callsOf(ids)).filter(seen);
+        const es = blind ? [] : await this.lineageOf(ids);
+        const [newer] = await this.db
+            .select({ n: batches.n })
+            .from(batches)
+            .where(and(eq(batches.subjectId, o.batch.subjectId), eq(batches.state, "open"), sql `${batches.n} > ${o.batch.n}`))
+            .orderBy(desc(batches.n))
+            .limit(1);
+        return {
+            ref: refOf(o.subject.slug, o.batch.n),
+            ...o.batch,
+            why: blind ? null : o.batch.why,
+            subject: o.subject,
+            goodRate: blind ? null : goodRateOf(sheets(rows, cs)),
+            judges: blind ? null : [...new Set(cs.map((c) => c.by))],
+            newer: newer ? { n: newer.n, ref: refOf(o.subject.slug, newer.n) } : null,
+            samples: rows.map((r) => ({
+                ...r,
+                name: blind ? null : r.name,
+                change: blind ? null : r.change,
+                ...pooled(cs.filter((c) => c.sampleId === r.id)),
+                calls: cs.filter((c) => c.sampleId === r.id),
+                notes: ns.filter((x) => x.sampleId === r.id),
+                parents: es
+                    .filter((e) => e.childId === r.id)
+                    .map((e) => ({ id: e.parentId, took: e.took })),
+            })),
+        };
+    }
     async catalog(opts = {}) {
         const subjectId = opts.subject == null ? null : (await this.subjectOf(opts.subject)).id;
         return this.db