@lde/search-pipeline 0.30.0 → 0.31.0

package/dist/extraction.d.ts

@@ -49,6 +49,12 @@ export interface ExtractionOptions {
  *   `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.
+ * - **references naming several targets**: the referent may be of any of them,
+ *   so its branch also reads the referent’s `rdf:type` (`OPTIONAL`, emitted
+ *   as is – framing carries it as `@type`), which is what the projection
+ *   matches against each target’s `class` to tell which one it is. Every
+ *   target then contributes its own expansion or key hop, so whichever the
+ *   referent turns out to be, its declaration is in the frame.
  *
  * 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;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"}
+{"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,EAGV,YAAY,EACZ,UAAU,EACX,MAAM,aAAa,CAAC;AAQrB,2CAA2C;AAC3C,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;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,10 +1,11 @@
 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, localLookupTypeOf, referenceTypeNamed, rootTypeNamed, } from '@lde/search/adapter';
+import { fieldNamed, irAlias, isInlineReference, localLookupTargetsOf, referencedTargetsOf, referenceTypeNamed, } from '@lde/search/adapter';
 const factory = new AstFactory();
 const parser = new Parser();
 const generator = new Generator();
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
 /**
  * Generate a type’s **Extraction** CONSTRUCT from its {@link SearchType}
  * declaration: the query whose output the projection frames and reads. Pure –
@@ -42,6 +43,12 @@ const generator = new Generator();
  *   `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.
+ * - **references naming several targets**: the referent may be of any of them,
+ *   so its branch also reads the referent’s `rdf:type` (`OPTIONAL`, emitted
+ *   as is – framing carries it as `@type`), which is what the projection
+ *   matches against each target’s `class` to tell which one it is. Every
+ *   target then contributes its own expansion or key hop, so whichever the
+ *   referent turns out to be, its declaration is in the frame.
  *
  * Wire the result into a `SparqlConstructReader` (see `searchStages`), which
  * runs it per batch with the roots injected as VALUES.
@@ -110,27 +117,42 @@ function buildFor(searchType, subject, schema, counter, visiting) {
             const patterns = [
                 factory.patternBgp([factory.triple(subject, sourcePath, value)], factory.gen()),
             ];
-            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);
-                }
+            const targets = referencedTargetsOf(field, schema);
+            // Every hop off the referent – its type, each key, each expansion – is
+            // its own branch of ONE optional union: each binds only its own
+            // variables, so a multi-valued type or key multiplies against nothing.
+            const expansions = [];
+            if (targets.length > 1) {
+                const built = buildTypeHop(value, counter);
+                template.push(built.triple);
+                expansions.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()));
+            const local = localTargetsOf(field, schema, onPath);
+            for (const target of targets) {
+                if (!local.includes(target)) {
+                    // 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 = keyedFieldOf(target);
+                    if (keyed !== undefined) {
+                        const built = buildKeyHop(target, keyed, value, counter);
+                        template.push(built.triple);
+                        expansions.push(built.pattern);
+                    }
+                    continue;
                 }
+                const nested = buildFor(target, value, schema, counter, onPath);
+                template.push(...nested.template);
+                expansions.push(...nested.branches);
+            }
+            // `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. Several
+            // targets’ expansions share the one UNION: a referent is of one kind,
+            // and the branches of the others simply bind nothing for it. A
+            // single-branch union serialises to just its group.
+            if (expansions.length > 0) {
+                patterns.push(factory.patternOptional([factory.patternUnion(expansions, factory.gen())], factory.gen()));
             }
             branches.push(factory.patternGroup(patterns, factory.gen()));
         }
@@ -138,53 +160,60 @@ function buildFor(searchType, subject, schema, counter, visiting) {
     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.
+ * The Root Types a {@link ReferenceStrategy.local} lookup expands into here:
+ * none where the field declares none, and never one 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;
+function localTargetsOf(field, schema, visiting) {
+    return localLookupTargetsOf(field, schema).filter((target) => !visiting.has(target.name));
 }
 /**
- * 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.
+ * The field a Root Type’s key is read from, when it declares a
+ * {@link RootType.key}. Naming the target is exactly the boundary the
+ * projection re-keys along ({@link referencedTargetsOf}), 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) {
+function keyedFieldOf(target) {
+    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 };
+    return fieldNamed(target, target.key.field);
+}
+/**
+ * The one-triple hop that reads a referent’s `rdf:type`, for a reference whose
+ * referent may be of several kinds: emitted under `rdf:type` itself, which
+ * framing turns into the node’s `@type`. The caller binds it inside the
+ * reference’s `OPTIONAL` union, so an untyped referent keeps its row and falls
+ * back to the first target declared.
+ */
+function buildTypeHop(referent, counter) {
+    const type = factory.termVariable(`t${counter.next++}`, factory.gen());
+    const predicate = factory.termNamed(factory.gen(), RDF_TYPE);
+    return {
+        triple: factory.triple(referent, predicate, type),
+        pattern: factory.patternGroup([
+            factory.patternBgp([factory.triple(referent, predicate, type)], factory.gen()),
+        ], factory.gen()),
+    };
 }
 /**
  * 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.
+ * key field under the **target’s** IR Alias, and a branch binding it. The
+ * referent recursion an inline reference already performs, for a single field –
+ * bound by the caller inside the reference’s `OPTIONAL` union 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.
+ * It is a branch of its own in that union, 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([
+        pattern: factory.patternGroup([
             factory.patternBgp([factory.triple(referent, liftPath(keyField.path), key)], factory.gen()),
         ], factory.gen()),
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-pipeline",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "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.28.0",
+    "@lde/search": "^0.29.0",
     "@traqula/generator-sparql-1-1": "^1.3.1",
     "@traqula/parser-sparql-1-1": "^1.3.1",
     "@traqula/rules-sparql-1-1": "^1.2.0",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "@lde/search-typesense": "^0.33.0",
+    "@lde/search-typesense": "^0.34.0",
     "@rdfjs/types": "^2.0.1",
     "n3": "^2.7.12",
     "testcontainers": "^12.1.0",