@lde/search 0.23.1 → 0.24.0

package/dist/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAmBhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,YAAY,GACzB,IAAI,CAuON"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAoBhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,YAAY,GACzB,IAAI,CAuRN"}

package/dist/testing.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { filterOn, filterOperatorFor, } from './query.js';
-import { facetableFields, filterableFields, ID_FIELD, nestedReferenceType, outputFields, } from './schema.js';
+import { facetableFields, filterableFields, ID_FIELD, inheritedFacetKeys, nestedReferenceType, outputFields, } from './schema.js';
 /**
  * The executable {@link SearchEngine} port contract (import from
  * `@lde/search/testing`): a vitest suite every engine adapter runs against a
@@ -200,6 +200,53 @@ export function describeSearchEngineContract(name, engine) {
                 }
             }
         });
+        it('buckets a facet inheriting a policy on admitted keys only, labelled, while filtering stays exact', async () => {
+            // A facet policy (`RootType.facetKeys`) narrows the FACET and nothing
+            // else. Two things an adapter can get wrong, each silently: facet the
+            // companion field but report its buckets under the engine’s name, which
+            // loses every label and files the counts under a key no consumer asked
+            // for; and pick the filter operator off the declaration, so a `where`
+            // on an excluded value – still `facetable` in the schema, no longer a
+            // facet in the engine – partial-matches on a shared path prefix. The
+            // adapter’s fixture should carry two IRIs sharing a prefix so the
+            // second assertion bites.
+            for (const searchType of types()) {
+                for (const field of facetableFields(searchType)) {
+                    const policy = inheritedFacetKeys(field, engine().schema);
+                    if (policy === undefined) {
+                        continue;
+                    }
+                    const result = await engine().search(searchType, {
+                        ...browse(searchType),
+                        limit: 20,
+                        facets: [field.name],
+                    });
+                    const buckets = result.facets[field.name] ?? [];
+                    for (const bucket of buckets) {
+                        expect(policy.only(bucket.value)).toBe(true);
+                        expect(bucket.label).toBeDefined();
+                    }
+                    if (field.output !== true || field.filterable !== true) {
+                        continue; // Nothing to read the stored values back from.
+                    }
+                    const excluded = result.hits
+                        .flatMap((hit) => referenceIds(hit.document[field.name]))
+                        .find((id) => !policy.only(id));
+                    if (excluded === undefined) {
+                        continue;
+                    }
+                    const filtered = await engine().search(searchType, {
+                        ...browse(searchType),
+                        limit: 20,
+                        where: [filterOn({ field: field.name, in: [excluded] })],
+                    });
+                    expect(filtered.total).toBeGreaterThan(0);
+                    for (const hit of filtered.hits) {
+                        expect(referenceIds(hit.document[field.name])).toContain(excluded);
+                    }
+                }
+            }
+        });
         it('answers a browse query with hits, a total and facets', async () => {
             for (const searchType of types()) {
                 const result = await engine().search(searchType, browse(searchType));
@@ -220,6 +267,16 @@ function mismatchedFilter(field, operator) {
         ? filterOn({ field, range: { min: 0 } })
         : filterOn({ field, in: ['x'] });
 }
+/** The ids a reconstructed reference value carries – one labelled reference
+ *  or a list of them – read the way a consumer reads them. */
+function referenceIds(value) {
+    const references = Array.isArray(value) ? value : [value];
+    return references
+        .map((reference) => typeof reference === 'object' && reference !== null && 'id' in reference
+        ? String(reference.id)
+        : undefined)
+        .filter((id) => id !== undefined);
+}
 /** The locale a query against this type may select (any is contract-valid). */
 function firstLocale(searchType) {
     for (const field of searchType.fields) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.23.1",
+  "version": "0.24.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",
@@ -52,7 +52,7 @@
   "devDependencies": {
     "@tpluscode/rdf-ns-builders": "^5.0.0",
     "@types/jsonld": "^1.5.15",
-    "n3": "^2.1.2"
+    "n3": "^2.4.0"
   },
   "peerDependencies": {
     "vitest": "^4.0.0"