@lde/search 0.7.1 → 0.8.0

package/dist/physical-name.d.ts

@@ -24,8 +24,17 @@ import type { SearchType } from './schema.js';
  * rules produce (`serieses`, `analysises`). An already-plural name is
  * idempotent (`People` → `people`).
  *
- * Returns an empty array when `name` carries no alphanumerics at all; the
- * adapter decides what that means, since only it knows its engine’s rules.
+ * **Throws rather than name the wrong container.** Dropping what it cannot
+ * match is what lets `creative_work` tokenize like `CreativeWork`, but it would
+ * just as quietly turn `Café` into `['cafs']` and `Musée` into `['mus', 'es']`
+ * – a perfectly legal name for a container nobody meant. So a name is spellable
+ * only when it is ASCII words and word separators, and only when it leaves at
+ * least one word to name anything after; anything else throws here. This guard
+ * lives with the split it protects, not in each adapter: an adapter cannot
+ * derive a name without going through this function, so it cannot forget to
+ * check – and `SearchType.name` is otherwise unvalidated
+ * ({@link validateSearchType} rules on field names only). A deployment whose
+ * type name this cannot spell passes its adapter an explicit name instead.
  */
 export declare function physicalNameTokens(searchType: SearchType): readonly string[];
 //# sourceMappingURL=physical-name.d.ts.map

package/dist/physical-name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"physical-name.d.ts","sourceRoot":"","sources":["../src/physical-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAK5E"}
+{"version":3,"file":"physical-name.d.ts","sourceRoot":"","sources":["../src/physical-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAiB5E"}

package/dist/physical-name.js

@@ -24,15 +24,43 @@ import { pluralize } from 'inflection';
  * rules produce (`serieses`, `analysises`). An already-plural name is
  * idempotent (`People` → `people`).
  *
- * Returns an empty array when `name` carries no alphanumerics at all; the
- * adapter decides what that means, since only it knows its engine’s rules.
+ * **Throws rather than name the wrong container.** Dropping what it cannot
+ * match is what lets `creative_work` tokenize like `CreativeWork`, but it would
+ * just as quietly turn `Café` into `['cafs']` and `Musée` into `['mus', 'es']`
+ * – a perfectly legal name for a container nobody meant. So a name is spellable
+ * only when it is ASCII words and word separators, and only when it leaves at
+ * least one word to name anything after; anything else throws here. This guard
+ * lives with the split it protects, not in each adapter: an adapter cannot
+ * derive a name without going through this function, so it cannot forget to
+ * check – and `SearchType.name` is otherwise unvalidated
+ * ({@link validateSearchType} rules on field names only). A deployment whose
+ * type name this cannot spell passes its adapter an explicit name instead.
  */
 export function physicalNameTokens(searchType) {
-    const words = searchType.name.match(NAME_WORD_PATTERN) ?? [];
-    const tokens = words.map((word) => word.toLowerCase());
+    const { name } = searchType;
+    if (!SPELLABLE_NAME.test(name)) {
+        throw new Error(`Cannot name search type “${name}”: a physical name is derived from the type’s name, and this one carries characters outside ASCII words and word separators – deriving would silently drop them and name the wrong container. Rename the type, or give the adapter an explicit name.`);
+    }
+    const tokens = (name.match(NAME_WORD_PATTERN) ?? []).map((word) => word.toLowerCase());
     const last = tokens.at(-1);
-    return last === undefined ? [] : [...tokens.slice(0, -1), pluralize(last)];
+    if (last === undefined) {
+        throw new Error(`Cannot name search type “${name}”: its name carries no word to name a container after. Rename the type, or give the adapter an explicit name.`);
+    }
+    return [...tokens.slice(0, -1), pluralize(last)];
 }
+/**
+ * A name the split can spell without losing part of it: ASCII letters and
+ * digits, plus the separators a name may already be written with (`creative
+ * work`, `creative_work`, `creative-work` all tokenize like `CreativeWork`).
+ * Deliberately narrower than what {@link NAME_WORD_PATTERN} would tolerate –
+ * that one skips anything it does not match, which is precisely the silent
+ * mangling this rejects.
+ *
+ * Matches the empty name too, on purpose: nothing about it is *unspellable*,
+ * there is simply nothing to spell, which the no-word check below reports far
+ * better than a complaint about characters it does not carry.
+ */
+const SPELLABLE_NAME = /^[A-Za-z0-9 _-]*$/;
 /**
  * One word of a PascalCase/camelCase name, in precedence order: a run of
  * capitals not followed by a lowercase letter (an acronym – `DCAT` in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Engine- and domain-agnostic core for RDF-backed search: a unified declarative field model (SearchField/SearchType/SearchSchema), a neutral query IR, the SearchEngine port with logical result types, and a streaming CONSTRUCT-to-document projection. Bakes in no engine, protocol, or domain.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",