@mason-data/cli 0.7.0 → 0.8.0

package/dist/src/cli/control.js

@@ -1,3 +1,9 @@
+/**
+ * THE COMMANDS' LINE TO A RUN: `mason status`, `mason tables`, `mason add` and `mason wait` ask the run's
+ * command server (src/cli/run-server.ts) — with the
+ * run's token as `Authorization: Bearer` (src/cli/security.ts), read from the project's .mason/config.json (src/cli/runs.ts).
+ */
+import * as http from "node:http";
 /** The run does not answer: a failure with the reason as `why` and mason logs as the way out (`failure` is what a command
  *  hands src/cli/command.ts failed). */
 export class RunUnreachable extends Error {
@@ -34,3 +40,56 @@ export async function callRun(run, method, route, body, timeoutMs = 30_000) {
     }
     return { status: res.status, body: parsed };
 }
+/**
+ * ONE REQUEST HELD OPEN (src/cli/share.ts): the run answers a line of JSON and keeps the answer open, so the end of the
+ * connection is the end of what was asked, however this process ends. On node:http, not fetch: fetch gives up on a body
+ * silent for five minutes, and here silence is the normal state. A refusal is answered whole, as `callRun` returns it.
+ */
+export function holdRun(run, route, body, timeoutMs = 30_000) {
+    return new Promise((resolve, reject) => {
+        const unreachable = (why) => new RunUnreachable(`Mason for ${run.name} (pid ${run.pid}) does not answer at ${run.control.url}`, why);
+        const text = JSON.stringify(body);
+        const req = http.request(`${run.control.url}${route}`, { method: "POST", headers: { Authorization: `Bearer ${run.control.token}`, "Content-Type": "application/json", "Content-Length": Buffer.byteLength(text) } }, (res) => {
+            let got = "", first = null, said = null;
+            let finish = () => undefined;
+            const ended = new Promise((r) => { finish = r; });
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                got += chunk;
+                if (res.statusCode !== 200)
+                    return;
+                for (let at = got.indexOf("\n"); at >= 0; at = got.indexOf("\n")) {
+                    const line = JSON.parse(got.slice(0, at));
+                    got = got.slice(at + 1);
+                    if (first === null) {
+                        first = line;
+                        clearTimeout(timer);
+                        resolve({ first, ended, close: () => req.destroy() });
+                    }
+                    else if (typeof line.ended === "string")
+                        said = line.ended;
+                }
+            });
+            res.on("close", () => {
+                clearTimeout(timer);
+                if (res.statusCode === 200) {
+                    if (first === null)
+                        reject(unreachable("it closed the answer before it said anything"));
+                    finish(said);
+                    return;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(got);
+                }
+                catch {
+                    parsed = { error: got.trim() || `HTTP ${res.statusCode}` };
+                }
+                resolve({ status: res.statusCode ?? 0, body: parsed });
+            });
+        });
+        const timer = setTimeout(() => { req.destroy(); reject(unreachable(`no answer in ${timeoutMs / 1000} s`)); }, timeoutMs);
+        req.on("error", (e) => { clearTimeout(timer); reject(unreachable(e.code ?? e.message)); });
+        req.end(text);
+    });
+}

package/dist/src/cli/demo.js

@@ -9,8 +9,8 @@
  *
  *   - THE PORT LIVES IN THE URL ALONE: `mason init demo` picks one free and writes it into `.env`; `mason start` reads
  *     it back from the resolved URL (`demoPort`), never from a second record that could disagree with it.
- *   - POLL ONLY: the demo database has no change log (no WAL sender), so `--replication` is refused before anything
- *     starts (`demoChangesRefusal`).
+ *   - POLL ONLY: the demo database has no change log (no WAL sender), so a table whose `sync:` is `replication` is
+ *     refused before anything starts (`demoChangesRefusal`).
  *   - A WRITER: every MASON_DEMO_CHANGE_MS (`demoSettings`) the run makes one round of changes (`demoChanges`), so the
  *     copy is seen keeping current.
  *
@@ -19,7 +19,7 @@
  */
 import * as path from "node:path";
 import { parseSource, isLocalHost } from "./preflight.js";
-import { changesOf } from "./replication-mode.js";
+import { entryName, replicatedEntries } from "./sources.js";
 import { heldText, portHolder } from "./ports.js";
 import { DEMO_DIR, STATE_DIR } from "./project.js";
 import { DEMO_DATABASE, DEMO_USER, demoUrl } from "../demo/seed.js";
@@ -30,7 +30,7 @@ export const DEMO_PORT = 5434;
 /** The demo database's tables (the seed's own list), the ones `mason init demo` adds to the sources file and the one it
  *  leaves for the person to add, and its URL (src/demo/seed.ts: no PGlite is loaded by it, so `mason init demo` and
  *  `demoPort` never load the database). */
-export { DEMO_ADDED_TABLES, DEMO_TABLES, DEMO_TABLE_TO_ADD, demoUrl } from "../demo/seed.js";
+export { DEMO_ADDED_TABLES, DEMO_SYNC, DEMO_TABLES, DEMO_TABLE_TO_ADD, demoUrl } from "../demo/seed.js";
 /** How often the run changes the demo database by default (MASON_DEMO_CHANGE_MS). */
 export const DEMO_CHANGE_MS = 5000;
 const DEMO_CHANGE_MIN_MS = 100;
@@ -69,14 +69,23 @@ export function demoPort(url, from) {
         return { problem: `${from} was changed: the demo database is ${demoUrl(s.port)}; ${wayOut}` };
     return { port: s.port };
 }
-/** The refusal of logical replication for a demo project (the flag, or a mode the config was edited to): before
- *  anything starts, with the way out; null for any other project, or a demo one polled. */
-export function demoChangesRefusal(cfg, flag) {
-    if (cfg.demo !== true || changesOf(flag, cfg.changes) !== "replication")
+/** The refusal of logical replication for a demo project (a table whose sync: is replication in its sources file,
+ *  `shown`, or the mode an older Mason recorded in the config, edited to it): before anything starts, with the way out;
+ *  null for any other project, or a demo one polled. */
+export function demoChangesRefusal(cfg, file = null, shown = "") {
+    if (cfg.demo !== true)
         return null;
-    return { message: "the demo database is read by polling only: --replication does not apply to it", code: "refused",
+    const streamed = file === null ? [] : replicatedEntries(file).map((e) => entryName(e.table));
+    if (streamed.length) {
+        return { message: `the demo database is read by polling only: sync: replication does not apply to it (${streamed.join(", ")})`, code: "refused",
+            why: "the demo database has no change log for logical replication to read; Mason polls it with SELECTs",
+            fix: `write sync: poll 5s for ${streamed.length === 1 ? "it" : "them"} in ${shown}, then mason start`, next: [["mason start", "the demo database and Mason, polled"]] };
+    }
+    if (cfg.changes !== "replication")
+        return null;
+    return { message: `the demo database is read by polling only: "changes": "replication" in ${STATE_DIR}/config.json does not apply to it`, code: "refused",
         why: "the demo database has no change log for logical replication to read; mason start polls it with SELECTs, every few seconds",
-        fix: flag === "replication" ? "mason start, without --replication" : `remove "changes": "replication" from ${STATE_DIR}/config.json, then mason start`,
+        fix: `remove "changes": "replication" from ${STATE_DIR}/config.json, then mason start`,
         next: [["mason start", "the demo database and Mason, polled"]] };
 }
 /** The step's done line: where the demo database listens, and whether it was seeded now or kept from the last run. */