@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/storage/accessors/MixDataAccessor.jsonld

@@ -0,0 +1,101 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^8.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@undefineds.co/xpod",
+  "components": [
+    {
+      "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor",
+      "@type": "Class",
+      "requireElement": "MixDataAccessor",
+      "extends": [
+        "css:dist/storage/accessors/DataAccessor.jsonld#DataAccessor"
+      ],
+      "comment": "MixDataAccessor - Routes data to appropriate storage based on content type  - RDF data (internal/quads) -> structuredDataAccessor (Quadstore or QuintStore) - Other data (binary, text, etc.) -> unstructuredDataAccessor (FileSystem, Minio, etc.)  This uses composition instead of inheritance, allowing any DataAccessor to be used as the RDF storage backend.",
+      "parameters": [
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor_structuredDataAccessor",
+          "range": "css:dist/storage/accessors/DataAccessor.jsonld#DataAccessor"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor_unstructuredDataAccessor",
+          "range": "css:dist/storage/accessors/DataAccessor.jsonld#DataAccessor"
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_logger",
+          "memberFieldName": "logger",
+          "range": {
+            "@type": "ParameterRangeWildcard"
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_structuredDataAccessor",
+          "memberFieldName": "structuredDataAccessor"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_unstructuredDataAccessor",
+          "memberFieldName": "unstructuredDataAccessor"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_canHandle",
+          "memberFieldName": "canHandle"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_isUnstructured",
+          "memberFieldName": "isUnstructured"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_getData",
+          "memberFieldName": "getData"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_getMetadata",
+          "memberFieldName": "getMetadata"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_getChildren",
+          "memberFieldName": "getChildren"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_writeContainer",
+          "memberFieldName": "writeContainer"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_writeDocument",
+          "memberFieldName": "writeDocument"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_writeMetadata",
+          "memberFieldName": "writeMetadata"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_deleteResource",
+          "memberFieldName": "deleteResource"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_executeSparqlUpdate",
+          "memberFieldName": "executeSparqlUpdate"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_writeUnstructuredDocument",
+          "memberFieldName": "writeUnstructuredDocument"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor_structuredDataAccessor"
+        },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor_unstructuredDataAccessor"
+        }
+      ]
+    }
+  ]
+}

package/dist/storage/accessors/QuadstoreSparqlDataAccessor.d.ts

@@ -0,0 +1,146 @@
+import { Readable } from 'node:stream';
+import type { NamedNode } from '@rdfjs/types';
+import type { ConstructQuery } from 'sparqljs';
+import { DataAccessor, RepresentationMetadata, IdentifierStrategy, type Representation, type ResourceIdentifier, type Guarded } from '@solid/community-server';
+export declare class QuadstoreSparqlDataAccessor implements DataAccessor {
+    protected readonly logger: import("global-logger-factory").Logger<unknown>;
+    private readonly endpoint;
+    private readonly publicEndpoint;
+    private readonly identifierStrategy;
+    private readonly store;
+    private readonly engine;
+    private readonly generator;
+    constructor(endpoint: string, identifierStrategy: IdentifierStrategy);
+    /**
+     * Get the public endpoint from the given endpoint.
+     */
+    private getPublicEndpoint;
+    /**
+     * Only Quad data streams are supported.
+     */
+    canHandle(representation: Representation): Promise<void>;
+    /**
+     * Returns all triples stored for the corresponding identifier.
+     * Note that this will not throw a 404 if no results were found.
+     */
+    getData(identifier: ResourceIdentifier): Promise<Guarded<Readable>>;
+    /**
+     * Returns the metadata for the corresponding identifier.
+     * Will throw 404 if no metadata was found.
+     */
+    getMetadata(identifier: ResourceIdentifier): Promise<RepresentationMetadata>;
+    getChildren(identifier: ResourceIdentifier): AsyncIterableIterator<RepresentationMetadata>;
+    /**
+     * Writes the given metadata for the container.
+     */
+    writeContainer(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
+    /**
+     * Reads the given data stream and stores it together with the metadata.
+     */
+    writeDocument(identifier: ResourceIdentifier, data: Guarded<Readable>, metadata: RepresentationMetadata): Promise<void>;
+    /**
+     * Reads the metadata and stores it.
+     */
+    writeMetadata(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
+    /**
+     * Removes all graph data relevant to the given identifier.
+     */
+    deleteResource(identifier: ResourceIdentifier): Promise<void>;
+    /**
+     * Helper function to get named nodes corresponding to the identifier and its parent container.
+     * In case of a root container only the name will be returned.
+     */
+    private getRelatedNames;
+    /**
+     * Creates the name for the metadata of a resource.
+     *
+     * @param name - Name of the (non-metadata) resource.
+     */
+    protected getMetadataNode(name: NamedNode): NamedNode;
+    /**
+     * Checks if the given identifier corresponds to the names used for metadata identifiers.
+     */
+    private isMetadataIdentifier;
+    /**
+     * Creates a CONSTRUCT query that returns all quads contained within a single resource.
+     *
+     * @param name - Name of the resource to query.
+     */
+    protected sparqlConstruct(name: NamedNode): ConstructQuery;
+    private sparqlSelectGraph;
+    /**
+     * Creates an update query that overwrites the data and metadata of a resource.
+     * If there are no triples we assume it's a container (so don't overwrite the main graph with containment triples).
+     *
+     * @param name - Name of the resource to update.
+     * @param metadata - New metadata of the resource.
+     * @param parent - Name of the parent to update the containment triples.
+     * @param triples - New data of the resource.
+     */
+    private sparqlInsert;
+    /**
+     * Creates an update query that overwrites metadata of a resource.
+     *
+     * @param metaName - Name of the metadata resource to update.
+     * @param metadata - New metadata of the resource.
+     */
+    private sparqlInsertMetadata;
+    /**
+     * Creates a query that deletes everything related to the given name.
+     *
+     * @param name - Name of resource to delete.
+     * @param parent - Parent of the resource to delete so the containment triple can be removed (unless root).
+     */
+    private sparqlDelete;
+    /**
+     * Helper function for creating SPARQL update queries.
+     * Creates an operation for deleting all triples in a graph.
+     *
+     * @param name - Name of the graph to delete.
+     */
+    private sparqlUpdateDeleteAll;
+    /**
+     * Helper function for creating SPARQL update queries.
+     * Creates a Graph selector with the given triples.
+     *
+     * @param name - Name of the graph.
+     * @param triples - Triples/triple patterns to select.
+     */
+    private sparqlUpdateGraph;
+    /**
+     * Sends a SPARQL CONSTRUCT query to the endpoint and returns a stream of quads.
+     *
+     * @param sparqlQuery - Query to execute.
+     */
+    protected sendSparqlConstruct(sparqlQuery: ConstructQuery): Promise<Guarded<Readable>>;
+    /**
+     * Sends a SPARQL update query to the stored endpoint.
+     *
+     * @param sparqlQuery - Query to send.
+     */
+    private sendSparqlUpdate;
+    /**
+     * Execute an arbitrary SPARQL UPDATE string.
+     */
+    executeSparqlUpdate(query: string, baseIri?: string): Promise<void>;
+    /**
+     * Execute a SPARQL SELECT query and return bindings as plain objects.
+     */
+    executeSparqlSelect(query: string): Promise<Record<string, string>[]>;
+    /**
+     * Execute a SPARQL ASK query.
+     */
+    executeSparqlAsk(query: string): Promise<boolean>;
+    /**
+     * Execute a raw CONSTRUCT query string.
+     */
+    executeSparqlConstruct(query: string): Promise<Guarded<Readable>>;
+    /**
+     * Wait for the store to be ready.
+     */
+    private waitForStoreReady;
+    /**
+     * Closes the underlying store.
+     */
+    close(): Promise<void>;
+}

package/dist/storage/accessors/QuadstoreSparqlDataAccessor.js

@@ -0,0 +1,415 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuadstoreSparqlDataAccessor = void 0;
+const node_stream_1 = require("node:stream");
+const global_logger_factory_1 = require("global-logger-factory");
+const arrayify_stream_1 = __importDefault(require("arrayify-stream"));
+const n3_1 = require("n3");
+const sparqljs_1 = require("sparqljs");
+const community_server_1 = require("@solid/community-server");
+const quadstore_1 = require("quadstore");
+const quadstore_comunica_1 = require("quadstore-comunica");
+const index_1 = require("../../libs/backends/index");
+const { defaultGraph, namedNode, quad, variable } = n3_1.DataFactory;
+class QuadstoreSparqlDataAccessor {
+    constructor(endpoint, identifierStrategy) {
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.endpoint = endpoint;
+        this.publicEndpoint = this.getPublicEndpoint(endpoint);
+        this.identifierStrategy = identifierStrategy;
+        this.generator = new sparqljs_1.Generator();
+        const backend = (0, index_1.getBackend)(endpoint, { tableName: 'quadstore' });
+        this.store = new quadstore_1.Quadstore({
+            backend: backend,
+            dataFactory: n3_1.DataFactory,
+        });
+        this.engine = new quadstore_comunica_1.Engine(this.store);
+    }
+    /**
+     * Get the public endpoint from the given endpoint.
+     */
+    getPublicEndpoint(endpoint) {
+        if (endpoint.startsWith('sqlite:')) {
+            return endpoint;
+        }
+        const url = new URL(endpoint);
+        const host = url.host.split(':')[0];
+        return `${url.protocol}//${host}`;
+    }
+    /**
+     * Only Quad data streams are supported.
+     */
+    async canHandle(representation) {
+        if (representation.binary || representation.metadata.contentType !== community_server_1.INTERNAL_QUADS) {
+            throw new community_server_1.UnsupportedMediaTypeHttpError('Only Quad data is supported.');
+        }
+    }
+    /**
+     * Returns all triples stored for the corresponding identifier.
+     * Note that this will not throw a 404 if no results were found.
+     */
+    async getData(identifier) {
+        const name = namedNode(identifier.path);
+        return this.sendSparqlConstruct(this.sparqlConstruct(name));
+    }
+    /**
+     * Returns the metadata for the corresponding identifier.
+     * Will throw 404 if no metadata was found.
+     */
+    async getMetadata(identifier) {
+        const name = namedNode(identifier.path);
+        const query = this.sparqlConstruct(this.getMetadataNode(name));
+        const stream = await this.sendSparqlConstruct(query);
+        const quads = await (0, arrayify_stream_1.default)(stream);
+        if (quads.length === 0) {
+            throw new community_server_1.NotFoundHttpError();
+        }
+        const metadata = new community_server_1.RepresentationMetadata(identifier).addQuads(quads);
+        if (!(0, community_server_1.isContainerIdentifier)(identifier)) {
+            metadata.contentType = community_server_1.INTERNAL_QUADS;
+        }
+        return metadata;
+    }
+    async *getChildren(identifier) {
+        // Only triples that have a container identifier as subject are the containment triples
+        const name = namedNode(identifier.path);
+        const stream = await this.sendSparqlConstruct(this.sparqlConstruct(name));
+        for await (const entry of stream) {
+            yield new community_server_1.RepresentationMetadata(entry.object);
+        }
+    }
+    /**
+     * Writes the given metadata for the container.
+     */
+    async writeContainer(identifier, metadata) {
+        (0, community_server_1.addResourceMetadata)(metadata, true);
+        (0, community_server_1.updateModifiedDate)(metadata);
+        const { name, parent } = this.getRelatedNames(identifier);
+        return this.sendSparqlUpdate(this.sparqlInsert(name, metadata, parent));
+    }
+    /**
+     * Reads the given data stream and stores it together with the metadata.
+     */
+    async writeDocument(identifier, data, metadata) {
+        if (this.isMetadataIdentifier(identifier)) {
+            throw new community_server_1.ConflictHttpError('Not allowed to create NamedNodes with the metadata extension.');
+        }
+        const { name, parent } = this.getRelatedNames(identifier);
+        const triples = await (0, arrayify_stream_1.default)(data);
+        const def = defaultGraph();
+        if (triples.some((triple) => !def.equals(triple.graph))) {
+            throw new community_server_1.NotImplementedHttpError('Only triples in the default graph are supported.');
+        }
+        // Not relevant since all content is triples
+        metadata.removeAll(community_server_1.CONTENT_TYPE_TERM);
+        return this.sendSparqlUpdate(this.sparqlInsert(name, metadata, parent, triples));
+    }
+    /**
+     * Reads the metadata and stores it.
+     */
+    async writeMetadata(identifier, metadata) {
+        const { name } = this.getRelatedNames(identifier);
+        const metaName = this.getMetadataNode(name);
+        return this.sendSparqlUpdate(this.sparqlInsertMetadata(metaName, metadata));
+    }
+    /**
+     * Removes all graph data relevant to the given identifier.
+     */
+    async deleteResource(identifier) {
+        const { name, parent } = this.getRelatedNames(identifier);
+        return this.sendSparqlUpdate(this.sparqlDelete(name, parent));
+    }
+    /**
+     * Helper function to get named nodes corresponding to the identifier and its parent container.
+     * In case of a root container only the name will be returned.
+     */
+    getRelatedNames(identifier) {
+        const name = namedNode(identifier.path);
+        // Root containers don't have a parent
+        if (this.identifierStrategy.isRootContainer(identifier)) {
+            return { name };
+        }
+        const parentIdentifier = this.identifierStrategy.getParentContainer(identifier);
+        const parent = namedNode(parentIdentifier.path);
+        return { name, parent };
+    }
+    /**
+     * Creates the name for the metadata of a resource.
+     *
+     * @param name - Name of the (non-metadata) resource.
+     */
+    getMetadataNode(name) {
+        return namedNode(`meta:${name.value}`);
+    }
+    /**
+     * Checks if the given identifier corresponds to the names used for metadata identifiers.
+     */
+    isMetadataIdentifier(identifier) {
+        return identifier.path.startsWith('meta:');
+    }
+    /**
+     * Creates a CONSTRUCT query that returns all quads contained within a single resource.
+     *
+     * @param name - Name of the resource to query.
+     */
+    sparqlConstruct(name) {
+        const pattern = quad(variable('s'), variable('p'), variable('o'));
+        return {
+            queryType: 'CONSTRUCT',
+            template: [pattern],
+            where: [this.sparqlSelectGraph(name, [pattern])],
+            type: 'query',
+            prefixes: {},
+        };
+    }
+    sparqlSelectGraph(name, triples) {
+        return {
+            type: 'graph',
+            name,
+            patterns: [{ type: 'bgp', triples }],
+        };
+    }
+    /**
+     * Creates an update query that overwrites the data and metadata of a resource.
+     * If there are no triples we assume it's a container (so don't overwrite the main graph with containment triples).
+     *
+     * @param name - Name of the resource to update.
+     * @param metadata - New metadata of the resource.
+     * @param parent - Name of the parent to update the containment triples.
+     * @param triples - New data of the resource.
+     */
+    sparqlInsert(name, metadata, parent, triples) {
+        const metaName = this.getMetadataNode(name);
+        // Insert new metadata and containment triple
+        const insert = [this.sparqlUpdateGraph(metaName, metadata.quads())];
+        if (parent) {
+            insert.push(this.sparqlUpdateGraph(parent, [quad(parent, community_server_1.LDP.terms.contains, name)]));
+        }
+        // Necessary updates: delete metadata and insert new data
+        const updates = [
+            this.sparqlUpdateDeleteAll(metaName),
+            {
+                updateType: 'insert',
+                insert,
+            },
+        ];
+        // Only overwrite data triples for documents
+        if (triples) {
+            // This needs to be first so it happens before the insert
+            updates.unshift(this.sparqlUpdateDeleteAll(name));
+            if (triples.length > 0) {
+                insert.push(this.sparqlUpdateGraph(name, triples));
+            }
+        }
+        return {
+            updates,
+            type: 'update',
+            prefixes: {},
+        };
+    }
+    /**
+     * Creates an update query that overwrites metadata of a resource.
+     *
+     * @param metaName - Name of the metadata resource to update.
+     * @param metadata - New metadata of the resource.
+     */
+    sparqlInsertMetadata(metaName, metadata) {
+        // Insert new metadata and containment triple
+        const insert = [this.sparqlUpdateGraph(metaName, metadata.quads())];
+        // Necessary updates: delete metadata and insert new data
+        const updates = [
+            this.sparqlUpdateDeleteAll(metaName),
+            {
+                updateType: 'insert',
+                insert,
+            },
+        ];
+        return {
+            updates,
+            type: 'update',
+            prefixes: {},
+        };
+    }
+    /**
+     * Creates a query that deletes everything related to the given name.
+     *
+     * @param name - Name of resource to delete.
+     * @param parent - Parent of the resource to delete so the containment triple can be removed (unless root).
+     */
+    sparqlDelete(name, parent) {
+        const update = {
+            updates: [
+                this.sparqlUpdateDeleteAll(name),
+                this.sparqlUpdateDeleteAll(this.getMetadataNode(name)),
+            ],
+            type: 'update',
+            prefixes: {},
+        };
+        if (parent) {
+            update.updates.push({
+                updateType: 'delete',
+                delete: [
+                    this.sparqlUpdateGraph(parent, [quad(parent, community_server_1.LDP.terms.contains, name)])
+                ],
+            });
+        }
+        return update;
+    }
+    /**
+     * Helper function for creating SPARQL update queries.
+     * Creates an operation for deleting all triples in a graph.
+     *
+     * @param name - Name of the graph to delete.
+     */
+    sparqlUpdateDeleteAll(name) {
+        return {
+            updateType: 'deletewhere',
+            delete: [
+                this.sparqlUpdateGraph(name, [quad(variable(`s`), variable(`p`), variable(`o`))])
+            ],
+        };
+    }
+    /**
+     * Helper function for creating SPARQL update queries.
+     * Creates a Graph selector with the given triples.
+     *
+     * @param name - Name of the graph.
+     * @param triples - Triples/triple patterns to select.
+     */
+    sparqlUpdateGraph(name, triples) {
+        return { type: 'graph', name, triples };
+    }
+    /**
+     * Sends a SPARQL CONSTRUCT query to the endpoint and returns a stream of quads.
+     *
+     * @param sparqlQuery - Query to execute.
+     */
+    async sendSparqlConstruct(sparqlQuery) {
+        const query = this.generator.stringify(sparqlQuery);
+        const logger = this.logger;
+        logger.verbose(`Sending SPARQL CONSTRUCT query to ${this.publicEndpoint}: ${query}`);
+        try {
+            await this.waitForStoreReady();
+            const start = Date.now();
+            const result = await this.engine.queryQuads(query);
+            const end = Date.now();
+            logger.verbose(`SPARQL CONSTRUCT query success. cost time: ${end - start}ms`);
+            const readable = new node_stream_1.Readable({ objectMode: true, read() { } });
+            result.on('start', () => {
+            });
+            result.on('data', (chunk) => {
+                readable.push(chunk);
+            });
+            result.on('end', () => {
+                readable.push(null);
+            });
+            result.on('error', (error) => {
+                logger.error(`SPARQL CONSTRUCT stream error: ${error}`);
+                readable.emit('error', error);
+            });
+            return (0, community_server_1.guardStream)(readable);
+        }
+        catch (error) {
+            logger.error(`SPARQL ${query} endpoint ${this.publicEndpoint} error: ${(0, community_server_1.createErrorMessage)(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Sends a SPARQL update query to the stored endpoint.
+     *
+     * @param sparqlQuery - Query to send.
+     */
+    async sendSparqlUpdate(sparqlQuery) {
+        const query = this.generator.stringify(sparqlQuery);
+        this.logger.verbose(`Sending SPARQL UPDATE query to ${this.publicEndpoint}: ${query}`);
+        try {
+            await this.waitForStoreReady();
+            const start = Date.now();
+            await this.engine.queryVoid(query);
+            const end = Date.now();
+            this.logger.verbose(`SPARQL UPDATE query success. cost time: ${end - start}ms`);
+        }
+        catch (error) {
+            this.logger.error(`SPARQL ${query} endpoint ${this.publicEndpoint} error: ${(0, community_server_1.createErrorMessage)(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Execute an arbitrary SPARQL UPDATE string.
+     */
+    async executeSparqlUpdate(query, baseIri) {
+        this.logger.verbose(`Executing SPARQL UPDATE on ${this.publicEndpoint}: ${query}`);
+        await this.waitForStoreReady();
+        await this.engine.queryVoid(query, { baseIRI: baseIri });
+    }
+    /**
+     * Execute a SPARQL SELECT query and return bindings as plain objects.
+     */
+    async executeSparqlSelect(query) {
+        this.logger.verbose(`Executing SPARQL SELECT on ${this.publicEndpoint}: ${query}`);
+        await this.waitForStoreReady();
+        const bindingsStream = await this.engine.queryBindings(query);
+        const results = [];
+        const iterable = bindingsStream;
+        for await (const binding of iterable) {
+            const row = {};
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore Comunica bindings expose Map-like iteration
+            for (const [key, value] of binding) {
+                row[key] = value.value;
+            }
+            results.push(row);
+        }
+        return results;
+    }
+    /**
+     * Execute a SPARQL ASK query.
+     */
+    async executeSparqlAsk(query) {
+        this.logger.verbose(`Executing SPARQL ASK on ${this.publicEndpoint}: ${query}`);
+        await this.waitForStoreReady();
+        return this.engine.queryBoolean(query);
+    }
+    /**
+     * Execute a raw CONSTRUCT query string.
+     */
+    async executeSparqlConstruct(query) {
+        this.logger.verbose(`Executing SPARQL CONSTRUCT on ${this.publicEndpoint}: ${query}`);
+        await this.waitForStoreReady();
+        const result = await this.engine.queryQuads(query);
+        const readable = new node_stream_1.Readable({ objectMode: true, read() { } });
+        // Register event listeners once, outside of read() to avoid memory leak
+        result.on('data', (quad) => {
+            readable.push(quad);
+        });
+        result.on('end', () => {
+            readable.push(null);
+        });
+        result.on('error', (error) => {
+            readable.emit('error', error);
+        });
+        return (0, community_server_1.guardStream)(readable);
+    }
+    /**
+     * Wait for the store to be ready.
+     */
+    async waitForStoreReady() {
+        if (this.store.db.status !== 'open' && this.store.db.status !== 'opening') {
+            throw new Error('Store is not open');
+        }
+        while (this.store.db.status !== 'open') {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+    /**
+     * Closes the underlying store.
+     */
+    async close() {
+        await this.store.close();
+    }
+}
+exports.QuadstoreSparqlDataAccessor = QuadstoreSparqlDataAccessor;
+//# sourceMappingURL=QuadstoreSparqlDataAccessor.js.map