@_linked/core 2.34.0 → 2.36.0

package/lib/esm/sparql/irToAlgebra.js

@@ -1,3 +1,4 @@
+import { RegistryCache } from '../utils/registryCache.js';
 import { findPropertyShapeById, getPropertyShapes } from '../shapes/nodeShapeData.js';
 import { pathExprToSparql, collectPathUris } from '../paths/pathExprToSparql.js';
 import { generateEntityUri } from './sparqlUtils.js';
@@ -6,8 +7,11 @@ import { rdf } from '../ontologies/rdf.js';
 import { shacl } from '../ontologies/shacl.js';
 import { xsd } from '../ontologies/xsd.js';
 import { getSimplePathId } from '../paths/normalizePropertyPath.js';
-import { getAllNodeShapes, getNodeShape, getRegistryVersion, getShapeClass, getSubShapes, getTargetClassId, isSubShapeOf, } from '../utils/ShapeClass.js';
+import { attachCatalog, catalogOf, getActiveShapeCatalog, getAllNodeShapes, getNodeShape, getShapeClass, getSubShapes, getTargetClassId, isSubShapeOf, withShapeCatalog, } from '../utils/ShapeClass.js';
 import { UnresolvedContextError } from '../queries/QueryContext.js';
+// The `*ToAlgebra` / `*ToSparql` exports compile in the catalog the IR was lowered in (its
+// non-enumerable `catalog` field). An IR without one — built by hand, or copied with a spread,
+// which drops the field — compiles in the active catalog, or globally outside any scope.
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -92,12 +96,11 @@ function resolveShapeScanIri(shapeId) {
  *   better is knowable; the caller passed an id no registered shape declares).
  */
 // Memoizes resolved predicate terms across the many call sites that resolve the
-// same property. Guarded by the shape-registry size so it self-invalidates when
-// new shapes register (e.g. across test-file module instances). Only successful
-// resolutions are cached — a not-found fallback is never stored, so a predicate
-// resolved before its shape registers can still resolve correctly afterwards.
-const predicateTermCache = new Map();
-let predicateTermCacheSize = -1;
+// same property. One map per catalog; the global one is rebuilt when the registry
+// version moves. Only successful resolutions are cached — a not-found fallback is never
+// stored, so a predicate resolved before its shape registers can still resolve
+// correctly afterwards.
+const predicateTermCache = new RegistryCache();
 /**
  * The `sh:datatype` declared for a property, if any. Lets the serializer emit the
  * term the shape asks for rather than one inferred from the JavaScript value: a
@@ -109,12 +112,8 @@ function resolvePropertyDatatype(propertyId) {
     return (_b = (_a = findPropertyShapeById(propertyId)) === null || _a === void 0 ? void 0 : _a.datatype) === null || _b === void 0 ? void 0 : _b.id;
 }
 function resolvePropertyPredicateTerm(propertyId) {
-    const version = getRegistryVersion();
-    if (version !== predicateTermCacheSize) {
-        predicateTermCache.clear();
-        predicateTermCacheSize = version;
-    }
-    const cached = predicateTermCache.get(propertyId);
+    const cache = predicateTermCache.get();
+    const cached = cache.get(propertyId);
     if (cached)
         return cached;
     const propertyShape = findPropertyShapeById(propertyId);
@@ -135,7 +134,7 @@ function resolvePropertyPredicateTerm(propertyId) {
                 uris: collectPathUris(propertyShape.path),
             };
         }
-        predicateTermCache.set(propertyId, term);
+        cache.set(propertyId, term);
         return term;
     }
     return iriTerm(propertyId);
@@ -477,6 +476,10 @@ function containsAggregate(expr) {
  */
 export function selectToAlgebra(query, _options) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => selectToAlgebra(query, _options));
+    }
     const registry = new VariableRegistry();
     // Promote bindings only when the top-level WHERE would reject rows without
     // them. This keeps human-like SPARQL for null-rejecting filters without
@@ -1561,6 +1564,10 @@ function generateNodeDataTriples(data, options, blanks, kind = 'iri') {
  * Converts an IRCreateMutation to a SparqlInsertDataPlan.
  */
 export function createToAlgebra(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => createToAlgebra(query, options));
+    }
     const { triples } = generateNodeDataTriples(query.data, options, { next: 0 });
     return {
         type: 'insert_data',
@@ -1815,6 +1822,10 @@ function wrapOldValueOptionals(base, oldValueTriples) {
  * Converts an IRUpdateMutation to a SparqlDeleteInsertPlan.
  */
 export function updateToAlgebra(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => updateToAlgebra(query, options));
+    }
     return buildDeleteInsertPlan(query, options);
 }
 /**
@@ -1827,6 +1838,10 @@ export function updateToAlgebra(query, options) {
  * needs no guard.
  */
 export function upsertToAlgebra(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => upsertToAlgebra(query, options));
+    }
     return buildDeleteInsertPlan(query, options, {
         // Must match the IRI `create` asserts and `select` scans for; the raw shape id is
         // not the same thing, and a node typed with it would be invisible to queries.
@@ -2005,8 +2020,7 @@ function simplePredicates(props) {
     }
     return [...predicates];
 }
-let blankWalkCache = new Map();
-let blankWalkCacheVersion = -1;
+const blankWalkCache = new RegistryCache();
 /**
  * The predicates the blank-node cascade follows *below* a blank value held by one of `start`:
  * the blank-capable properties of every shape the value (and, transitively, its blank values)
@@ -2017,13 +2031,9 @@ let blankWalkCacheVersion = -1;
  * `buildBlankCascade` refuses any node reached through an IRI.
  */
 function blankWalkPredicates(start) {
-    const version = getRegistryVersion();
-    if (version !== blankWalkCacheVersion) {
-        blankWalkCache = new Map();
-        blankWalkCacheVersion = version;
-    }
+    const cache = blankWalkCache.get();
     const key = start.map((ps) => ps.id).join('|');
-    const cached = blankWalkCache.get(key);
+    const cached = cache.get(key);
     if (cached)
         return cached;
     let everything = false;
@@ -2060,7 +2070,7 @@ function blankWalkPredicates(start) {
         }
     }
     const result = simplePredicates(predicates);
-    blankWalkCache.set(key, result);
+    cache.set(key, result);
     return result;
 }
 /** A SPARQL property-path term over `predicates`: `(p1|…|pn)`, then `*` / `+` when given. */
@@ -2203,23 +2213,19 @@ function ownedPredicate(ps) {
         return null;
     return (_b = getSimplePathId(ps.path)) !== null && _b !== void 0 ? _b : null;
 }
-let classHoldersCache = new Map();
-let classHoldersVersion = -1;
-/** Every registered shape id per `targetClass` (memoized per registry version). */
-function classHolders(classId) {
-    var _a, _b, _c;
-    const version = getRegistryVersion();
-    if (version !== classHoldersVersion) {
-        classHoldersCache = new Map();
-        for (const nodeShape of getAllNodeShapes().values()) {
-            const cls = (_a = nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.targetClass) === null || _a === void 0 ? void 0 : _a.id;
-            if (!cls)
-                continue;
-            classHoldersCache.set(cls, [...((_b = classHoldersCache.get(cls)) !== null && _b !== void 0 ? _b : []), nodeShape.id]);
-        }
-        classHoldersVersion = version;
+const classHoldersCache = new RegistryCache((holders) => {
+    var _a, _b;
+    for (const nodeShape of getAllNodeShapes().values()) {
+        const cls = (_a = nodeShape === null || nodeShape === void 0 ? void 0 : nodeShape.targetClass) === null || _a === void 0 ? void 0 : _a.id;
+        if (!cls)
+            continue;
+        holders.set(cls, [...((_b = holders.get(cls)) !== null && _b !== void 0 ? _b : []), nodeShape.id]);
     }
-    return (_c = classHoldersCache.get(classId)) !== null && _c !== void 0 ? _c : [];
+});
+/** Every registered shape id per `targetClass` (memoized per registry version, or per catalog). */
+function classHolders(classId) {
+    var _a;
+    return (_a = classHoldersCache.get().get(classId)) !== null && _a !== void 0 ? _a : [];
 }
 /**
  * Why the added `contains` property `ps` of the sub-shape `sub` cannot be followed from nodes of
@@ -2313,8 +2319,7 @@ function shapeClasses(shapeId) {
     }
     return [...classes];
 }
-let ownedWalkCache = new Map();
-let ownedWalkCacheVersion = -1;
+const ownedWalkCache = new RegistryCache();
 const warnedBranches = new Set();
 /**
  * The owned subtree of a root shape, as hops (memoized per registry version; read-only).
@@ -2326,12 +2331,8 @@ const warnedBranches = new Set();
  * `MAX_OWNED_RECURSION` hops into a shape already on it.
  */
 function ownedWalk(rootShapeId) {
-    const version = getRegistryVersion();
-    if (version !== ownedWalkCacheVersion) {
-        ownedWalkCache = new Map();
-        ownedWalkCacheVersion = version;
-    }
-    const cached = ownedWalkCache.get(rootShapeId);
+    const cache = ownedWalkCache.get();
+    const cached = cache.get(rootShapeId);
     if (cached)
         return cached;
     const edgesOf = new Map();
@@ -2419,7 +2420,7 @@ function ownedWalk(rootShapeId) {
         rootBlankProps: blankCapableProperties(rootShapeId),
         targets,
     };
-    ownedWalkCache.set(rootShapeId, walk);
+    cache.set(rootShapeId, walk);
     return walk;
 }
 /** `FILTER(!sameTerm(?n, rdf:nil))`: the walk never deletes `rdf:nil`, which every list ends in. */
@@ -2596,6 +2597,10 @@ export function buildOwnedSelfDelete(subjectTerm, propertyTerm, oldTerm, varPref
  * shape, the WHERE has no solution and nothing is deleted.
  */
 export function deleteToAlgebra(query, _options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => deleteToAlgebra(query, _options));
+    }
     const deletePatterns = [];
     const guards = [];
     const blocks = [];
@@ -2669,6 +2674,10 @@ function bulkDeleteUnion(shapeId, subjectVar, rootWildcard, typeTriple, deletePa
  * (see `bulkDeleteUnion`). Unlike a delete by id, incoming references are not deleted.
  */
 export function deleteAllToAlgebra(query, _options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => deleteAllToAlgebra(query, _options));
+    }
     const subjectVar = 'a0';
     // DELETE patterns: root wildcard
     const deletePatterns = [
@@ -2696,6 +2705,10 @@ export function deleteAllToAlgebra(query, _options) {
  * so only the matched subjects' children are deleted.
  */
 export function deleteWhereToAlgebra(query, _options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => deleteWhereToAlgebra(query, _options));
+    }
     const subjectVar = 'a0';
     const registry = new VariableRegistry();
     // DELETE patterns: root wildcard
@@ -2747,6 +2760,10 @@ export function deleteWhereToAlgebra(query, _options) {
  * filter conditions from the where clause.
  */
 export function updateWhereToAlgebra(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => updateWhereToAlgebra(query, options));
+    }
     const subjectTerm = varTerm('a0');
     const result = processUpdateFields(query.data, subjectTerm, options);
     // WHERE: type triple is always required
@@ -2803,6 +2820,10 @@ export function updateWhereToAlgebra(query, options) {
  * lowers to `GROUP BY` + `HAVING` rather than to a `FILTER`; see below.
  */
 export function askToAlgebra(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => askToAlgebra(query, options));
+    }
     if (!query.root) {
         if (!query.subjectId) {
             throw new Error('askToAlgebra: a shapeless ask needs a subject — there is no shape to scan ' +
@@ -2817,7 +2838,7 @@ export function askToAlgebra(query, options) {
         };
         return { type: 'ask', algebra: bgp };
     }
-    const inner = selectToAlgebra({
+    const inner = selectToAlgebra(attachCatalog({
         kind: 'select',
         root: query.root,
         patterns: query.patterns,
@@ -2825,7 +2846,7 @@ export function askToAlgebra(query, options) {
         where: query.where,
         subjectId: query.subjectId,
         subjectIds: query.subjectIds,
-    }, options);
+    }, catalog), options);
     if (inner.having) {
         // Same trap as in `countToAlgebra`: an aggregate in the WHERE clause (e.g.
         // `p.friends.size().gt(2)`) lowers to HAVING + GROUP BY on the select plan, and
@@ -2869,11 +2890,15 @@ export function askToAlgebra(query, options) {
  * nothing to guard against, because {@link IRCountQuery} cannot carry them.
  */
 export function countToAlgebra(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => countToAlgebra(query, options));
+    }
     if (!query.root) {
         throw new Error('countToAlgebra: query.root is undefined. A count needs a shape to scan — a ' +
             'shapeless count would count every node in the store.');
     }
-    const inner = selectToAlgebra({
+    const inner = selectToAlgebra(attachCatalog({
         kind: 'select',
         root: query.root,
         patterns: query.patterns,
@@ -2881,7 +2906,7 @@ export function countToAlgebra(query, options) {
         where: query.where,
         subjectId: query.subjectId,
         subjectIds: query.subjectIds,
-    }, options);
+    }, catalog), options);
     if (inner.having) {
         // An aggregate in the WHERE clause (e.g. `p.friends.size().gt(2)`) lowers to
         // HAVING + GROUP BY on the select plan. Only `algebra` is carried over here, so
@@ -2916,6 +2941,10 @@ export function countToAlgebra(query, options) {
  * Converts an IRSelectQuery to a SPARQL string.
  */
 export function selectToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => selectToSparql(query, options));
+    }
     const plan = selectToAlgebra(query, options);
     return selectPlanToSparql(plan, options);
 }
@@ -2923,6 +2952,10 @@ export function selectToSparql(query, options) {
  * Converts an {@link IRAskQuery} to a SPARQL `ASK` string.
  */
 export function askToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => askToSparql(query, options));
+    }
     const plan = askToAlgebra(query, options);
     return askPlanToSparql(plan, options);
 }
@@ -2931,6 +2964,10 @@ export function askToSparql(query, options) {
  * string, through the same {@link selectPlanToSparql} every select uses.
  */
 export function countToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => countToSparql(query, options));
+    }
     const plan = countToAlgebra(query, options);
     return selectPlanToSparql(plan, options);
 }
@@ -2939,6 +2976,10 @@ export function countToSparql(query, options) {
  * Stub: will be implemented when algebraToString is available.
  */
 export function createToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => createToSparql(query, options));
+    }
     const plan = createToAlgebra(query, options);
     return insertDataPlanToSparql(plan, options);
 }
@@ -2947,11 +2988,19 @@ export function createToSparql(query, options) {
  * Stub: will be implemented when algebraToString is available.
  */
 export function updateToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => updateToSparql(query, options));
+    }
     const plan = updateToAlgebra(query, options);
     return deleteInsertPlanToSparql(plan, options);
 }
 /** Lowers an IRUpsertMutation all the way to a SPARQL update string. */
 export function upsertToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => upsertToSparql(query, options));
+    }
     const plan = upsertToAlgebra(query, options);
     return deleteInsertPlanToSparql(plan, options);
 }
@@ -2959,6 +3008,10 @@ export function upsertToSparql(query, options) {
  * Converts an IRDeleteMutation to a SPARQL string.
  */
 export function deleteToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => deleteToSparql(query, options));
+    }
     const plan = deleteToAlgebra(query, options);
     return deleteInsertPlanToSparql(plan, options);
 }
@@ -2966,6 +3019,10 @@ export function deleteToSparql(query, options) {
  * Converts an IRDeleteAllMutation to a SPARQL string.
  */
 export function deleteAllToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => deleteAllToSparql(query, options));
+    }
     const plan = deleteAllToAlgebra(query, options);
     return deleteInsertPlanToSparql(plan, options);
 }
@@ -2973,6 +3030,10 @@ export function deleteAllToSparql(query, options) {
  * Converts an IRDeleteWhereMutation to a SPARQL string.
  */
 export function deleteWhereToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => deleteWhereToSparql(query, options));
+    }
     const plan = deleteWhereToAlgebra(query, options);
     return deleteInsertPlanToSparql(plan, options);
 }
@@ -2980,6 +3041,10 @@ export function deleteWhereToSparql(query, options) {
  * Converts an IRUpdateWhereMutation to a SPARQL string.
  */
 export function updateWhereToSparql(query, options) {
+    const catalog = catalogOf(query);
+    if (catalog !== undefined && catalog !== getActiveShapeCatalog()) {
+        return withShapeCatalog(catalog, () => updateWhereToSparql(query, options));
+    }
     const plan = updateWhereToAlgebra(query, options);
     return deleteInsertPlanToSparql(plan, options);
 }