@bongos/core 1.19.316 → 1.19.318

package/modules/lifecycle/db-versions.js

@@ -0,0 +1,118 @@
+// modules/lifecycle/db-versions.js — version rows + version progress.
+//
+// Carved out of modules/lifecycle/db.js by task 1003204 (goal 1000079, the R03
+// de-monolith plan) — a STRUCTURAL move, not a rewrite: the code below is the
+// original db.js lines 561-656 unchanged. db.js remains the facade that
+// re-exports every name, so every existing db call site is unchanged.
+//
+// THE BOUNDARY (ADR 0093 §1): this file reaches core ONLY through the published
+// doorway ../../src/module-api.js — never a core internal, never a sibling module.
+
+'use strict';
+
+const api = require('../../src/module-api');
+const { pool, withTx } = api;
+const doneWhen = require('./done-when.js');
+
+async function listVersions() {
+  const { rows } = await pool.query(
+    `SELECT id, name, track, status, scope_doc_path, started_at, shipped_at, done_when
+       FROM versions
+       ORDER BY started_at`
+  );
+  return rows;
+}
+
+
+async function getVersion(id) {
+  const { rows } = await pool.query(
+    `SELECT id, name, track, status, scope_doc_path, started_at, shipped_at, done_when
+       FROM versions WHERE id = $1`,
+    [id]
+  );
+  return rows[0] ?? null;
+}
+
+
+async function versionProgress() {
+  // Joins the rolled-up progress view (any of completed/confirmed/shipped counts
+  // as "done") with the per-state breakdown view from migration 012 so the
+  // public dashboard can render a stacked three-segment progress bar.
+  //
+  // Also surfaces two version-level fields the Works-in-Progress surfaces need
+  // (task 938): `done_when` (the senate-voice short description rendered as the
+  // version's blurb on both the status mirror and the work board) and
+  // `criteria_count` (how many done_when_criteria are seeded). The status mirror
+  // uses criteria_count > 0 to tell a genuinely-active version from a freshly
+  // stubbed "future placeholder" (e.g. a next-version row created by
+  // version-close that has no criteria seeded yet) without needing a schema flag.
+  const { rows } = await pool.query(
+    `SELECT vp.version_id, vp.name, vp.status,
+            vp.shipped_count, vp.total_count, vp.shipped_weight, vp.total_weight,
+            v.done_when,
+            COALESCE(dwc.criteria_count, 0) AS criteria_count,
+            COALESCE(vlb.completed_count, 0) AS lifecycle_completed_count,
+            COALESCE(vlb.confirmed_count, 0) AS lifecycle_confirmed_count,
+            COALESCE(vlb.shipped_count,   0) AS lifecycle_shipped_count
+       FROM version_progress vp
+       LEFT JOIN version_lifecycle_breakdown vlb ON vlb.version_id = vp.version_id
+       LEFT JOIN versions v ON v.id = vp.version_id
+       LEFT JOIN (
+         SELECT version_id, count(*) AS criteria_count
+           FROM done_when_criteria
+          GROUP BY version_id
+       ) dwc ON dwc.version_id = vp.version_id
+       ORDER BY vp.version_id`
+  );
+  return rows.map((r) => ({
+    ...r,
+    criteria_count: Number(r.criteria_count),
+    lifecycle_completed_count: Number(r.lifecycle_completed_count),
+    lifecycle_confirmed_count: Number(r.lifecycle_confirmed_count),
+    lifecycle_shipped_count: Number(r.lifecycle_shipped_count),
+    percent_complete:
+      r.total_weight > 0 ? Math.round((Number(r.shipped_weight) / Number(r.total_weight)) * 100) : 0,
+  }));
+}
+
+// Create a version + (optionally) its done-when criteria in one atomic write —
+// the seed primitive `bongos init` uses so a fresh instance needs no hand-written
+// seed-*.js script (task 1204 / R65). Atomic: the version and all its criteria
+// commit together, so a bad criterion leaves nothing half-created. Criteria are
+// idempotent on (version_id, criterion_id) so a re-run can't double-insert.
+
+async function createVersion({ id, name, status = 'planning', track = 'product', scopeDocPath = null, doneWhen = null, criteria = [] }) {
+  // versions.track is NOT NULL with no DB default (migration 003) — omitting it
+  // here made every create 500. An instance's first version is its product
+  // track, so that's the default; 'internal' is the platform's own track.
+  return withTx(async (client) => {
+    const { rows } = await client.query(
+      `INSERT INTO versions (id, name, status, track, scope_doc_path, done_when)
+            VALUES ($1, $2, $3, $4, $5, $6)
+       RETURNING id, name, status, track, scope_doc_path, started_at, shipped_at, done_when`,
+      [id, name, status, track, scopeDocPath, doneWhen]
+    );
+    const version = rows[0];
+    const createdCriteria = [];
+    let i = 0;
+    for (const c of (criteria || [])) {
+      const { rows: cr } = await client.query(
+        `INSERT INTO done_when_criteria (version_id, criterion_id, criterion_md, sort_order)
+              VALUES ($1, $2, $3, $4)
+         ON CONFLICT (version_id, criterion_id) DO NOTHING
+         RETURNING id, version_id, criterion_id, criterion_md, sort_order, satisfied`,
+        [id, c.criterion_id, c.criterion_md, Number.isFinite(c.sort_order) ? c.sort_order : (i + 1) * 10]
+      );
+      if (cr[0]) createdCriteria.push(cr[0]);
+      i++;
+    }
+    return { version, criteria: createdCriteria };
+  });
+}
+
+module.exports = {
+  createVersion,
+  getVersion,
+  listVersions,
+  versionProgress,
+};