@lde/search-pipeline 0.24.0 → 0.24.2

package/dist/extraction.d.ts

@@ -33,6 +33,13 @@ export interface ExtractionOptions {
  *   nested template (`{ ?root <…/ref> ?r . ?r <…/field> ?v }`), recursing into
  *   the reference type to the schema’s declared depth. The referent-binding hop
  *   uses the source `path`; the emitted triples use the minted aliases.
+ * - **references into a keyed type**: a reference naming a target that declares
+ *   a `key` gets its branch extended with an `OPTIONAL` hop reading the
+ *   referent’s key field, emitted under the **target’s** alias for it – so the
+ *   projection can store the referent’s document key rather than its node IRI.
+ *   `OPTIONAL`, so a referent with no key candidate keeps its row. The root side
+ *   needs nothing: a key field is a declared field, so its own branch and
+ *   template triple are already there.
  *
  * Wire the result into a `SparqlConstructReader` (see `searchStages`), which
  * runs it per batch with the roots injected as VALUES.

package/dist/extraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extraction.d.ts","sourceRoot":"","sources":["../src/extraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAIpB,MAAM,2BAA2B,CAAC;AAQnC,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAM5D,2CAA2C;AAC3C,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,iBAAsB,GAC9B,cAAc,CAqBhB;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAER"}
+{"version":3,"file":"extraction.d.ts","sourceRoot":"","sources":["../src/extraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAIpB,MAAM,2BAA2B,CAAC;AAWnC,OAAO,KAAK,EAIV,YAAY,EACZ,UAAU,EACX,MAAM,aAAa,CAAC;AAMrB,2CAA2C;AAC3C,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,iBAAsB,GAC9B,cAAc,CAqBhB;AAED,+EAA+E;AAC/E,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,CAER"}

package/dist/extraction.js

@@ -1,7 +1,7 @@
 import { AstFactory, } from '@traqula/rules-sparql-1-1';
 import { Parser } from '@traqula/parser-sparql-1-1';
 import { Generator } from '@traqula/generator-sparql-1-1';
-import { irAlias, isInlineReference, referenceTypeNamed, } from '@lde/search/adapter';
+import { fieldNamed, irAlias, isInlineReference, labelSourceNameOf, referenceTypeNamed, rootTypeNamed, } from '@lde/search/adapter';
 const factory = new AstFactory();
 const parser = new Parser();
 const generator = new Generator();
@@ -26,6 +26,13 @@ const generator = new Generator();
  *   nested template (`{ ?root <…/ref> ?r . ?r <…/field> ?v }`), recursing into
  *   the reference type to the schema’s declared depth. The referent-binding hop
  *   uses the source `path`; the emitted triples use the minted aliases.
+ * - **references into a keyed type**: a reference naming a target that declares
+ *   a `key` gets its branch extended with an `OPTIONAL` hop reading the
+ *   referent’s key field, emitted under the **target’s** alias for it – so the
+ *   projection can store the referent’s document key rather than its node IRI.
+ *   `OPTIONAL`, so a referent with no key candidate keeps its row. The root side
+ *   needs nothing: a key field is a declared field, so its own branch and
+ *   template triple are already there.
  *
  * Wire the result into a `SparqlConstructReader` (see `searchStages`), which
  * runs it per batch with the roots injected as VALUES.
@@ -83,13 +90,63 @@ function buildFor(searchType, subject, schema, counter) {
         else {
             const value = factory.termVariable(`v${counter.next++}`, factory.gen());
             template.push(factory.triple(subject, alias, value));
-            branches.push(factory.patternGroup([
+            const patterns = [
                 factory.patternBgp([factory.triple(subject, sourcePath, value)], factory.gen()),
-            ], factory.gen()));
+            ];
+            const keyed = keyedTargetOf(field, schema);
+            if (keyed !== undefined) {
+                const built = buildKeyHop(keyed.target, keyed.keyField, value, counter);
+                template.push(built.triple);
+                patterns.push(built.pattern);
+            }
+            branches.push(factory.patternGroup(patterns, factory.gen()));
         }
     }
     return { template, branches };
 }
+/**
+ * The keyed Root Type a reference points at, with the field its key is read
+ * from: a `lookup`’s `target` or an `idOnly`’s `labelSource`
+ * ({@link labelSourceNameOf}) that declares a {@link RootType.key}, or
+ * `undefined` for every other field. Naming the target is exactly the boundary
+ * the projection re-keys along, so the extraction reads the same declarations
+ * rather than a rule of its own: a reference that names no target keeps the
+ * node IRI, and needs no hop.
+ */
+function keyedTargetOf(field, schema) {
+    if (field.kind !== 'reference') {
+        return undefined;
+    }
+    const targetName = labelSourceNameOf(field);
+    const target = targetName === undefined ? undefined : rootTypeNamed(schema, targetName);
+    if (target?.key === undefined) {
+        return undefined;
+    }
+    // `searchSchema` guarantees a declared, path-bearing key field, so the target
+    // – which came out of the schema – always has one.
+    const keyField = fieldNamed(target, target.key.field);
+    return { target, keyField };
+}
+/**
+ * The one-field hop that reads a referent’s key: a template triple emitting the
+ * key field under the **target’s** IR Alias, and an `OPTIONAL` branch binding
+ * it. The referent recursion an inline reference already performs, for a single
+ * field and wrapped in `OPTIONAL` rather than conjoined – so a referent with no
+ * key candidate keeps its row and still stores its own IRI, instead of the
+ * whole reference dropping out of the CONSTRUCT.
+ *
+ * It sits inside its own UNION branch (the one the reference contributes), so it
+ * multiplies against nothing.
+ */
+function buildKeyHop(target, keyField, referent, counter) {
+    const key = factory.termVariable(`k${counter.next++}`, factory.gen());
+    return {
+        triple: factory.triple(referent, factory.termNamed(factory.gen(), irAlias(target, keyField)), key),
+        pattern: factory.patternOptional([
+            factory.patternBgp([factory.triple(referent, liftPath(keyField.path), key)], factory.gen()),
+        ], factory.gen()),
+    };
+}
 /**
  * Lift a field’s `path` – written in the SPARQL reader adapter’s grammar (a
  * property path) – into a predicate AST node, by parsing it inside a throwaway

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-pipeline",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "Search indexing as an @lde/pipeline instance: a Writer<Quad> that applies the @lde/search projection to extracted RDF and fans each document out to the transactional engine writer for its type's collection. Glue between the pipeline quad world and the search-engine document world; owns no projection or engine logic itself.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -25,21 +25,21 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/search": "^0.23.0",
+    "@lde/search": "^0.23.1",
     "@traqula/generator-sparql-1-1": "^1.1.8",
     "@traqula/parser-sparql-1-1": "^1.2.0",
     "@traqula/rules-sparql-1-1": "^1.2.0",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "@lde/search-typesense": "^0.27.0",
+    "@lde/search-typesense": "^0.27.2",
     "@rdfjs/types": "^2.0.1",
     "n3": "^2.1.2",
-    "testcontainers": "^12.0.3",
+    "testcontainers": "^12.1.0",
     "typesense": "^3.0.6"
   },
   "peerDependencies": {
     "@lde/dataset": "^0.7.9",
-    "@lde/pipeline": "^0.36.0"
+    "@lde/pipeline": "^0.36.1"
   }
 }