@loadbare/app 0.4.0

package/dist/tests/lb-server.test.js

@@ -0,0 +1,495 @@
+/**
+ * The engine — see docs/testing.md, tier 2.
+ *
+ * `createHub` takes a plain object and returns an object. Nothing in
+ * server/lb-server.ts opens a socket or knows what a request is, so every
+ * fixture here is a counting stub and the whole tier runs in node.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createHub, patch, rows, } from "../server/lb-server";
+import { isProjection } from "../core/lb-types";
+import { captured } from "./helpers/console";
+/**
+ * A context to compare by identity.
+ *
+ * The engine never reads the context — it only hands it on — so what a test
+ * needs of one is that it can tell the same object apart from another. The
+ * cast is because an application fills the interface in by declaration
+ * merging, and the demo's is the one in this compilation.
+ */
+function context() {
+    return {};
+}
+/** A query that answers a fixed tuple and records that it ran. */
+function stub(log, name, answer) {
+    return (ctx) => {
+        log.push(name);
+        seen.set(name, ctx);
+        return answer;
+    };
+}
+const seen = new Map();
+function pages(entries) {
+    const map = {};
+    for (const [name, entry] of Object.entries(entries)) {
+        map[name] = { queries: entry.queries, hooks: entry.hooks ?? {} };
+    }
+    return map;
+}
+// --- The page GET --------------------------------------------------------
+describe("a page GET", () => {
+    it("runs beforeGet before any query, then the whole query set", async () => {
+        const log = [];
+        const hub = createHub(pages({
+            report: {
+                queries: {
+                    head: stub(log, "head", { title: "Q1" }),
+                    body: stub(log, "body", { line: "one" }),
+                },
+                hooks: {
+                    beforeGet: () => void log.push("beforeGet"),
+                },
+            },
+        }));
+        const data = await hub.dataForPage("report", context());
+        assert.deepEqual(log, ["beforeGet", "head", "body"]);
+        assert.deepEqual(data, { head: { title: "Q1" }, body: { line: "one" } });
+    });
+    it("runs the query set when the page declares no hooks", async () => {
+        const log = [];
+        const hub = createHub(pages({ report: { queries: { head: stub(log, "head", { a: "1" }) } } }));
+        assert.deepEqual(await hub.dataForPage("report", context()), {
+            head: { a: "1" },
+        });
+    });
+    it("hands every query the context it was called with", async () => {
+        // The context is request-scoped — an authenticated database handle is the
+        // expected case — so which one a query gets is the whole of the contract.
+        seen.clear();
+        const log = [];
+        const hub = createHub(pages({
+            report: {
+                queries: {
+                    head: stub(log, "head", {}),
+                    body: stub(log, "body", {}),
+                },
+            },
+        }));
+        const ctx = context();
+        await hub.dataForPage("report", ctx);
+        assert.equal(seen.get("head"), ctx);
+        assert.equal(seen.get("body"), ctx);
+    });
+    it("answers nothing for a page it does not have, and says so", async () => {
+        const hub = createHub(pages({}));
+        const { result, warn } = await captured(() => hub.dataForPage("nope", context()));
+        assert.deepEqual(result, {});
+        assert.match(warn.join("\n"), /no page 'nope'/);
+    });
+    it("awaits a query that returns a promise", async () => {
+        const hub = createHub(pages({
+            report: { queries: { head: async () => ({ a: "1" }) } },
+        }));
+        assert.deepEqual(await hub.dataForPage("report", context()), {
+            head: { a: "1" },
+        });
+    });
+});
+// --- Actions -------------------------------------------------------------
+describe("an action", () => {
+    it("is refused unless the page declared it", async () => {
+        // The rule that keeps this from being an RPC endpoint: the wire cannot
+        // reach anything the page has not published.
+        const log = [];
+        const hub = createHub(pages({
+            counter: {
+                queries: { count: stub(log, "count", { n: "1" }) },
+                hooks: {
+                    actions: {
+                        bump: { run: () => void log.push("bump"), refresh: ["count"] },
+                    },
+                },
+            },
+        }));
+        const { result, warn } = await captured(() => hub.runAction("counter", "drop", {}, context()));
+        assert.deepEqual(result, {});
+        assert.deepEqual(log, [], "nothing ran");
+        assert.match(warn.join("\n"), /page 'counter' declares no action 'drop'/);
+    });
+    it("is refused on a page that does not exist", async () => {
+        const hub = createHub(pages({}));
+        const { result, warn } = await captured(() => hub.runAction("nope", "bump", {}, context()));
+        assert.deepEqual(result, {});
+        assert.match(warn.join("\n"), /declares no action 'bump'/);
+    });
+    it("runs, then runs the refresh set it declared", async () => {
+        const log = [];
+        const hub = createHub(pages({
+            counter: {
+                queries: {
+                    count: stub(log, "count", { n: "1" }),
+                    unrelated: stub(log, "unrelated", { x: "9" }),
+                },
+                hooks: {
+                    actions: {
+                        bump: { run: () => void log.push("bump"), refresh: ["count"] },
+                    },
+                },
+            },
+        }));
+        const data = await hub.runAction("counter", "bump", {}, context());
+        assert.deepEqual(log, ["bump", "count"], "the action runs first");
+        assert.deepEqual(data, { count: { n: "1" } }, "only the refresh set ran");
+    });
+    it("hands the action where the interaction happened", async () => {
+        let where;
+        const hub = createHub(pages({
+            roster: {
+                queries: {},
+                hooks: {
+                    actions: {
+                        pick: { run: (_ctx, w) => void (where = w), refresh: [] },
+                    },
+                },
+            },
+        }));
+        await hub.runAction("roster", "pick", { query: "members", key: "7", cell: "role", value: "lead" }, context());
+        assert.deepEqual(where, {
+            query: "members",
+            key: "7",
+            cell: "role",
+            value: "lead",
+        });
+    });
+    it("hands the action and its refresh queries one context", async () => {
+        seen.clear();
+        const log = [];
+        let actionCtx;
+        const hub = createHub(pages({
+            counter: {
+                queries: { count: stub(log, "count", {}) },
+                hooks: {
+                    actions: {
+                        bump: {
+                            run: (ctx) => void (actionCtx = ctx),
+                            refresh: ["count"],
+                        },
+                    },
+                },
+            },
+        }));
+        const ctx = context();
+        await hub.runAction("counter", "bump", {}, ctx);
+        assert.equal(actionCtx, ctx);
+        assert.equal(seen.get("count"), ctx);
+    });
+    it("refreshes against whatever the action wrote", async () => {
+        // The refresh queries run after the action, against the same context, so
+        // they see it. This is the case a store makes concrete.
+        const store = { n: 1 };
+        const hub = createHub(pages({
+            counter: {
+                queries: { count: () => ({ n: String(store.n) }) },
+                hooks: {
+                    actions: {
+                        bump: { run: () => void (store.n += 1), refresh: ["count"] },
+                    },
+                },
+            },
+        }));
+        assert.deepEqual(await hub.runAction("counter", "bump", {}, context()), {
+            count: { n: "2" },
+        });
+    });
+    it("lays what it stated over what the refresh produced", async () => {
+        // This is how a patch reaches the browser at all. A query answers for its
+        // whole set and cannot know why it was re-run; the action knows exactly
+        // what it changed and may say only that. The narrower answer wins.
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([{ id: "1" }, { id: "2" }]) },
+                hooks: {
+                    actions: {
+                        rename: {
+                            run: () => ({ members: patch({ rows: [{ id: "2" }] }) }),
+                            refresh: ["members"],
+                        },
+                    },
+                },
+            },
+        }));
+        const data = await hub.runAction("roster", "rename", {}, context());
+        assert.deepEqual(data, { members: { op: "patch", rows: [{ id: "2" }] } });
+    });
+    it("answers with the refresh set alone when it states nothing", async () => {
+        const hub = createHub(pages({
+            counter: {
+                queries: { count: () => ({ n: "1" }) },
+                hooks: { actions: { bump: { run: () => { }, refresh: ["count"] } } },
+            },
+        }));
+        assert.deepEqual(await hub.runAction("counter", "bump", {}, context()), {
+            count: { n: "1" },
+        });
+    });
+    it("skips a refresh name the page does not declare, and runs its siblings", async () => {
+        const hub = createHub(pages({
+            counter: {
+                queries: { count: () => ({ n: "1" }) },
+                hooks: {
+                    actions: {
+                        bump: { run: () => { }, refresh: ["ghost", "count"] },
+                    },
+                },
+            },
+        }));
+        const { result, warn } = await captured(() => hub.runAction("counter", "bump", {}, context()));
+        assert.deepEqual(result, { count: { n: "1" } });
+        assert.match(warn.join("\n"), /page 'counter' declares no query 'ghost'/);
+    });
+    it("awaits an action that returns a promise", async () => {
+        const action = {
+            run: async () => ({ count: { n: "5" } }),
+            refresh: [],
+        };
+        const hub = createHub(pages({ counter: { queries: {}, hooks: { actions: { bump: action } } } }));
+        assert.deepEqual(await hub.runAction("counter", "bump", {}, context()), {
+            count: { n: "5" },
+        });
+    });
+});
+// --- Cell change -----------------------------------------------------------
+describe("a cell-change", () => {
+    it("is refused unless the query declared it", async () => {
+        const hub = createHub(pages({ roster: { queries: { members: () => rows([]) } } }));
+        const { result, warn } = await captured(() => hub.runCellChange("roster", { query: "members", key: "1", cell: "name", value: "Ada" }, context()));
+        assert.deepEqual(result, {});
+        assert.match(warn.join("\n"), /page 'roster' declares no cell-change for query 'members'/);
+    });
+    it("hands the operation its key, cell and value, then runs its refresh set", async () => {
+        let where;
+        const log = [];
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: stub(log, "members", { n: "1" }) },
+                hooks: {
+                    crud: {
+                        members: {
+                            cellChange: {
+                                run: (_ctx, w) => void (where = w),
+                                refresh: ["members"],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        const data = await hub.runCellChange("roster", { query: "members", key: "7", cell: "role", value: "lead" }, context());
+        assert.deepEqual(where, { key: "7", cell: "role", value: "lead" });
+        assert.deepEqual(log, ["members"]);
+        assert.deepEqual(data, { members: { n: "1" } });
+    });
+    it("lays what it stated over what the refresh produced", async () => {
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([{ id: "1" }, { id: "2" }]) },
+                hooks: {
+                    crud: {
+                        members: {
+                            cellChange: {
+                                run: (_ctx, w) => ({
+                                    members: patch({ rows: [{ id: "2", name: w.value }] }),
+                                }),
+                                refresh: ["members"],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        const data = await hub.runCellChange("roster", { query: "members", key: "2", cell: "name", value: "Grace" }, context());
+        assert.deepEqual(data, {
+            members: { op: "patch", rows: [{ id: "2", name: "Grace" }] },
+        });
+    });
+});
+// --- Tuple delete ------------------------------------------------------
+describe("a tuple-delete", () => {
+    it("is refused unless the query declared it", async () => {
+        const hub = createHub(pages({ roster: { queries: { members: () => rows([]) } } }));
+        const { result, warn } = await captured(() => hub.runTupleDelete("roster", { query: "members", key: "1" }, context()));
+        assert.deepEqual(result, {});
+        assert.match(warn.join("\n"), /page 'roster' declares no tuple-delete for query 'members'/);
+    });
+    it("hands the operation its key, then runs its refresh set", async () => {
+        let where;
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([]) },
+                hooks: {
+                    crud: {
+                        members: {
+                            tupleDelete: {
+                                run: (_ctx, w) => void (where = w),
+                                refresh: [],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        await hub.runTupleDelete("roster", { query: "members", key: "7" }, context());
+        assert.deepEqual(where, { key: "7" });
+    });
+    it("answers with the drop it stated", async () => {
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([{ id: "1" }, { id: "2" }]) },
+                hooks: {
+                    crud: {
+                        members: {
+                            tupleDelete: {
+                                run: (_ctx, w) => ({
+                                    members: patch({ drop: [w.key] }),
+                                }),
+                                refresh: [],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        const data = await hub.runTupleDelete("roster", { query: "members", key: "1" }, context());
+        assert.deepEqual(data, { members: { op: "patch", drop: ["1"] } });
+    });
+});
+// --- Tuple insert --------------------------------------------------------
+describe("a tuple-insert", () => {
+    it("is refused unless the query declared it", async () => {
+        const hub = createHub(pages({ roster: { queries: { members: () => rows([]) } } }));
+        const { result, warn } = await captured(() => hub.runTupleInsert("roster", { query: "members", values: { name: "Ada" } }, context()));
+        assert.deepEqual(result, {});
+        assert.match(warn.join("\n"), /page 'roster' declares no tuple-insert for query 'members'/);
+    });
+    it("hands the operation the gathered values, then runs its refresh set", async () => {
+        let where;
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([]) },
+                hooks: {
+                    crud: {
+                        members: {
+                            tupleInsert: {
+                                run: (_ctx, w) => void (where = w),
+                                refresh: [],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        await hub.runTupleInsert("roster", { query: "members", values: { name: "Ada", role: "Analyst" } }, context());
+        assert.deepEqual(where, { values: { name: "Ada", role: "Analyst" } });
+    });
+    it("answers with the row it stated", async () => {
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([{ id: "1" }]) },
+                hooks: {
+                    crud: {
+                        members: {
+                            tupleInsert: {
+                                run: (_ctx, w) => ({
+                                    members: patch({ rows: [{ id: "2", ...w.values }] }),
+                                }),
+                                refresh: [],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        const data = await hub.runTupleInsert("roster", { query: "members", values: { name: "Ada" } }, context());
+        assert.deepEqual(data, {
+            members: { op: "patch", rows: [{ id: "2", name: "Ada" }] },
+        });
+    });
+});
+// --- Tuple update ----------------------------------------------------------
+describe("a tuple-update", () => {
+    it("is refused unless the query declared it", async () => {
+        const hub = createHub(pages({ roster: { queries: { members: () => rows([]) } } }));
+        const { result, warn } = await captured(() => hub.runTupleUpdate("roster", { query: "members", key: "1", values: { name: "Ada" } }, context()));
+        assert.deepEqual(result, {});
+        assert.match(warn.join("\n"), /page 'roster' declares no tuple-update for query 'members'/);
+    });
+    it("hands the operation the key and the gathered values, then runs its refresh set", async () => {
+        let where;
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([]) },
+                hooks: {
+                    crud: {
+                        members: {
+                            tupleUpdate: {
+                                run: (_ctx, w) => void (where = w),
+                                refresh: [],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        await hub.runTupleUpdate("roster", { query: "members", key: "7", values: { name: "Ada", role: "Analyst" } }, context());
+        assert.deepEqual(where, {
+            key: "7",
+            values: { name: "Ada", role: "Analyst" },
+        });
+    });
+    it("answers with the row it stated", async () => {
+        const hub = createHub(pages({
+            roster: {
+                queries: { members: () => rows([{ id: "1", name: "old" }]) },
+                hooks: {
+                    crud: {
+                        members: {
+                            tupleUpdate: {
+                                run: (_ctx, w) => ({
+                                    members: patch({ rows: [{ id: w.key, ...w.values }] }),
+                                }),
+                                refresh: [],
+                            },
+                        },
+                    },
+                },
+            },
+        }));
+        const data = await hub.runTupleUpdate("roster", { query: "members", key: "1", values: { name: "Ada" } }, context());
+        assert.deepEqual(data, {
+            members: { op: "patch", rows: [{ id: "1", name: "Ada" }] },
+        });
+    });
+});
+// --- The wire vocabulary -------------------------------------------------
+describe("the projection helpers", () => {
+    it("name the whole set", () => {
+        assert.deepEqual(rows([{ id: "1" }]), { op: "rows", rows: [{ id: "1" }] });
+    });
+    it("name only what changed, and carry nothing they were not given", () => {
+        assert.deepEqual(patch({ drop: ["1"] }), { op: "patch", drop: ["1"] });
+        assert.deepEqual(patch({}), { op: "patch" });
+    });
+    it("are what isProjection recognises", () => {
+        assert.equal(isProjection(rows([])), true);
+        assert.equal(isProjection(patch({})), true);
+        assert.equal(isProjection({ id: "1", name: "Ada" }), false);
+    });
+    it("share one word with a tuple's cells, which reserves it", () => {
+        // Stated in core/lb-types.ts: `op` is a reserved cell name, because a
+        // tuple carrying one whose value is 'rows' or 'patch' is read as a
+        // projection. The hazard is real and this is where it is written down.
+        assert.equal(isProjection({ op: "rows" }), true);
+        assert.equal(isProjection({ op: "deleted" }), false);
+    });
+});

package/dist/tests/lb-table.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * lb-table — see docs/testing.md, tier 4.
+ *
+ * What this widget adds at run time is placement, and only placement:
+ * `lb-sort` names the column rows are ordered by, `lb-group` names the
+ * column they are sectioned by. Both answers are local, which is the whole
+ * argument for the Place callback existing.
+ *
+ * The markup below is what widgets/lb-table.html expands to once the page
+ * has supplied its head and its row template — a real <thead> holding a real
+ * <tr>, because expansion unwrapped the templates that carried them past the
+ * parser.
+ */
+export {};
+//# sourceMappingURL=lb-table.test.d.ts.map

package/dist/tests/lb-table.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lb-table.test.d.ts","sourceRoot":"","sources":["../../tests/lb-table.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}