@undefineds.co/xpod 0.3.18 → 0.3.23

package/dist/storage/accessors/MixDataAccessor.js

@@ -10,6 +10,7 @@ const arrayify_stream_1 = __importDefault(require("arrayify-stream"));
 const n3_1 = require("n3");
 const jsonld_1 = __importDefault(require("jsonld"));
 const rdf_parse_1 = require("rdf-parse");
+const sparqljs_1 = require("sparqljs");
 const community_server_1 = require("@solid/community-server");
 const RdfSparqlAdapter_1 = require("../rdf/RdfSparqlAdapter");
 const RdfContentTypes_1 = require("../rdf/RdfContentTypes");
@@ -20,7 +21,7 @@ const MetadataRequestContext_1 = require("../MetadataRequestContext");
 /**
  * MixDataAccessor - Routes data to appropriate storage based on content type
  *
- * - RDF data (internal/quads) -> structuredDataAccessor (Quadstore or QuintStore)
+ * - RDF data (internal/quads) -> structuredDataAccessor (Solid RDF engine by default)
  * - RDF file mirrors (.ttl/.jsonld) -> rdfFileDataAccessor (local FileSystem)
  * - Other data (binary, text, etc.) -> unstructuredDataAccessor (FileSystem, Minio, etc.)
  *
@@ -179,16 +180,18 @@ class MixDataAccessor {
      * Execute SPARQL UPDATE.
      *
      * Supported embedded deltas patch the local RDF authority file first and then
-     * rebuild the structured RDF index. Unsupported shapes keep using the
-     * compatibility accessor until the embedded engine covers them.
+     * rebuild the structured RDF index. The structured accessor decides whether
+     * unsupported shapes have an explicitly configured compatibility path.
      */
     async executeSparqlUpdate(query, baseIri) {
         if (baseIri) {
             const identifier = { path: baseIri };
             if (this.isByLineRdfIdentifier(identifier)) {
                 try {
-                    await this.executeLocalRdfSparqlUpdate(query, identifier);
-                    this.invalidateMetadataCache(identifier);
+                    const writtenIdentifiers = await this.executeLocalRdfSparqlUpdate(query, identifier);
+                    for (const writtenIdentifier of writtenIdentifiers) {
+                        this.invalidateMetadataCache(writtenIdentifier);
+                    }
                     return;
                 }
                 catch (error) {
@@ -210,62 +213,104 @@ class MixDataAccessor {
         }
     }
     async executeLocalRdfSparqlUpdate(query, identifier) {
-        const delta = this.rdfSparqlAdapter.compileUpdateDelta(query, identifier.path);
-        this.assertLocalRdfDeltaTargetsGraph(delta.operations, identifier.path);
-        const existingText = await this.readLocalRdfTextOrEmpty(identifier);
-        const graph = n3_1.DataFactory.namedNode(identifier.path);
-        const existingQuads = existingText.length > 0
-            ? await this.parseLocalRdf(identifier, existingText, this.localRdfContentType(identifier))
-                .then((quads) => quads.map((quad) => this.toGraphQuad(quad, graph)))
-            : [];
-        const nextQuads = this.applyLocalRdfDelta(existingQuads, delta.operations);
-        const authorityQuads = nextQuads.map((quad) => this.toDefaultGraphQuad(quad));
-        await this.writeLocalRdfAuthority(identifier, authorityQuads);
-        await this.writeStructuredRdfIndex(identifier, authorityQuads, new community_server_1.RepresentationMetadata(identifier));
-    }
-    applyLocalRdfDelta(quads, operations) {
-        const byKey = new Map(quads.map((quad) => [this.quadKey(quad), quad]));
+        const parsed = new sparqljs_1.Parser({ baseIRI: identifier.path }).parse(query);
+        const delta = this.rdfSparqlAdapter.compileUpdateDelta(parsed, this.parentContainer(identifier).path, {
+            defaultGraph: identifier.path,
+        });
+        const writableGraphIris = this.localRdfDeltaWriteGraphIris(delta.operations);
+        const graphStates = await this.loadLocalRdfDeltaGraphs(delta.operations, writableGraphIris);
+        const graphQuads = new Map([...graphStates].map(([graphIri, state]) => [graphIri, state.quads]));
+        const nextQuadsByGraph = this.applyLocalRdfDelta(graphQuads, delta.operations, writableGraphIris);
+        const patches = writableGraphIris.map((graphIri) => {
+            const previous = graphStates.get(graphIri);
+            return {
+                identifier: { path: graphIri },
+                previousQuads: previous?.quads ?? [],
+                previousExists: previous?.existed ?? false,
+                nextQuads: nextQuadsByGraph.get(graphIri) ?? [],
+            };
+        });
+        await this.writeLocalRdfAuthorityPatches(patches);
+        return patches.map((patch) => patch.identifier);
+    }
+    applyLocalRdfDelta(graphQuads, operations, writableGraphIris) {
+        const writableGraphs = new Set(writableGraphIris);
+        const byGraph = new Map();
+        for (const [graphIri, quads] of graphQuads) {
+            byGraph.set(graphIri, new Map(quads.map((quad) => [this.quadKey(quad), quad])));
+        }
+        const currentQuads = () => [...byGraph.values()].flatMap((quads) => [...quads.values()]);
+        const writableQuads = (graphIri) => {
+            let quads = byGraph.get(graphIri);
+            if (!quads) {
+                quads = new Map();
+                byGraph.set(graphIri, quads);
+            }
+            return quads;
+        };
+        const deleteQuads = (quads) => {
+            for (const quad of quads) {
+                const target = writableQuads(this.localRdfWriteGraphIri(quad.graph, writableGraphs));
+                target.delete(this.quadKey(quad));
+            }
+        };
+        const insertQuads = (quads) => {
+            for (const quad of quads) {
+                const target = writableQuads(this.localRdfWriteGraphIri(quad.graph, writableGraphs));
+                target.set(this.quadKey(quad), quad);
+            }
+        };
         for (const operation of operations) {
             if (operation.type === 'insert') {
-                for (const quad of operation.quads) {
-                    byKey.set(this.quadKey(quad), quad);
-                }
+                insertQuads(operation.quads);
                 continue;
             }
             if (operation.type === 'delete') {
-                for (const quad of operation.quads) {
-                    byKey.delete(this.quadKey(quad));
-                }
+                deleteQuads(operation.quads);
                 continue;
             }
             if (operation.type === 'insertDeleteWhere') {
-                const rows = this.queryLocalUpdateBindings([...byKey.values()], operation.query);
-                for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.deletes, rows)) {
-                    byKey.delete(this.quadKey(quad));
-                }
-                for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows)) {
-                    byKey.set(this.quadKey(quad), quad);
-                }
+                const rows = this.queryLocalUpdateBindings(currentQuads(), operation.query);
+                deleteQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.deletes, rows));
+                insertQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows));
                 continue;
             }
             if (operation.type === 'insertWhere') {
-                const rows = this.queryLocalUpdateBindings([...byKey.values()], operation.query);
-                for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows)) {
-                    byKey.set(this.quadKey(quad), quad);
-                }
+                const rows = this.queryLocalUpdateBindings(currentQuads(), operation.query);
+                insertQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows));
                 continue;
             }
-            const rows = this.queryLocalUpdateBindings([...byKey.values()], operation.query);
-            for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.template, rows)) {
-                byKey.delete(this.quadKey(quad));
+            const rows = this.queryLocalUpdateBindings(currentQuads(), operation.query);
+            deleteQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.template, rows));
+        }
+        return new Map(writableGraphIris.map((graphIri) => [graphIri, [...(byGraph.get(graphIri)?.values() ?? [])]]));
+    }
+    async loadLocalRdfDeltaGraphs(operations, writableGraphIris) {
+        const graphIris = this.localRdfDeltaGraphIris(operations, writableGraphIris);
+        const graphStates = new Map();
+        for (const graphIri of graphIris) {
+            const graphIdentifier = { path: graphIri };
+            if (!this.isByLineRdfIdentifier(graphIdentifier)) {
+                throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports by-line local RDF graph documents');
             }
-        }
-        return [...byKey.values()];
-    }
-    assertLocalRdfDeltaTargetsGraph(operations, graphIri) {
+            const existing = await this.readLocalRdfState(graphIdentifier);
+            const graph = n3_1.DataFactory.namedNode(graphIri);
+            const quads = existing.text.length > 0
+                ? await this.parseLocalRdf(graphIdentifier, existing.text, this.localRdfContentType(graphIdentifier))
+                    .then((items) => items.map((quad) => this.toGraphQuad(quad, graph)))
+                : [];
+            graphStates.set(graphIri, { quads, existed: existing.existed });
+        }
+        return graphStates;
+    }
+    localRdfDeltaGraphIris(operations, writableGraphIris) {
+        const graphIris = new Set(writableGraphIris);
         for (const operation of operations) {
             const graphTerms = operation.type === 'deleteWhere'
-                ? operation.template.map((item) => item.graph)
+                ? [
+                    ...operation.template.map((item) => item.graph),
+                    ...this.queryGraphTerms(operation.query),
+                ]
                 : operation.type === 'insertDeleteWhere'
                     ? [
                         ...operation.deletes.map((item) => item.graph),
@@ -279,12 +324,64 @@ class MixDataAccessor {
                         ]
                         : operation.quads.map((quad) => quad.graph);
             for (const graph of graphTerms) {
-                if (!('termType' in graph) || graph.termType !== 'NamedNode' || graph.value !== graphIri) {
-                    throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports the target document graph');
-                }
+                this.addNamedGraphIris(graph, graphIris);
+            }
+        }
+        return [...graphIris];
+    }
+    localRdfDeltaWriteGraphIris(operations) {
+        const graphIris = new Set();
+        for (const operation of operations) {
+            if (operation.type === 'deleteWhere') {
+                this.addWritableTemplateGraphIris(operation.template.map((item) => item.graph), operation.query, graphIris);
+                continue;
+            }
+            if (operation.type === 'insertDeleteWhere') {
+                this.addWritableTemplateGraphIris([
+                    ...operation.deletes.map((item) => item.graph),
+                    ...operation.inserts.map((item) => item.graph),
+                ], operation.query, graphIris);
+                continue;
+            }
+            if (operation.type === 'insertWhere') {
+                this.addWritableTemplateGraphIris(operation.inserts.map((item) => item.graph), operation.query, graphIris);
+                continue;
+            }
+            const graphTerms = operation.quads.map((quad) => quad.graph);
+            for (const graph of graphTerms) {
+                this.addWritableNamedGraphIri(graph, graphIris);
+            }
+        }
+        if (graphIris.size === 0) {
+            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update requires explicit local RDF graph write targets');
+        }
+        return [...graphIris];
+    }
+    addWritableTemplateGraphIris(graphs, query, graphIris) {
+        for (const graph of graphs) {
+            if (this.isQueryVariable(graph)) {
+                this.addWritableGraphVariableIris(query, graph.variable, graphIris);
+                continue;
             }
+            this.addWritableNamedGraphIri(graph, graphIris);
+        }
+    }
+    addWritableGraphVariableIris(query, variable, graphIris) {
+        const values = new Set();
+        this.collectGraphVariableFilterIris(query, variable, values);
+        if (values.size === 0) {
+            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports finite GRAPH variable write targets');
+        }
+        for (const value of values) {
+            this.addWritableNamedGraphIri(n3_1.DataFactory.namedNode(value), graphIris);
         }
     }
+    localRdfWriteGraphIri(graph, writableGraphs) {
+        if (graph.termType !== 'NamedNode' || !writableGraphs.has(graph.value)) {
+            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update can only write declared local RDF graph documents');
+        }
+        return graph.value;
+    }
     queryLocalUpdateBindings(quads, query) {
         const index = new RdfQuadIndex_1.RdfQuadIndex({ path: ':memory:' });
         index.open();
@@ -298,33 +395,194 @@ class MixDataAccessor {
         }
     }
     queryGraphTerms(query) {
-        const patterns = [...query.patterns];
+        const graphTerms = [];
+        const graphVariables = new Set();
+        this.collectQueryGraphTerms(query, graphTerms, graphVariables);
+        this.collectGraphVariableFilterTerms(query, graphVariables, graphTerms);
+        return graphTerms;
+    }
+    collectQueryGraphTerms(query, graphTerms, graphVariables) {
+        for (const pattern of query.patterns) {
+            if (!pattern.graph) {
+                continue;
+            }
+            graphTerms.push(pattern.graph);
+            if (this.isQueryVariable(pattern.graph)) {
+                graphVariables.add(pattern.graph.variable);
+            }
+        }
+        for (const optional of query.optional ?? []) {
+            this.collectQueryGraphTerms(Array.isArray(optional) ? { patterns: optional } : optional, graphTerms, graphVariables);
+        }
+        for (const union of query.unions ?? []) {
+            for (const branch of union.branches) {
+                this.collectQueryGraphTerms(branch, graphTerms, graphVariables);
+            }
+        }
+        for (const minus of query.minus ?? []) {
+            this.collectQueryGraphTerms(minus, graphTerms, graphVariables);
+        }
+        for (const exists of query.exists ?? []) {
+            this.collectQueryGraphTerms(exists, graphTerms, graphVariables);
+        }
+    }
+    collectGraphVariableFilterTerms(query, graphVariables, graphTerms) {
+        for (const filter of query.filters ?? []) {
+            if (!graphVariables.has(filter.variable)) {
+                continue;
+            }
+            if (filter.value && this.isRdfTerm(filter.value)) {
+                graphTerms.push(filter.value);
+            }
+            for (const value of filter.values ?? []) {
+                if (this.isRdfTerm(value)) {
+                    graphTerms.push(value);
+                }
+            }
+        }
+        this.collectGraphVariableValueTerms(query.values ?? [], graphVariables, graphTerms);
+        for (const optional of query.optional ?? []) {
+            if (!Array.isArray(optional)) {
+                this.collectGraphVariableFilterTerms(optional, graphVariables, graphTerms);
+            }
+        }
+        for (const union of query.unions ?? []) {
+            for (const branch of union.branches) {
+                this.collectGraphVariableFilterTerms(branch, graphVariables, graphTerms);
+            }
+        }
+        for (const minus of query.minus ?? []) {
+            this.collectGraphVariableFilterTerms(minus, graphVariables, graphTerms);
+        }
+        for (const exists of query.exists ?? []) {
+            this.collectGraphVariableFilterTerms(exists, graphVariables, graphTerms);
+        }
+    }
+    collectGraphVariableFilterIris(query, variable, values) {
+        for (const filter of query.filters ?? []) {
+            if (filter.variable !== variable) {
+                continue;
+            }
+            if ((filter.operator === '$eq' || filter.operator === '$sameTerm') && filter.value && this.isRdfTerm(filter.value)) {
+                this.addGraphFilterValueIri(filter.value, values);
+            }
+            if (filter.operator === '$in') {
+                for (const value of filter.values ?? []) {
+                    if (this.isRdfTerm(value)) {
+                        this.addGraphFilterValueIri(value, values);
+                    }
+                }
+            }
+        }
+        this.collectGraphVariableValueIris(query.values ?? [], variable, values);
         for (const optional of query.optional ?? []) {
-            patterns.push(...(Array.isArray(optional) ? optional : optional.patterns));
+            if (!Array.isArray(optional)) {
+                this.collectGraphVariableFilterIris(optional, variable, values);
+            }
         }
         for (const union of query.unions ?? []) {
             for (const branch of union.branches) {
-                patterns.push(...branch.patterns);
-                for (const optional of branch.optional ?? []) {
-                    patterns.push(...(Array.isArray(optional) ? optional : optional.patterns));
+                this.collectGraphVariableFilterIris(branch, variable, values);
+            }
+        }
+        for (const minus of query.minus ?? []) {
+            this.collectGraphVariableFilterIris(minus, variable, values);
+        }
+        for (const exists of query.exists ?? []) {
+            this.collectGraphVariableFilterIris(exists, variable, values);
+        }
+    }
+    collectGraphVariableValueTerms(sources, graphVariables, graphTerms) {
+        for (const source of sources) {
+            for (const variable of source.variables) {
+                if (!graphVariables.has(variable)) {
+                    continue;
+                }
+                for (const row of source.rows) {
+                    const value = row[variable];
+                    if (value) {
+                        graphTerms.push(value);
+                    }
                 }
             }
         }
-        return patterns.flatMap((pattern) => pattern.graph ? [pattern.graph] : []);
     }
-    async readLocalRdfTextOrEmpty(identifier) {
+    collectGraphVariableValueIris(sources, variable, values) {
+        for (const source of sources) {
+            if (!source.variables.includes(variable)) {
+                continue;
+            }
+            for (const row of source.rows) {
+                const value = row[variable];
+                if (value) {
+                    this.addGraphFilterValueIri(value, values);
+                }
+            }
+        }
+    }
+    addGraphFilterValueIri(value, values) {
+        if (value.termType !== 'NamedNode') {
+            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update GRAPH variable write targets must be named graph documents');
+        }
+        values.add(value.value);
+    }
+    addNamedGraphIris(graph, graphIris) {
+        if (this.isRdfTerm(graph)) {
+            if (graph.termType !== 'NamedNode') {
+                throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports named graph documents');
+            }
+            graphIris.add(graph.value);
+            return;
+        }
+        const values = graph.$in;
+        if (Array.isArray(values) && values.every((value) => this.isRdfTerm(value))) {
+            for (const value of values) {
+                if (value.termType !== 'NamedNode') {
+                    throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports named graph documents');
+                }
+                graphIris.add(value.value);
+            }
+            return;
+        }
+        if (this.isQueryVariable(graph)) {
+            return;
+        }
+        throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports explicit local RDF graph documents');
+    }
+    addWritableNamedGraphIri(graph, graphIris) {
+        if (!this.isRdfTerm(graph) || graph.termType !== 'NamedNode') {
+            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports explicit local RDF graph write targets');
+        }
+        if (!this.isByLineRdfIdentifier({ path: graph.value })) {
+            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports by-line local RDF graph write targets');
+        }
+        graphIris.add(graph.value);
+    }
+    isQueryVariable(value) {
+        return Boolean(value && typeof value === 'object' && 'variable' in value);
+    }
+    isRdfTerm(value) {
+        return Boolean(value && typeof value === 'object' && 'termType' in value);
+    }
+    async readLocalRdfState(identifier) {
         try {
-            return await this.readStreamText(await this.rdfFileDataAccessor.getData(identifier));
+            return {
+                text: await this.readStreamText(await this.rdfFileDataAccessor.getData(identifier)),
+                existed: true,
+            };
         }
         catch (error) {
             if (community_server_1.NotFoundHttpError.isInstance(error)) {
                 await this.refreshLocalRdfMirror(identifier);
                 try {
-                    return await this.readStreamText(await this.rdfFileDataAccessor.getData(identifier));
+                    return {
+                        text: await this.readStreamText(await this.rdfFileDataAccessor.getData(identifier)),
+                        existed: true,
+                    };
                 }
                 catch (retryError) {
                     if (community_server_1.NotFoundHttpError.isInstance(retryError)) {
-                        return '';
+                        return { text: '', existed: false };
                     }
                     throw retryError;
                 }
@@ -336,6 +594,54 @@ class MixDataAccessor {
         await this.ensureRdfFileParentContainers(identifier);
         await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([await this.serializeQuadsForLocalFile(identifier, quads)])), this.createLocalRdfMetadata(identifier, new community_server_1.RepresentationMetadata(identifier)));
     }
+    async writeLocalRdfAuthorityPatches(patches) {
+        const applied = [];
+        try {
+            for (const patch of patches) {
+                let localAuthorityWritten = false;
+                try {
+                    const authorityQuads = patch.nextQuads.map((quad) => this.toDefaultGraphQuad(quad));
+                    await this.writeLocalRdfAuthority(patch.identifier, authorityQuads);
+                    localAuthorityWritten = true;
+                    await this.writeStructuredRdfIndex(patch.identifier, authorityQuads, new community_server_1.RepresentationMetadata(patch.identifier));
+                    applied.push(patch);
+                }
+                catch (error) {
+                    if (localAuthorityWritten) {
+                        applied.push(patch);
+                    }
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            await this.rollbackLocalRdfAuthorityPatches(applied);
+            throw error;
+        }
+    }
+    async rollbackLocalRdfAuthorityPatches(patches) {
+        const failures = [];
+        for (const patch of patches.slice().reverse()) {
+            try {
+                if (patch.previousExists) {
+                    const authorityQuads = patch.previousQuads.map((quad) => this.toDefaultGraphQuad(quad));
+                    await this.writeLocalRdfAuthority(patch.identifier, authorityQuads);
+                    await this.writeStructuredRdfIndex(patch.identifier, authorityQuads, new community_server_1.RepresentationMetadata(patch.identifier));
+                }
+                else {
+                    await this.deleteRdfFileResourceIfPresent(patch.identifier);
+                    await this.deleteLocalRdfIndex(patch.identifier);
+                }
+                this.invalidateMetadataCache(patch.identifier);
+            }
+            catch (rollbackError) {
+                failures.push(`${patch.identifier.path}: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+            }
+        }
+        if (failures.length > 0) {
+            this.logger.warn(`Failed to fully roll back local RDF authority patch: ${failures.join('; ')}`);
+        }
+    }
     toDefaultGraphQuad(quad) {
         return n3_1.DataFactory.quad(quad.subject, quad.predicate, quad.object);
     }
@@ -447,9 +753,18 @@ class MixDataAccessor {
         }
     }
     async getExistingLocalRdfMetadata(identifier) {
-        const metadata = await this.rdfFileDataAccessor.getMetadata(identifier);
-        metadata.contentType = this.localRdfContentType(identifier);
-        return metadata;
+        try {
+            const metadata = await this.rdfFileDataAccessor.getMetadata(identifier);
+            metadata.contentType = this.localRdfContentType(identifier);
+            return metadata;
+        }
+        catch (error) {
+            if (community_server_1.NotFoundHttpError.isInstance(error)) {
+                throw error;
+            }
+            this.logger.warn(`Ignoring unreadable local RDF metadata for ${identifier.path}: ${error instanceof Error ? error.message : String(error)}`);
+            return this.createLocalRdfMetadata(identifier, new community_server_1.RepresentationMetadata(identifier));
+        }
     }
     createLocalRdfMetadata(identifier, metadata) {
         const localMetadata = new community_server_1.RepresentationMetadata(metadata);