@undefineds.co/xpod 0.3.75 → 0.4.0-rc.139

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

@@ -1,102 +0,0 @@
-/**
- * QuintStoreSparqlDataAccessor - Data accessor using QuintStore
- *
- * Key features:
- * 1. Graph prefix filtering for efficient subgraph queries
- * 2. Backend-agnostic storage (SQLite, PostgreSQL, etc.)
- * 3. Future: vector similarity search
- */
-import { Readable } from 'node:stream';
-import type { NamedNode, Quad } from '@rdfjs/types';
-import type { ConstructQuery } from 'sparqljs';
-import { DataAccessor, RepresentationMetadata, IdentifierStrategy, type Representation, type ResourceIdentifier, type Guarded } from '@solid/community-server';
-import type { QuintStore, Quint } from '../quint/types';
-import type { RdfSourceInput } from '../rdf/types';
-export declare class QuintStoreSparqlDataAccessor implements DataAccessor {
-    protected readonly logger: import("global-logger-factory").Logger<unknown>;
-    private readonly identifierStrategy;
-    private readonly store;
-    private readonly engine;
-    private readonly generator;
-    private readonly baseUrl;
-    private initialized;
-    private initializing;
-    constructor(store: QuintStore, identifierStrategy: IdentifierStrategy);
-    /**
-     * Initialize the store (open database connection)
-     */
-    initialize(): Promise<void>;
-    private initializeStore;
-    /**
-     * Close the store
-     */
-    finalize(): Promise<void>;
-    /**
-     * Only Quad data streams are supported.
-     */
-    canHandle(representation: Representation): Promise<void>;
-    /**
-     * Returns all triples stored for the corresponding identifier.
-     */
-    getData(identifier: ResourceIdentifier): Promise<Guarded<Readable>>;
-    /**
-     * Returns the metadata for the corresponding identifier.
-     */
-    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>;
-    writeRdfSourceDocument(identifier: ResourceIdentifier, quads: Quad[], metadata: RepresentationMetadata, source: RdfSourceInput): Promise<void>;
-    deleteRdfSourceDocument(identifier: ResourceIdentifier): 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>;
-    /**
-     * Get data with graph prefix filtering (key feature!)
-     * This is much more efficient than full SPARQL for subgraph queries.
-     */
-    getDataByGraphPrefix(prefix: string): Promise<Quint[]>;
-    /**
-     * Execute SPARQL query with graph prefix filtering
-     */
-    queryWithGraphPrefix(query: string, graphPrefix: string): Promise<Quad[]>;
-    private getRelatedNames;
-    protected getMetadataNode(name: NamedNode): NamedNode;
-    private isMetadataIdentifier;
-    protected sparqlConstruct(name: NamedNode): ConstructQuery;
-    private sparqlSelectGraph;
-    private sparqlSelectGraphAsQuads;
-    /**
-     * Creates an update query that overwrites the data and metadata of a resource.
-     * If triples is undefined, we assume it's a container (so don't overwrite the main graph with containment triples).
-     * This follows the same pattern as CSS's SparqlDataAccessor.
-     *
-     * @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 (undefined for containers).
-     */
-    private sparqlInsert;
-    private sparqlInsertMetadata;
-    private sparqlDelete;
-    private sendSparqlConstruct;
-    private sendSparqlUpdate;
-    private sourceScopedStore;
-    private replaceCompatibilityMetadata;
-    /**
-     * Execute a SPARQL UPDATE query string directly.
-     * Used by SparqlUpdateResourceStore for LDP PATCH operations.
-     */
-    executeSparqlUpdate(query: string, baseIri?: string): Promise<void>;
-}

package/dist/storage/accessors/QuintStoreSparqlDataAccessor.js

@@ -1,474 +0,0 @@
-"use strict";
-/**
- * QuintStoreSparqlDataAccessor - Data accessor using QuintStore
- *
- * Key features:
- * 1. Graph prefix filtering for efficient subgraph queries
- * 2. Backend-agnostic storage (SQLite, PostgreSQL, etc.)
- * 3. Future: vector similarity search
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuintStoreSparqlDataAccessor = void 0;
-const global_logger_factory_1 = require("global-logger-factory");
-const node_stream_1 = require("node:stream");
-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 { defaultGraph, namedNode, quad, variable } = n3_1.DataFactory;
-class QuintStoreSparqlDataAccessor {
-    constructor(store, identifierStrategy) {
-        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
-        this.initialized = false;
-        this.initializing = null;
-        this.store = store;
-        this.identifierStrategy = identifierStrategy;
-        this.generator = new sparqljs_1.Generator();
-        this.engine = Promise.resolve().then(() => __importStar(require('../sparql/ComunicaQuintEngine'))).then(({ ComunicaQuintEngine }) => new ComunicaQuintEngine(this.store));
-        // Get baseUrl from identifierStrategy
-        const strategy = identifierStrategy;
-        this.baseUrl = strategy.baseUrl ?? '';
-        this.logger.info(`QuintStoreSparqlDataAccessor initialized with identifierStrategy: ${identifierStrategy.constructor.name}, baseUrl: ${this.baseUrl || 'N/A'}`);
-    }
-    /**
-     * Initialize the store (open database connection)
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        this.initializing ??= this.initializeStore().finally(() => {
-            this.initializing = null;
-        });
-        await this.initializing;
-    }
-    async initializeStore() {
-        await this.store.open();
-        this.initialized = true;
-        this.logger.info('QuintStore initialized');
-    }
-    /**
-     * Close the store
-     */
-    async finalize() {
-        if (this.initializing) {
-            await this.initializing.catch(() => { });
-        }
-        if (this.initialized) {
-            await this.store.close();
-            this.initialized = false;
-            this.logger.info('QuintStore closed');
-        }
-    }
-    /**
-     * 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.
-     */
-    async getData(identifier) {
-        await this.initialize();
-        const name = namedNode(identifier.path);
-        return this.sendSparqlConstruct(this.sparqlConstruct(name));
-    }
-    /**
-     * Returns the metadata for the corresponding identifier.
-     */
-    async getMetadata(identifier) {
-        console.log(`[getMetadata] Starting for ${identifier.path}`);
-        await this.initialize();
-        const name = namedNode(identifier.path);
-        const query = this.sparqlConstruct(this.getMetadataNode(name));
-        console.log(`[getMetadata] Sending CONSTRUCT for ${identifier.path}`);
-        const stream = await this.sendSparqlConstruct(query);
-        console.log(`[getMetadata] Got stream for ${identifier.path}, reading...`);
-        const quads = await (0, arrayify_stream_1.default)(stream);
-        console.log(`[getMetadata] Read ${quads.length} quads for ${identifier.path}`);
-        if (quads.length === 0) {
-            throw new community_server_1.NotFoundHttpError();
-        }
-        const metadata = new community_server_1.RepresentationMetadata(identifier).addQuads(quads);
-        // Only set default contentType if not already present in metadata
-        if (!(0, community_server_1.isContainerIdentifier)(identifier) && !metadata.contentType) {
-            metadata.contentType = community_server_1.INTERNAL_QUADS;
-        }
-        return metadata;
-    }
-    async *getChildren(identifier) {
-        await this.initialize();
-        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) {
-        console.log(`[writeContainer] Starting for ${identifier.path}`);
-        await this.initialize();
-        (0, community_server_1.addResourceMetadata)(metadata, true);
-        (0, community_server_1.updateModifiedDate)(metadata);
-        const { name, parent } = this.getRelatedNames(identifier);
-        console.log(`[writeContainer] Sending SPARQL update for ${identifier.path}, parent: ${parent?.value || 'none'}`);
-        console.log(`[writeContainer] Metadata quads: ${metadata.quads().length}`);
-        const result = await this.sendSparqlUpdate(this.sparqlInsert(name, metadata, parent));
-        console.log(`[writeContainer] Completed for ${identifier.path}`);
-        return result;
-    }
-    /**
-     * Reads the given data stream and stores it together with the metadata.
-     */
-    async writeDocument(identifier, data, metadata) {
-        console.log(`[writeDocument] Starting for ${identifier.path}`);
-        await this.initialize();
-        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);
-        console.log(`[writeDocument] Reading stream for ${identifier.path}`);
-        // 添加超时处理
-        const timeoutMs = 5000;
-        const triplesPromise = (0, arrayify_stream_1.default)(data);
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`arrayifyStream timed out after ${timeoutMs}ms`)), timeoutMs);
-        });
-        let triples;
-        try {
-            triples = await Promise.race([triplesPromise, timeoutPromise]);
-            console.log(`[writeDocument] Read ${triples.length} triples for ${identifier.path}`);
-        }
-        catch (e) {
-            console.error(`[writeDocument] Failed to read stream for ${identifier.path}:`, e?.message || e);
-            throw e;
-        }
-        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.');
-        }
-        metadata.removeAll(community_server_1.CONTENT_TYPE_TERM);
-        console.log(`[writeDocument] Sending SPARQL update for ${identifier.path}`);
-        const result = await this.sendSparqlUpdate(this.sparqlInsert(name, metadata, parent, triples));
-        console.log(`[writeDocument] Completed for ${identifier.path}`);
-        return result;
-    }
-    async writeRdfSourceDocument(identifier, quads, metadata, source) {
-        await this.initialize();
-        const sourceScopedStore = this.sourceScopedStore();
-        if (!sourceScopedStore) {
-            await this.writeDocument(identifier, (0, community_server_1.guardStream)(node_stream_1.Readable.from(quads)), metadata);
-            return;
-        }
-        if (this.isMetadataIdentifier(identifier)) {
-            throw new community_server_1.ConflictHttpError('Not allowed to create NamedNodes with the metadata extension.');
-        }
-        const def = defaultGraph();
-        if (quads.some((triple) => !def.equals(triple.graph))) {
-            throw new community_server_1.NotImplementedHttpError('Only triples in the default graph are supported.');
-        }
-        metadata.removeAll(community_server_1.CONTENT_TYPE_TERM);
-        const { name, parent } = this.getRelatedNames(identifier);
-        await this.replaceCompatibilityMetadata(name, metadata, parent);
-        await sourceScopedStore.replaceSource(quads.map((value) => quad(value.subject, value.predicate, value.object, name)), source);
-    }
-    async deleteRdfSourceDocument(identifier) {
-        await this.initialize();
-        const sourceScopedStore = this.sourceScopedStore();
-        if (!sourceScopedStore) {
-            await this.deleteResource(identifier);
-            return;
-        }
-        const { name, parent } = this.getRelatedNames(identifier);
-        const metaName = this.getMetadataNode(name);
-        await sourceScopedStore.deleteSource(identifier.path);
-        await this.store.del({ graph: metaName });
-        if (parent) {
-            await this.store.del({
-                graph: parent,
-                subject: parent,
-                predicate: community_server_1.LDP.terms.contains,
-                object: name,
-            });
-        }
-    }
-    /**
-     * Reads the metadata and stores it.
-     */
-    async writeMetadata(identifier, metadata) {
-        await this.initialize();
-        const { name, parent } = this.getRelatedNames(identifier);
-        const metaName = this.getMetadataNode(name);
-        return this.sendSparqlUpdate(this.sparqlInsertMetadata(metaName, metadata, parent, name));
-    }
-    /**
-     * Removes all graph data relevant to the given identifier.
-     */
-    async deleteResource(identifier) {
-        await this.initialize();
-        const { name, parent } = this.getRelatedNames(identifier);
-        return this.sendSparqlUpdate(this.sparqlDelete(name, parent));
-    }
-    // ============================================
-    // QuintStore specific methods
-    // ============================================
-    /**
-     * Get data with graph prefix filtering (key feature!)
-     * This is much more efficient than full SPARQL for subgraph queries.
-     */
-    async getDataByGraphPrefix(prefix) {
-        await this.initialize();
-        return this.store.getByGraphPrefix(prefix);
-    }
-    /**
-     * Execute SPARQL query with graph prefix filtering
-     */
-    async queryWithGraphPrefix(query, graphPrefix) {
-        await this.initialize();
-        const stream = await (await this.engine).queryBindings(query, { graphPrefix });
-        return (0, arrayify_stream_1.default)(stream);
-    }
-    // ============================================
-    // Private helpers
-    // ============================================
-    getRelatedNames(identifier) {
-        const name = namedNode(identifier.path);
-        if (this.identifierStrategy.isRootContainer(identifier)) {
-            return { name };
-        }
-        const parentIdentifier = this.identifierStrategy.getParentContainer(identifier);
-        const parent = namedNode(parentIdentifier.path);
-        return { name, parent };
-    }
-    getMetadataNode(name) {
-        return namedNode(`meta:${name.value}`);
-    }
-    isMetadataIdentifier(identifier) {
-        return identifier.path.startsWith('meta:');
-    }
-    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 }],
-        };
-    }
-    sparqlSelectGraphAsQuads(name, triples) {
-        return this.sparqlSelectGraph(name, triples);
-    }
-    /**
-     * Creates an update query that overwrites the data and metadata of a resource.
-     * If triples is undefined, we assume it's a container (so don't overwrite the main graph with containment triples).
-     * This follows the same pattern as CSS's SparqlDataAccessor.
-     *
-     * @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 (undefined for containers).
-     */
-    sparqlInsert(name, metadata, parent, triples) {
-        const metaName = this.getMetadataNode(name);
-        // Insert new metadata and containment triple
-        const insert = [
-            {
-                type: 'graph',
-                name: metaName,
-                triples: metadata.quads(),
-            },
-        ];
-        if (parent) {
-            insert.push({
-                type: 'graph',
-                name: parent,
-                triples: [quad(parent, community_server_1.LDP.terms.contains, name)],
-            });
-        }
-        // Necessary updates: delete metadata and insert new data
-        const updates = [
-            // Always delete and reinsert metadata
-            {
-                updateType: 'deletewhere',
-                delete: [this.sparqlSelectGraphAsQuads(metaName, [quad(variable('s'), variable('p'), variable('o'))])],
-            },
-            {
-                updateType: 'insert',
-                insert,
-            },
-        ];
-        // Only overwrite data triples for documents (when triples is defined)
-        // For containers, we don't touch the data graph to preserve ldp:contains triples
-        if (triples !== undefined) {
-            // This needs to be first so it happens before the insert
-            updates.unshift({
-                updateType: 'deletewhere',
-                delete: [this.sparqlSelectGraphAsQuads(name, [quad(variable('s'), variable('p'), variable('o'))])],
-            });
-            if (triples.length > 0) {
-                insert.push({
-                    type: 'graph',
-                    name,
-                    triples,
-                });
-            }
-        }
-        return {
-            type: 'update',
-            updates,
-            prefixes: {},
-        };
-    }
-    sparqlInsertMetadata(metaName, metadata, parent, name) {
-        const metaGraphs = {
-            type: 'graph',
-            name: metaName,
-            triples: metadata.quads(),
-        };
-        const insert = [metaGraphs];
-        if (parent && name) {
-            insert.push({
-                type: 'graph',
-                name: parent,
-                triples: [quad(parent, community_server_1.LDP.terms.contains, name)],
-            });
-        }
-        const deleteOp = {
-            updateType: 'deletewhere',
-            delete: [this.sparqlSelectGraphAsQuads(metaName, [quad(variable('s'), variable('p'), variable('o'))])],
-        };
-        const insertOp = {
-            updateType: 'insert',
-            insert,
-        };
-        return {
-            type: 'update',
-            updates: [deleteOp, insertOp],
-            prefixes: {},
-        };
-    }
-    sparqlDelete(name, parent) {
-        const metaName = this.getMetadataNode(name);
-        const updates = [
-            {
-                updateType: 'deletewhere',
-                delete: [this.sparqlSelectGraphAsQuads(name, [quad(variable('s'), variable('p'), variable('o'))])],
-            },
-            {
-                updateType: 'deletewhere',
-                delete: [this.sparqlSelectGraphAsQuads(metaName, [quad(variable('s'), variable('p'), variable('o'))])],
-            },
-        ];
-        if (parent) {
-            updates.push({
-                updateType: 'deletewhere',
-                delete: [{
-                        type: 'graph',
-                        name: parent,
-                        triples: [quad(parent, community_server_1.LDP.terms.contains, name)],
-                    }],
-            });
-        }
-        return {
-            type: 'update',
-            updates,
-            prefixes: {},
-        };
-    }
-    async sendSparqlConstruct(query) {
-        const queryString = this.generator.stringify(query);
-        this.logger.verbose(`SPARQL CONSTRUCT: ${queryString}`);
-        try {
-            const quadStream = await (await this.engine).queryQuads(queryString);
-            return (0, community_server_1.guardStream)(node_stream_1.Readable.from(quadStream));
-        }
-        catch (error) {
-            this.logger.error(`SPARQL query failed: ${(0, community_server_1.createErrorMessage)(error)}`);
-            throw error;
-        }
-    }
-    async sendSparqlUpdate(query) {
-        const queryString = this.generator.stringify(query);
-        this.logger.verbose(`SPARQL UPDATE: ${queryString}`);
-        try {
-            await (await this.engine).queryVoid(queryString);
-        }
-        catch (error) {
-            this.logger.error(`SPARQL update failed: ${(0, community_server_1.createErrorMessage)(error)}`);
-            throw error;
-        }
-    }
-    sourceScopedStore() {
-        const store = this.store;
-        if (typeof store.replaceSource === 'function' && typeof store.deleteSource === 'function') {
-            return store;
-        }
-        return undefined;
-    }
-    async replaceCompatibilityMetadata(name, metadata, parent) {
-        const metaName = this.getMetadataNode(name);
-        await this.store.del({ graph: metaName });
-        const inserts = metadata.quads().map((value) => quad(value.subject, value.predicate, value.object, metaName));
-        if (parent) {
-            inserts.push(quad(parent, community_server_1.LDP.terms.contains, name, parent));
-        }
-        if (inserts.length > 0) {
-            await this.store.multiPut(inserts);
-        }
-    }
-    /**
-     * Execute a SPARQL UPDATE query string directly.
-     * Used by SparqlUpdateResourceStore for LDP PATCH operations.
-     */
-    async executeSparqlUpdate(query, baseIri) {
-        this.logger.verbose(`executeSparqlUpdate: ${query}`);
-        try {
-            await (await this.engine).queryVoid(query);
-        }
-        catch (error) {
-            this.logger.error(`SPARQL update failed: ${(0, community_server_1.createErrorMessage)(error)}`);
-            throw error;
-        }
-    }
-}
-exports.QuintStoreSparqlDataAccessor = QuintStoreSparqlDataAccessor;
-//# sourceMappingURL=QuintStoreSparqlDataAccessor.js.map