@loadbare/app 0.9.0 → 0.11.0

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

@@ -1,9 +1,9 @@
-import type { Patch, Row, HubData, HubResult } from "../core/lb-types.js";
+import type { HubData, HubRequest, HubResponse, HubResult, Kind, Patch, RequestFields, Row } from "../core/lb-types.js";
 /**
  * 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:
+ * Loadbare 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 {
@@ -21,192 +21,134 @@ import type { Patch, Row, HubData, HubResult } from "../core/lb-types.js";
 export interface HubContext {
 }
 /**
- * A declared query: the request context in, one result out.
+ * A declared query: its kind, its key, and the run that answers it.
  *
- * Cardinality is a property of the name rather than of any one answer, so it
- * is declared here and never inferred from what comes back. One name answers
- * with one shape, always. A page that wants the roster once as a single row
- * and once as a set declares two queries.
+ * Kind and key are properties of the name rather than of any one answer, so
+ * they are declared here and never inferred from what comes back. The engine
+ * sends both with every answer, so the markup repeats neither. Every query
+ * has a key; an aggregate row answers with a constant one.
  *
- * Write one with `row()` or `list()` below; nothing else builds one.
+ * Write one with `row()` or `rows()` below; nothing else builds one.
  */
 export interface Query {
-    readonly kind: "row" | "list";
+    readonly kind: Kind;
+    readonly key: string;
     readonly run: (ctx: HubContext) => HubResult | Promise<HubResult>;
 }
-/** A query that answers with one row. */
-export declare function row(run: (ctx: HubContext) => Row | Promise<Row>): Query;
+/** A query that answers with one row, identified by its `key` column. */
+export declare function row(key: string, run: (ctx: HubContext) => Row | Promise<Row>): Query;
 /**
- * A query that answers with the entire set, and therefore also the order. A
- * list reconciles to exactly this: a row whose key is not here is gone.
- *
- * There is no wrapper around the array, because the declaration already said
- * this name answers with rows.
+ * A query that answers with all its rows, and therefore also their order.
+ * Rows land by their `key` column: a row whose key is not in the answer is
+ * gone.
  */
-export declare function list(run: (ctx: HubContext) => Row[] | Promise<Row[]>): Query;
+export declare function rows(key: string, run: (ctx: HubContext) => Row[] | Promise<Row[]>): Query;
 /**
- * Only what changed, returned from a `crud` run rather than from a query.
- * 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.
+ * Only what changed, returned from a handler for a `rows` query. Rows named
+ * here are added or updated, keys in `drop` are removed, and everything
+ * unnamed is left alone — its contents, and its place in whatever order the
+ * page is keeping.
  *
- * `Array.isArray` is what tells a patch from a whole set, so a patch needs no
+ * `Array.isArray` is what tells a patch from all rows, so a patch needs no
  * marker of its own and no column name is reserved to carry one.
  */
 export declare function patch(change: {
     rows?: Row[];
-    drop?: string[];
+    drop?: unknown[];
 }): Patch;
 /**
- * Query parms a write decided, returned from a request's `run` when only the
- * write can know them: the key of a row it inserted, or the absence of one it
- * deleted. Each named parm is set, or taken out when its value is empty, and
- * every other parm is left as it is. Name at least one.
+ * A new row for `lb-url`, returned from a handler when only the handler can
+ * know where the page belongs: the key of a row it inserted, or the absence
+ * of one it deleted.
  *
- * The page then loads at that query string in the same round trip, as a
- * cold load of it would, so the refresh set is not run and whatever else
- * `run` returned is dropped: both were answers for the query string the page
- * is leaving. This is Post/Redirect/Get without the redirect. The hub writes the parms into the URL, replacing the history
- * entry, and lands the load.
+ * A column other than `lb-path` is a query parm: set, or taken out when its
+ * value is empty. With `lb-path` naming another page, the page is entered
+ * with only the parms named here; otherwise every other parm is kept.
  *
- * Only parms. The path is never the server's to change.
+ * The page then loads at the new URL in the same round trip, as a cold load
+ * of it would, so the refresh set is not run and whatever else the handler
+ * returned is dropped: both were answers for the URL the page is leaving.
+ * This is Post/Redirect/Get without the redirect.
  */
-export declare function queryParms(parms: Record<string, string>): HubData;
-/** The shape of a `<name>.queries.ts` module. */
+export declare function url(columns: Record<string, string>): HubData;
+/** The shape of a `<stub>.queries.ts` module. */
 export type Queries = Record<string, Query>;
 /**
- * Where the interaction happened, in the binding 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 {
-    list?: string;
-    row?: string;
-    key?: string;
-    cell?: string;
-    value?: string;
-}
-/**
- * What an action does, and which queries must re-run once it has.
+ * What a handler does, and which queries 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.
+ * `run` may also return answers of its own, which are laid over the
+ * refreshed ones. That is how a patch reaches the browser: a query answers
+ * for all its rows and cannot know why it re-ran, but the handler knows
+ * exactly what it changed and can say only that.
  */
-export interface Action {
-    run: (ctx: HubContext, where: Where) => void | HubData | Promise<void | HubData>;
+export interface Handler<R = RequestFields> {
+    run: (ctx: HubContext, request: R) => 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 RowDeleteOp = CrudOp<{
-    key: string;
-}>;
-export type RowInsertOp = CrudOp<{
+export type RowInsertHandler = Handler<{
+    key?: string;
     values: Record<string, string>;
 }>;
-/** `values` holds only the columns being set; see `Hub.runRowUpdate`. */
-export type RowUpdateOp = CrudOp<{
+/** `values` holds only the columns being set, as an SQL UPDATE sets them. */
+export type RowUpdateHandler = Handler<{
     key: string;
     values: Record<string, string>;
 }>;
+export type RowDeleteHandler = Handler<{
+    key: string;
+}>;
 /**
- * The CRUD operations declared for one list, keyed by its name in
- * `Requests.crud`. A name with no entry here permits none of them — the wire
- * cannot reach anything the page has not published, exactly as for a named
- * action.
+ * What the requests Loadbare provides do to one query, keyed by its name in
+ * `Requests.crud`. A query with no entry here permits none of them: the wire
+ * cannot reach anything the page has not published.
  *
- * Every key here is the reserved `lb-action` value with the prefix stripped
- * and the rest camel-cased, so the attribute, the wire field and this key
- * are one vocabulary. All three are list operations: each needs a key, and a
- * key exists only on a live row inside a list.
+ * Every key is the request name with the prefix stripped and the rest
+ * camel-cased: `lb-row-insert` runs `rowInsert`.
  */
 export interface Crud {
-    rowDelete?: RowDeleteOp;
-    rowInsert?: RowInsertOp;
-    rowUpdate?: RowUpdateOp;
+    rowInsert?: RowInsertHandler;
+    rowUpdate?: RowUpdateHandler;
+    rowDelete?: RowDeleteHandler;
 }
 /**
- * The shape of a `<name>.requests.ts` module.
+ * The shape of a `<stub>.requests.ts` module.
  *
- * `onPageEnter` runs once when the page is entered, before any query. It
- * declares no refresh set: entering the page runs the whole query set
- * afterward, so whatever the hook changed is already in the response.
+ * `onPageEnter` runs when the page loads, before its queries. It declares no
+ * refresh set: the page's queries all run afterward, so whatever it 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.
+ * `handlers` holds the page's declared requests, by name. 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 list
- * they operate on rather than by a declared name — there is nothing to name,
- * since the row's own binding says what it is.
+ * `crud` holds what the requests Loadbare provides run, by query name.
  */
 export interface Requests {
     onPageEnter?: (ctx: HubContext) => void | Promise<void>;
-    actions?: Record<string, Action>;
+    handlers?: Record<string, Handler>;
     crud?: Record<string, Crud>;
 }
-/** A page is three files sharing a basename; two of them are these. */
+/** A page is three files sharing a stub; two of them are these. */
 export interface Page {
     queries: Queries;
     requests: Requests;
 }
 /**
- * The page registry. The builder populates this automatically from every
- * `.requests.ts`/`.queries.ts` pair it discovers — see docs/reference/builder.md,
- * "Generating the server-side page registry".
+ * The page registry. The builder writes it from every `.requests.ts` and
+ * `.queries.ts` it discovers — see docs/reference/builder.md.
  */
 export type Pages = Record<string, Page>;
 /**
- * The engine. Each of the four operations answers either with what its
- * refresh set and `run` produced, or, when `run` returned `queryParms()`,
- * with `QUERY_PARMS_ROW` alone. That second answer is not finished: the
- * caller builds a context from the query string with those parms set, calls
- * `dataForPage` with it, and sends the load with the row beside it.
- * `hubRoutes` does exactly that.
+ * The engine. Both calls answer with response items. A request whose
+ * handler returned `url()` answers with the `lb-url` item alone: the caller
+ * builds a context at the new URL, calls `dataForPage` with it, and sends
+ * the load beside the item. `hubRoutes` does exactly that.
  */
 export interface Hub {
-    /** Entering a page: run its onPageEnter 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>;
-    /** Drop one row: run the list's declared `rowDelete`, then its refresh set. */
-    runRowDelete(page: string, where: {
-        list: string;
-        key: string;
-    }, ctx: HubContext): Promise<HubData>;
-    /** Add one row: run the list's declared `rowInsert`, then its refresh set. */
-    runRowInsert(page: string, where: {
-        list: string;
-        values: Record<string, string>;
-    }, ctx: HubContext): Promise<HubData>;
-    /**
-     * Edit a row: run the list's declared `rowUpdate`, then its refresh set.
-     * `values` holds only the columns being set — one from a widget that
-     * commits a cell, several from a form — and a column absent from it is left
-     * as it is, as an SQL UPDATE leaves it.
-     */
-    runRowUpdate(page: string, where: {
-        list: string;
-        key: string;
-        values: Record<string, string>;
-    }, ctx: HubContext): Promise<HubData>;
+    /** A page load: its `onPageEnter`, then all of its queries. */
+    dataForPage(page: string, ctx: HubContext): Promise<HubResponse>;
+    /** A request: run the handler its name picks, then the refresh set. */
+    runRequest(page: string, request: HubRequest, ctx: HubContext): Promise<HubResponse>;
 }
 /**
  * Build the engine over a set of pages. The pages are fixed at startup; the

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

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

@@ -2,65 +2,78 @@
 //
 // 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.
-import { LB_RESERVED_PREFIX, QUERY_PARMS_ROW } from "../core/lb-constants.js";
-/** A query that answers with one row. */
-export function row(run) {
-    return { kind: "row", run };
+// writes. The engine below is the whole of Loadbare on the server. It ships
+// no HTTP server, no router, and no data layer.
+import { isRowRequest } from "../core/lb-types.js";
+import { KIND_ROW, KIND_ROWS, LB_RESERVED_PREFIX, REQUEST_ROW_DELETE, REQUEST_ROW_INSERT, REQUEST_ROW_UPDATE, URL_COLUMN_PATH, URL_QUERY, } from "../core/lb-constants.js";
+/** A query that answers with one row, identified by its `key` column. */
+export function row(key, run) {
+    return { kind: KIND_ROW, key, run };
 }
 /**
- * A query that answers with the entire set, and therefore also the order. A
- * list reconciles to exactly this: a row whose key is not here is gone.
- *
- * There is no wrapper around the array, because the declaration already said
- * this name answers with rows.
+ * A query that answers with all its rows, and therefore also their order.
+ * Rows land by their `key` column: a row whose key is not in the answer is
+ * gone.
  */
-export function list(run) {
-    return { kind: "list", run };
+export function rows(key, run) {
+    return { kind: KIND_ROWS, key, run };
 }
 /**
- * Only what changed, returned from a `crud` run rather than from a query.
- * 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.
+ * Only what changed, returned from a handler for a `rows` query. Rows named
+ * here are added or updated, keys in `drop` are removed, and everything
+ * unnamed is left alone — its contents, and its place in whatever order the
+ * page is keeping.
  *
- * `Array.isArray` is what tells a patch from a whole set, so a patch needs no
+ * `Array.isArray` is what tells a patch from all rows, so a patch needs no
  * marker of its own and no column name is reserved to carry one.
  */
 export function patch(change) {
-    return { ...change };
+    const made = { ...change };
+    patches.add(made);
+    return made;
 }
 /**
- * Query parms a write decided, returned from a request's `run` when only the
- * write can know them: the key of a row it inserted, or the absence of one it
- * deleted. Each named parm is set, or taken out when its value is empty, and
- * every other parm is left as it is. Name at least one.
+ * Every object `patch()` made. A patch and a row are both plain objects, so
+ * this is how the engine refuses a patch answering a `row` query.
+ */
+const patches = new WeakSet();
+/**
+ * A new row for `lb-url`, returned from a handler when only the handler can
+ * know where the page belongs: the key of a row it inserted, or the absence
+ * of one it deleted.
  *
- * The page then loads at that query string in the same round trip, as a
- * cold load of it would, so the refresh set is not run and whatever else
- * `run` returned is dropped: both were answers for the query string the page
- * is leaving. This is Post/Redirect/Get without the redirect. The hub writes the parms into the URL, replacing the history
- * entry, and lands the load.
+ * A column other than `lb-path` is a query parm: set, or taken out when its
+ * value is empty. With `lb-path` naming another page, the page is entered
+ * with only the parms named here; otherwise every other parm is kept.
  *
- * Only parms. The path is never the server's to change.
+ * The page then loads at the new URL in the same round trip, as a cold load
+ * of it would, so the refresh set is not run and whatever else the handler
+ * returned is dropped: both were answers for the URL the page is leaving.
+ * This is Post/Redirect/Get without the redirect.
  */
-export function queryParms(parms) {
-    return { [QUERY_PARMS_ROW]: { ...parms } };
+export function url(columns) {
+    return { [URL_QUERY]: { ...columns } };
 }
+/** The camel-cased `Crud` key of a request Loadbare provides. */
+const CRUD_KEYS = {
+    [REQUEST_ROW_INSERT]: "rowInsert",
+    [REQUEST_ROW_UPDATE]: "rowUpdate",
+    [REQUEST_ROW_DELETE]: "rowDelete",
+};
 /**
  * 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) {
-    // Names beginning with the reserved prefix are Loadbare's — the hub's
-    // own query, the CRUD operations — so an application cannot declare one.
+    // Names beginning with the reserved prefix are Loadbare's — its own query,
+    // the requests it provides — so an application cannot declare one.
     // Refused at startup, because a name is a fact about the page and not
     // about any request.
     for (const [page, entry] of Object.entries(pages)) {
         const declared = [
             ...Object.keys(entry.queries),
-            ...Object.keys(entry.requests.actions ?? {}),
+            ...Object.keys(entry.requests.handlers ?? {}),
+            ...Object.keys(entry.requests.crud ?? {}),
         ];
         for (const name of declared) {
             if (name.startsWith(LB_RESERVED_PREFIX)) {
@@ -69,6 +82,44 @@ export function createHub(pages) {
             }
         }
     }
+    /**
+     * Answers into response items, adding the kind and key each query
+     * declared. An answer that disagrees with its declaration is a mistake in
+     * the application rather than a case to handle, and is left out: a page is
+     * better off missing one query than showing the wrong shape for it.
+     */
+    function items(page, data) {
+        const out = [];
+        for (const [name, result] of Object.entries(data)) {
+            const query = pages[page]?.queries[name];
+            if (!query) {
+                console.warn(`loadbare: page '${page}' declares no query '${name}'`);
+                continue;
+            }
+            const item = {
+                query: name,
+                kind: query.kind,
+                key: query.key,
+            };
+            if (query.kind === KIND_ROW) {
+                if (Array.isArray(result) || patches.has(result)) {
+                    console.warn(`loadbare: query '${name}' is declared row but answered with ` +
+                        `${Array.isArray(result) ? "rows" : "a patch"}`);
+                    continue;
+                }
+                item.row = result;
+            }
+            else if (Array.isArray(result)) {
+                item.rows = result;
+            }
+            else {
+                item.patch = result;
+            }
+            out.push(item);
+        }
+        return out;
+    }
+    /** Run queries by name, each answering with all its rows or its row. */
     async function run(page, names, ctx) {
         const data = {};
         for (const name of names) {
@@ -78,10 +129,7 @@ export function createHub(pages) {
                 continue;
             }
             const result = await query.run(ctx);
-            // Cardinality is declared, so an answer that disagrees is a mistake in
-            // the query rather than a case to handle. Refused here, because a page
-            // is better off missing one name than showing the wrong shape for it.
-            if (Array.isArray(result) !== (query.kind === "list")) {
+            if (Array.isArray(result) !== (query.kind === KIND_ROWS)) {
                 console.warn(`loadbare: query '${name}' is declared ${query.kind} but answered ` +
                     `with ${Array.isArray(result) ? "rows" : "one row"}`);
                 continue;
@@ -91,73 +139,78 @@ export function createHub(pages) {
         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.
+     * Run a handler, then its refresh set against the same context, laying
+     * what the handler itself returned over the refreshed queries — the
+     * narrower answer wins because it knows what actually changed.
      *
-     * An operation that changed the query parms answers with the parms alone.
-     * Loading the page at them needs a context built from the new query
-     * string, and building one is the caller's: see `queryParms()`.
+     * A handler that returned `url()` answers with the `lb-url` item alone.
+     * Loading the page there needs a context built at the new URL, and
+     * building one is the caller's.
      */
-    async function settle(page, declared, where, ctx, notFound) {
-        if (!declared) {
+    async function settle(page, handler, request, ctx, notFound) {
+        if (!handler) {
             console.warn(notFound);
-            return {};
+            return [];
         }
-        const { [QUERY_PARMS_ROW]: parms, ...stated } = (await declared.run(ctx, where)) ?? {};
-        if (parms !== undefined) {
-            const refused = refusal(parms);
+        const { [URL_QUERY]: moved, ...stated } = (await handler.run(ctx, request)) ?? {};
+        if (moved !== undefined) {
+            const refused = refusal(moved);
             if (refused === undefined) {
-                return { [QUERY_PARMS_ROW]: parms };
+                return [
+                    {
+                        query: URL_QUERY,
+                        kind: KIND_ROW,
+                        key: URL_COLUMN_PATH,
+                        row: moved,
+                    },
+                ];
             }
-            // The write has already happened, so the page still hears about it,
-            // by its refresh set, as if no parms had been named.
-            console.warn(`loadbare: page '${page}' returned ${QUERY_PARMS_ROW} ${refused}, ` +
-                `ignoring it`);
+            // The handler has already run, so the page still hears about it, by
+            // its refresh set, as if no row for lb-url had been returned.
+            console.warn(`loadbare: page '${page}' returned ${URL_QUERY} ${refused}, ignoring it`);
         }
-        return { ...(await run(page, declared.refresh, ctx)), ...stated };
+        return items(page, {
+            ...(await run(page, handler.refresh, ctx)),
+            ...stated,
+        });
     }
     return {
         async dataForPage(page, ctx) {
             const entry = pages[page];
             if (!entry) {
                 console.warn(`loadbare: no page '${page}'`);
-                return {};
+                return [];
             }
             await entry.requests.onPageEnter?.(ctx);
-            return run(page, Object.keys(entry.queries), ctx);
+            return items(page, await run(page, Object.keys(entry.queries), ctx));
         },
-        runAction(page, name, where, ctx) {
-            return settle(page, pages[page]?.requests.actions?.[name], where, ctx, `loadbare: page '${page}' declares no action '${name}'`);
-        },
-        runRowDelete(page, where, ctx) {
-            return settle(page, pages[page]?.requests.crud?.[where.list]?.rowDelete, { key: where.key }, ctx, `loadbare: page '${page}' declares no rowDelete for '${where.list}'`);
-        },
-        runRowInsert(page, where, ctx) {
-            return settle(page, pages[page]?.requests.crud?.[where.list]?.rowInsert, { values: where.values }, ctx, `loadbare: page '${page}' declares no rowInsert for '${where.list}'`);
-        },
-        runRowUpdate(page, where, ctx) {
-            return settle(page, pages[page]?.requests.crud?.[where.list]?.rowUpdate, { key: where.key, values: where.values }, ctx, `loadbare: page '${page}' declares no rowUpdate for '${where.list}'`);
+        runRequest(page, request, ctx) {
+            const { name, ...fields } = request;
+            if (isRowRequest(name)) {
+                const query = fields.query ?? "";
+                return settle(page, pages[page]?.requests.crud?.[query]?.[CRUD_KEYS[name]], fields, ctx, `loadbare: page '${page}' declares no ${CRUD_KEYS[name]} for '${query}'`);
+            }
+            return settle(page, pages[page]?.requests.handlers?.[name], fields, ctx, `loadbare: page '${page}' declares no request '${name}'`);
         },
     };
 }
 /**
- * Why returned query parms cannot be used, or nothing when they can.
+ * Why a returned row for `lb-url` cannot be used, or nothing when it can.
  *
- * A value is a string, as a control's is and a URL's is. At least one parm
- * is named: a response naming none changes nothing, and reloading the whole
- * page at the same URL is not what this is for.
+ * A value is a string, as a control's is and a URL's is. At least one column
+ * is named: a row naming none changes nothing.
  */
-function refusal(parms) {
-    if (typeof parms !== "object" || parms === null || Array.isArray(parms)) {
+function refusal(columns) {
+    if (typeof columns !== "object" ||
+        columns === null ||
+        Array.isArray(columns)) {
         return "that is not a row";
     }
-    const values = Object.values(parms);
+    const values = Object.values(columns);
     if (values.length === 0)
-        return "naming no parm";
+        return "naming no column";
     if (!values.every((v) => typeof v === "string")) {
-        return `holding a value that is not a string; write queryParms({ name: "..." })`;
+        return `holding a value that is not a string; write url({ name: "..." })`;
     }
     return undefined;
 }