@uniweb/core 0.16.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -9,6 +9,7 @@
     "./collection-address": "./src/query-address.js",
     "./query-address": "./src/query-address.js",
     "./data-paths": "./src/data-paths.js",
+    "./datastore": "./src/datastore.js",
     "./detail-url": "./src/detail-url.js",
     "./fetch-config": "./src/fetch-config.js",
     "./icon-corpus": "./src/icon-corpus.js",
@@ -42,8 +43,8 @@
     "vitest": "^4.1.7"
   },
   "dependencies": {
-    "@uniweb/theming": "^0.1.15",
-    "@uniweb/semantic-parser": "^1.4.0"
+    "@uniweb/semantic-parser": "^1.4.0",
+    "@uniweb/theming": "^0.1.15"
   },
   "scripts": {
     "test": "vitest run"

package/src/datastore.js

@@ -35,12 +35,21 @@
  * @returns {string} A stable JSON string usable as a cache-Map key
  */
 export function deriveCacheKey(request) {
-  const { path, url, endpoint, schema, transform } = request || {}
+  // ⭐ `as` is the binding key; `schema` is the name it had until 2026-09-02 and
+  // still arrives on every payload published before then. Normalised HERE so one
+  // logical request hashes to one key whichever spelling reached us — a consumer
+  // deriving a key must not get two entries for the same fetch.
+  const { path, url, endpoint, transform } = request || {}
+  const as = request?.as ?? request?.schema
   const method = request?.method && request.method.toUpperCase() !== 'GET'
     ? request.method.toUpperCase()
     : undefined
   const body = method === 'POST' ? request?.body : undefined
-  return JSON.stringify({ path, url, endpoint, schema, transform, method, body })
+  // ⚠️ The field NAME is part of the hash, so renaming it moves every key ONCE.
+  // In-memory stores repopulate; a consumer with a persistent cache takes one
+  // cold pass. Chosen over hashing under the old name, which would have hidden
+  // the rename inside the one function whose job is to be canonical.
+  return JSON.stringify({ path, url, endpoint, as, transform, method, body })
 }
 
 export default class DataStore {

package/src/entity-store.js

@@ -15,6 +15,13 @@
  */
 
 import { isFetchRefinement, resolveFetchConfigs } from './fetch-config.js'
+
+/**
+ * A fetch config's binding key — the `content.data.<key>` a component reads.
+ * `as` is the name; `schema` is what it was called until 2026-09-02 and still
+ * arrives on any payload published before then. See `fetch-config.js`.
+ */
+const bindingKeyOf = (cfg) => cfg?.as ?? cfg?.schema
 import { buildDetailConfig } from './detail-url.js'
 
 /**
@@ -201,7 +208,7 @@ export default class EntityStore {
     // collecting all cascade matches.
     if (requested === null && block.fetch) {
       const blockFetchList = Array.isArray(block.fetch) ? block.fetch : [block.fetch]
-      const schemas = blockFetchList.filter((cfg) => cfg.schema).map((cfg) => cfg.schema)
+      const schemas = blockFetchList.filter(bindingKeyOf).map(bindingKeyOf)
       if (schemas.length > 0) requested = schemas
     }
 
@@ -299,7 +306,7 @@ export default class EntityStore {
     let requested = this._getRequestedSchemas(meta)
     if (requested === null && block.fetch) {
       const blockFetchList = Array.isArray(block.fetch) ? block.fetch : [block.fetch]
-      const schemas = blockFetchList.filter((cfg) => cfg.schema).map((cfg) => cfg.schema)
+      const schemas = blockFetchList.filter(bindingKeyOf).map(bindingKeyOf)
       if (schemas.length > 0) requested = schemas
     }
     if (requested === null) return { data: null }

package/src/fetch-config.js

@@ -109,19 +109,37 @@ function applyDeferredDetail(cfg, queries, records) {
   // projection is not obliged to carry — so on such a host that rule can never
   // fire, and this is the only way a detail page reaches a whole record.
   if (cfg.endpoint) {
-    const recordPattern = resolveRecordAddressPattern(cfg.query ?? cfg.schema, records)
+    // ⛔ `cfg.query`, not `cfg.query ?? cfg.schema`. The `??` was unreachable:
+    // `endpoint` is set in exactly one place (`resolveQuerySource`), which returns
+    // early unless `cfg.query` is a non-empty string — so reaching here proves it.
+    // It read as a tolerance for two producer shapes and was really a vestige of
+    // the build lane not emitting `query`, which it now does.
+    const recordPattern = resolveRecordAddressPattern(cfg.query, records)
     if (recordPattern) return { ...cfg, detail: recordPattern }
   }
 
-  const schema = cfg.schema
-  if (!schema || !queries) return cfg
-  const collConfig = queries[schema]
+  // ⛔ **`config.queries` is keyed by QUERY NAME, so look it up by the query.**
+  // This read `cfg.schema` — the BINDING KEY, which merely defaults to the query
+  // name. `fetch: { query: 'articles', schema: 'posts' }` is a supported, allow-
+  // listed, unwarned form (`RECOGNIZED_FETCH_KEYS.query`), and under it the lookup
+  // missed and a detail page silently rendered the brief without its body.
+  // Measured 2026-09-01, control passing: `{query:'articles'}` resolved
+  // `/data/articles/{slug}.json`; `{query:'articles',schema:'posts'}` resolved
+  // nothing, from the same file.
+  //
+  // ⚖️ The `|| cfg.schema` is NOT the vestige deleted above. A source-shape fetch
+  // (`{ path: … }`) has no query at all, and its schema — inferred from the path —
+  // is the only key there is. Two shapes, two answers; the deleted one had one
+  // shape and pretended otherwise.
+  const queryName = cfg.query || bindingKey(cfg)
+  if (!queryName || !queries) return cfg
+  const collConfig = queries[queryName]
   if (!collConfig || typeof collConfig !== 'object') return cfg
   const deferred = Array.isArray(collConfig.deferred) ? collConfig.deferred : null
   if (!deferred || deferred.length === 0) return cfg
   const pattern = typeof collConfig.detailUrl === 'string'
     ? collConfig.detailUrl
-    : recordDataUrl(schema, '{slug}')
+    : recordDataUrl(queryName, '{slug}')
   return { ...cfg, detail: pattern }
 }
 
@@ -164,6 +182,28 @@ function resolveQuerySource(cfg, records) {
   return { ...cfg, path: queryDataUrl(cfg.query) }
 }
 
+/**
+ * The binding key of a fetch config — the `content.data.<key>` a component reads.
+ *
+ * ⭐ **`as` is the name; `schema` is what it was called until 2026-09-02.** The old
+ * spelling still arrives on every payload published before then and on any seed
+ * built against an older release, so this is not a deprecation window — it is a
+ * permanent reader of stored data. *(Renaming it was not cosmetic: `schema`
+ * already means the MODEL REF one record over, on a `queries` declaration, and
+ * one word for two things is what let a binding-key override silently break
+ * detail resolution.)*
+ *
+ * ⛔ Do not "simplify" this to `cfg.as`. The `??` here is earned — it spans
+ * stored payloads we cannot rewrite — unlike the one deleted from
+ * `applyDeferredDetail`, which spanned two producers we control.
+ *
+ * @param {Object} cfg
+ * @returns {string|undefined}
+ */
+function bindingKey(cfg) {
+  return cfg?.as ?? cfg?.schema
+}
+
 /**
  * Resolve the applicable fetch configs from an ordered list of sources.
  *
@@ -206,14 +246,15 @@ export function resolveFetchConfigs(sources, options = {}) {
     if (!source) continue
     const configList = Array.isArray(source) ? source : [source]
     for (const cfg of configList) {
-      if (!cfg?.schema) continue
-      if (configs.has(cfg.schema)) continue
-      if (!collectAll && !schemas.includes(cfg.schema)) continue
+      const key = bindingKey(cfg)
+      if (!key) continue
+      if (configs.has(key)) continue
+      if (!collectAll && !schemas.includes(key)) continue
       // Address first: localization and deferred-detail both key on `path`,
       // which a query ref does not have until this runs.
       const sourced = resolveQuerySource(cfg, records)
       const localized = localizeConfig(sourced, locale, defaultLocale)
-      configs.set(cfg.schema, applyDeferredDetail(localized, queries, records))
+      configs.set(key, applyDeferredDetail(localized, queries, records))
     }
   }