@directory-builder/core 0.1.0 → 0.1.1

package/README.md

@@ -93,8 +93,10 @@ INSTANCE=../sosuse-directory-builder npm run webapp  # any other instance dir
 
 Instances own the About page by providing `webapp/content/about.md` (markdown,
 served and deployed like config and data); without one, a generic default
-renders. Declaring `:federation :repository "https://github.com/…"` adds the
-GitHub links (nav, static-source folders); without it they stay hidden.
+renders — and the Query page's starting query the same way, via
+`webapp/content/query.sparql`. On the `:federation` node, `rdfs:label` sets
+the page title and `:repository "https://github.com/…"` adds the GitHub links
+(nav, static-source folders); both stay generic/hidden when absent.
 
 Instances can inject **exporters** — output adapters mapping the directory
 into an external schema. The federation declares them (`:federation
@@ -110,3 +112,12 @@ exported separately so bundlers never see the engines' Node imports:
 ```js
 import { CDP, parseTtl, PATHS } from "@directory-builder/core/utils"
 ```
+
+## Roadmap
+
+- Testing
+- Periodic harvesting
+- `@directory-builder/create`: an npm initializer scaffolding a new use
+  case, plus a `validate` command checking an instance setup
+- `@directory-builder/ui`: extract the webapp into its own package
+- ...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directory-builder/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Use-case-agnostic engine for config-driven federation pipelines",
   "author": "Civic Data Lab",
   "repository": "github:foederierter-datenpool/directory-builder-core",

package/src/index.js

@@ -2,5 +2,5 @@
 // "./utils" subpath export — import those from "@directory-builder/core/utils"
 // so bundlers never see the engines' fs/child_process imports.
 export { Pipeline } from "./pipeline.js"
-export { ingest } from "./ingest.js"
-export { federate } from "./federate.js"
+export { ingest } from "./pipeline/ingest.js"
+export { federate } from "./pipeline/federate.js"

package/src/pipeline/federate.js

@@ -0,0 +1,69 @@
+import { newStore, parser as n3Parser, storeFromTurtles } from "@foerderfunke/sem-ops-utils"
+import { CDP, objectsOf, parseTtl, PATHS, sourceGraph, sourceName, stepIri, stepJournal } from "../utils.js"
+import { COMMON_PREFIXES, writeTurtleFile } from "./write-turtle.js"
+import { MAPPED_GRAPH, runMap } from "./steps/map.js"
+import { runClean } from "./steps/clean.js"
+import { runMatch } from "./steps/match.js"
+import { runMerge } from "./steps/merge.js"
+import { runResolve } from "./steps/resolve.js"
+import { DataFactory } from "n3"
+import path from "path"
+import fs from "fs"
+
+const df = DataFactory
+
+// ---- Federate engine -----------------------------------------------------
+// Clean per source, load, then map → match → merge → resolve (one module per
+// step under steps/, sharing the ctx of store + config + path resolver). The
+// step sequence is the engine's own shape; config declares only the sources,
+// processed in :hasSource declaration order. Paths follow from the source
+// name (PATHS), resolved against the instance `root`. Each step runs through
+// the journal, which records what executed and is rendered by the webapp's
+// Pipeline page. The clean steps' predecessors are the other engine's lift
+// steps, referenced by their conventional stepIri.
+
+export async function federate(root = process.cwd()) {
+    const abs = (p) => path.join(root, p)
+    const federationTtl = fs.readFileSync(abs(PATHS.federation), "utf8")
+    const defStore = storeFromTurtles([federationTtl, fs.readFileSync(abs(PATHS.matchKnowledge), "utf8")])
+    const sources = objectsOf(parseTtl(federationTtl), `${CDP}hasSource`)
+
+    const store = newStore()
+    const journal = stepJournal()
+    const ctx = { store, defStore, abs }
+
+    const cleanSteps = []
+    for (const src of sources) {
+        const name = sourceName(src)
+        cleanSteps.push(await journal.step("clean", { source: src, after: [stepIri("lift", name)] },
+            () => runClean(ctx, name)))
+    }
+
+    // Load each source's cleaned TTL into its own graph — plain mechanics, not a
+    // pipeline step.
+    for (const src of sources) {
+        const name = sourceName(src)
+        console.log(`load   ${PATHS.cleaned(name)} → <${sourceGraph(name)}>`)
+        const graph = df.namedNode(sourceGraph(name))
+        for (const quad of n3Parser.parse(fs.readFileSync(abs(PATHS.cleaned(name)), "utf8"))) {
+            store.addQuad(df.quad(quad.subject, quad.predicate, quad.object, graph))
+        }
+    }
+
+    const mapStep = await journal.step("map", { after: cleanSteps }, async () => {
+        await runMap(ctx, PATHS.mappingQueries)
+        const mappedQuads = store.getQuads(null, null, null, MAPPED_GRAPH)
+        await writeTurtleFile(abs(PATHS.mapped), mappedQuads, { ...COMMON_PREFIXES, cdp: CDP })
+        console.log(`map: wrote ${mappedQuads.length} triples → ${PATHS.mapped}`)
+    })
+    const matchStep   = await journal.step("match",   { after: [mapStep] },   () => runMatch(ctx, PATHS.matches))
+    const mergeStep   = await journal.step("merge",   { after: [matchStep] }, () => runMerge(ctx, PATHS.merged, PATHS.provenance))
+    await journal.step("resolve", { after: [mergeStep] }, () => runResolve(ctx, PATHS.final))
+
+    fs.writeFileSync(abs(PATHS.federateLog), `@prefix :      <${CDP}> .
+@prefix p-plan: <http://purl.org/net/p-plan#> .
+
+${journal.toTurtle()}
+`)
+    console.log(`log:   wrote steps → ${PATHS.federateLog}`)
+}

package/src/pipeline/ingest.js

@@ -0,0 +1,97 @@
+import { sparqlSelect, storeFromTurtles } from "@foerderfunke/sem-ops-utils"
+import { CDP, objectsOf, parseTtl, PATHS, sourceName, stepJournal } from "../utils.js"
+import { ensureJar, runLift } from "./steps/lift.js"
+import { runFetch } from "./steps/fetch.js"
+import path from "path"
+import fs from "fs"
+
+// Ingest engine: fetch + lift per source declared in the instance's
+// federation.ttl. `root` is the instance directory all PATHS resolve against.
+export async function ingest(root = process.cwd()) {
+    const abs = (p) => path.join(root, p)
+    const federationTtl = fs.readFileSync(abs(PATHS.federation), "utf8")
+    const defStore = storeFromTurtles([federationTtl])
+
+    // ---- Read the sources ------------------------------------------------
+    // The step graph (fetch → lift per source) is the engine's own shape;
+    // config declares only the sources and their facts. Lift params are SPARQL
+    // Anything variables declared per source. Sources run in :hasSource
+    // declaration order.
+
+    const facts = new Map()
+    for (const r of await sparqlSelect(`
+        PREFIX : <${CDP}>
+        SELECT ?source ?fetchUrl ?format ?paramName ?paramValue WHERE {
+            :federation :hasSource ?source .
+            OPTIONAL { ?source :fetchUrl ?fetchUrl }
+            OPTIONAL { ?source :format   ?format   }
+            OPTIONAL { ?source :hasLiftParam [ :name ?paramName ; :value ?paramValue ] }
+        }`, [defStore])) {
+        if (!facts.has(r.source)) facts.set(r.source, { fetchUrl: r.fetchUrl, format: r.format, params: [] })
+        if (r.paramName) facts.get(r.source).params.push([r.paramName, r.paramValue])
+    }
+    const sources = new Map(objectsOf(parseTtl(federationTtl), `${CDP}hasSource`).map((iri) => [iri, facts.get(iri)]))
+    for (const [iri, s] of sources) {
+        if (!s.format) throw new Error(`${iri} declares no :format (needed to pick the lift query)`)
+    }
+
+    const jar = await ensureJar(abs)
+
+    // ---- Run steps ----------------------------------------------------------
+
+    // All :hasRunParam values grouped by name, handed to every fetcher as one
+    // JSON argument — each fetcher picks the parameters it needs.
+    const runParams = {}
+    for (const r of await sparqlSelect(`
+        PREFIX : <${CDP}>
+        SELECT ?name ?value WHERE { :federation :hasRunParam [ :name ?name ; :value ?value ] } ORDER BY ?name ?value`, [defStore])) {
+        (runParams[r.name] ??= []).push(r.value)
+    }
+    const paramsJson = JSON.stringify(runParams)
+
+    const runStart = new Date()
+    const harvests = []
+    const journal = stepJournal()
+    const fetchStepOf = new Map()
+    const ctx = { abs, root }
+
+    for (const [iri, s] of sources) {
+        const name = sourceName(iri)
+        fetchStepOf.set(iri, await journal.step("fetch", { source: iri }, () => {
+            harvests.push({ source: iri, ...runFetch(ctx, { name, fetchUrl: s.fetchUrl, paramsJson }) })
+        }))
+    }
+
+    for (const [iri, s] of sources) {
+        const name = sourceName(iri)
+        await journal.step("lift", { source: iri, after: [fetchStepOf.get(iri)] },
+            () => runLift(ctx, { jar, name, format: s.format, params: s.params }))
+    }
+
+    const dt = (s) => `"${s}"^^xsd:dateTime`
+    const runId = "run" + runStart.toISOString().replace(/\D/g, "").slice(0, 14)
+    const harvestPart = harvests.length
+        ? ` ;\n    :harvested\n` + harvests.map((h) => {
+            const local = h.source.split("#").pop()
+            const committed = h.staticCommittedAt ? ` ; :staticCommittedAt ${dt(h.staticCommittedAt)}` : ""
+            return `        [ :ofSource :${local} ; prov:atTime ${dt(h.time)}${committed} ]`
+        }).join(" ,\n")
+        : ""
+
+    const block = `
+${journal.toTurtle()}
+
+:${runId} a :IngestRun ;
+    prov:startedAtTime ${dt(runStart.toISOString())} ;
+    prov:endedAtTime   ${dt(new Date().toISOString())}${harvestPart} .
+`
+
+    const prefixes = `@prefix :      <${CDP}> .
+@prefix p-plan: <http://purl.org/net/p-plan#> .
+@prefix prov:   <http://www.w3.org/ns/prov#> .
+@prefix xsd:    <http://www.w3.org/2001/XMLSchema#> .
+`
+    fs.mkdirSync(path.dirname(abs(PATHS.ingestLog)), { recursive: true })
+    fs.writeFileSync(abs(PATHS.ingestLog), prefixes + block)
+    console.log(`log:   wrote steps + IngestRun → ${PATHS.ingestLog}`)
+}

package/src/pipeline/run.js

@@ -0,0 +1,8 @@
+import { spawnSync } from "child_process"
+
+// Run an external command (a fetcher's node process, SPARQL Anything's java),
+// inheriting stdio; non-zero exit aborts the step.
+export const run = (cmd, args) => {
+    const r = spawnSync(cmd, args, { stdio: "inherit" })
+    if (r.status !== 0) throw new Error(`Exit ${r.status}: ${cmd} ${args.join(" ")}`)
+}

package/src/pipeline/steps/clean.js

@@ -0,0 +1,27 @@
+import { sparqlConstruct, storeFromTurtles } from "@foerderfunke/sem-ops-utils"
+import { writeTurtleFile } from "../write-turtle.js"
+import { CDP, PATHS } from "../../utils.js"
+import path from "path"
+import fs from "fs"
+
+// Clean step: the source's clean.sparql reshapes its lifted RDF into
+// federation subjects (xyz:/cdp: vocabulary only — schema: enters at map).
+export const runClean = async ({ abs }, name) => {
+    const cleanQuery = fs.readFileSync(abs(PATHS.cleanQuery(name)), "utf8")
+    const inDir = PATHS.lifted(name)
+    const outPath = PATHS.cleaned(name)
+    // Run CONSTRUCT per file so each lifted TTL stays isolated in its
+    // own store — the clean SPARQL can't cross-join across documents.
+    const inAbs = abs(inDir)
+    const files = fs.readdirSync(inAbs).filter(f => f.endsWith(".ttl")).sort()
+    console.log(`clean  ${inDir} (${files.length} files) → ${outPath}`)
+    const allQuads = []
+    for (const f of files) {
+        const fileStore = storeFromTurtles([fs.readFileSync(path.join(inAbs, f), "utf8")])
+        allQuads.push(...await sparqlConstruct(cleanQuery, [fileStore]))
+    }
+    await writeTurtleFile(abs(outPath), allQuads, {
+        xyz: "http://sparql.xyz/facade-x/data/",
+        cdp: CDP,
+    })
+}

package/src/pipeline/steps/fetch.js

@@ -0,0 +1,24 @@
+import { PATHS } from "../../utils.js"
+import { execSync } from "child_process"
+import { run } from "../run.js"
+import fs from "fs"
+
+// Fetch step: run the source's fetch.js. Live sources pass their :fetchUrl;
+// static-file sources pass the absolute static dir instead — the script gets
+// whichever applies, plus the federation's run params as one JSON argument.
+// Returns the harvest record for the ingest log.
+export const runFetch = ({ abs, root }, { name, fetchUrl, paramsJson }) => {
+    const outDir = PATHS.raw(name)
+    const origin = fetchUrl ?? abs(PATHS.staticDir(name))
+    console.log(`fetch  ${fetchUrl ?? PATHS.staticDir(name)} (params ${paramsJson}) → ${outDir}`)
+    fs.mkdirSync(abs(outDir), { recursive: true })
+    run("node", [abs(PATHS.fetchScript(name)), abs(outDir), origin, paramsJson])
+    const harvest = { time: new Date().toISOString() }
+    // Static sources have no live harvest — record the files' git commit
+    // time instead (the freshness the Sources page shows for them).
+    if (!fetchUrl) try {
+        const iso = execSync(`git log -1 --format=%cI -- "${PATHS.staticDir(name)}"`, { cwd: root, encoding: "utf8" }).trim()
+        if (iso) harvest.staticCommittedAt = iso
+    } catch { /* not committed yet / no git → omit */ }
+    return harvest
+}

package/src/pipeline/steps/lift.js

@@ -0,0 +1,58 @@
+import { localName, PATHS } from "../../utils.js"
+import { run } from "../run.js"
+import path from "path"
+import fs from "fs"
+
+const SPARQL_ANYTHING_VERSION = "v1.1.0"
+
+// The generic lift queries ship with the engine — they resolve against this
+// package, not the instance root like everything else in PATHS.
+const liftQueryFor = (formatIri) =>
+    path.join(import.meta.dirname, "../../lift", `${localName(formatIri).toLowerCase()}.sparql`)
+
+// SPARQL Anything is the lift tool — cached per instance (tools/, gitignored),
+// downloaded on first run and re-downloaded on version bumps.
+export async function ensureJar(abs) {
+    const JAR = abs("tools/sparql-anything.jar")
+    const VERSION_FILE = abs("tools/sparql-anything.version")
+    const haveCurrentJar = fs.existsSync(JAR) && fs.existsSync(VERSION_FILE)
+        && fs.readFileSync(VERSION_FILE, "utf8").trim() === SPARQL_ANYTHING_VERSION
+
+    if (!haveCurrentJar) {
+        const url = `https://github.com/SPARQL-Anything/sparql.anything/releases/download/${SPARQL_ANYTHING_VERSION}/sparql-anything-${SPARQL_ANYTHING_VERSION}.jar`
+        console.log(`Downloading sparql-anything ${SPARQL_ANYTHING_VERSION}...`)
+        fs.mkdirSync(path.dirname(JAR), { recursive: true })
+        const response = await fetch(url)
+        if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status}`)
+        fs.writeFileSync(JAR, Buffer.from(await response.arrayBuffer()))
+        fs.writeFileSync(VERSION_FILE, SPARQL_ANYTHING_VERSION)
+        console.log(`Saved to ${JAR}`)
+    }
+    return JAR
+}
+
+// Lift step: SPARQL Anything turns each raw file into TTL, via the bundled
+// query for the source's :format, with the source's :hasLiftParam variables.
+export const runLift = ({ abs }, { jar, name, format, params }) => {
+    // TODO: directory mode spawns one JVM per file (~1s startup each).
+    // Fine at small N; revisit if a source crosses ~50 items. SPARQL Anything
+    // accepts VALUES ?_location { … } in the lift query, which would let one
+    // invocation handle the whole batch.
+    const liftQuery = liftQueryFor(format)
+    const liftOne = (location, outPath) => {
+        const args = ["-jar", jar, "-q", liftQuery,
+                      "-v", `location=${location}`,
+                      "-f", "TTL", "-o", outPath]
+        for (const [pName, value] of params) args.push("-v", `${pName}=${value}`)
+        run("java", args)
+    }
+    const inAbs = abs(PATHS.raw(name))
+    const outAbs = abs(PATHS.lifted(name))
+    const files = fs.readdirSync(inAbs).filter(f => !f.startsWith(".")).sort()
+    fs.mkdirSync(outAbs, { recursive: true })
+    console.log(`lift   ${PATHS.raw(name)} (${files.length} files) → ${PATHS.lifted(name)}`)
+    for (const f of files) {
+        const stem = path.basename(f, path.extname(f))
+        liftOne(path.join(inAbs, f), path.join(outAbs, `${stem}.ttl`))
+    }
+}

package/src/pipeline/steps/map.js

@@ -0,0 +1,172 @@
+import { sparqlInsertDelete, sparqlSelect } from "@foerderfunke/sem-ops-utils"
+import { buildPrefixBlock, CDP, PATHS, shrink, sourceName } from "../../utils.js"
+import { DataFactory } from "n3"
+import path from "path"
+import fs from "fs"
+
+const df = DataFactory
+
+export const MAPPED_GRAPH = df.namedNode("urn:mapped")
+
+// ---- Direct-mapping generator ------------------------------------------
+
+const XYZ = "http://sparql.xyz/facade-x/data/"
+
+const buildDirectInsert = ({ sourceGraph, source, targetClass, target }, fields) => {
+    const prefixes = {
+        xyz:    XYZ,
+        cdp:    CDP,
+        cdf:    "https://civic-data.de/federated-directory#",
+        schema: "http://schema.org/",
+        foaf:   "http://xmlns.com/foaf/0.1/",
+        dct:    "http://purl.org/dc/terms/",
+    }
+    // shrink() returns the IRI verbatim if no prefix matches; wrap that as <…>.
+    const short = (iri) => {
+        const s = shrink(iri, prefixes)
+        return s === iri ? `<${iri}>` : s
+    }
+
+    const v      = (path) => `?${path}`
+    // STR() before the emptiness check so the guard works for any literal
+    // datatype — a bare `?v != ""` errors on e.g. xsd:int and would silently
+    // drop the field (AWO's numeric ids hit exactly this).
+    const optLit = (subj, path) =>
+        `OPTIONAL { ${subj} xyz:${path} ${v(path)} . ` +
+        `FILTER(isLiteral(${v(path)}) && STR(${v(path)}) != "") }`
+
+    const insertBlock = fields
+        .map(f => `        ?entity ${short(f.predicate)} ${v(f.fieldPath)} .`)
+        .join("\n")
+
+    const topLevel  = fields.filter(f => !f.parentPath)
+    const subFields = fields.filter(f => f.parentPath)
+
+    // Source subjects = federation IRIs after the clean step, identified via
+    // cdp:fromSource — no minting from a key field. Where clean reshapes one
+    // source into several entity kinds it tags each subject with cdp:targetSchema;
+    // select only those for this mapping's schema. Subjects with no marker
+    // (single-entity sources like caritas/dhs) match unconditionally.
+    const bgp = [`?entity cdp:fromSource ${short(source)} .`]
+    if (target) {
+        bgp.push(`OPTIONAL { ?entity cdp:targetSchema ?_ts }`)
+        bgp.push(`FILTER(!bound(?_ts) || ?_ts = ${short(target)})`)
+    }
+    for (const f of topLevel) bgp.push(optLit("?entity", f.fieldPath))
+
+    const byParent = new Map()
+    for (const f of subFields) {
+        if (!byParent.has(f.parentPath)) byParent.set(f.parentPath, [])
+        byParent.get(f.parentPath).push(f)
+    }
+    let parentIdx = 0
+    for (const [parent, subs] of byParent) {
+        const pv    = `?_p${parentIdx++}`
+        const inner = subs.map(s => `    ${optLit(pv, s.fieldPath)}`).join("\n")
+        bgp.push(`OPTIONAL {\n    ?entity xyz:${parent} ${pv} .\n${inner}\n  }`)
+    }
+
+    // The target schema's :targetClass becomes the record's rdf:type here in the
+    // mapped graph — this is where schema: vocabulary first enters; the clean step
+    // stays in xyz:/cdp: only.
+    const typeClause = targetClass ? `a ${short(targetClass)} ; ` : ""
+
+    return `${buildPrefixBlock(prefixes)}
+
+INSERT {
+    GRAPH <urn:mapped> {
+        ?entity ${typeClause}cdp:fromSource ${short(source)} .
+${insertBlock}
+    }
+} WHERE {
+    GRAPH <${sourceGraph}> {
+        ${bgp.join("\n        ")}
+    }
+}`
+}
+
+export const runMap = async ({ store, defStore, abs }, queriesDir) => {
+    const mappings = await sparqlSelect(`
+        PREFIX : <${CDP}>
+        SELECT ?mapping ?source ?sourceGraph ?target ?targetClass WHERE {
+            ?mapping a :Mapping ;
+                :fromSource ?source .
+            OPTIONAL { ?mapping :sourceGraph ?sourceGraph }
+            OPTIONAL { ?mapping :toTarget ?target }
+            OPTIONAL { ?mapping :toTarget/:targetClass ?targetClass }
+        } ORDER BY ?mapping`, [defStore])
+
+    for (const m of mappings) {
+        const directRows = await sparqlSelect(`
+            PREFIX : <${CDP}>
+            SELECT ?fieldPath ?predicate ?parentPath WHERE {
+                <${m.mapping}> :hasFieldMapping ?fm .
+                ?fm :from ?src ; :to ?tgt .
+                FILTER NOT EXISTS { ?fm :via ?_v }
+                ?tgt :targetPredicate ?predicate .
+                ?src :fieldPath ?fieldPath .
+                OPTIONAL { ?parent :hasSubField ?src . ?parent :fieldPath ?parentPath }
+            }`, [defStore])
+
+        if (directRows.length && m.sourceGraph) {
+            const localName = m.mapping.split("#").pop()
+            const query = buildDirectInsert(m, directRows)
+            const queryPath = abs(path.join(queriesDir, `${localName}.sparql`))
+            fs.mkdirSync(path.dirname(queryPath), { recursive: true })
+            fs.writeFileSync(queryPath, query)
+            console.log(`map  ${localName} direct (${directRows.length} mappings) → ${queryPath}`)
+            await sparqlInsertDelete(query, store)
+        }
+
+        // :via names a transform of the mapping's source — the script path
+        // follows by convention (sources/<source>/transform-<via>.sparql).
+        const viaRows = await sparqlSelect(`
+            PREFIX : <${CDP}>
+            SELECT DISTINCT ?via WHERE {
+                <${m.mapping}> :hasFieldMapping/:via ?via .
+            } ORDER BY ?via`, [defStore])
+
+        for (const v of viaRows) {
+            const script = PATHS.transform(sourceName(m.source), v.via)
+            console.log(`map  ${script}`)
+            await sparqlInsertDelete(fs.readFileSync(abs(script), "utf8"), store)
+        }
+    }
+
+    // A mapping's :hasRelationship turns the clean step's source-level link
+    // (e.g. :providedBy) into a target predicate (schema:provider), matching the
+    // two ends by their cdp:targetSchema. Both ends are still source IRIs here;
+    // the merge step rewrites them to the minted cluster IRIs.
+    const linkRows = await sparqlSelect(`
+        PREFIX : <${CDP}>
+        SELECT ?mapping ?sourceGraph ?fromSchema ?sourcePredicate ?targetPredicate ?toSchema WHERE {
+            ?mapping a :Mapping ;
+                :sourceGraph     ?sourceGraph ;
+                :toTarget        ?fromSchema ;
+                :hasRelationship ?rel .
+            ?rel :sourcePredicate ?sourcePredicate ;
+                 :toTargetField   ?field ;
+                 :toTargetSchema  ?toSchema .
+            ?field :targetPredicate ?targetPredicate .
+        } ORDER BY ?mapping`, [defStore])
+
+    for (const rel of linkRows) {
+        const prefixes = { cdp: CDP, schema: "http://schema.org/" }
+        const short = (iri) => { const s = shrink(iri, prefixes); return s === iri ? `<${iri}>` : s }
+        const query = `${buildPrefixBlock(prefixes)}
+
+INSERT {
+    GRAPH <urn:mapped> {
+        ?from ${short(rel.targetPredicate)} ?to .
+    }
+} WHERE {
+    GRAPH <${rel.sourceGraph}> {
+        ?from ${short(rel.sourcePredicate)} ?to ;
+              cdp:targetSchema ${short(rel.fromSchema)} .
+        ?to cdp:targetSchema ${short(rel.toSchema)} .
+    }
+}`
+        console.log(`map  ${rel.mapping.split("#").pop()} link (${short(rel.targetPredicate)})`)
+        await sparqlInsertDelete(query, store)
+    }
+}