@uniweb/core 0.19.0 → 0.21.0

package/src/website.js

@@ -11,7 +11,9 @@ import FetcherDispatcher from './fetcher-dispatcher.js'
 import ObservableState from './observable-state.js'
 import { normalizeSeo } from './seo.js'
 import { resolveDefaultLocale, localeLabel } from './locale-config.js'
-import { matchDynamicRoute, decodeRouteValue } from './route-match.js'
+import { matchDynamicRoute, decodeRouteValue, routePatternToRegex, splitPathCapture, routeParamValue } from './route-match.js'
+import { resolveFetchConfigs } from './fetch-config.js'
+import { buildDetailConfig } from './detail-url.js'
 import { resolveService } from './services.js'
 
 /**
@@ -558,14 +560,36 @@ export default class Website {
     pageData.route = concreteRoute
     pageData.isDynamic = false // No longer a template
 
-    const paramName = Object.keys(params)[0]
-    const paramValue = Object.values(params)[0]
+    // ⭐ The route's variables, and the param the record is delivered by.
+    //
+    // `[slug]` — the one capture, under the folder's own label: `paramName` is
+    // that label and the record is matched on `item[paramName]`.
+    //
+    // `[...path]` — the capture is split by the rule in `route-match.js`
+    // (`:path` the whole capture · `:dir` everything before the last segment ·
+    // `:slug` the last segment); the record is delivered by `slug`, its handle,
+    // exactly as under `[slug]`, and `path` / `dir` exist for a query to bind
+    // (`scope: :dir`, `where: { tag: :dir }`). Ruled 2026-09-04 [Diego]: the
+    // variables are standard, never author-named.
+    const { catchAll } = routePatternToRegex(templatePage.route)
+    let variables = { ...params }
+    let paramName
+    let paramValue
+    if (catchAll && params[catchAll] !== undefined) {
+      const parts = splitPathCapture(params[catchAll])
+      variables = { ...params, ...parts }
+      paramName = originalData.paramName || 'slug'
+      paramValue = parts.slug
+    } else {
+      paramName = originalData.paramName || Object.keys(params)[0]
+      paramValue = params[paramName]
+    }
     const pluralSchema = originalData.parentSchema // e.g., 'articles'
 
     // Store dynamic context for components to access
     pageData.dynamicContext = {
       templateRoute: templatePage.route,
-      params,
+      params: variables,
       paramName,
       paramValue,
       schema: pluralSchema,
@@ -580,32 +604,65 @@ export default class Website {
 
     // Try to resolve page metadata from DataStore
     // Look up the parent page's fetch config to find data in the store
-    const parentRoute = templatePage.route.replace(/\/:[\w]+$/, '') || '/'
+    // The template's parent: the route without its `:param` — or `:path*` — tail.
+    const parentRoute = templatePage.route.replace(/\/:[\w-]+\*?$/, '') || '/'
     const parentPage = this.pages.find(p => p.route === parentRoute || p.getNavRoute() === parentRoute)
 
     if (parentPage && pluralSchema) {
-      // Find the records from the parent's fetch config via the dispatcher's
-      // peek (sync cache probe). Used to populate the page title / notFound
-      // flag on dynamic pages before the page instance is constructed.
+      // Find the record the page is ABOUT via the dispatcher's peek (a sync
+      // cache probe), to set the page title / description / notFound flag
+      // before the page instance is constructed.
+      //
+      // ⛔ RESOLVED THE WAY THE ENTITY STORE RESOLVES IT, not the raw declaration.
+      // Until 2026-09-04 this peeked `parentPage.fetch` as authored — `{ query,
+      // path, as }` — while the store writes under the RESOLVED config: on a door
+      // lane that carries `door` and no `path`, and on a non-default locale a
+      // `/fr/data/…` path. Two different keys for one dataset, so the probe
+      // missed on exactly those lanes: no title, no not-found, and the page was
+      // never cached (`recordsLoaded` false on every visit). Silent, on a
+      // visitor's page — the "write key ≠ read key" failure.
       const parentFetch = parentPage.fetch
       let items = []
+      let currentItem = null
 
       if (parentFetch && this.fetcher) {
         // ⛔ `as` is the binding key. This matched on `schema` alone until
         // 2026-09-02 — which, once the alias went, would have found nothing:
         // `items` stays `[]` and the page reports "Not found" for a record that
         // exists. Silent, and on a visitor's page.
-        const keyOf = (f) => f?.as
-        const fetchConfig = Array.isArray(parentFetch)
-          ? parentFetch.find((f) => keyOf(f) === pluralSchema)
-          : (keyOf(parentFetch) === pluralSchema ? parentFetch : null)
+        const fetchConfig = resolveFetchConfigs([parentFetch], {
+          schemas: [pluralSchema],
+          locale: this.getActiveLocale(),
+          defaultLocale: this.getDefaultLocale(),
+          queries: this.config?.queries ?? null,
+          records: this.config?.records ?? null,
+          variables,
+        }).get(pluralSchema)
         if (fetchConfig) {
-          const cached = this.fetcher.peek(fetchConfig, { website: this })
+          const ctx = { website: this }
+          // ⭐ The page is about ONE record, so ask for that record first: a
+          // cached detail fetch (a live lane's record address, a deferred
+          // query's per-record file) carries the title even when the list was
+          // never fetched — a cold load on a detail URL — where a scan of the
+          // list finds nothing and silently sets no title (F3, 2026-09-04).
+          const detailCfg = fetchConfig.detail
+            ? buildDetailConfig(fetchConfig, { paramName, paramValue })
+            : null
+          const detailCached = detailCfg ? this.fetcher.peek(detailCfg, ctx) : null
+          // A door answers the record question as a list of one (a question's
+          // answer is always a list); a per-record file answers the bare record.
+          const raw = detailCached?.data
+          const record = Array.isArray(raw) ? raw[0] : raw
+          if (record && typeof record === 'object') currentItem = record
+
+          const cached = this.fetcher.peek(fetchConfig, ctx)
           items = Array.isArray(cached?.data) ? cached.data : []
         }
       }
 
-      const currentItem = items.find(item => String(item[paramName]) === String(paramValue))
+      if (!currentItem) {
+        currentItem = items.find(item => String(routeParamValue(item, paramName)) === String(paramValue)) ?? null
+      }
 
       if (currentItem) {
         if (currentItem.title) pageData.title = currentItem.title
@@ -624,7 +681,7 @@ export default class Website {
       // { paramName, paramValue, schema }; the record reaches components via
       // content.data, siblings via `fetch: { refine: true, detail: false }`).
       // The local `currentItem`/`items` above drive title/description/notFound.
-      pageData._recordsLoaded = items.length > 0
+      pageData._recordsLoaded = items.length > 0 || currentItem !== null
     }
 
     // Create the page instance
@@ -814,6 +871,31 @@ export default class Website {
     return resolvedHref
   }
 
+  /**
+   * The route template that renders ONE record of a binding key — `{ route,
+   * paramName }` for the `[param]` page whose parent query lands under `key`,
+   * or null when the site routes no detail page over it.
+   *
+   * ⭐ This is how a caller outside a template page learns which record field
+   * the site's URL is built on: `kit`'s `useEntityDetail` asks it so a hover
+   * card and the page it links to address the record by the SAME field. It
+   * hardcoded `slug` until 2026-09-04, which was quietly wrong on any site
+   * routing `[id]`. The first template found
+   * wins, matching `parentSchema`'s own rule that one key indexes one template.
+   *
+   * @param {string} key - a binding key (`content.data.<key>`)
+   * @returns {{ route: string, paramName: string } | null}
+   */
+  detailTemplateFor(key) {
+    if (!key) return null
+    for (const data of this._dynamicPageData.values()) {
+      if (data?.parentSchema === key && data.paramName) {
+        return { route: data.route, paramName: data.paramName }
+      }
+    }
+    return null
+  }
+
   /**
    * Resolve a `page:<stable_id>` detail-page reference (from a fetch config's
    * `detailPage`) to a locale-specific route TEMPLATE, e.g. '/blog/:slug'. The

package/src/request-styles/index.js

@@ -1,59 +0,0 @@
-/**
- * Request style — how the default fetcher reshapes a normalized request
- * into wire format: which operators become URL params, which go into a
- * body, what envelope the response carries.
- *
- * One style ships: `json-body`, the framework's own conventions, and it
- * is the only wire the default fetcher speaks. A backend with another
- * dialect is reached through a named transport — shipped by the
- * foundation, or by an extension the site selects per schema in
- * `site.yml fetcher.transports` — never through a second built-in style.
- * Two vendor dialects, `flat-query` and `strapi`, shipped here from
- * `@uniweb/core` 0.7.1 and were removed: a third party's wire is not a
- * framework concern, and core is loaded by every site and never
- * tree-shaken.
- *
- * `site.yml fetcher.request.style` is still read, for one reason: a site
- * that names a style the framework does not ship must be told. Falling
- * back silently would send the default wire to a backend that does not
- * speak it — the request succeeds and the data is wrong.
- *
- * Internal to @uniweb/core. Consumed by @uniweb/runtime's default-fetcher.
- */
-
-import { jsonBody } from './json-body.js'
-
-const unknownStyleMessage = (name) =>
-  `[default-fetcher] unknown request style "${name}". The framework ships one wire, ` +
-  `"json-body"; a backend with a different dialect is reached through a named transport ` +
-  `(site.yml fetcher.transports), shipped by the foundation or by an extension.`
-
-/**
- * Resolve the request style. No name, or `json-body`, returns the one
- * shipped style. Any other name is a site declaring a wire dialect the
- * framework does not ship: in dev this throws, so the site does not boot
- * on the wrong wire; in production it logs an error once and falls back
- * to `json-body`, so the site still renders.
- *
- * @param {string|undefined|null} name
- * @param {{ dev?: boolean }} [options]
- * @returns {Object} A style module.
- * @throws {Error} in dev, on a name that is not `json-body`.
- */
-export function resolveStyle(name, { dev = false } = {}) {
-  if (!name || name === jsonBody.name) return jsonBody
-  if (dev) {
-    const err = new Error(unknownStyleMessage(name))
-    err.code = 'UNKNOWN_REQUEST_STYLE'
-    throw err
-  }
-  if (!erroredUnknownStyles.has(name)) {
-    erroredUnknownStyles.add(name)
-    console.error(unknownStyleMessage(name) + ' Falling back to "json-body".')
-  }
-  return jsonBody
-}
-
-const erroredUnknownStyles = new Set()
-
-export { jsonBody }

package/src/request-styles/json-body.js

@@ -1,117 +0,0 @@
-/**
- * json-body — the framework's general-purpose request style.
- *
- * Ambient default when the site doesn't pick a style. Speaks the
- * framework's own conventions:
- *
- *   GET   — operators travel as URL params prefixed with underscore:
- *             ?_where=<JSON.stringify(predicate)>
- *             ?_limit=N
- *             ?_sort=field:dir       (comma-separated for multi-key)
- *           The leading underscore avoids collision with backend-
- *           specific query params the author may have included in `url:`.
- *
- *   POST  — operators merge as top-level keys into an object body,
- *           alongside any author-supplied body. Content-Type defaults
- *           to `application/json` unless the site set a different one.
- *           String POST bodies (rare; typically GraphQL-only) don't
- *           receive operator merge — the string is sent as-is.
- *
- * Operator name renames are applied from the `rename:` map passed in
- * context. Shallow substitutions only — `rename: { limit: pageSize }`
- * swaps the wire name `_limit` → `pageSize` on GET, or the body key
- * `limit` → `pageSize` on POST. The operator identity (what `limit`
- * means in the query) does not change.
- *
- * Internal module. Accessed by `default-fetcher.js` via the registry;
- * never imported directly from outside `@uniweb/runtime`.
- */
-
-export const jsonBody = {
-  name: 'json-body',
-
-  // Which operators this style knows how to push. The effective push set
-  // is the intersection of this and the site's `supports:` list.
-  canPush: new Set(['where', 'limit', 'sort']),
-
-  // Default response envelope. null = no wrapper (a plain JSON payload).
-  defaultEnvelope: null,
-
-  /**
-   * Encode a request against the json-body conventions.
-   *
-   * @param {Object} request - The normalized fetch request.
-   * @param {Object} ctx
-   * @param {'GET'|'POST'} ctx.method - The method the fetcher chose.
-   * @param {Set<string>} ctx.pushCandidates - Operators present on the
-   *   request AND listed in the site's `supports:`. Style may choose to
-   *   push all, some, or none of these based on what it knows how to
-   *   express on the wire.
-   * @param {Object|null} ctx.rename - Optional { operator → wireName } map.
-   * @returns {{
-   *   queryParams: Array<[string, string]>,
-   *   bodyMerge: Object|null,
-   *   pushed: Set<string>,
-   * }}
-   *   queryParams — pairs appended to the URL's query string.
-   *   bodyMerge   — object merged into the POST body, or null.
-   *   pushed      — the operators that actually rode on the wire.
-   *                 Feeds the fetcher's cache-key derivation and
-   *                 runtime-fallback skip.
-   */
-  encode(request, { method, pushCandidates, rename }) {
-    const pushed = new Set()
-    const queryParams = []
-    let bodyMerge = null
-
-    if (method === 'GET') {
-      if (pushCandidates.has('where') && request.where !== undefined) {
-        queryParams.push([
-          wireName('where', '_where', rename),
-          JSON.stringify(request.where),
-        ])
-        pushed.add('where')
-      }
-      if (pushCandidates.has('limit') && request.limit !== undefined) {
-        queryParams.push([
-          wireName('limit', '_limit', rename),
-          String(request.limit),
-        ])
-        pushed.add('limit')
-      }
-      if (pushCandidates.has('sort') && request.sort !== undefined) {
-        queryParams.push([
-          wireName('sort', '_sort', rename),
-          String(request.sort),
-        ])
-        pushed.add('sort')
-      }
-    } else if (method === 'POST') {
-      const merged = {}
-      if (pushCandidates.has('where') && request.where !== undefined) {
-        merged[wireName('where', 'where', rename)] = request.where
-        pushed.add('where')
-      }
-      if (pushCandidates.has('limit') && request.limit !== undefined) {
-        merged[wireName('limit', 'limit', rename)] = request.limit
-        pushed.add('limit')
-      }
-      if (pushCandidates.has('sort') && request.sort !== undefined) {
-        merged[wireName('sort', 'sort', rename)] = request.sort
-        pushed.add('sort')
-      }
-      if (Object.keys(merged).length > 0) bodyMerge = merged
-    }
-
-    return { queryParams, bodyMerge, pushed }
-  },
-}
-
-function wireName(operator, defaultWire, rename) {
-  if (rename && typeof rename[operator] === 'string' && rename[operator].length > 0) {
-    return rename[operator]
-  }
-  return defaultWire
-}
-
-export default jsonBody