@lde/search-pipeline 0.26.0 → 0.26.2

package/dist/extraction.d.ts

@@ -33,6 +33,15 @@ 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.
+ * - **`local` lookups** ({@link ReferenceStrategy.local}): a reference that also
+ *   stores what this document states about its referent gets its branch
+ *   extended with the **target Root Type’s own** fields, read off the referent
+ *   and emitted under that type’s aliases – the same recursion an inline
+ *   reference makes, through a Root Type rather than a Reference Type, and the
+ *   same reach {@link inlineFramingDepth} already frames for. `OPTIONAL`, so a
+ *   referent the document states nothing about keeps its row and still stores
+ *   its id. It subsumes the key hop below, the key field being one of the
+ *   target’s own.
  * - **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

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;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"}
+{"version":3,"file":"extraction.d.ts","sourceRoot":"","sources":["../src/extraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAIpB,MAAM,2BAA2B,CAAC;AAYnC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;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 { fieldNamed, irAlias, isInlineReference, labelSourceNameOf, referenceTypeNamed, rootTypeNamed, } from '@lde/search/adapter';
+import { fieldNamed, irAlias, isInlineReference, labelSourceNameOf, localLookupTypeOf, referenceTypeNamed, rootTypeNamed, } from '@lde/search/adapter';
 const factory = new AstFactory();
 const parser = new Parser();
 const generator = new Generator();
@@ -26,6 +26,15 @@ 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.
+ * - **`local` lookups** ({@link ReferenceStrategy.local}): a reference that also
+ *   stores what this document states about its referent gets its branch
+ *   extended with the **target Root Type’s own** fields, read off the referent
+ *   and emitted under that type’s aliases – the same recursion an inline
+ *   reference makes, through a Root Type rather than a Reference Type, and the
+ *   same reach {@link inlineFramingDepth} already frames for. `OPTIONAL`, so a
+ *   referent the document states nothing about keeps its row and still stores
+ *   its id. It subsumes the key hop below, the key field being one of the
+ *   target’s own.
  * - **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
@@ -40,7 +49,7 @@ const generator = new Generator();
 export function extractionQuery(searchType, schema, options = {}) {
     const subjectVariable = options.subjectVariable ?? 'root';
     const subject = factory.termVariable(subjectVariable, factory.gen());
-    const built = buildFor(searchType, subject, schema, { next: 0 });
+    const built = buildFor(searchType, subject, schema, { next: 0 }, new Set());
     if (built.branches.length === 0) {
         throw new Error(`Cannot generate an extraction CONSTRUCT for “${searchType.name}”: it declares no path-bearing field, so there is nothing to extract.`);
     }
@@ -54,14 +63,22 @@ export function extractionQueryString(searchType, schema, options) {
 /**
  * Walk a type’s path-bearing fields off a subject variable, collecting the
  * template triples (minted aliases) and one WHERE branch per field (source
- * paths). Recurses into an inline reference’s type off a fresh referent
- * variable, so the nested template keeps the `subject → referent → value` link
- * in one CONSTRUCT. The recursion terminates because `searchSchema` rejects
- * inline reference cycles.
+ * paths). Recurses off a fresh referent variable for the two references that
+ * store a referent’s fields rather than only its id – an inline reference,
+ * through its Reference Type, and a {@link ReferenceStrategy.local} lookup,
+ * through its target Root Type – so the nested template keeps the
+ * `subject → referent → value` link in one CONSTRUCT.
+ *
+ * `visiting` is what terminates the second one. `searchSchema` rejects inline
+ * reference cycles, but nothing forbids two Root Types whose `local` lookups
+ * point at each other, so a type already on this path contributes no further
+ * hop – the same cut {@link inlineFramingDepth} makes, so the depth framed and
+ * the depth extracted stay the same number.
  */
-function buildFor(searchType, subject, schema, counter) {
+function buildFor(searchType, subject, schema, counter, visiting) {
     const template = [];
     const branches = [];
+    const onPath = new Set(visiting).add(searchType.name);
     for (const field of searchType.fields) {
         if (field.path === undefined) {
             continue;
@@ -75,7 +92,7 @@ function buildFor(searchType, subject, schema, counter) {
             }
             const referent = factory.termVariable(`r${counter.next++}`, factory.gen());
             template.push(factory.triple(subject, alias, referent));
-            const nested = buildFor(referenceType, referent, schema, counter);
+            const nested = buildFor(referenceType, referent, schema, counter, onPath);
             template.push(...nested.template);
             const patterns = [
                 factory.patternBgp([factory.triple(subject, sourcePath, referent)], factory.gen()),
@@ -93,17 +110,42 @@ function buildFor(searchType, subject, schema, counter) {
             const patterns = [
                 factory.patternBgp([factory.triple(subject, sourcePath, value)], 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);
+            const local = localTargetOf(field, schema, onPath);
+            if (local === undefined) {
+                // Only where no local expansion follows: a `local` lookup reads the
+                // target’s every path-bearing field, and a keyed target’s key field is
+                // one of them, so emitting the hop as well would state it twice.
+                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);
+                }
+            }
+            else {
+                const nested = buildFor(local, value, schema, counter, onPath);
+                template.push(...nested.template);
+                // `OPTIONAL`, unlike an inline reference’s conjoined nesting: this
+                // referent is stored by id whether or not the referring document says
+                // anything about it, and conjoining would drop both together.
+                if (nested.branches.length > 0) {
+                    patterns.push(factory.patternOptional([factory.patternUnion(nested.branches, factory.gen())], factory.gen()));
+                }
             }
             branches.push(factory.patternGroup(patterns, factory.gen()));
         }
     }
     return { template, branches };
 }
+/**
+ * The Root Type a {@link ReferenceStrategy.local} lookup expands into here, or
+ * `undefined` where the field declares none – or where that type is already on
+ * this path, which is where the recursion stops.
+ */
+function localTargetOf(field, schema, visiting) {
+    const local = localLookupTypeOf(field, schema);
+    return local === undefined || visiting.has(local.name) ? undefined : local;
+}
 /**
  * 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`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-pipeline",
-  "version": "0.26.0",
+  "version": "0.26.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,14 +25,14 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/search": "^0.24.0",
+    "@lde/search": "^0.24.2",
     "@traqula/generator-sparql-1-1": "^1.2.0",
     "@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.29.0",
+    "@lde/search-typesense": "^0.29.2",
     "@rdfjs/types": "^2.0.1",
     "n3": "^2.4.0",
     "testcontainers": "^12.1.0",