Fix ScopedGraphRepository.contains() dropping resolvable imports

ontapi consults GraphRepository.contains() before get() when resolving
an ontology's imports closure. PrefixGraphRepository.contains() reports
cache state (loaded graphs), not resolvability, so every import that
resolves through a bundled location mapping (dh, sp, spin, foaf, sioc,
sd), SPARQL-first loading or HTTP was answered with false on first
resolution — and ontapi silently substituted an empty ontology graph
for it (its ignoreUnresolvedImports fallback). The closure kept its
shape but lost the content of every such import: SPIN constraints
vanished, so validation enforced nothing (422 tests wrote through,
eventually applying invalid dataspace settings and cascading into
NPEs), and vocabulary term lookups came up empty. This is what failed
the HTTP test suite in CI.

contains() now attempts resolution through the backing repository
(which loads and caches the graph) after the cache checks, reporting
absent only for genuinely unresolvable ids. Adds a production-shaped
regression test: ns# ontology importing the SPARQL-seeded ldh#
vocabulary with its transitive imports resolved through the real
bundled location mappings.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: namedgraph

src/main/java/com/atomgraph/linkeddatahub/server/util/ScopedGraphRepository.java

@@ -91,7 +91,21 @@ public void clear()
     @Override
     public boolean contains(String id)
     {
-        return local.containsKey(id) || getBacking().contains(id);
+        if (local.containsKey(id) || getBacking().contains(id)) return true;
+
+        // the backing repository's contains() only reports already-cached graphs, but ontapi consults
+        // contains() before get() when resolving imports — a false negative for a resolvable id (bundled
+        // mapping, SPARQL-first, HTTP) makes ontapi silently substitute an empty ontology graph for the
+        // import. Attempt resolution instead: the backing repository loads and caches the graph, and only
+        // a genuinely unresolvable id reports absent
+        try
+        {
+            return getBacking().get(id) != null;
+        }
+        catch (RuntimeException ex)
+        {
+            return false;
+        }
     }
 
     @Override

src/test/java/com/atomgraph/linkeddatahub/server/filter/request/OntologyClosureCIReproTest.java

@@ -0,0 +1,101 @@
+/**
+ *  Copyright 2026 Martynas Jusevičius <martynas@atomgraph.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+package com.atomgraph.linkeddatahub.server.filter.request;
+
+import com.atomgraph.client.util.jena.PrefixGraphRepository;
+import org.apache.jena.ontapi.UnionGraph;
+import org.apache.jena.rdf.model.Model;
+import org.apache.jena.rdf.model.ModelFactory;
+import org.apache.jena.rdf.model.Resource;
+import org.apache.jena.rdf.model.ResourceFactory;
+import org.apache.jena.riot.RDFParser;
+import org.apache.jena.vocabulary.OWL;
+import org.apache.jena.vocabulary.RDF;
+import org.apache.jena.vocabulary.RDFS;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Production-shaped regression guard for the imports closure: the end-user ns# ontology as the SPARQL
+ * CONSTRUCT returns it (header + imports + unrelated document resources), importing the SPARQL-loaded
+ * ldh# vocabulary, whose transitive imports resolve through the real bundled location mappings
+ * (dh, spin, sp, foaf, sioc, sd) plus store-seeded stubs for the non-mapped ones (ac, nfo, owl).
+ * <p>
+ * Pins the fix for ontapi consulting {@code contains()} before {@code get()} during import resolution:
+ * a cache-state (rather than resolvability) answer made ontapi silently substitute empty ontology
+ * graphs for every bundled-mapped import, stripping SPIN constraints and vocabularies from the closure.
+ *
+ * @author Martynas Jusevičius {@literal <martynas@atomgraph.com>}
+ */
+public class OntologyClosureCIReproTest
+{
+
+    private static final String NS = "https://localhost:4443/ns#";
+    private static final String LDH = "https://w3id.org/atomgraph/linkeddatahub#";
+
+    @Test
+    public void productionShapedClosureContainsAllImports()
+    {
+        PrefixGraphRepository repository = new PrefixGraphRepository(null);
+
+        // real bundled mappings
+        Model mappingModel = ModelFactory.createDefaultModel();
+        RDFParser.create().source("location-mapping.ttl").streamManager(repository.getStreamManager()).build().parse(mappingModel);
+        repository.processConfig(mappingModel);
+
+        // mimic SPARQL-first load result: the ldh# vocabulary as a store graph
+        Model ldh = ModelFactory.createDefaultModel();
+        RDFParser.create().source("com/atomgraph/linkeddatahub/ldh.ttl").base(LDH).streamManager(repository.getStreamManager()).build().parse(ldh);
+        repository.put(LDH, ldh.getGraph());
+
+        // stub graphs for ldh#'s non-mapped imports (SPARQL/HTTP-loaded in production)
+        for (String stub : new String[] {
+            "https://w3id.org/atomgraph/client#",
+            "http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#",
+            "http://www.w3.org/2002/07/owl#" })
+        {
+            Model m = ModelFactory.createDefaultModel();
+            m.add(m.createResource(stub), RDF.type, OWL.Ontology);
+            repository.put(stub, m.getGraph());
+        }
+
+        // ns# base graph as the ontology CONSTRUCT returns it: ontology header + imports + document resource
+        Model ns = ModelFactory.createDefaultModel();
+        Resource nsOnt = ns.createResource(NS);
+        ns.add(nsOnt, RDF.type, OWL.Ontology);
+        ns.add(nsOnt, OWL.imports, ns.createResource(LDH));
+        Resource doc = ns.createResource("https://admin.localhost:4443/ontologies/namespace/");
+        ns.add(doc, RDF.type, ns.createResource("https://www.w3.org/ns/ldt/document-hierarchy#Item"));
+        ns.add(doc, ResourceFactory.createProperty("http://purl.org/dc/terms/title"), "Namespace");
+        repository.put(NS, ns.getGraph());
+
+        UnionGraph union = OntologyFilter.loadOntology(repository, NS);
+        Model closure = ModelFactory.createModelForGraph(union);
+
+        // direct import: ldh.ttl content
+        assertTrue(closure.contains(closure.createResource(LDH + "View"), RDF.type, RDFS.Class), "ldh# (direct import) must be in the closure");
+        // transitive via ldh#: dh.ttl (bundled mapping)
+        assertTrue(closure.contains(closure.createResource("https://www.w3.org/ns/ldt/document-hierarchy#Item"), RDF.type, OWL.Class), "dh# (transitive, bundled) must be in the closure");
+        // transitive via ldh#: spin.ttl imported as http://spinrdf.org/spin (no hash)
+        assertTrue(closure.contains(closure.createResource("http://spinrdf.org/spin#constraint"), RDF.type, RDF.Property), "spin (transitive, bundled, hashless import URI) must be in the closure");
+        // transitive via dh#: sp.ttl imported as http://spinrdf.org/sp#
+        assertTrue(closure.contains(closure.createResource("http://spinrdf.org/sp#text"), RDF.type, RDF.Property), "sp# (transitive via dh#, bundled) must be in the closure");
+        // transitive via dh#: foaf (bundled)
+        assertFalse(closure.listStatements(closure.createResource("http://xmlns.com/foaf/0.1/Agent"), null, (org.apache.jena.rdf.model.RDFNode)null).toList().isEmpty(), "foaf (transitive, bundled) must be in the closure");
+    }
+
+}