@undefineds.co/drizzle-solid 0.2.6

package/dist/core/pod-dialect.js

@@ -0,0 +1,1300 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodDialect = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const expressions_1 = require("./expressions");
+const sparql_executor_1 = require("./sparql-executor");
+const pod_executor_1 = require("./execution/pod-executor");
+const origin_auth_1 = require("./utils/origin-auth");
+const pod_runtime_1 = require("./runtime/pod-runtime");
+const pod_services_1 = require("./services/pod-services");
+class PodDialect {
+    constructor(config) {
+        this.registeredTables = new Set();
+        this.preparedContainers = new Set();
+        this.preparedResources = new Set();
+        this.config = config;
+        const session = config.session;
+        // 从session中获取webId
+        const webId = session.info.webId;
+        const clientId = session.info.clientId || session.info.client_id || process.env.SOLID_CLIENT_ID;
+        if (!webId) {
+            throw new Error('Session中未找到webId');
+        }
+        this.runtime = new pod_runtime_1.PodRuntime({
+            session,
+            webId,
+            podUrl: config.podUrl,
+        });
+        this.webId = this.runtime.getWebId();
+        this.podUrl = this.runtime.getPodUrl();
+        this.services = new pod_services_1.PodServices({
+            runtime: this.runtime,
+            clientId,
+            disableInteropDiscovery: config.disableInteropDiscovery,
+            listContainerResources: (containerUrl) => this.listContainerResources(containerUrl),
+            findSubjectsForCondition: (condition, table, resourceUrl) => this.findSubjectsForCondition(condition, table, resourceUrl),
+        });
+        this.uriResolver = this.services.getUriResolver();
+        this.sparqlConverter = this.services.getSparqlConverter();
+        this.sparqlExecutor = this.services.getSparqlExecutor();
+        this.ldpExecutor = this.services.getLdpExecutor();
+        this.typeIndexManager = this.services.getTypeIndexManager();
+        this.discovery = this.services.getDiscovery();
+        this.shapeManager = this.services.getShapeManager();
+        this.resolverFactory = this.services.getResolverFactory();
+        this.strategyFactory = this.services.getStrategyFactory();
+        this.executor = new pod_executor_1.PodExecutor({
+            ensureConnected: async () => {
+                if (!this.runtime.isConnected()) {
+                    await this.connect();
+                }
+            },
+            ensureTableResourcePath: (table) => this.ensureTableResourcePath(table),
+            resolveTableResource: (table) => this.resolveTableResource(table),
+            resolveTableUrls: (table) => this.resolveTableUrls(table),
+            normalizeResourceUrl: (resourceUrl) => this.normalizeResourceUrl(resourceUrl),
+            normalizeContainerKey: (containerUrl) => this.normalizeContainerKey(containerUrl),
+            normalizeResourceKey: (resourceUrl) => this.normalizeResourceKey(resourceUrl),
+            ensureContainerExists: (containerUrl) => this.ensureContainerExists(containerUrl),
+            ensureResourceExists: (resourceUrl, options) => this.ensureResourceExists(resourceUrl, options),
+            ensureIdentifierCondition: (condition, table, resourceUrl) => this.ensureIdentifierCondition(condition, table, resourceUrl),
+            resourceExists: (resourceUrl) => this.resourceExists(resourceUrl),
+            getStrategy: (table) => this.getStrategy(table),
+            getLdpStrategy: () => this.strategyFactory.getLdpStrategy(),
+            preparedContainers: this.preparedContainers,
+            preparedResources: this.preparedResources,
+            sparqlConverter: this.sparqlConverter,
+            sparqlExecutor: this.sparqlExecutor,
+            isSelectPlan: (plan) => this.isSelectPlan(plan),
+            isInsertPlan: (plan) => this.isInsertPlan(plan),
+            isUpdatePlan: (plan) => this.isUpdatePlan(plan),
+            isDeletePlan: (plan) => this.isDeletePlan(plan),
+        });
+    }
+    /**
+     * Get the ResourceResolver for a table
+     */
+    getResolver(table) {
+        return this.resolverFactory.getResolver(table);
+    }
+    /**
+     * Get the ExecutionStrategy for a table
+     */
+    getStrategy(table) {
+        return this.strategyFactory.getStrategy(table);
+    }
+    /**
+     * 获取 ShapeManager 实例
+     */
+    getShapeManager() {
+        return this.services.getShapeManager();
+    }
+    /**
+     * 获取 UriResolver 实例
+     */
+    getUriResolver() {
+        return this.services.getUriResolver();
+    }
+    /**
+     * 获取 DataDiscovery 实例
+     */
+    getDiscovery() {
+        return this.services.getDiscovery();
+    }
+    /**
+     * 设置 schema（表注册表）
+     * 用于 URI 引用字段的自动补全
+     *
+     * 构建两个注册表：
+     * - tableRegistry: rdfClass -> tables[]（同一 class 可能对应多个表）
+     * - tableNameRegistry: tableName -> table（用于明确指定表名时查找）
+     */
+    setSchema(schema) {
+        const tableRegistry = new Map();
+        const tableNameRegistry = new Map();
+        for (const [key, value] of Object.entries(schema)) {
+            if (value && typeof value === 'object' && 'config' in value) {
+                const table = value;
+                const rdfClass = table.getType?.() || table.config?.type;
+                const tableName = table.config?.name || key;
+                // 添加到表名注册表
+                tableNameRegistry.set(tableName, table);
+                // 添加到 class 注册表（同一 class 可能对应多个表）
+                if (rdfClass) {
+                    const existing = tableRegistry.get(rdfClass) || [];
+                    existing.push(table);
+                    tableRegistry.set(rdfClass, existing);
+                }
+            }
+        }
+        this.ldpExecutor.setTableRegistry(tableRegistry, tableNameRegistry);
+        this.ldpExecutor.setBaseUri(this.podUrl);
+        // Also set table registry for SPARQL converter (for reference URI resolution in queries)
+        this.sparqlConverter.setTableRegistry(tableRegistry, tableNameRegistry, this.podUrl);
+    }
+    async findSubjectsForCondition(condition, table, resourceUrl) {
+        const plan = this.buildSubjectLookupPlan(table, condition);
+        const sparqlQuery = this.sparqlConverter.convertSelectPlan(plan);
+        const normalizedUrl = this.normalizeResourceUrl(resourceUrl);
+        const rows = await this.executeOnResource(normalizedUrl, sparqlQuery);
+        return rows
+            .map((row) => this.extractSubjectFromRow(row))
+            .filter((value) => Boolean(value));
+    }
+    /**
+     * @deprecated 此方法仅被废弃的 executeComplexUpdate 使用
+     * 保留仅用于参考
+     */
+    buildUpdateQueryForSubject(subject, data, table, columns) {
+        const prefixLines = this.buildPrefixLines();
+        const deleteStatements = [];
+        const insertTriples = [];
+        columns.forEach((columnName, index) => {
+            const column = table.columns[columnName];
+            if (!column) {
+                return;
+            }
+            const predicate = this.sparqlConverter.getPredicateForColumnPublic(column, table);
+            deleteStatements.push(`DELETE WHERE {\n  <${subject}> <${predicate}> ?value${index} .\n}`);
+            const newValue = data[columnName];
+            if (newValue === null || newValue === undefined) {
+                return;
+            }
+            const literal = this.sparqlConverter.formatLiteralValue(newValue, column);
+            if (literal === 'NULL') {
+                return;
+            }
+            insertTriples.push(`  <${subject}> <${predicate}> ${literal} .`);
+        });
+        if (deleteStatements.length === 0 && insertTriples.length === 0) {
+            return null;
+        }
+        const parts = [];
+        if (deleteStatements.length > 0) {
+            parts.push(deleteStatements.join(';\n'));
+        }
+        if (insertTriples.length > 0) {
+            parts.push(`INSERT DATA {\n${insertTriples.join('\n')}\n}`);
+        }
+        return `${prefixLines}\n${parts.join(';\n')}`;
+    }
+    buildPrefixLines() {
+        const prefixes = this.sparqlConverter.getPrefixes();
+        return Object.entries(prefixes)
+            .map(([prefix, uri]) => `PREFIX ${prefix}: <${uri}>`)
+            .join('\n');
+    }
+    isSubjectResolutionError(error) {
+        if (!(error instanceof Error)) {
+            return false;
+        }
+        return error.message.includes('requires an id or @id condition');
+    }
+    async connect() {
+        await this.runtime.connect();
+    }
+    async disconnect() {
+        await this.runtime.disconnect();
+    }
+    isConnected() {
+        return this.runtime.isConnected();
+    }
+    // 从 webId 中提取用户路径
+    extractUserPathFromWebId() {
+        if (!this.webId) {
+            return '';
+        }
+        try {
+            const url = new URL(this.webId);
+            // 从 webId 中提取路径，例如：
+            // http://localhost:3000/alice/profile/card#me -> /alice/
+            // http://localhost:3000/bob/profile/card#me -> /bob/
+            const pathParts = url.pathname.split('/');
+            if (pathParts.length >= 2) {
+                const username = pathParts[1]; // 获取用户名部分
+                return `/${username}/`;
+            }
+        }
+        catch (error) {
+            console.warn('Failed to parse webId:', this.webId, error);
+        }
+        return '';
+    }
+    resolveTableResource(table) {
+        const endpointSource = table.getSparqlEndpoint?.();
+        if (endpointSource) {
+            const endpoint = this.isAbsoluteUrl(endpointSource)
+                ? endpointSource
+                : this.resolveAbsoluteUrl(endpointSource);
+            return { mode: 'sparql', endpoint };
+        }
+        const { containerUrl, resourceUrl } = this.resolveLdpResource(table);
+        return { mode: 'ldp', containerUrl, resourceUrl };
+    }
+    /**
+     * Resolve LDP container/resource URLs for a table.
+     *
+     * Always returns the physical LDP storage location, regardless of whether
+     * the table has a sparqlEndpoint configured. SPARQL strategy will resolve
+     * the endpoint URL separately via table.getSparqlEndpoint().
+     */
+    resolveTableUrls(table) {
+        return this.resolveLdpResource(table);
+    }
+    resolveLdpResource(table) {
+        const configuredResourcePath = typeof table.getResourcePath === 'function'
+            ? table.getResourcePath()
+            : table.config?.resourcePath;
+        if (configuredResourcePath) {
+            const absoluteResource = this.resolveAbsoluteUrl(configuredResourcePath);
+            // Check if this is a container path (ends with /)
+            const isContainer = configuredResourcePath.endsWith('/');
+            if (isContainer) {
+                // Document mode: resourceUrl is the container
+                // Actual resource files are determined by subjectTemplate at query time
+                const containerUrl = absoluteResource.endsWith('/') ? absoluteResource : `${absoluteResource}/`;
+                return {
+                    containerUrl,
+                    resourceUrl: containerUrl
+                };
+            }
+            // File mode (Fragment mode or explicit file path): derive container from resource path
+            const normalizedResource = this.normalizeResourceUrl(absoluteResource);
+            const lastSlash = normalizedResource.lastIndexOf('/');
+            const containerUrl = lastSlash >= 0 ? `${normalizedResource.slice(0, lastSlash + 1)}` : `${normalizedResource}/`;
+            return {
+                containerUrl,
+                resourceUrl: normalizedResource
+            };
+        }
+        const configuredPath = table.getContainerPath() || '/data/';
+        const isAbsolute = configuredPath.startsWith('http://') || configuredPath.startsWith('https://');
+        const ensureTrailingSlash = (value) => (value.endsWith('/') ? value : `${value}/`);
+        if (isAbsolute) {
+            if (configuredPath.endsWith('/')) {
+                const containerUrl = ensureTrailingSlash(configuredPath);
+                return {
+                    containerUrl,
+                    resourceUrl: `${containerUrl}${table.config.name}.ttl`
+                };
+            }
+            const normalizedResource = configuredPath;
+            const lastSlash = normalizedResource.lastIndexOf('/');
+            if (lastSlash === -1) {
+                throw new Error(`Invalid containerPath for table ${table.config.name}: ${configuredPath}`);
+            }
+            const containerUrl = ensureTrailingSlash(normalizedResource.slice(0, lastSlash + 1));
+            return {
+                containerUrl,
+                resourceUrl: normalizedResource
+            };
+        }
+        const userPath = this.extractUserPathFromWebId();
+        const trimmedPath = configuredPath.replace(/^\/+/, '');
+        const baseUrl = this.podUrl.endsWith('/') ? this.podUrl : `${this.podUrl}/`;
+        const userPrefix = userPath.replace(/^\/+/, '');
+        const trimHasUserPrefix = userPrefix && trimmedPath.startsWith(userPrefix);
+        if (configuredPath.endsWith('/')) {
+            const relativeContainer = trimHasUserPrefix ? trimmedPath : `${userPrefix}${trimmedPath}`;
+            const containerUrl = ensureTrailingSlash(`${baseUrl}${relativeContainer.replace(/^\/+/, '')}`);
+            return {
+                containerUrl,
+                resourceUrl: `${containerUrl}${table.config.name}.ttl`
+            };
+        }
+        const resourceRelative = trimHasUserPrefix ? trimmedPath : `${userPrefix}${trimmedPath}`;
+        const lastSlash = resourceRelative.lastIndexOf('/');
+        const containerRelative = lastSlash >= 0 ? resourceRelative.slice(0, lastSlash + 1) : userPrefix;
+        const containerUrl = ensureTrailingSlash(`${baseUrl}${containerRelative.replace(/^\/+/, '')}`);
+        const resourceUrl = `${baseUrl}${resourceRelative.replace(/^\/+/, '')}`;
+        return { containerUrl, resourceUrl };
+    }
+    collectSelectSources(plan) {
+        const tables = new Set();
+        if (plan.baseTable) {
+            tables.add(plan.baseTable);
+        }
+        if (Array.isArray(plan.joins)) {
+            for (const join of plan.joins) {
+                if (join?.table) {
+                    tables.add(join.table);
+                }
+            }
+        }
+        if (plan.aliasToTable instanceof Map) {
+            for (const table of plan.aliasToTable.values()) {
+                if (table) {
+                    tables.add(table);
+                }
+            }
+        }
+        const seen = new Set();
+        const sources = [];
+        for (const table of tables) {
+            const descriptor = this.resolveTableResource(table);
+            if (descriptor.mode === 'ldp') {
+                // Document mode: query the container, not a single file
+                const resourceMode = this.uriResolver.getResourceMode(table);
+                const sourceUrl = resourceMode === 'document'
+                    ? descriptor.containerUrl
+                    : descriptor.resourceUrl;
+                const key = `ldp:${sourceUrl}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    sources.push(sourceUrl);
+                }
+            }
+            else {
+                const key = `sparql:${descriptor.endpoint}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    sources.push({ type: 'sparql', value: descriptor.endpoint });
+                }
+            }
+        }
+        return sources;
+    }
+    async resourceExists(resourceUrl) {
+        const normalizedUrl = this.normalizeResourceUrl(resourceUrl);
+        if (this.preparedResources.has(normalizedUrl)) {
+            return true;
+        }
+        try {
+            const response = await this.runtime.getFetch()(normalizedUrl, { method: 'HEAD' });
+            if (response.ok || response.status === 409) {
+                this.markResourcePrepared(normalizedUrl);
+                return true;
+            }
+            if (response.status === 404) {
+                return false;
+            }
+            if (response.status === 405) {
+                const getResponse = await this.runtime.getFetch()(normalizedUrl, {
+                    method: 'GET',
+                    headers: { 'Accept': 'text/turtle' }
+                });
+                if (getResponse.ok) {
+                    this.markResourcePrepared(normalizedUrl);
+                    return true;
+                }
+                return false;
+            }
+            if (response.status === 401 || response.status === 403) {
+                // 无法验证是否存在，假定存在以避免破坏流程
+                this.markResourcePrepared(normalizedUrl);
+                return true;
+            }
+            return response.ok;
+        }
+        catch (error) {
+            console.warn('[PodDialect] Failed to check resource existence via HEAD, falling back to GET', error);
+            try {
+                const getResponse = await this.runtime.getFetch()(normalizedUrl, {
+                    method: 'GET',
+                    headers: { 'Accept': 'text/turtle' }
+                });
+                if (getResponse.ok) {
+                    this.markResourcePrepared(normalizedUrl);
+                    return true;
+                }
+                return false;
+            }
+            catch (fallbackError) {
+                console.warn('[PodDialect] Resource existence fallback GET failed', fallbackError);
+                return false;
+            }
+        }
+    }
+    normalizeResourceUrl(resourceUrl) {
+        if (!resourceUrl) {
+            return resourceUrl;
+        }
+        let normalized = resourceUrl;
+        while (normalized.endsWith('/') && !normalized.endsWith('://')) {
+            normalized = normalized.slice(0, -1);
+        }
+        return normalized;
+    }
+    normalizeContainerKey(containerUrl) {
+        const absoluteContainer = containerUrl.startsWith('http')
+            ? containerUrl
+            : this.resolveAbsoluteUrl(containerUrl);
+        return absoluteContainer.endsWith('/') ? absoluteContainer : `${absoluteContainer}/`;
+    }
+    normalizeResourceKey(resourceUrl) {
+        const absoluteResource = resourceUrl.startsWith('http')
+            ? resourceUrl
+            : this.resolveAbsoluteUrl(resourceUrl);
+        return this.normalizeResourceUrl(absoluteResource);
+    }
+    markContainerPrepared(containerUrl) {
+        this.preparedContainers.add(this.normalizeContainerKey(containerUrl));
+    }
+    markResourcePrepared(resourceUrl) {
+        this.preparedResources.add(this.normalizeResourceKey(resourceUrl));
+    }
+    isAbsoluteUrl(value) {
+        return /^https?:\/\//i.test(value);
+    }
+    resolveAbsoluteUrl(path) {
+        if (!path) {
+            return this.podUrl.replace(/\/$/, '');
+        }
+        if (this.isAbsoluteUrl(path)) {
+            return path;
+        }
+        const sanitizedPath = path.replace(/^(\.\/)+/, '');
+        const base = this.podUrl.endsWith('/') ? this.podUrl : `${this.podUrl}/`;
+        const hasTrailingSlash = sanitizedPath.endsWith('/');
+        const rawUserPath = this.extractUserPathFromWebId();
+        const normalizedUser = rawUserPath.replace(/^\/+|\/+$/g, '');
+        const trimmedPath = sanitizedPath.replace(/^\/+/, '');
+        let relativePath = trimmedPath;
+        const userPrefixWithSlash = normalizedUser.length > 0 ? `${normalizedUser}/` : '';
+        if (normalizedUser.length > 0) {
+            let podPathHasUser = false;
+            try {
+                const podPath = new URL(base).pathname.replace(/^\/+|\/+$/g, '');
+                podPathHasUser = podPath.startsWith(normalizedUser);
+            }
+            catch {
+                podPathHasUser = false;
+            }
+            const needsUserPrefix = (!podPathHasUser) &&
+                (relativePath.length === 0 ||
+                    (relativePath !== normalizedUser && !relativePath.startsWith(userPrefixWithSlash)));
+            if (needsUserPrefix) {
+                relativePath = relativePath.length > 0
+                    ? `${normalizedUser}/${relativePath}`
+                    : normalizedUser;
+            }
+        }
+        if (hasTrailingSlash && !relativePath.endsWith('/')) {
+            relativePath = `${relativePath}/`;
+        }
+        const absolute = new URL(relativePath, base).toString();
+        if (!hasTrailingSlash && absolute.endsWith('/')) {
+            return absolute.replace(/\/$/, '');
+        }
+        return absolute;
+    }
+    async ensureResourceExists(resourceUrl, options = {}) {
+        const { createIfMissing = true } = options;
+        const normalizedUrl = this.normalizeResourceUrl(resourceUrl);
+        if (this.preparedResources.has(normalizedUrl)) {
+            return;
+        }
+        const exists = await this.resourceExists(normalizedUrl);
+        if (exists) {
+            this.markResourcePrepared(normalizedUrl);
+            return;
+        }
+        if (!createIfMissing) {
+            throw new Error(`Resource not found: ${normalizedUrl}`);
+        }
+        for (let i = 0; i < 3; i++) {
+            try {
+                const response = await this.runtime.getFetch()(normalizedUrl, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'text/turtle'
+                    },
+                    body: ''
+                });
+                if (response.ok || [201, 202, 204, 409].includes(response.status)) {
+                    // Invalidate cache for the new resource
+                    await this.sparqlExecutor.invalidateHttpCache(normalizedUrl);
+                    this.markResourcePrepared(normalizedUrl);
+                    return;
+                }
+                if (response.status >= 500) {
+                    console.warn(`[PodDialect] ensureResourceExists attempt ${i + 1}/3 failed with ${response.status}, retrying...`);
+                    await new Promise(r => setTimeout(r, 1000));
+                    continue;
+                }
+                throw new Error(`Failed to create resource: ${response.status} ${response.statusText}`);
+            }
+            catch (error) {
+                if (i === 2) {
+                    console.error('[PodDialect] ensureResourceExists failed after 3 attempts:', error);
+                    throw error;
+                }
+                console.warn(`[PodDialect] ensureResourceExists attempt ${i + 1}/3 failed with error:`, error);
+                await new Promise(r => setTimeout(r, 1000));
+            }
+        }
+    }
+    async executeOnResource(resourceUrl, sparqlQuery, descriptor) {
+        const normalizedUrl = this.normalizeResourceUrl(resourceUrl);
+        if (descriptor?.mode === 'sparql') {
+            return await this.executeOnSparqlEndpoint(descriptor.endpoint, sparqlQuery);
+        }
+        // LDP 模式：仅允许 SELECT/ASK 通过 Comunica；UPDATE 走 N3 Patch
+        if (sparqlQuery.type === 'SELECT' || sparqlQuery.type === 'ASK') {
+            return await this.sparqlExecutor.queryContainer(normalizedUrl, sparqlQuery);
+        }
+        throw new Error('LDP mode does not support SPARQL UPDATE; use N3 patch helpers instead.');
+    }
+    /**
+     * Get the appropriate fetch function for a SPARQL endpoint
+     * - Same-origin endpoints (e.g., CSS SPARQL sidecar): use authenticated session.fetch
+     * - Cross-origin endpoints: use unauthenticated fetch (standard SPARQL endpoint behavior)
+     */
+    getFetchForEndpoint(endpoint) {
+        return (0, origin_auth_1.getFetchForOrigin)(endpoint, this.podUrl, this.runtime.getFetch());
+    }
+    async executeOnSparqlEndpoint(endpoint, sparqlQuery) {
+        const fetchFn = this.getFetchForEndpoint(endpoint);
+        if (sparqlQuery.type === 'SELECT' || sparqlQuery.type === 'ASK') {
+            // For SELECT/ASK, we need to create a temporary executor with the appropriate fetch
+            if ((0, origin_auth_1.isSameOrigin)(endpoint, this.podUrl)) {
+                // Same origin: use authenticated executor
+                return await this.sparqlExecutor.executeQueryWithSource(sparqlQuery, endpoint);
+            }
+            else {
+                // Cross-origin: create an unauthenticated executor
+                const unauthExecutor = new sparql_executor_1.ComunicaSPARQLExecutor({
+                    sources: [endpoint],
+                    fetch: fetch, // Use standard fetch without auth
+                    logging: false
+                });
+                return await unauthExecutor.executeQueryWithSource(sparqlQuery, endpoint);
+            }
+        }
+        const response = await fetchFn(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/sparql-update' },
+            body: sparqlQuery.query
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`SPARQL endpoint update failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ''}`);
+        }
+        return [{ success: true, source: endpoint, status: response.status, via: 'sparql-endpoint' }];
+    }
+    /**
+     * 确保表有 resourcePath，如果没有则从 TypeIndex 自动发现
+     * 如果设置了 typeIndex，优先使用发现的位置（覆盖配置的 base）
+     */
+    async ensureTableResourcePath(table) {
+        const rdfClass = typeof table.config.type === 'string'
+            ? table.config.type
+            : table.config.type.value || String(table.config.type);
+        // 检查是否已经有 resourcePath
+        const configuredResourcePath = (typeof table.getResourcePath === 'function' && table.getResourcePath()) ||
+            table.config?.resourcePath;
+        // 如果没有设置 typeIndex，使用配置的 resourcePath（如果有）
+        if (!table.config.typeIndex) {
+            if (configuredResourcePath && configuredResourcePath.trim().length > 0) {
+                // 已经有 resourcePath，直接使用配置
+                return;
+            }
+            // 没有 resourcePath，使用默认容器
+            console.log(`[AutoDiscover] Table ${table.config.name} has no resourcePath, using default container path`);
+            table.config.containerPath = '/data/';
+            return;
+        }
+        // 设置了 typeIndex，尝试从 TypeIndex/SAI 发现位置
+        // 发现的位置会覆盖配置的 base，实现动态路由
+        console.log(`[AutoDiscover] Table ${table.config.name} has typeIndex enabled, discovering from TypeIndex/SAI...`);
+        try {
+            const locations = await this.discovery.discover(rdfClass);
+            const location = locations[0]; // 使用第一个发现的位置
+            if (location) {
+                // 动态设置 containerPath 和 resourcePath
+                // 假设 location.container 是 containerPath 或 URL
+                let containerPath = location.container;
+                // 如果返回的是绝对 URL，尝试转为相对路径（可选，但保持一致性较好）
+                // 这里暂时直接使用
+                if (!containerPath.endsWith('/')) {
+                    containerPath += '/';
+                }
+                // 如果发现了 subjectTemplate，应用到表配置
+                if (location.subjectTemplate && typeof table.setSubjectTemplate === 'function') {
+                    table.setSubjectTemplate(location.subjectTemplate);
+                    console.log(`[AutoDiscover] ✓ Applied subjectTemplate from discovery: ${location.subjectTemplate}`);
+                }
+                // 推断 resourcePath
+                // 根据资源模式决定 resourcePath:
+                // - Document 模式：resourcePath = containerPath (每条记录独立文件，查询扫描整个容器)
+                // - Fragment 模式：resourcePath = containerPath + tableName.ttl (所有记录在同一文件)
+                const resourceMode = this.uriResolver.getResourceMode(table);
+                let resourcePath;
+                if (resourceMode === 'document') {
+                    // Document 模式：resourcePath 就是容器本身
+                    // SELECT 查询会扫描容器下的所有 .ttl 文件
+                    resourcePath = containerPath;
+                }
+                else {
+                    // Fragment 模式：resourcePath 指向单个文件
+                    resourcePath = `${containerPath}${table.config.name}.ttl`;
+                }
+                console.log(`[AutoDiscover] ✓ Found resource path from TypeIndex: ${resourcePath} (mode: ${resourceMode})`);
+                // 动态注入到表配置中
+                // 使用 setBase 更新内部状态和 config.base，确保 SubjectResolver 能获取到正确路径
+                if (typeof table.setBase === 'function') {
+                    table.setBase(resourcePath);
+                }
+                else {
+                    // Fallback for minimal mock tables
+                    table.config.containerPath = containerPath;
+                    table.config.resourcePath = resourcePath;
+                    table.config.base = resourcePath;
+                }
+                // 尝试自动发现 SPARQL endpoint
+                await this.tryDiscoverSparqlEndpoint(table, containerPath);
+            }
+            else {
+                // Discovery 没有找到位置
+                if (configuredResourcePath && configuredResourcePath.trim().length > 0) {
+                    // 有配置的 resourcePath，使用它作为 fallback
+                    console.log(`[AutoDiscover] No discovery result, using configured path: ${configuredResourcePath}`);
+                    return;
+                }
+                // 没有配置的 resourcePath，抛出错误
+                throw new Error(`[AutoDiscover] No data location found for type ${rdfClass}. Please ensure the data is registered in TypeIndex or SAI Registry.`);
+            }
+        }
+        catch (error) {
+            // 发现过程出错
+            if (configuredResourcePath && configuredResourcePath.trim().length > 0) {
+                // 有配置的 resourcePath，使用它作为 fallback
+                console.warn('[AutoDiscover] Discovery process failed, using configured path:', configuredResourcePath);
+                return;
+            }
+            console.warn('[AutoDiscover] Discovery process failed:', error);
+            throw error; // Re-throw
+        }
+    }
+    /**
+     * 尝试自动发现 SPARQL endpoint
+     * 按约定：${base}/-/sparql
+     */
+    async tryDiscoverSparqlEndpoint(table, base) {
+        // 如果表已经配置了 sparqlEndpoint，跳过
+        if (table.getSparqlEndpoint()) {
+            return;
+        }
+        // 构建约定的 endpoint URL
+        const potentialEndpoint = `${base.replace(/\/$/, '')}/-/sparql`;
+        try {
+            const response = await this.runtime.getFetch()(potentialEndpoint, { method: 'HEAD' });
+            if (response.ok) {
+                console.log(`[AutoDiscover] ✓ Found SPARQL endpoint: ${potentialEndpoint}`);
+                if (typeof table.setSparqlEndpoint === 'function') {
+                    table.setSparqlEndpoint(potentialEndpoint);
+                }
+            }
+        }
+        catch {
+            // SPARQL endpoint 不存在，继续使用 LDP 模式
+        }
+    }
+    // 核心查询方法 - 通过 ExecutionStrategy 执行
+    async query(operation) {
+        return this.executor.query(operation);
+    }
+    buildIdInConditionFromSubjects(subjects) {
+        if (!subjects || subjects.length === 0) {
+            return undefined;
+        }
+        return new expressions_1.BinaryExpression('@id', 'IN', subjects);
+    }
+    isInsertPlan(plan) {
+        return Boolean(plan && typeof plan.table !== 'undefined' && Array.isArray(plan.rows));
+    }
+    isUpdatePlan(plan) {
+        return Boolean(plan && typeof plan.table !== 'undefined' && 'data' in plan);
+    }
+    isDeletePlan(plan) {
+        if (!plan) {
+            return false;
+        }
+        const candidate = plan;
+        if (typeof candidate.table === 'undefined') {
+            return false;
+        }
+        return typeof candidate.rows === 'undefined' && typeof candidate.data === 'undefined';
+    }
+    isSelectPlan(plan) {
+        if (!plan) {
+            return false;
+        }
+        return typeof plan.baseTable !== 'undefined';
+    }
+    buildSubjectLookupPlan(table, condition) {
+        const alias = table.config.name ?? 'table';
+        return {
+            baseTable: table,
+            baseAlias: alias,
+            selectAll: true,
+            conditionTree: condition,
+            aliasToTable: new Map([[alias, table]]),
+            tableToAlias: new Map([[table, alias]])
+        };
+    }
+    buildSubjectUriFromFragment(fragment, table) {
+        // This method is used by rewriteWhereConditionWithSubjects and other internal logic
+        // Ideally we should use SubjectResolver, but for fragment building relative to base, we need this helper.
+        // Or delegate to SubjectResolver if it exposes parsing.
+        // SubjectResolver.parse handles URIs.
+        // For now, keep this simple helper as it was used by extractSubjectFromRow logic context.
+        // Wait, extractSubjectFromRow doesn't use this.
+        // But `rewriteWhereConditionWithSubjects` calls `findSubjectsForCondition`.
+        // `findSubjectsForCondition` calls `buildSubjectLookupPlan` which is also missing?
+        return this.sparqlConverter.generateSubjectUri({ id: fragment }, table);
+    }
+    extractSubjectFromRow(row) {
+        const subject = row.subject ?? row['?subject'];
+        if (!subject) {
+            return null;
+        }
+        if (typeof subject === 'string') {
+            return subject;
+        }
+        if (typeof subject.value === 'string') {
+            return subject.value;
+        }
+        return null;
+    }
+    operationHasInlineObjects(table, data) {
+        return Object.entries(data).some(([key, value]) => {
+            if (value === undefined)
+                return false;
+            const col = table.columns?.[key];
+            if (!col)
+                return false;
+            return this.isInlineObjectColumn(col);
+        });
+    }
+    isInlineObjectColumn(column) {
+        if (!column)
+            return false;
+        if (column.dataType === 'object')
+            return true;
+        if (column.dataType === 'array') {
+            const elem = column.elementType ?? column.options?.baseType;
+            return elem === 'object';
+        }
+        return false;
+    }
+    conditionTargetsIdentifier(condition) {
+        if (!condition) {
+            return false;
+        }
+        // BinaryExpression: check 'left' property
+        if (condition.type === 'binary_expr') {
+            const left = condition.left;
+            const colName = typeof left === 'string' ? left : left?.name;
+            if (colName === '@id' || colName === 'id') {
+                return true;
+            }
+        }
+        // LogicalExpression: check 'expressions' property
+        if (condition.type === 'logical_expr') {
+            const exprs = condition.expressions;
+            if (exprs) {
+                return exprs.some((child) => this.conditionTargetsIdentifier(child));
+            }
+        }
+        // UnaryExpression: check 'value' property
+        if (condition.type === 'unary_expr') {
+            const val = condition.value;
+            if (val && typeof val === 'object' && 'type' in val) {
+                return this.conditionTargetsIdentifier(val);
+            }
+        }
+        return false;
+    }
+    async ensureIdentifierCondition(condition, table, resourceUrl) {
+        if (!condition) {
+            return undefined;
+        }
+        if (this.conditionTargetsIdentifier(condition)) {
+            return condition;
+        }
+        return await this.rewriteWhereConditionWithSubjects(condition, table, resourceUrl);
+    }
+    async rewriteWhereConditionWithSubjects(condition, table, resourceUrl) {
+        if (!condition) {
+            return undefined;
+        }
+        const subjects = await this.findSubjectsForCondition(condition, table, resourceUrl);
+        return this.buildIdInConditionFromSubjects(subjects);
+    }
+    // 处理 Drizzle 的 SQL 对象
+    async executeSql(sql, table) {
+        // 解析 SQL 对象确定操作类型
+        const sqlString = sql.queryChunks.join('');
+        let operationType;
+        if (sqlString.toLowerCase().includes('select')) {
+            operationType = 'select';
+        }
+        else if (sqlString.toLowerCase().includes('insert')) {
+            operationType = 'insert';
+        }
+        else if (sqlString.toLowerCase().includes('update')) {
+            operationType = 'update';
+        }
+        else if (sqlString.toLowerCase().includes('delete')) {
+            operationType = 'delete';
+        }
+        else {
+            throw new Error(`Unsupported SQL operation: ${sqlString}`);
+        }
+        const operation = {
+            type: operationType,
+            table,
+            sql,
+            values: sql.params || [] // 参数作为值
+        };
+        return this.query(operation);
+    }
+    // 添加自定义命名空间到 SPARQL 转换器
+    addNamespace(prefix, uri) {
+        this.sparqlConverter.addPrefix(prefix, uri);
+    }
+    // 获取配置信息
+    getConfig() {
+        return {
+            podUrl: this.podUrl,
+            webId: this.webId,
+            connected: this.runtime.isConnected()
+        };
+    }
+    /**
+     * 获取认证的 fetch 函数
+     * 用于需要认证访问的操作（如 Notifications）
+     */
+    getAuthenticatedFetch() {
+        return this.runtime.getFetch();
+    }
+    // 获取 SPARQL 转换器（用于调试）
+    getSPARQLConverter() {
+        return this.sparqlConverter;
+    }
+    // 获取 SPARQL 执行器（用于调试）
+    getSPARQLExecutor() {
+        return this.sparqlExecutor;
+    }
+    getPodUrl() {
+        return this.runtime.getPodUrl();
+    }
+    /**
+     * 获取用户的 WebID
+     */
+    getWebId() {
+        return this.runtime.getWebId();
+    }
+    /**
+     * 发现特定 RDF 类型的数据位置
+     * 通过 TypeIndex 和 Interop 发现
+     *
+     * @param rdfClass RDF 类型 URI
+     * @returns 数据位置列表
+     */
+    async discoverDataLocations(rdfClass, options) {
+        return this.discovery.discover(rdfClass, options);
+    }
+    /**
+     * 获取所有数据注册信息
+     */
+    async discoverAll() {
+        if (this.discovery.discoverAll) {
+            return this.discovery.discoverAll();
+        }
+        return [];
+    }
+    /**
+     * 按应用 ID 发现数据位置
+     */
+    async discoverByApp(appId) {
+        if (this.discovery.discoverByApp) {
+            return this.discovery.discoverByApp(appId);
+        }
+        return [];
+    }
+    // 添加数据源进行联邦查询（高级用法）
+    // 注意：正常情况下不需要手动添加数据源，表定义中的 containerPath 会自动使用
+    addSource(source) {
+        console.warn('⚠️  addSource 是高级用法，通常不需要手动管理数据源。表定义中的 containerPath 会自动使用。');
+        this.sparqlExecutor.addSource(source);
+    }
+    // 移除数据源
+    removeSource(source) {
+        this.sparqlExecutor.removeSource(source);
+    }
+    // 获取当前数据源列表
+    getSources() {
+        return this.sparqlExecutor.getSources();
+    }
+    // 自动从 TypeIndex 添加数据源（推荐用法）
+    async addSourcesFromTypeIndex() {
+        try {
+            const typeIndexEntries = await this.typeIndexManager.discoverTypes();
+            for (const entry of typeIndexEntries) {
+                if (entry.instanceContainer) {
+                    // 使用实例容器路径作为数据源
+                    this.sparqlExecutor.addSource(entry.instanceContainer);
+                }
+                else if (entry.containerPath) {
+                    // 使用容器路径作为数据源
+                    const fullPath = entry.containerPath.startsWith('http')
+                        ? entry.containerPath
+                        : `${this.podUrl}${entry.containerPath}`;
+                    this.sparqlExecutor.addSource(fullPath);
+                }
+            }
+            console.log(`✅ 从 TypeIndex 自动添加了 ${typeIndexEntries.length} 个数据源`);
+        }
+        catch (error) {
+            console.warn('⚠️  无法从 TypeIndex 自动添加数据源:', error);
+        }
+    }
+    // 查询特定容器
+    async queryContainer(containerPath, sql, table) {
+        // Use proper AST conversion with table context
+        const ast = this.sparqlConverter.parseDrizzleAST(sql, table);
+        const sparqlQuery = this.sparqlConverter.convertSelect(ast, table);
+        // 使用表定义中的容器路径，如果提供了的话
+        const targetPath = table?.config?.containerPath || containerPath;
+        return this.sparqlExecutor.queryContainer(targetPath, sparqlQuery);
+    }
+    // 获取 Pod 元数据
+    async getPodMetadata() {
+        if (!this.runtime.isConnected()) {
+            throw new Error('Not connected to Pod');
+        }
+        return {
+            podUrl: this.podUrl,
+            webId: this.webId,
+            connected: this.runtime.isConnected(),
+            sources: this.sparqlExecutor.getSources()
+        };
+    }
+    // 直接执行 SPARQL 查询（高级用法）
+    async executeSPARQL(query) {
+        if (!this.runtime.isConnected()) {
+            throw new Error('Not connected to Pod');
+        }
+        const sparqlQuery = {
+            type: 'SELECT',
+            query,
+            prefixes: {}
+        };
+        return this.sparqlExecutor.executeQuery(sparqlQuery);
+    }
+    // 事务支持
+    async transaction(transaction) {
+        console.log('Starting transaction');
+        try {
+            const result = await transaction(this);
+            console.log('Transaction completed successfully');
+            return result;
+        }
+        catch (error) {
+            console.error('Transaction failed:', error);
+            throw error;
+        }
+    }
+    // ========== TypeIndex 相关方法 ==========
+    /**
+     * 注册表到 TypeIndex
+     */
+    async registerTable(table) {
+        if (table.config.autoRegister === false) {
+            return;
+        }
+        const tableKey = table.config.name ?? JSON.stringify(table.config);
+        if (this.registeredTables.has(tableKey)) {
+            return;
+        }
+        try {
+            const descriptor = this.resolveTableResource(table);
+            if (descriptor.mode === 'sparql') {
+                // No probe needed - if endpoint fails, the actual query will report the error
+            }
+            else {
+                await this.ensureContainerExists(descriptor.containerUrl);
+                try {
+                    await this.ensureResourceExists(descriptor.resourceUrl, { createIfMissing: true });
+                    this.markResourcePrepared(descriptor.resourceUrl);
+                }
+                catch (error) {
+                    console.warn(`[registerTable] ensureResourceExists failed for ${descriptor.resourceUrl}:`, error);
+                    // 不标记为已准备，让后续 INSERT 有机会重试创建
+                }
+                this.markContainerPrepared(descriptor.containerUrl);
+                // 将表的 base 固定为已解析的绝对资源路径，避免后续重复 TypeIndex 解析
+                try {
+                    table.setBase?.(descriptor.resourceUrl);
+                }
+                catch (error) {
+                    console.warn(`[registerTable] setBase failed for ${table.config.name}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`[registerTable] Resource preparation failed for ${table.config.name}:`, error);
+        }
+        this.registeredTables.add(tableKey);
+        // 委托给 DataDiscovery 进行注册
+        await this.discovery.register(table, {
+            registryPath: table.config.saiRegistryPath,
+        });
+    }
+    /**
+     * 查找用户的 TypeIndex
+     */
+    async findTypeIndex() {
+        return this.typeIndexManager.findTypeIndex();
+    }
+    /**
+     * 创建 TypeIndex
+     */
+    async createTypeIndex() {
+        return this.typeIndexManager.createTypeIndex();
+    }
+    /**
+     * 发现已注册的类型
+     */
+    async discoverTypes(typeIndexUrl) {
+        return this.typeIndexManager.discoverTypes(typeIndexUrl);
+    }
+    /**
+     * 自动发现和注册类型（用于数据消费方）
+     */
+    async autoDiscoverAndRegister(webId) {
+        return this.typeIndexManager.autoDiscoverAndRegister(webId);
+    }
+    /**
+     * 从 Profile 中自动发现类型（不依赖 TypeIndex）
+     */
+    async discoverTypesFromProfile() {
+        return this.typeIndexManager.discoverTypesFromProfile();
+    }
+    /**
+     * 发现特定的类型定义（按需发现）
+     * @param rdfClassUri 要发现的 RDF 类型 URI
+     */
+    async discoverSpecificType(rdfClassUri) {
+        return this.typeIndexManager.discoverSpecificType(rdfClassUri);
+    }
+    /**
+     * 发现多个特定类型
+     * @param rdfClassUris 要发现的 RDF 类型 URI 数组
+     */
+    async discoverSpecificTypes(rdfClassUris) {
+        return this.typeIndexManager.discoverSpecificTypes(rdfClassUris);
+    }
+    /**
+     * 发现并创建可用的表定义
+     * @param rdfClassUri 要发现的 RDF 类型 URI
+     * @returns 可用的表定义，如果未找到则返回 null
+     */
+    async discoverTable(rdfClassUri) {
+        return this.typeIndexManager.discoverTable(rdfClassUri);
+    }
+    /**
+     * 发现并创建多个可用的表定义
+     * @param rdfClassUris 要发现的 RDF 类型 URI 数组
+     * @returns 可用的表定义数组
+     */
+    async discoverTables(rdfClassUris) {
+        return this.typeIndexManager.discoverTables(rdfClassUris);
+    }
+    /**
+     * 检查类型是否已注册
+     */
+    async isTypeRegistered(type, typeIndexUrl) {
+        return this.typeIndexManager.isTypeRegistered(type, typeIndexUrl);
+    }
+    /**
+     * 获取 TypeIndex 管理器
+     */
+    getTypeIndexManager() {
+        return this.typeIndexManager;
+    }
+    /**
+     * @deprecated 此方法已废弃，不再使用
+     *
+     * 原因：
+     * 1. 每次 GET 整个容器内容效率极低（对于大容器可能有几 MB）
+     * 2. 使用字符串匹配检查资源存在性不够可靠
+     * 3. SPARQL INSERT 本身不会覆盖已存在的三元组，重复插入只会添加新的三元组
+     * 4. 如果需要防止重复插入，应该由业务层处理（使用 INSERT WHERE NOT EXISTS）
+     *
+     * 改进的资源存在性检查 - 使用直接 HTTP 而不是 Comunica ASK
+     * 这解决了 409 冲突问题：当 ASK 查询失败时，不应该继续 INSERT
+     */
+    async checkResourceExistence(values, table, containerUrl) {
+        console.warn('[DEPRECATED] checkResourceExistence is deprecated and should not be used');
+        try {
+            let targetContainer = containerUrl.startsWith('http')
+                ? containerUrl
+                : this.resolveAbsoluteUrl(containerUrl);
+            if (!targetContainer.endsWith('/')) {
+                targetContainer = `${targetContainer}/`;
+            }
+            console.log(`🔍 检查资源存在性: ${targetContainer}`);
+            // 直接读取容器内容，检查是否包含我们要插入的资源
+            const response = await this.runtime.getFetch()(targetContainer, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'text/turtle'
+                }
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    // 容器不存在，资源肯定不存在
+                    console.log(`✅ 容器不存在，可以执行 INSERT`);
+                    return true; // 可以继续 INSERT
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const turtleData = await response.text();
+            console.log(`📖 容器内容长度: ${turtleData.length} 字符`);
+            // 检查每个要插入的资源是否已存在
+            for (const record of values) {
+                const subjectUri = this.sparqlConverter.generateSubjectUri(record, table);
+                // 检查 Turtle 数据中是否包含这个资源 URI
+                if (turtleData.includes(subjectUri)) {
+                    console.log(`❌ 发现已存在的资源: ${subjectUri}`);
+                    return false; // 资源已存在，不能 INSERT
+                }
+            }
+            console.log(`✅ 资源存在性检查通过，可以执行 INSERT`);
+            return true; // 所有资源都不存在，可以 INSERT
+        }
+        catch (error) {
+            console.error('❌ 资源存在性检查失败:', error);
+            throw error;
+        }
+    }
+    // 确保容器存在（递归创建父目录）
+    async ensureContainerExists(containerUrl) {
+        try {
+            const targetContainer = this.normalizeContainerKey(containerUrl);
+            if (this.preparedContainers.has(targetContainer)) {
+                return;
+            }
+            const checkResponse = await this.runtime.getFetch()(targetContainer, {
+                method: 'HEAD'
+            });
+            if (checkResponse.status === 401 || checkResponse.status === 403) {
+                console.log(`[Container] ${targetContainer} 不允许 HEAD，视为已存在`);
+                this.markContainerPrepared(targetContainer);
+                return;
+            }
+            if (checkResponse.status === 404) {
+                // 先递归创建父容器
+                const parentContainer = this.getParentContainer(targetContainer);
+                if (parentContainer && parentContainer !== targetContainer) {
+                    console.log(`[Container] 先创建父容器: ${parentContainer}`);
+                    await this.ensureContainerExists(parentContainer);
+                }
+                // 再创建当前容器
+                console.log(`[Container] 创建容器: ${targetContainer}`);
+                const createResponse = await this.runtime.getFetch()(targetContainer, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'text/turtle',
+                        'Link': '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
+                    }
+                });
+                if (createResponse.ok) {
+                    console.log(`[Container] 容器创建成功: ${createResponse.status}`);
+                    await this.sparqlExecutor.invalidateHttpCache(targetContainer);
+                    this.markContainerPrepared(targetContainer);
+                }
+                else if (createResponse.status === 409) {
+                    console.log(`[Container] 容器已存在（409冲突）: ${targetContainer}`);
+                    this.markContainerPrepared(targetContainer);
+                }
+                else {
+                    throw new Error(`Failed to create container: ${createResponse.status} ${createResponse.statusText}`);
+                }
+            }
+            else if (checkResponse.status === 200) {
+                console.log(`[Container] 容器已存在: ${targetContainer}`);
+                this.markContainerPrepared(targetContainer);
+            }
+            else if (checkResponse.status === 409) {
+                console.log(`[Container] 容器已存在（409冲突）: ${targetContainer}`);
+                this.markContainerPrepared(targetContainer);
+            }
+            else if (!checkResponse.ok) {
+                throw new Error(`Failed to check container: ${checkResponse.status} ${checkResponse.statusText}`);
+            }
+        }
+        catch (error) {
+            console.error('[Container] 确保容器存在时出错:', error);
+            throw error;
+        }
+    }
+    /**
+     * 获取父容器 URL
+     * 例如: https://pod.com/alice/data/users/ -> https://pod.com/alice/data/
+     */
+    getParentContainer(containerUrl) {
+        try {
+            const url = new URL(containerUrl);
+            const pathParts = url.pathname.split('/').filter(part => part.length > 0);
+            // 如果已经是根目录或只有一层，返回 null
+            if (pathParts.length <= 1) {
+                return null;
+            }
+            // 移除最后一个路径部分
+            pathParts.pop();
+            // 重建父容器 URL
+            url.pathname = '/' + pathParts.join('/') + '/';
+            return url.toString();
+        }
+        catch (error) {
+            console.error('[Container] 解析父容器 URL 失败:', error);
+            return null;
+        }
+    }
+    /**
+     * List all resources in a container
+     * Uses LDP containment triples to discover resources
+     */
+    async listContainerResources(containerUrl) {
+        const normalizedUrl = this.normalizeContainerKey(containerUrl);
+        const resources = [];
+        try {
+            // Query the container for ldp:contains relationships via SPARQL
+            // This is more reliable than parsing Turtle as it handles all serialization formats
+            const sparql = {
+                type: 'SELECT',
+                query: `
+          PREFIX ldp: <http://www.w3.org/ns/ldp#>
+          SELECT ?resource WHERE {
+            <${normalizedUrl}> ldp:contains ?resource .
+          }
+        `,
+                prefixes: { ldp: 'http://www.w3.org/ns/ldp#' }
+            };
+            const results = await this.sparqlExecutor.queryContainer(normalizedUrl, sparql);
+            for (const row of results) {
+                const resource = row.resource;
+                if (resource) {
+                    const resourceUrl = typeof resource === 'object' && resource.value
+                        ? resource.value
+                        : String(resource);
+                    resources.push(resourceUrl);
+                }
+            }
+        }
+        catch (e) {
+            console.warn('[listContainerResources] SPARQL query failed:', e);
+        }
+        return resources;
+    }
+}
+exports.PodDialect = PodDialect;
+_a = drizzle_orm_1.entityKind;
+PodDialect[_a] = 'PodDialect';
+//# sourceMappingURL=pod-dialect.js.map