@loadbare/app 0.6.0 → 0.7.0

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

@@ -1,9 +0,0 @@
-/**
- * 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.
- */
-export {};
-//# sourceMappingURL=lb-server.test.d.ts.map

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

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

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

@@ -1,546 +0,0 @@
-/**
- * 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, list, patch, row, } from "../server/lb-server";
-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 row and records that it ran. */
-function stub(log, name, answer) {
-    return row((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, requests: entry.requests ?? {} };
-    }
-    return map;
-}
-// --- Entering a page ----------------------------------------------------
-describe("entering a page", () => {
-    it("runs onPageEnter 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" }),
-                },
-                requests: {
-                    onPageEnter: () => void log.push("onPageEnter"),
-                },
-            },
-        }));
-        const data = await hub.dataForPage("report", context());
-        assert.deepEqual(log, ["onPageEnter", "head", "body"]);
-        assert.deepEqual(data, { head: { title: "Q1" }, body: { line: "one" } });
-    });
-    it("runs the query set when the page declares no requests", 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: row(async () => ({ a: "1" })) } },
-        }));
-        assert.deepEqual(await hub.dataForPage("report", context()), {
-            head: { a: "1" },
-        });
-    });
-});
-// --- Actions -------------------------------------------------------------
-describe("a reserved name", () => {
-    // Names beginning with lb- are Loadbare's: the hub's own query, the CRUD
-    // operations. See LB_RESERVED_PREFIX in core/lb-constants.ts.
-    it("is refused as a query, at startup", () => {
-        assert.throws(() => createHub({
-            home: {
-                queries: { "lb-navigation": row(async () => ({})) },
-                requests: {},
-            },
-        }), /page 'home' declares 'lb-navigation', but names beginning with 'lb-' are reserved/);
-    });
-    it("is refused as an action, at startup", () => {
-        assert.throws(() => createHub({
-            home: {
-                queries: {},
-                requests: {
-                    actions: { "lb-delete": { run: () => { }, refresh: [] } },
-                },
-            },
-        }), /declares 'lb-delete', but names beginning with 'lb-' are reserved/);
-    });
-});
-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" }) },
-                requests: {
-                    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" }),
-                },
-                requests: {
-                    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: {},
-                requests: {
-                    actions: {
-                        pick: { run: (_ctx, w) => void (where = w), refresh: [] },
-                    },
-                },
-            },
-        }));
-        await hub.runAction("roster", "pick", { list: "members", key: "7", cell: "role", value: "lead" }, context());
-        assert.deepEqual(where, {
-            list: "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", {}) },
-                requests: {
-                    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: row(() => ({ n: String(store.n) })) },
-                requests: {
-                    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: list(() => [{ id: "1" }, { id: "2" }]) },
-                requests: {
-                    actions: {
-                        rename: {
-                            run: () => ({ members: patch({ rows: [{ id: "2" }] }) }),
-                            refresh: ["members"],
-                        },
-                    },
-                },
-            },
-        }));
-        const data = await hub.runAction("roster", "rename", {}, context());
-        assert.deepEqual(data, { members: { rows: [{ id: "2" }] } });
-    });
-    it("answers with the refresh set alone when it states nothing", async () => {
-        const hub = createHub(pages({
-            counter: {
-                queries: { count: row(() => ({ n: "1" })) },
-                requests: {
-                    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: row(() => ({ n: "1" })) },
-                requests: {
-                    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: {}, requests: { 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: list(() => []) } } }));
-        const { result, warn } = await captured(() => hub.runCellChange("roster", { list: "members", key: "1", cell: "name", value: "Ada" }, context()));
-        assert.deepEqual(result, {});
-        assert.match(warn.join("\n"), /page 'roster' declares no cellChange for '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" }) },
-                requests: {
-                    crud: {
-                        members: {
-                            cellChange: {
-                                run: (_ctx, w) => void (where = w),
-                                refresh: ["members"],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        const data = await hub.runCellChange("roster", { list: "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: list(() => [{ id: "1" }, { id: "2" }]) },
-                requests: {
-                    crud: {
-                        members: {
-                            cellChange: {
-                                run: (_ctx, w) => ({
-                                    members: patch({ rows: [{ id: "2", name: w.value }] }),
-                                }),
-                                refresh: ["members"],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        const data = await hub.runCellChange("roster", { list: "members", key: "2", cell: "name", value: "Grace" }, context());
-        assert.deepEqual(data, {
-            members: { rows: [{ id: "2", name: "Grace" }] },
-        });
-    });
-});
-// --- Row delete ------------------------------------------------------
-describe("a row-delete", () => {
-    it("is refused unless the query declared it", async () => {
-        const hub = createHub(pages({ roster: { queries: { members: list(() => []) } } }));
-        const { result, warn } = await captured(() => hub.runRowDelete("roster", { list: "members", key: "1" }, context()));
-        assert.deepEqual(result, {});
-        assert.match(warn.join("\n"), /page 'roster' declares no rowDelete for 'members'/);
-    });
-    it("hands the operation its key, then runs its refresh set", async () => {
-        let where;
-        const hub = createHub(pages({
-            roster: {
-                queries: { members: list(() => []) },
-                requests: {
-                    crud: {
-                        members: {
-                            rowDelete: {
-                                run: (_ctx, w) => void (where = w),
-                                refresh: [],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        await hub.runRowDelete("roster", { list: "members", key: "7" }, context());
-        assert.deepEqual(where, { key: "7" });
-    });
-    it("answers with the drop it stated", async () => {
-        const hub = createHub(pages({
-            roster: {
-                queries: { members: list(() => [{ id: "1" }, { id: "2" }]) },
-                requests: {
-                    crud: {
-                        members: {
-                            rowDelete: {
-                                run: (_ctx, w) => ({
-                                    members: patch({ drop: [w.key] }),
-                                }),
-                                refresh: [],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        const data = await hub.runRowDelete("roster", { list: "members", key: "1" }, context());
-        assert.deepEqual(data, { members: { drop: ["1"] } });
-    });
-});
-// --- Row insert --------------------------------------------------------
-describe("a row-insert", () => {
-    it("is refused unless the query declared it", async () => {
-        const hub = createHub(pages({ roster: { queries: { members: list(() => []) } } }));
-        const { result, warn } = await captured(() => hub.runRowInsert("roster", { list: "members", values: { name: "Ada" } }, context()));
-        assert.deepEqual(result, {});
-        assert.match(warn.join("\n"), /page 'roster' declares no rowInsert for 'members'/);
-    });
-    it("hands the operation the gathered values, then runs its refresh set", async () => {
-        let where;
-        const hub = createHub(pages({
-            roster: {
-                queries: { members: list(() => []) },
-                requests: {
-                    crud: {
-                        members: {
-                            rowInsert: {
-                                run: (_ctx, w) => void (where = w),
-                                refresh: [],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        await hub.runRowInsert("roster", { list: "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: list(() => [{ id: "1" }]) },
-                requests: {
-                    crud: {
-                        members: {
-                            rowInsert: {
-                                run: (_ctx, w) => ({
-                                    members: patch({ rows: [{ id: "2", ...w.values }] }),
-                                }),
-                                refresh: [],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        const data = await hub.runRowInsert("roster", { list: "members", values: { name: "Ada" } }, context());
-        assert.deepEqual(data, {
-            members: { rows: [{ id: "2", name: "Ada" }] },
-        });
-    });
-});
-// --- Row update ----------------------------------------------------------
-describe("a row-update", () => {
-    it("is refused unless the query declared it", async () => {
-        const hub = createHub(pages({ roster: { queries: { members: list(() => []) } } }));
-        const { result, warn } = await captured(() => hub.runRowUpdate("roster", { list: "members", key: "1", values: { name: "Ada" } }, context()));
-        assert.deepEqual(result, {});
-        assert.match(warn.join("\n"), /page 'roster' declares no rowUpdate for '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: list(() => []) },
-                requests: {
-                    crud: {
-                        members: {
-                            rowUpdate: {
-                                run: (_ctx, w) => void (where = w),
-                                refresh: [],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        await hub.runRowUpdate("roster", { list: "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: list(() => [{ id: "1", name: "old" }]) },
-                requests: {
-                    crud: {
-                        members: {
-                            rowUpdate: {
-                                run: (_ctx, w) => ({
-                                    members: patch({ rows: [{ id: w.key, ...w.values }] }),
-                                }),
-                                refresh: [],
-                            },
-                        },
-                    },
-                },
-            },
-        }));
-        const data = await hub.runRowUpdate("roster", { list: "members", key: "1", values: { name: "Ada" } }, context());
-        assert.deepEqual(data, {
-            members: { rows: [{ id: "1", name: "Ada" }] },
-        });
-    });
-});
-// --- The wire vocabulary -------------------------------------------------
-describe("cardinality is declared, not inspected", () => {
-    it("marks a list query and a row query apart", () => {
-        assert.equal(list(() => []).kind, "list");
-        assert.equal(row(() => ({})).kind, "row");
-    });
-    it("carries a whole set as the array itself, with no wrapper", async () => {
-        const set = [{ id: "1" }, { id: "2" }];
-        const hub = createHub(pages({ roster: { queries: { members: list(() => set) } } }));
-        assert.deepEqual(await hub.dataForPage("roster", context()), {
-            members: set,
-        });
-    });
-    it("carries only what changed as an object, and adds nothing", () => {
-        assert.deepEqual(patch({ drop: ["1"] }), { drop: ["1"] });
-        assert.deepEqual(patch({}), {});
-    });
-    it("tells a whole set from a patch by Array.isArray, so no column is reserved", () => {
-        // `op` used to be a reserved column name, because the hub read it to
-        // decide which shape had arrived. Nothing inspects a value now.
-        assert.equal(Array.isArray(patch({ rows: [] })), false);
-        assert.equal(Array.isArray([{ op: "rows" }]), true);
-    });
-    it("refuses a list query that answers with one row", async () => {
-        const hub = createHub(pages({
-            roster: {
-                queries: {
-                    members: list(() => ({})),
-                },
-            },
-        }));
-        const { result, warn } = await captured(() => hub.dataForPage("roster", context()));
-        assert.deepEqual(result, {});
-        assert.match(warn.join("\n"), /query 'members' is declared list but answered with one row/);
-    });
-    it("refuses a row query that answers with rows", async () => {
-        const hub = createHub(pages({
-            roster: {
-                queries: {
-                    chosen: row(() => []),
-                },
-            },
-        }));
-        const { result, warn } = await captured(() => hub.dataForPage("roster", context()));
-        assert.deepEqual(result, {});
-        assert.match(warn.join("\n"), /query 'chosen' is declared row but answered with rows/);
-    });
-});

package/dist/tests/origins.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * The origin cascade — see build/origins.ts.
- *
- * Definitions, scripts and stylesheets all come from the same ordered list of
- * origins, so they are all tested here: that one origin is scanned the same
- * way whatever it is, that a duplicate tag inside one origin is an error, and
- * that a later origin wins over an earlier one.
- */
-export {};
-//# sourceMappingURL=origins.test.d.ts.map

package/dist/tests/origins.test.d.ts.map

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