@loadbare/app 0.4.0

package/dist/server/lb-express.js

@@ -0,0 +1,77 @@
+/**
+ * The Express adapter — the standard hand-off from an Express router to a
+ * Hub built by createHub(). Every Hub application wires this same router,
+ * which is why it ships from here rather than being copied into each one.
+ *
+ * Express itself is a peer dependency: nothing outside this file imports it,
+ * so an application that hosts Hub some other way never pays for it.
+ *
+ * Two endpoints, and no third:
+ *
+ *   GET  /hub/data?page=<name>   the page's whole query set
+ *   POST /hub?page=<name>        one operation, then its refresh set
+ *
+ * The page rides on the query string rather than in the body, which is what
+ * lets the operation set stay closed.
+ */
+import express from "express";
+import { LB_DATA_ENDPOINT, LB_REQUEST_ENDPOINT } from "../core/lb-constants";
+export function hubRoutes(hub, contextFor) {
+    const router = express.Router();
+    // Mounted here rather than on the app so that Hub's need for a parsed
+    // body is stated where the routes that need it are.
+    router.use(express.json());
+    router.get(LB_DATA_ENDPOINT, async (req, res) => {
+        const page = String(req.query.page ?? "");
+        res.json(await hub.dataForPage(page, contextFor(req)));
+    });
+    router.post(LB_REQUEST_ENDPOINT, async (req, res) => {
+        const page = String(req.query.page ?? "");
+        // The body is unknown until op says which shape it is, so it is read
+        // once through this loose view for the case that does not match one.
+        const body = req.body;
+        const request = req.body;
+        const ctx = contextFor(req);
+        // A thrown error is how application code (a query, an action, a CRUD
+        // op) says "this request is invalid" or hits an unexpected failure —
+        // it resolves to a real response rather than an unhandled rejection, so
+        // the browser side has something to catch.
+        try {
+            switch (request?.op) {
+                case "action": {
+                    const { name, query, key, cell, value } = request;
+                    res.json(await hub.runAction(page, name, { query, key, cell, value }, ctx));
+                    return;
+                }
+                case "cell-change": {
+                    const { query, key, cell, value } = request;
+                    res.json(await hub.runCellChange(page, { query, key, cell, value }, ctx));
+                    return;
+                }
+                case "tuple-delete": {
+                    const { query, key } = request;
+                    res.json(await hub.runTupleDelete(page, { query, key }, ctx));
+                    return;
+                }
+                case "tuple-insert": {
+                    const { query, values } = request;
+                    res.json(await hub.runTupleInsert(page, { query, values }, ctx));
+                    return;
+                }
+                case "tuple-update": {
+                    const { query, key, values } = request;
+                    res.json(await hub.runTupleUpdate(page, { query, key, values }, ctx));
+                    return;
+                }
+                default:
+                    console.warn(`loadbare: operation '${body?.op}' not implemented`);
+                    res.status(400).json({});
+            }
+        }
+        catch (err) {
+            console.error(`loadbare: operation '${request?.op}' threw`, err);
+            res.status(500).json({});
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,174 @@
+import type { Projection, QueryResult, HubData, HubResult } from "../core/lb-types";
+/**
+ * Whatever the application hands the engine for the duration of one request.
+ *
+ * Hub declares it empty and never reads it. An application fills it in by
+ * declaration merging, once, anywhere in its own source:
+ *
+ *     declare module "@loadbare/app/server" {
+ *       interface HubContext {
+ *         db: Db;
+ *       }
+ *     }
+ *
+ * That is why no type on this page takes a type parameter. The context is a
+ * request-scoped handle — an authenticated database connection is the
+ * expected case — so it is passed per call rather than held by the engine.
+ */
+export interface HubContext {
+}
+/**
+ * A declared query: the request context in, one result out.
+ *
+ * A plain object is one tuple and is the common case. A query that returns
+ * many tuples says so with `rows`, below.
+ */
+export type Query = (ctx: HubContext) => HubResult | Promise<HubResult>;
+/**
+ * The entire set, and therefore also the order. A list widget reconciles to
+ * exactly this: a row whose key is not here is gone.
+ */
+export declare function rows(list: QueryResult[]): Projection;
+/**
+ * Only what changed. Rows named here arrive or are updated, keys in `drop`
+ * are gone, and everything unnamed is left alone — its contents, and its
+ * place in whatever order the widget is keeping.
+ */
+export declare function patch(change: {
+    rows?: QueryResult[];
+    drop?: string[];
+}): Projection;
+/** The shape of a `<name>.queries.ts` module. */
+export type Queries = Record<string, Query>;
+/**
+ * Where the interaction happened, in the addressing vocabulary, plus the one
+ * value a control may carry.
+ *
+ * The browser fills these from attributes it already has. It never names a
+ * function — only a name the page declared — which is what keeps this from
+ * being an RPC endpoint. A value may ride along because a `<select>` has one
+ * and there is nowhere else to put it; it is a string from a control, not an
+ * argument list.
+ */
+export interface Where {
+    query?: string;
+    key?: string;
+    cell?: string;
+    value?: string;
+}
+/**
+ * What an action does, and which queries must re-run once it has.
+ *
+ * `run` may also return results of its own, which are laid over the refreshed
+ * ones. That is how a patch reaches the browser: a query answers for its
+ * whole set and cannot know why it was re-run, but the action knows exactly
+ * what it changed and can say only that.
+ */
+export interface Action {
+    run: (ctx: HubContext, where: Where) => void | HubData | Promise<void | HubData>;
+    refresh: string[];
+}
+/**
+ * One CRUD operation on a declared query. Same shape as `Action` — run, then
+ * refresh — but `where` carries only what that operation is typed to carry
+ * on the wire, rather than the general `Where`.
+ */
+export interface CrudOp<W> {
+    run: (ctx: HubContext, where: W) => void | HubData | Promise<void | HubData>;
+    refresh: string[];
+}
+export type CellChangeOp = CrudOp<{
+    key: string;
+    cell: string;
+    value: string;
+}>;
+export type TupleDeleteOp = CrudOp<{
+    key: string;
+}>;
+export type TupleInsertOp = CrudOp<{
+    values: Record<string, string>;
+}>;
+export type TupleUpdateOp = CrudOp<{
+    key: string;
+    values: Record<string, string>;
+}>;
+/**
+ * The CRUD operations declared for one query, keyed by query name in
+ * `Hooks.crud`. A query with no entry here permits none of them — the
+ * wire cannot reach anything the page has not published, exactly as for a
+ * named action.
+ */
+export interface Crud {
+    cellChange?: CellChangeOp;
+    tupleDelete?: TupleDeleteOp;
+    tupleInsert?: TupleInsertOp;
+    tupleUpdate?: TupleUpdateOp;
+}
+/**
+ * The shape of a `<name>.hooks.ts` module.
+ *
+ * `beforeGet` runs on the page's data GET, before any query. It declares no
+ * refresh set: the page GET runs the whole query set afterward, so whatever
+ * the hook changed is already in the response.
+ *
+ * `actions` names what this page may be asked to do. A name the page did not
+ * declare is refused, so the wire cannot reach anything the page has not
+ * published.
+ *
+ * `crud` is the same rule for the typed CRUD operations, keyed by the query
+ * they operate on rather than by a declared name — there is nothing to name,
+ * since the row's own coordinates say what it is.
+ */
+export interface Hooks {
+    beforeGet?: (ctx: HubContext) => void | Promise<void>;
+    actions?: Record<string, Action>;
+    crud?: Record<string, Crud>;
+}
+/** A page is four files sharing a basename; two of them are these. */
+export interface Page {
+    queries: Queries;
+    hooks: Hooks;
+}
+/**
+ * The page registry. Nothing scans a directory yet, so the application names
+ * its pages — see docs/guide.md, "What Hub does not do yet".
+ */
+export type Pages = Record<string, Page>;
+export interface Hub {
+    /** A page GET: run the page's beforeGet hook, then all of its queries. */
+    dataForPage(page: string, ctx: HubContext): Promise<HubData>;
+    /**
+     * An action: run what the page declared under that name, then the refresh
+     * set declared with it.
+     */
+    runAction(page: string, name: string, where: Where, ctx: HubContext): Promise<HubData>;
+    /** Edit one cell: run the query's declared `cellChange`, then its refresh set. */
+    runCellChange(page: string, where: {
+        query: string;
+        key: string;
+        cell: string;
+        value: string;
+    }, ctx: HubContext): Promise<HubData>;
+    /** Drop one tuple: run the query's declared `tupleDelete`, then its refresh set. */
+    runTupleDelete(page: string, where: {
+        query: string;
+        key: string;
+    }, ctx: HubContext): Promise<HubData>;
+    /** Add one tuple: run the query's declared `tupleInsert`, then its refresh set. */
+    runTupleInsert(page: string, where: {
+        query: string;
+        values: Record<string, string>;
+    }, ctx: HubContext): Promise<HubData>;
+    /** Edit several cells at once: run the query's declared `tupleUpdate`, then its refresh set. */
+    runTupleUpdate(page: string, where: {
+        query: string;
+        key: string;
+        values: Record<string, string>;
+    }, ctx: HubContext): Promise<HubData>;
+}
+/**
+ * Build the engine over a set of pages. The pages are fixed at startup; the
+ * context is not, and arrives with each call.
+ */
+export declare function createHub(pages: Pages): Hub;
+//# sourceMappingURL=lb-server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lb-server.d.ts","sourceRoot":"","sources":["../../server/lb-server.ts"],"names":[],"mappings":"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"}

package/dist/server/lb-server.js

@@ -0,0 +1,79 @@
+// The server-side contract and the engine that runs it.
+//
+// This is the counterpart to core/lb-constants.ts: that file is the
+// vocabulary the browser writes, this one is the vocabulary the application
+// writes. The engine below is the whole of Hub on the server. It ships no
+// HTTP server, no router, and no data layer.
+/**
+ * The entire set, and therefore also the order. A list widget reconciles to
+ * exactly this: a row whose key is not here is gone.
+ */
+export function rows(list) {
+    return { op: "rows", rows: list };
+}
+/**
+ * Only what changed. Rows named here arrive or are updated, keys in `drop`
+ * are gone, and everything unnamed is left alone — its contents, and its
+ * place in whatever order the widget is keeping.
+ */
+export function patch(change) {
+    return { op: "patch", ...change };
+}
+/**
+ * Build the engine over a set of pages. The pages are fixed at startup; the
+ * context is not, and arrives with each call.
+ */
+export function createHub(pages) {
+    async function run(page, names, ctx) {
+        const data = {};
+        for (const name of names) {
+            const query = pages[page]?.queries[name];
+            if (!query) {
+                console.warn(`loadbare: page '${page}' declares no query '${name}'`);
+                continue;
+            }
+            data[name] = await query(ctx);
+        }
+        return data;
+    }
+    /**
+     * Shared by every operation kind: run what was declared, then its refresh
+     * set against the same context, laying what the operation itself stated
+     * over the refreshed queries — the narrower answer wins because it is the
+     * one that knows what actually changed.
+     */
+    async function settle(page, declared, where, ctx, notFound) {
+        if (!declared) {
+            console.warn(notFound);
+            return {};
+        }
+        const stated = await declared.run(ctx, where);
+        return { ...(await run(page, declared.refresh, ctx)), ...(stated ?? {}) };
+    }
+    return {
+        async dataForPage(page, ctx) {
+            const entry = pages[page];
+            if (!entry) {
+                console.warn(`loadbare: no page '${page}'`);
+                return {};
+            }
+            await entry.hooks.beforeGet?.(ctx);
+            return run(page, Object.keys(entry.queries), ctx);
+        },
+        runAction(page, name, where, ctx) {
+            return settle(page, pages[page]?.hooks.actions?.[name], where, ctx, `loadbare: page '${page}' declares no action '${name}'`);
+        },
+        runCellChange(page, where, ctx) {
+            return settle(page, pages[page]?.hooks.crud?.[where.query]?.cellChange, { key: where.key, cell: where.cell, value: where.value }, ctx, `loadbare: page '${page}' declares no cell-change for query '${where.query}'`);
+        },
+        runTupleDelete(page, where, ctx) {
+            return settle(page, pages[page]?.hooks.crud?.[where.query]?.tupleDelete, { key: where.key }, ctx, `loadbare: page '${page}' declares no tuple-delete for query '${where.query}'`);
+        },
+        runTupleInsert(page, where, ctx) {
+            return settle(page, pages[page]?.hooks.crud?.[where.query]?.tupleInsert, { values: where.values }, ctx, `loadbare: page '${page}' declares no tuple-insert for query '${where.query}'`);
+        },
+        runTupleUpdate(page, where, ctx) {
+            return settle(page, pages[page]?.hooks.crud?.[where.query]?.tupleUpdate, { key: where.key, values: where.values }, ctx, `loadbare: page '${page}' declares no tuple-update for query '${where.query}'`);
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Assembling a chrome file and its pages — see build/assemble.ts.
+ *
+ * The chrome and pages together are one write to a temp tree per test,
+ * since assemble() reads from disk rather than taking sources in memory.
+ */
+export {};
+//# sourceMappingURL=assemble.test.d.ts.map

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

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

package/dist/tests/assemble.test.js

@@ -0,0 +1,51 @@
+/**
+ * Assembling a chrome file and its pages — see build/assemble.ts.
+ *
+ * The chrome and pages together are one write to a temp tree per test,
+ * since assemble() reads from disk rather than taking sources in memory.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { assemble } from "../build/assemble";
+import { resolveLocations } from "../build/locations";
+async function tree(files) {
+    const dir = await mkdtemp(path.join(tmpdir(), "loadbare-assemble-"));
+    for (const [name, content] of Object.entries(files)) {
+        const file = path.join(dir, name);
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, content, "utf-8");
+    }
+    return dir;
+}
+describe("assemble", () => {
+    it("expands a widget written in the chrome, not only in pages", async () => {
+        const src = await tree({
+            "chrome.chrome.html": `<!doctype html><body><lb-nav exp-label="Site"><a href="/a">A</a></lb-nav><lb-hub><main></main></lb-hub></body>`,
+            "lb-nav.html": `<nav aria-label="{{label}}" lb-slot></nav>`,
+        });
+        try {
+            const locations = await resolveLocations({ src, out: `${src}/dist` });
+            const { html, usedTags } = await assemble(locations);
+            assert.match(html, /<nav aria-label="Site"><a href="\/a">A<\/a><\/nav>/);
+            assert.ok(usedTags.has("lb-nav"));
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+    it("still throws when the chrome uses an undefined widget", async () => {
+        const src = await tree({
+            "chrome.chrome.html": `<!doctype html><body><lb-nope></lb-nope></body>`,
+        });
+        try {
+            const locations = await resolveLocations({ src, out: `${src}/dist` });
+            await assert.rejects(() => assemble(locations), /<lb-nope> has no definition/);
+        }
+        finally {
+            await rm(src, { recursive: true, force: true });
+        }
+    });
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Resolving a used tag to the script that registers it — see build/elements.ts.
+ *
+ * Fixtures under tests/fixtures/elements/ each stand in for one <src> tree,
+ * the same role tests/fixtures/definitions plays for expand.ts.
+ */
+export {};
+//# sourceMappingURL=elements.test.d.ts.map

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

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

package/dist/tests/elements.test.js

@@ -0,0 +1,111 @@
+/**
+ * Resolving a used tag to the script that registers it — see build/elements.ts.
+ *
+ * Fixtures under tests/fixtures/elements/ each stand in for one <src> tree,
+ * the same role tests/fixtures/definitions plays for expand.ts.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { customElementTags } from "../build/expand";
+import { loadElementManifest, resolveElements } from "../build/elements";
+import { discoverSrc, packageInfo } from "../build/locations";
+const FIXTURES = fileURLToPath(new URL("./fixtures/elements", import.meta.url));
+/**
+ * The locations resolveElements needs, discovered the same way the CLI
+ * discovers them — but via discoverSrc/packageInfo directly rather than the
+ * full resolveLocations, since none of these fixtures has a chrome file and
+ * resolveElements does not need one.
+ */
+async function locationsFor(src) {
+    const [{ widgets, elementsCandidates }, info] = await Promise.all([
+        discoverSrc(src),
+        packageInfo(),
+    ]);
+    return { widgets, elementsFile: elementsCandidates[0], ...info };
+}
+describe("customElementTags", () => {
+    it("collects every hyphenated tag, native elements excluded", () => {
+        const tags = customElementTags(`<div><lb-input></lb-input><app-box>hi</app-box><span></span></div>`);
+        assert.deepEqual([...tags].sort(), ["app-box", "lb-input"]);
+    });
+    it("reaches into template content", () => {
+        const tags = customElementTags(`<template><acme-widget></acme-widget></template>`);
+        assert.deepEqual([...tags], ["acme-widget"]);
+    });
+});
+describe("loadElementManifest", () => {
+    it("returns the default export, keyed by tag", async () => {
+        const manifest = await loadElementManifest(`${FIXTURES}/manifest/elements.ts`);
+        assert.deepEqual(manifest, { "acme-widget": "@acme/widget" });
+    });
+    it("returns empty when there is no elements.ts", async () => {
+        const manifest = await loadElementManifest(`${FIXTURES}/local/elements.ts`);
+        assert.deepEqual(manifest, {});
+    });
+    it("rejects a key that is not a valid custom element name", async () => {
+        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-bad-tag/elements.ts`), /'acmewidget' is not a valid custom element name/);
+    });
+    it("rejects a value that is not an import specifier string", async () => {
+        await assert.rejects(() => loadElementManifest(`${FIXTURES}/manifest-bad-value/elements.ts`), /must map to an import specifier string/);
+    });
+});
+describe("resolveElements", () => {
+    it("resolves a built-in tag to the package's own widgets export", async () => {
+        const { resolved } = await resolveElements({
+            used: new Set(["lb-input"]),
+            ...(await locationsFor(`${FIXTURES}/local`)),
+        });
+        assert.deepEqual(resolved.get("lb-input"), {
+            kind: "specifier",
+            value: "@loadbare/app/widgets/lb-input",
+        });
+    });
+    it("resolves lb-hub the same way, by its script in hub/ rather than widgets/", async () => {
+        const { resolved } = await resolveElements({
+            used: new Set(["lb-hub"]),
+            ...(await locationsFor(`${FIXTURES}/local`)),
+        });
+        assert.deepEqual(resolved.get("lb-hub"), {
+            kind: "specifier",
+            value: "@loadbare/app",
+        });
+    });
+    it("resolves a local tag to its file in <src>/widgets", async () => {
+        const { resolved } = await resolveElements({
+            used: new Set(["app-box"]),
+            ...(await locationsFor(`${FIXTURES}/local`)),
+        });
+        assert.equal(resolved.get("app-box")?.kind, "file");
+        assert.match(resolved.get("app-box").value, /local\/widgets\/app-box$/);
+    });
+    it("resolves a tag declared only in elements.ts", async () => {
+        const { resolved } = await resolveElements({
+            used: new Set(["acme-widget"]),
+            ...(await locationsFor(`${FIXTURES}/manifest`)),
+        });
+        assert.deepEqual(resolved.get("acme-widget"), {
+            kind: "specifier",
+            value: "@acme/widget",
+        });
+    });
+    it("needs no script for a tag with only an .html definition", async () => {
+        const { resolved } = await resolveElements({
+            used: new Set(["lb-nav"]),
+            ...(await locationsFor(`${FIXTURES}/markup-only`)),
+        });
+        assert.equal(resolved.size, 0);
+    });
+    it("throws when a used tag registers nothing", async () => {
+        await assert.rejects(async () => resolveElements({
+            used: new Set(["nowhere-widget"]),
+            ...(await locationsFor(`${FIXTURES}/local`)),
+        }), /<nowhere-widget> has neither a script nor a definition/);
+    });
+    it("throws when a used tag is declared in more than one place", async () => {
+        await assert.rejects(async () => resolveElements({
+            used: new Set(["acme-widget"]),
+            ...(await locationsFor(`${FIXTURES}/collision`)),
+        }), /<acme-widget> is declared in more than one place: src, .*elements\.ts/);
+    });
+});

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

@@ -0,0 +1,10 @@
+/**
+ * Expansion — see docs/expansion.md and docs/testing.md, tier 1.
+ *
+ * Definitions are written inline here because `expand` takes them as a map
+ * and a two-line definition beside its assertion reads better than a file
+ * reference. The cases that genuinely need files — the checks `loadDefinitions`
+ * runs, and directory ordering — use tests/fixtures/definitions.
+ */
+export {};
+//# sourceMappingURL=expand.test.d.ts.map

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

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