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

package/dist/storage/sparql/CompatibilitySparqlEngine.jsonld

@@ -1,123 +0,0 @@
-{
-  "@context": [
-    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld"
-  ],
-  "@id": "npmd:@undefineds.co/xpod",
-  "components": [
-    {
-      "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine",
-      "@type": "Class",
-      "requireElement": "QuadstoreSparqlEngine",
-      "extends": [
-        "undefineds:dist/storage/sparql/SubgraphQueryEngine.jsonld#SparqlEngine"
-      ],
-      "parameters": [
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine_endpoint",
-          "range": "xsd:string"
-        }
-      ],
-      "memberFields": [
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_delegate",
-          "memberFieldName": "delegate"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_constructor",
-          "memberFieldName": "constructor"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_queryBindings",
-          "memberFieldName": "queryBindings"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_queryQuads",
-          "memberFieldName": "queryQuads"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_queryBoolean",
-          "memberFieldName": "queryBoolean"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_queryVoid",
-          "memberFieldName": "queryVoid"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_constructGraph",
-          "memberFieldName": "constructGraph"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_listGraphs",
-          "memberFieldName": "listGraphs"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine__member_close",
-          "memberFieldName": "close"
-        }
-      ],
-      "constructorArguments": [
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuadstoreSparqlEngine_endpoint"
-        }
-      ]
-    },
-    {
-      "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine",
-      "@type": "Class",
-      "requireElement": "QuintstoreSparqlEngine",
-      "extends": [
-        "undefineds:dist/storage/sparql/SubgraphQueryEngine.jsonld#SparqlEngine"
-      ],
-      "comment": "Comunica-backed compatibility engine component.",
-      "parameters": [
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine_store",
-          "range": "undefineds:dist/storage/quint/types.jsonld#QuintStore"
-        }
-      ],
-      "memberFields": [
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_delegate",
-          "memberFieldName": "delegate"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_constructor",
-          "memberFieldName": "constructor"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_queryBindings",
-          "memberFieldName": "queryBindings"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_queryQuads",
-          "memberFieldName": "queryQuads"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_queryBoolean",
-          "memberFieldName": "queryBoolean"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_queryVoid",
-          "memberFieldName": "queryVoid"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_constructGraph",
-          "memberFieldName": "constructGraph"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_listGraphs",
-          "memberFieldName": "listGraphs"
-        },
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine__member_close",
-          "memberFieldName": "close"
-        }
-      ],
-      "constructorArguments": [
-        {
-          "@id": "undefineds:dist/storage/sparql/CompatibilitySparqlEngine.jsonld#QuintstoreSparqlEngine_store"
-        }
-      ]
-    }
-  ]
-}

package/dist/storage/sparql/CompatibilitySparqlEngineImpl.d.ts

@@ -1,36 +0,0 @@
-import type { Quad } from '@rdfjs/types';
-import type { AsyncIterator } from 'asynciterator';
-import type { SparqlEngine, SparqlVoidOptions } from './SubgraphQueryEngine';
-import type { QuintStore } from '../quint/types';
-import { type RdfAccessScope } from '../rdf/RdfAccessScope';
-/**
- * @deprecated Compatibility wrapper preserved for older call sites.
- * Mainline xpod uses SolidRdfEngine for server-owned Pod queries.
- */
-export declare class QuadstoreSparqlEngine implements SparqlEngine {
-    private readonly delegate;
-    constructor(endpoint: string);
-    queryBindings(query: string, basePath: string, accessScope?: RdfAccessScope): Promise<any>;
-    queryQuads(query: string, basePath: string, accessScope?: RdfAccessScope): Promise<any>;
-    queryBoolean(query: string, basePath: string, accessScope?: RdfAccessScope): Promise<boolean>;
-    queryVoid(query: string, basePath: string, accessScope?: RdfAccessScope, options?: SparqlVoidOptions): Promise<void>;
-    constructGraph(graph: string, basePath: string, accessScope?: RdfAccessScope): Promise<AsyncIterator<Quad>>;
-    listGraphs(basePath: string, accessScope?: RdfAccessScope): Promise<Set<string>>;
-    close(): Promise<void>;
-}
-/**
- * Comunica-backed compatibility engine.
- */
-export declare class QuintstoreSparqlEngine implements SparqlEngine {
-    private readonly store;
-    private readonly engine;
-    private readonly ready;
-    constructor(store: QuintStore);
-    queryBindings(query: string, basePath: string, accessScope?: RdfAccessScope): Promise<any>;
-    queryQuads(query: string, basePath: string, accessScope?: RdfAccessScope): Promise<any>;
-    queryBoolean(query: string, basePath: string, accessScope?: RdfAccessScope): Promise<boolean>;
-    queryVoid(query: string, basePath: string, accessScope?: RdfAccessScope, options?: SparqlVoidOptions): Promise<void>;
-    constructGraph(graph: string, basePath: string, accessScope?: RdfAccessScope): Promise<AsyncIterator<Quad>>;
-    listGraphs(basePath: string, accessScope?: RdfAccessScope): Promise<Set<string>>;
-    close(): Promise<void>;
-}

package/dist/storage/sparql/CompatibilitySparqlEngineImpl.js

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuintstoreSparqlEngine = exports.QuadstoreSparqlEngine = void 0;
-const ComunicaQuintEngine_1 = require("./ComunicaQuintEngine");
-const QuintEngine_1 = require("./QuintEngine");
-const RdfAccessScope_1 = require("../rdf/RdfAccessScope");
-/**
- * @deprecated Compatibility wrapper preserved for older call sites.
- * Mainline xpod uses SolidRdfEngine for server-owned Pod queries.
- */
-class QuadstoreSparqlEngine {
-    constructor(endpoint) {
-        const store = new QuintEngine_1.QuintEngine({ endpoint }).getStore();
-        this.delegate = new QuintstoreSparqlEngine(store);
-    }
-    async queryBindings(query, basePath, accessScope) {
-        return this.delegate.queryBindings(query, basePath, accessScope);
-    }
-    async queryQuads(query, basePath, accessScope) {
-        return this.delegate.queryQuads(query, basePath, accessScope);
-    }
-    async queryBoolean(query, basePath, accessScope) {
-        return this.delegate.queryBoolean(query, basePath, accessScope);
-    }
-    async queryVoid(query, basePath, accessScope, options) {
-        await this.delegate.queryVoid(query, basePath, accessScope, options);
-    }
-    async constructGraph(graph, basePath, accessScope) {
-        return this.delegate.constructGraph(graph, basePath, accessScope);
-    }
-    async listGraphs(basePath, accessScope) {
-        return this.delegate.listGraphs(basePath, accessScope);
-    }
-    async close() {
-        await this.delegate.close();
-    }
-}
-exports.QuadstoreSparqlEngine = QuadstoreSparqlEngine;
-/**
- * Comunica-backed compatibility engine.
- */
-class QuintstoreSparqlEngine {
-    constructor(store) {
-        this.store = store;
-        this.engine = new ComunicaQuintEngine_1.ComunicaQuintEngine(this.store);
-        this.ready = this.store.open();
-    }
-    async queryBindings(query, basePath, accessScope) {
-        assertCompatibilityAccessScope(accessScope, 'queryBindings');
-        await this.ready;
-        return this.engine.queryBindings(query, {
-            baseIRI: basePath,
-            filters: { graph: { $startsWith: basePath } },
-        });
-    }
-    async queryQuads(query, basePath, accessScope) {
-        assertCompatibilityAccessScope(accessScope, 'queryQuads');
-        await this.ready;
-        return this.engine.queryQuads(query, {
-            baseIRI: basePath,
-            filters: { graph: { $startsWith: basePath } },
-        });
-    }
-    async queryBoolean(query, basePath, accessScope) {
-        assertCompatibilityAccessScope(accessScope, 'queryBoolean');
-        await this.ready;
-        return this.engine.queryBoolean(query, {
-            baseIRI: basePath,
-            filters: { graph: { $startsWith: basePath } },
-        });
-    }
-    async queryVoid(query, basePath, accessScope, options) {
-        assertCompatibilityAccessScope(accessScope, 'queryVoid');
-        await this.ready;
-        return this.engine.queryVoid(query, {
-            baseIRI: basePath,
-            filters: { graph: { $startsWith: basePath } },
-        });
-    }
-    async constructGraph(graph, basePath, accessScope) {
-        assertCompatibilityAccessScope(accessScope, 'constructGraph');
-        await this.ready;
-        const constructQuery = `CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <${graph}> { ?s ?p ?o } }`;
-        return this.engine.queryQuads(constructQuery, {
-            baseIRI: basePath,
-            filters: { graph: { $startsWith: basePath } },
-        });
-    }
-    async listGraphs(basePath, accessScope) {
-        assertCompatibilityAccessScope(accessScope, 'listGraphs');
-        await this.ready;
-        const graphs = new Set();
-        const query = 'SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } }';
-        const stream = await this.engine.queryBindings(query, {
-            baseIRI: basePath,
-            filters: { graph: { $startsWith: basePath } },
-        });
-        try {
-            for await (const binding of stream) {
-                const value = binding.get('g');
-                if (value?.termType === 'NamedNode') {
-                    graphs.add(value.value);
-                }
-            }
-        }
-        finally {
-            const close = stream.close;
-            if (typeof close === 'function') {
-                close();
-            }
-        }
-        return graphs;
-    }
-    async close() {
-        await this.store.close();
-    }
-}
-exports.QuintstoreSparqlEngine = QuintstoreSparqlEngine;
-function assertCompatibilityAccessScope(accessScope, operation) {
-    if ((0, RdfAccessScope_1.isRestrictiveRdfAccessScope)(accessScope)) {
-        throw new Error(`Compatibility SPARQL engine cannot safely execute ${operation} with ACL/ACR graph restrictions`);
-    }
-}
-//# sourceMappingURL=CompatibilitySparqlEngineImpl.js.map

package/dist/storage/sparql/ComunicaOptimizedEngine.d.ts

@@ -1,59 +0,0 @@
-/**
- * ComunicaOptimizedEngine - 基于 Comunica 的优化查询引擎
- *
- * 通过自定义 Source 实现查询下推优化：
- * 1. 在查询执行前分析 SPARQL，提取 LIMIT/ORDER BY 等优化参数
- * 2. 将参数存储在 Engine 实例上
- * 3. 自定义 Source 在 match() 时读取这些参数并传给 quadstore
- */
-import type { Quad } from '@rdfjs/types';
-import type { Bindings, ResultStream } from '@rdfjs/types';
-import { Quadstore } from 'quadstore';
-export interface ComunicaOptimizedEngineOptions {
-    debug?: boolean;
-}
-export interface QueryContext {
-    sources?: unknown[];
-    baseIRI?: string;
-    [key: string]: unknown;
-}
-export declare class ComunicaOptimizedEngine {
-    private readonly store;
-    private readonly source;
-    private readonly engine;
-    private readonly debug;
-    private currentOptimizeParams;
-    constructor(store: Quadstore, options?: ComunicaOptimizedEngineOptions);
-    /**
-     * 执行 SELECT 查询
-     */
-    queryBindings(query: string, context?: QueryContext): Promise<ResultStream<Bindings>>;
-    /**
-     * 执行 ASK 查询
-     */
-    queryBoolean(query: string, context?: QueryContext): Promise<boolean>;
-    /**
-     * 执行 CONSTRUCT/DESCRIBE 查询
-     */
-    queryQuads(query: string, context?: QueryContext): Promise<ResultStream<Quad>>;
-    /**
-     * 执行 UPDATE 查询
-     */
-    queryVoid(query: string, context?: QueryContext): Promise<void>;
-    /**
-     * 分析查询，提取优化参数
-     */
-    private analyzeQuery;
-    /**
-     * 从 Algebra 提取优化参数
-     *
-     * 只提取可以安全下推的参数：
-     * - LIMIT（对于单 BGP 查询可以直接下推）
-     * - ORDER BY（简单变量排序）
-     */
-    private extractOptimizeParams;
-    /**
-     * 将 SPARQL 变量名映射到 quadstore 的 TermName
-     */
-    private variableToTermName;
-}

package/dist/storage/sparql/ComunicaOptimizedEngine.js

@@ -1,254 +0,0 @@
-"use strict";
-/**
- * ComunicaOptimizedEngine - 基于 Comunica 的优化查询引擎
- *
- * 通过自定义 Source 实现查询下推优化：
- * 1. 在查询执行前分析 SPARQL，提取 LIMIT/ORDER BY 等优化参数
- * 2. 将参数存储在 Engine 实例上
- * 3. 自定义 Source 在 match() 时读取这些参数并传给 quadstore
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComunicaOptimizedEngine = void 0;
-const query_sparql_rdfjs_1 = require("@comunica/query-sparql-rdfjs");
-const sparqlalgebrajs_1 = require("sparqlalgebrajs");
-const asynciterator_1 = require("asynciterator");
-/**
- * 自定义 RDF/JS Source，通过闭包访问优化参数
- */
-class OptimizedSource {
-    constructor(store, getParams, debug) {
-        this.store = store;
-        this.getParams = getParams;
-        this.debug = debug;
-    }
-    match(subject, predicate, object, graph) {
-        // 构建 quadstore pattern
-        const pattern = {};
-        if (subject && subject.termType !== 'Variable') {
-            pattern.subject = subject;
-        }
-        if (predicate && predicate.termType !== 'Variable') {
-            pattern.predicate = predicate;
-        }
-        if (object && object.termType !== 'Variable') {
-            pattern.object = object;
-        }
-        if (graph && graph.termType !== 'Variable' && graph.termType !== 'DefaultGraph') {
-            pattern.graph = graph;
-        }
-        // 获取优化参数
-        const params = this.getParams();
-        const opts = {};
-        if (params) {
-            if (params.limit !== undefined) {
-                // 如果有 offset，需要多获取一些
-                opts.limit = params.limit + (params.offset ?? 0);
-            }
-            if (params.order !== undefined) {
-                opts.order = params.order;
-            }
-            if (params.reverse !== undefined) {
-                opts.reverse = params.reverse;
-            }
-        }
-        if (this.debug) {
-            console.log(`[OptimizedSource] match() called`);
-            console.log(`  pattern: ${JSON.stringify(pattern)}`);
-            console.log(`  opts: ${JSON.stringify(opts)}`);
-        }
-        // 使用 wrap 函数将 Promise<Array> 转换为 AsyncIterator
-        // wrap 会正确处理空数组的情况
-        const promiseIterator = (0, asynciterator_1.wrap)(this.store.get(pattern, opts).then(result => result.items));
-        return promiseIterator;
-    }
-}
-class ComunicaOptimizedEngine {
-    constructor(store, options) {
-        // 当前查询的优化参数（通过闭包共享给 Source）
-        this.currentOptimizeParams = null;
-        this.store = store;
-        this.debug = options?.debug ?? false;
-        // 创建 Source，通过闭包访问 currentOptimizeParams
-        this.source = new OptimizedSource(store, () => this.currentOptimizeParams, this.debug);
-        this.engine = new query_sparql_rdfjs_1.QueryEngine();
-    }
-    /**
-     * 执行 SELECT 查询
-     */
-    async queryBindings(query, context) {
-        // 分析查询，设置优化参数
-        this.currentOptimizeParams = this.analyzeQuery(query);
-        if (this.debug && this.currentOptimizeParams) {
-            console.log(`[ComunicaOptimizedEngine] Optimization params:`, this.currentOptimizeParams);
-        }
-        try {
-            return await this.engine.queryBindings(query, {
-                sources: [this.source],
-                ...context,
-            });
-        }
-        finally {
-            // 查询完成后清除参数
-            this.currentOptimizeParams = null;
-        }
-    }
-    /**
-     * 执行 ASK 查询
-     */
-    async queryBoolean(query, context) {
-        this.currentOptimizeParams = this.analyzeQuery(query);
-        // 对于 ASK，设置 limit=1 优化
-        if (!this.currentOptimizeParams) {
-            this.currentOptimizeParams = { limit: 1 };
-        }
-        else if (this.currentOptimizeParams.limit === undefined) {
-            this.currentOptimizeParams.limit = 1;
-        }
-        try {
-            return await this.engine.queryBoolean(query, {
-                sources: [this.source],
-                ...context,
-            });
-        }
-        finally {
-            this.currentOptimizeParams = null;
-        }
-    }
-    /**
-     * 执行 CONSTRUCT/DESCRIBE 查询
-     */
-    async queryQuads(query, context) {
-        this.currentOptimizeParams = this.analyzeQuery(query);
-        try {
-            return await this.engine.queryQuads(query, {
-                sources: [this.source],
-                ...context,
-            });
-        }
-        finally {
-            this.currentOptimizeParams = null;
-        }
-    }
-    /**
-     * 执行 UPDATE 查询
-     */
-    async queryVoid(query, context) {
-        // UPDATE 不需要优化
-        return this.engine.queryVoid(query, {
-            sources: [this.source],
-            ...context,
-        });
-    }
-    /**
-     * 分析查询，提取优化参数
-     */
-    analyzeQuery(query) {
-        try {
-            const algebra = (0, sparqlalgebrajs_1.translate)(query, { quads: true });
-            return this.extractOptimizeParams(algebra);
-        }
-        catch (error) {
-            if (this.debug) {
-                console.log(`[ComunicaOptimizedEngine] Failed to analyze query:`, error);
-            }
-            return null;
-        }
-    }
-    /**
-     * 从 Algebra 提取优化参数
-     *
-     * 只提取可以安全下推的参数：
-     * - LIMIT（对于单 BGP 查询可以直接下推）
-     * - ORDER BY（简单变量排序）
-     */
-    extractOptimizeParams(algebra) {
-        let limit;
-        let offset;
-        let order;
-        let reverse;
-        let currentOp = algebra;
-        let canPushLimit = true; // 是否可以下推 LIMIT
-        while (currentOp) {
-            switch (currentOp.type) {
-                case 'slice': {
-                    const slice = currentOp;
-                    if (slice.length !== undefined) {
-                        limit = slice.length;
-                    }
-                    if (slice.start !== undefined) {
-                        offset = slice.start;
-                    }
-                    currentOp = slice.input;
-                    break;
-                }
-                case 'orderby': {
-                    const orderBy = currentOp;
-                    if (orderBy.expressions.length === 1) {
-                        const expr = orderBy.expressions[0];
-                        if (expr.expression.expressionType === 'term' &&
-                            expr.expression.term.termType === 'Variable') {
-                            const varName = expr.expression.term.value;
-                            const termName = this.variableToTermName(varName);
-                            if (termName) {
-                                order = [termName];
-                                reverse = !expr.ascending;
-                            }
-                        }
-                    }
-                    currentOp = orderBy.input;
-                    break;
-                }
-                case 'project':
-                case 'distinct':
-                case 'reduced': {
-                    currentOp = currentOp.input;
-                    break;
-                }
-                case 'bgp': {
-                    const bgp = currentOp;
-                    if (bgp.patterns.length === 1) {
-                        // 单个 triple pattern，可以完全下推
-                        return { limit, offset, order, reverse };
-                    }
-                    // 多个 patterns 需要 JOIN，只能下推到每个 pattern
-                    // 但 LIMIT 不能直接下推（会影响 JOIN 结果）
-                    canPushLimit = false;
-                    return canPushLimit ? { limit, offset, order, reverse } : null;
-                }
-                case 'join':
-                case 'leftjoin':
-                case 'union':
-                case 'minus':
-                    // 复杂操作，不能直接下推 LIMIT
-                    canPushLimit = false;
-                    return null;
-                case 'filter':
-                case 'extend':
-                case 'group':
-                    // 这些操作不支持优化
-                    return null;
-                default:
-                    return null;
-            }
-        }
-        return null;
-    }
-    /**
-     * 将 SPARQL 变量名映射到 quadstore 的 TermName
-     */
-    variableToTermName(varName) {
-        const mapping = {
-            's': 'subject',
-            'subject': 'subject',
-            'p': 'predicate',
-            'predicate': 'predicate',
-            'o': 'object',
-            'object': 'object',
-            'g': 'graph',
-            'graph': 'graph',
-        };
-        return mapping[varName.toLowerCase()] ?? null;
-    }
-}
-exports.ComunicaOptimizedEngine = ComunicaOptimizedEngine;
-//# sourceMappingURL=ComunicaOptimizedEngine.js.map