@undefineds.co/xpod 0.2.0 → 0.2.1

package/node_modules/@undefineds.co/drizzle-solid/dist/core/pod-database.js

@@ -0,0 +1,1342 @@
+"use strict";
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodDatabase = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const schema_1 = require("./schema");
+const query_conditions_1 = require("./query-conditions");
+const notifications_1 = require("./notifications");
+const federated_1 = require("./federated");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isPodTable(value) {
+    return isRecord(value) && 'columns' in value && 'config' in value;
+}
+function hasStringValue(value) {
+    return isRecord(value) && typeof value.value === 'string';
+}
+class PodDatabase {
+    constructor(dialect, session, schema) {
+        this.dialect = dialect;
+        this.session = session;
+        this.schema = schema;
+        this.notificationsClient = null;
+        this.federatedExecutor = null;
+        /** 最近一次联邦查询的错误（如果有） */
+        this.lastFederatedErrors = [];
+    }
+    /**
+     * 获取最近一次联邦查询的错误
+     * 在调用 findMany 等方法后可以检查此值
+     */
+    getLastFederatedErrors() {
+        return this.lastFederatedErrors;
+    }
+    /**
+     * 清除联邦查询错误
+     */
+    clearFederatedErrors() {
+        this.lastFederatedErrors = [];
+    }
+    /**
+     * 获取或创建 FederatedQueryExecutor
+     */
+    getFederatedExecutor() {
+        if (!this.federatedExecutor) {
+            this.federatedExecutor = new federated_1.FederatedQueryExecutor({
+                fetch: this.dialect.getAuthenticatedFetch(),
+            });
+        }
+        return this.federatedExecutor;
+    }
+    /**
+     * Create a table from a schema with hooks
+     *
+     * This is the recommended way to create tables when you need hooks that
+     * can access the database instance (e.g., for cross-table operations).
+     *
+     * @param schema - The schema definition (created via solidSchema())
+     * @param options - Table options including base path and hooks
+     * @returns A PodTable instance with hooks bound to this database
+     *
+     * @example
+     * ```typescript
+     * const userSchema = solidSchema('users', {
+     *   id: id(),
+     *   name: text('name').predicate(SCHEMA.name),
+     *   email: text('email').predicate(SCHEMA.email),
+     * }, {
+     *   type: SCHEMA.Person,
+     * });
+     *
+     * const userTable = db.createTable(userSchema, {
+     *   base: '/data/users/',
+     *   hooks: {
+     *     afterInsert: async (ctx, record) => {
+     *       // ctx.db is available - can query/insert other tables
+     *       await ctx.db.insert(auditTable).values({
+     *         action: 'user_created',
+     *         userId: record['@id'],
+     *       });
+     *     },
+     *     afterUpdate: async (ctx, record, changes) => {
+     *       if ('email' in changes) {
+     *         // Send verification email via another service
+     *         await ctx.db.insert(notificationTable).values({
+     *           type: 'email_changed',
+     *           userId: record['@id'],
+     *         });
+     *       }
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    createTable(schema, options) {
+        // Create table using schema.table() with the base path
+        const table = schema.table('default', options);
+        // Attach hooks if provided
+        if (options.hooks) {
+            table.config.hooks = options.hooks;
+        }
+        // Store db handle in table for hook context
+        // This allows hooks to access db when invoked
+        Reflect.set(table, '_db', this);
+        return table;
+    }
+    // SELECT 查询
+    select(fields) {
+        return this.session.select(fields);
+    }
+    // INSERT 查询
+    insert(table) {
+        return this.session.insert(table);
+    }
+    // UPDATE 查询
+    update(table) {
+        return this.session.update(table);
+    }
+    // DELETE 查询
+    delete(table) {
+        return this.session.delete(table);
+    }
+    // 直接执行 SPARQL 查询（高级 escape hatch）
+    async execute(query) {
+        return await this.executeSPARQL(query);
+    }
+    // 显式 SPARQL 执行入口
+    async executeSPARQL(query) {
+        if (typeof query !== 'string' || query.trim().length === 0) {
+            throw new Error('executeSPARQL requires a non-empty SPARQL query string');
+        }
+        return await this.dialect.executeSPARQL(query);
+    }
+    // 顺序执行一组操作，保持与 Drizzle batch 类似的调用方式
+    async batch(operations) {
+        const results = [];
+        for (const operation of operations) {
+            results.push(await operation);
+        }
+        return results;
+    }
+    // Find first matching row (LIMIT 1)
+    async findFirst(table, where) {
+        const builder = this.select().from(table).limit(1);
+        if (where && Object.keys(where).length > 0) {
+            builder.where(where);
+        }
+        const rows = await builder;
+        return rows.length > 0 ? rows[0] : null;
+    }
+    getLocatorTemplate(table) {
+        return table.getSubjectTemplate?.() ?? table.config?.subjectTemplate ?? '{id}';
+    }
+    getRequiredLocatorKeys(table) {
+        const template = this.getLocatorTemplate(table);
+        const keys = Array.from(template.matchAll(/\{([^}]+)\}/g))
+            .map((match) => match[1])
+            .filter((key) => key !== 'index');
+        return Array.from(new Set(keys));
+    }
+    resolveLocatorSubject(table, locator, methodName) {
+        if (!isRecord(locator) || Array.isArray(locator)) {
+            throw new Error(`${methodName} requires a locator object`);
+        }
+        if ('@id' in locator) {
+            throw new Error(`${methodName} does not accept '@id'. Use ${methodName.replace('Locator', 'Iri')}(table, iri) instead.`);
+        }
+        const idValue = locator.id;
+        if (typeof idValue === 'string' && (idValue.startsWith('http://') || idValue.startsWith('https://'))) {
+            throw new Error(`${methodName} does not accept a full IRI in locator.id. Use ${methodName.replace('Locator', 'Iri')}(table, iri) instead.`);
+        }
+        const requiredKeys = this.getRequiredLocatorKeys(table);
+        const missingKeys = requiredKeys.filter((key) => locator[key] === undefined || locator[key] === null);
+        if (missingKeys.length > 0) {
+            const template = this.getLocatorTemplate(table);
+            throw new Error(`${methodName} requires a complete locator for subjectTemplate '${template}'. ` +
+                `Missing [${missingKeys.join(', ')}]. ` +
+                `Use ${methodName.replace('Locator', 'Iri')}(table, iri) when you already have a full IRI.`);
+        }
+        const resolver = this.dialect.getResolver(table);
+        return resolver.resolveSubject(table, locator);
+    }
+    async findByLocator(table, locator) {
+        const iri = this.resolveLocatorSubject(table, locator, 'findByLocator');
+        return await this.findByIri(table, iri);
+    }
+    /**
+     * 通过完整 IRI 查询单个实体
+     *
+     * @param table - 表定义（用于解析 schema）
+     * @param iri - 完整 IRI，本地或远程
+     * @returns 实体数据，如果不存在则返回 null
+     *
+     * @example
+     * ```typescript
+     * // 本地 Agent
+     * db.findByIri(agentTable, 'https://my.pod/agents/translator')
+     *
+     * // 远程 Profile
+     * db.findByIri(solidProfileTable, 'https://alice.pod/profile/card#me')
+     *
+     * // 业务层不区分本地远程
+     * db.findByIri(agentTable, contact.entityUri)
+     * ```
+     */
+    async findByIri(table, iri) {
+        if (!iri || typeof iri !== 'string') {
+            throw new Error('findByIri requires a valid IRI string');
+        }
+        // 保持原始表上下文，让 subjectTemplate/base 反解保持一致。
+        // whereByIri() 已经会把 SELECT 精确定位到目标资源，不需要把表重绑到具体文档。
+        const rows = await this.session
+            .select()
+            .from(table)
+            .whereByIri(iri)
+            .limit(1);
+        return (rows[0] ?? null);
+    }
+    /**
+     * 解析 IRI 为文档 URL 和 fragment
+     */
+    parseIri(iri) {
+        const hashIndex = iri.indexOf('#');
+        if (hashIndex >= 0) {
+            return {
+                documentUrl: iri.substring(0, hashIndex),
+                fragment: iri.substring(hashIndex + 1)
+            };
+        }
+        return { documentUrl: iri, fragment: null };
+    }
+    /**
+     * 通过完整 IRI 订阅单个实体的变更
+     *
+     * @param table - 表定义
+     * @param iri - 完整 IRI，本地或远程
+     * @param options - 订阅选项
+     * @returns 取消订阅函数
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = await db.subscribeByIri(
+     *   solidProfileTable,
+     *   'https://alice.pod/profile/card#me',
+     *   {
+     *     onUpdate: (data) => {
+     *       console.log('Profile updated:', data.name)
+     *     },
+     *     onDelete: () => {
+     *       console.log('Profile deleted')
+     *     },
+     *     onError: (error) => {
+     *       console.log('Subscription error:', error)
+     *     }
+     *   }
+     * )
+     *
+     * // 离开时取消订阅
+     * unsubscribe()
+     * ```
+     */
+    async subscribeByIri(table, iri, options) {
+        if (!iri || typeof iri !== 'string') {
+            throw new Error('subscribeByIri requires a valid IRI string');
+        }
+        if (!iri.startsWith('http://') && !iri.startsWith('https://')) {
+            throw new Error(`subscribeByIri requires an absolute IRI, got: ${iri}`);
+        }
+        // 懒初始化 NotificationsClient
+        if (!this.notificationsClient) {
+            const authenticatedFetch = this.dialect.getAuthenticatedFetch();
+            const config = {
+                preferredChannels: this.dialect.config.preferredChannels ?? ['streaming-http', 'websocket'],
+            };
+            this.notificationsClient = new notifications_1.NotificationsClient(authenticatedFetch, config);
+        }
+        // 解析文档 URL（订阅文档，而不是 fragment）
+        const { documentUrl } = this.parseIri(iri);
+        // 订阅文档变更
+        const subscription = await this.notificationsClient.subscribe(documentUrl, {
+            channel: options.channel,
+            features: options.features,
+            onNotification: async (event) => {
+                try {
+                    if (event.type === 'Update') {
+                        // 重新获取数据
+                        const data = await this.findByIri(table, iri);
+                        if (data) {
+                            await options.onUpdate(data);
+                        }
+                    }
+                    else if (event.type === 'Delete') {
+                        await options.onDelete?.();
+                    }
+                }
+                catch (error) {
+                    options.onError?.(error);
+                }
+            },
+            onError: options.onError,
+        });
+        // 返回取消订阅函数
+        return () => subscription.unsubscribe();
+    }
+    /**
+     * 通过完整 IRI 更新单个实体
+     *
+     * @param table - 表定义
+     * @param iri - 完整 IRI
+     * @param data - 要更新的数据
+     * @returns 更新后的实体数据
+     *
+     * @example
+     * ```typescript
+     * const updated = await db.updateByIri(
+     *   agentTable,
+     *   'https://my.pod/agents/translator#agent',
+     *   { name: 'New Name', description: 'Updated description' }
+     * )
+     * ```
+     */
+    async updateByIri(table, iri, data) {
+        if (!iri || typeof iri !== 'string') {
+            throw new Error('updateByIri requires a valid IRI string');
+        }
+        if (!iri.startsWith('http://') && !iri.startsWith('https://')) {
+            throw new Error(`updateByIri requires an absolute IRI, got: ${iri}`);
+        }
+        const updateData = data;
+        // 使用 whereByIri 内部方法进行更新
+        await this.session
+            .update(table)
+            .set(updateData)
+            .whereByIri(iri);
+        // 返回更新后的数据
+        return await this.findByIri(table, iri);
+    }
+    async updateByLocator(table, locator, data) {
+        const iri = this.resolveLocatorSubject(table, locator, 'updateByLocator');
+        return await this.updateByIri(table, iri, data);
+    }
+    /**
+     * 通过完整 IRI 删除单个实体
+     *
+     * @param table - 表定义
+     * @param iri - 完整 IRI
+     * @returns 是否删除成功
+     *
+     * @example
+     * ```typescript
+     * const deleted = await db.deleteByIri(
+     *   agentTable,
+     *   'https://my.pod/agents/translator#agent'
+     * )
+     * ```
+     */
+    async deleteByIri(table, iri) {
+        if (!iri || typeof iri !== 'string') {
+            throw new Error('deleteByIri requires a valid IRI string');
+        }
+        if (!iri.startsWith('http://') && !iri.startsWith('https://')) {
+            throw new Error(`deleteByIri requires an absolute IRI, got: ${iri}`);
+        }
+        // 先检查实体是否存在
+        const existing = await this.findByIri(table, iri);
+        if (!existing) {
+            return false;
+        }
+        // 使用 whereByIri 内部方法进行删除
+        await this.session
+            .delete(table)
+            .whereByIri(iri);
+        return true;
+    }
+    async deleteByLocator(table, locator) {
+        const iri = this.resolveLocatorSubject(table, locator, 'deleteByLocator');
+        return await this.deleteByIri(table, iri);
+    }
+    // 事务支持
+    async transaction(transaction) {
+        return await this.session.transaction(async (txSession) => {
+            const txDb = new PodDatabase(this.dialect, txSession, this.schema);
+            return await transaction(txDb);
+        });
+    }
+    // 获取方言信息
+    getDialect() {
+        return this.dialect;
+    }
+    // 获取会话信息
+    getSession() {
+        return this.session;
+    }
+    // 获取模式信息
+    getSchema() {
+        return this.schema;
+    }
+    /**
+     * 数据发现入口（TypeIndex + SAI 组合策略）
+     */
+    get discovery() {
+        return this.dialect.getDiscovery();
+    }
+    // 连接状态
+    async connect() {
+        return await this.dialect.connect();
+    }
+    // 断开连接
+    async disconnect() {
+        // 取消所有订阅
+        if (this.notificationsClient) {
+            this.notificationsClient.unsubscribeAll();
+        }
+        return await this.dialect.disconnect();
+    }
+    /**
+     * 订阅表/资源的变化通知
+     *
+     * @param table - 要订阅的表（会订阅其容器或资源）
+     * @param options - 订阅选项，支持按类型分开的回调
+     * @returns 订阅句柄，可用于取消订阅
+     *
+     * @example
+     * ```typescript
+     * const subscription = await db.subscribe(posts, {
+     *   onCreate: async (activity) => {
+     *     console.log('Created:', activity.object);
+     *     const latest = await db.select().from(posts);
+     *   },
+     *   onUpdate: async (activity) => {
+     *     console.log('Updated:', activity.object);
+     *     const latest = await db.select().from(posts);
+     *   },
+     *   onDelete: (activity) => {
+     *     console.log('Deleted:', activity.object);
+     *   },
+     *   onError: (error) => {
+     *     console.error('Subscription error:', error);
+     *   }
+     * });
+     *
+     * // 取消订阅
+     * subscription.unsubscribe();
+     * ```
+     */
+    async subscribe(table, options) {
+        // 懒初始化 NotificationsClient
+        if (!this.notificationsClient) {
+            const authenticatedFetch = this.dialect.getAuthenticatedFetch();
+            const config = {
+                preferredChannels: this.dialect.config.preferredChannels ?? ['streaming-http', 'websocket'],
+            };
+            this.notificationsClient = new notifications_1.NotificationsClient(authenticatedFetch, config);
+        }
+        // 获取表的资源 URL（容器或文件），支持 iri 覆盖
+        const topic = this.resolveTableTopic(table, options.iri);
+        // 将 TableSubscribeOptions 转换为底层 SubscribeOptions
+        const subscribeOptions = {
+            channel: options.channel,
+            features: options.features,
+            onNotification: (event) => {
+                options.onNotification?.(event);
+                const hasTypedHandlers = Boolean(options.onCreate || options.onUpdate || options.onDelete || options.onAdd || options.onRemove);
+                if (hasTypedHandlers) {
+                    // 构造 Activity 对象
+                    const activity = {
+                        id: event.id,
+                        type: event.type,
+                        object: event.object,
+                        published: event.published,
+                        state: event.state,
+                    };
+                    // 根据类型分发到对应回调
+                    switch (event.type) {
+                        case 'Create':
+                            options.onCreate?.(activity);
+                            break;
+                        case 'Update':
+                            options.onUpdate?.(activity);
+                            break;
+                        case 'Delete':
+                            options.onDelete?.(activity);
+                            break;
+                        case 'Add':
+                            options.onAdd?.(activity);
+                            break;
+                        case 'Remove':
+                            options.onRemove?.(activity);
+                            break;
+                    }
+                }
+            },
+            onError: options.onError,
+            onClose: options.onClose,
+        };
+        return this.notificationsClient.subscribe(topic, subscribeOptions);
+    }
+    /**
+     * 解析表对应的订阅主题 URL
+     * @param table 表定义
+     * @param iriOverride 可选的 IRI 覆盖（用于订阅其他 Pod 的资源）
+     */
+    resolveTableTopic(table, iriOverride) {
+        // 如果提供了 iri 覆盖，直接使用
+        if (iriOverride) {
+            if (!iriOverride.startsWith('http://') && !iriOverride.startsWith('https://')) {
+                throw new Error(`iri must be an absolute URL, got: ${iriOverride}`);
+            }
+            return iriOverride;
+        }
+        const base = table.config.base || '';
+        // 如果 base 已经是绝对 URL，直接使用
+        if (base.startsWith('http://') || base.startsWith('https://')) {
+            return base;
+        }
+        // 使用 dialect.getPodUrl() 获取正确的 Pod 根路径
+        // 这确保与其他 URL 解析逻辑一致（如 TypeIndex、SPARQL endpoint 等）
+        const podUrl = this.dialect.getPodUrl();
+        const baseUrl = podUrl.endsWith('/') ? podUrl : `${podUrl}/`;
+        const relativeBase = base.startsWith('/') ? base.slice(1) : base;
+        return `${baseUrl}${relativeBase}`;
+    }
+    // 获取连接配置
+    getConfig() {
+        return this.dialect.getConfig();
+    }
+    /**
+     * 通过 RDF 类型自动发现并生成表定义
+     *
+     * 流程：
+     * 1. 通过 TypeIndex/Interop 发现数据位置
+     * 2. 如果有 ShapeTree/Shape，加载并解析
+     * 3. 从 Shape 生成 PodTable 定义
+     *
+     * @param rdfClass RDF 类型 URI (如 'http://schema.org/Person')
+     * @returns 生成的 PodTable，如果未发现则返回 null
+     *
+     * @example
+     * ```typescript
+     * // 自动发现 Person 类型的表
+     * const persons = await db.discoverTable('http://schema.org/Person');
+     * if (persons) {
+     *   const data = await db.select().from(persons);
+     * }
+     * ```
+     */
+    async discoverTable(rdfClass) {
+        // 1. 发现数据位置
+        const locations = await this.dialect.discoverDataLocations(rdfClass);
+        if (locations.length === 0) {
+            console.log(`[discoverTable] No data locations found for ${rdfClass}`);
+            return null;
+        }
+        const location = locations[0]; // 使用第一个发现的位置
+        const shapeUrl = location.shapes[0]?.url;
+        console.log(`[discoverTable] Found location: ${location.container}, shape: ${shapeUrl || 'none'}`);
+        // 2. 如果有 Shape，加载并生成表
+        if (shapeUrl) {
+            const shapeManager = this.dialect.getShapeManager();
+            const shape = await shapeManager.loadShape(shapeUrl, this.dialect.getAuthenticatedFetch());
+            if (shape) {
+                console.log(`[discoverTable] Loaded shape with ${shape.properties.length} properties`);
+                const generated = shapeManager.shapeToTable(shape, location.container);
+                // 初始化表
+                await this.init(generated.table);
+                return generated.table;
+            }
+        }
+        // 3. 没有 Shape，使用基础表定义（仅 id 列）
+        console.log(`[discoverTable] No shape available, creating basic table`);
+        const { podTable, string } = await Promise.resolve().then(() => __importStar(require('./schema')));
+        const tableName = this.extractClassName(rdfClass);
+        const table = podTable(tableName, {
+            id: string('id').primaryKey()
+        }, {
+            type: rdfClass,
+            base: location.container
+        });
+        await this.init(table);
+        return table;
+    }
+    /**
+     * 发现多个类型的表
+     */
+    async discoverTables(rdfClasses) {
+        const tables = [];
+        for (const rdfClass of rdfClasses) {
+            const table = await this.discoverTable(rdfClass);
+            if (table) {
+                tables.push(table);
+            }
+        }
+        return tables;
+    }
+    /**
+     * 发现某类型数据的所有位置
+     * @param rdfClass RDF 类型 URI
+     * @param options 可选的过滤选项
+     * @returns 数据位置列表
+     *
+     * @example
+     * ```typescript
+     * // 发现所有 Person 类型的数据位置
+     * const locations = await db.discover('https://schema.org/Person');
+     *
+     * // 按 appId 过滤
+     * const acmeLocations = await db.discover('https://schema.org/Person', {
+     *   appId: 'https://acme.com/app#id'
+     * });
+     * ```
+     */
+    async discover(rdfClass, options) {
+        return this.dialect.discoverDataLocations(rdfClass, options);
+    }
+    /**
+     * 获取所有数据注册信息
+     * @returns 所有注册的数据信息列表
+     *
+     * @example
+     * ```typescript
+     * const allRegistrations = await db.discoverAll();
+     * for (const reg of allRegistrations) {
+     *   console.log(`${reg.rdfClass} at ${reg.container}`);
+     *   console.log(`  Shape: ${reg.shape}`);
+     *   console.log(`  Registered by: ${reg.registeredBy}`);
+     * }
+     * ```
+     */
+    async discoverAll() {
+        return this.dialect.discoverAll();
+    }
+    /**
+     * 按应用 ID 发现数据位置
+     * @param appId 应用标识符
+     * @returns 该应用注册的数据位置列表
+     *
+     * @example
+     * ```typescript
+     * const acmeData = await db.discoverByApp('https://acme.com/app#id');
+     * ```
+     */
+    async discoverByApp(appId) {
+        return this.dialect.discoverByApp(appId);
+    }
+    /**
+     * 从 DataLocation 创建 PodTable
+     * 如果 location 有 shape，会加载 Shape 并生成完整的表定义
+     *
+     * @param location 数据位置信息
+     * @param options 转换选项，可指定使用哪个 Shape
+     * @returns PodTable 实例
+     *
+     * @example
+     * ```typescript
+     * // 使用第一个可用的 Shape
+     * const table = await db.locationToTable(location);
+     *
+     * // 指定使用某个 app 注册的 Shape
+     * const table = await db.locationToTable(location, {
+     *   appId: 'https://acme.com/app#id'
+     * });
+     *
+     * // 直接传入 ShapeInfo 对象
+     * const table = await db.locationToTable(location, {
+     *   shape: location.shapes[0]
+     * });
+     *
+     * // 或者传入 Shape URL
+     * const table = await db.locationToTable(location, {
+     *   shape: 'https://shapes.example/Person.shacl'
+     * });
+     * ```
+     */
+    async locationToTable(location, options) {
+        const opts = options ?? {};
+        // 1. 选择 Shape（按优先级：shape > appId > 默认第一个）
+        let selectedShape;
+        if (opts.shape) {
+            // 直接指定 Shape
+            if (typeof opts.shape === 'string') {
+                // Shape URL
+                selectedShape = location.shapes.find(s => s.url === opts.shape);
+                if (!selectedShape) {
+                    // URL 不在 shapes 列表中，创建临时 ShapeInfo
+                    selectedShape = { url: opts.shape, source: 'config' };
+                }
+            }
+            else {
+                // ShapeInfo 对象
+                selectedShape = opts.shape;
+            }
+        }
+        else if (opts.appId) {
+            // 按 appId 选择
+            selectedShape = location.shapes.find(s => s.registeredBy === opts.appId);
+            if (!selectedShape) {
+                throw new Error(`[locationToTable] No shape found for appId: ${opts.appId}`);
+            }
+        }
+        else {
+            // 默认使用第一个
+            selectedShape = location.shapes[0];
+        }
+        // 2. 如果有 Shape，加载并生成表
+        if (selectedShape?.url) {
+            const shapeManager = this.dialect.getShapeManager();
+            const shape = await shapeManager.loadShape(selectedShape.url, this.dialect.getAuthenticatedFetch());
+            if (shape) {
+                console.log(`[locationToTable] Loaded shape: ${selectedShape.url} (${shape.properties.length} properties)`);
+                if (selectedShape.registeredBy) {
+                    console.log(`[locationToTable] -> registeredBy: ${selectedShape.registeredBy}`);
+                }
+                const generated = shapeManager.shapeToTable(shape, location.container);
+                // 初始化表
+                await this.init(generated.table);
+                return generated.table;
+            }
+        }
+        // 3. 没有 Shape，返回仅含 id 的基础表
+        console.log(`[locationToTable] No shape available, creating basic table for container: ${location.container}`);
+        const { podTable, string } = await Promise.resolve().then(() => __importStar(require('./schema')));
+        const tableName = this.extractContainerName(location.container);
+        const table = podTable(tableName, {
+            id: string('id').primaryKey()
+        }, {
+            type: 'http://www.w3.org/2000/01/rdf-schema#Resource',
+            base: location.container
+        });
+        await this.init(table);
+        return table;
+    }
+    /**
+     * 从容器 URL 提取表名
+     */
+    extractContainerName(containerUrl) {
+        // 去掉末尾斜杠
+        const url = containerUrl.replace(/\/$/, '');
+        const lastSlash = url.lastIndexOf('/');
+        if (lastSlash >= 0) {
+            return url.substring(lastSlash + 1).toLowerCase() || 'data';
+        }
+        return 'data';
+    }
+    /**
+     * 发现并转换为表 - 支持按 appId 过滤
+     *
+     * @param rdfClass RDF 类型 URI
+     * @param options 发现选项
+     * @param tableOptions 转表选项（指定使用哪个 Shape）
+     *
+     * @example
+     * ```typescript
+     * // 发现所有 Person 表
+     * const allPersonTables = await db.discoverTablesFor('schema:Person');
+     *
+     * // 只要 Acme app 的 Person 表，并使用 Acme 的 Shape
+     * const acmePersonTable = await db.discoverTablesFor('schema:Person',
+     *   { appId: 'https://acme.com/app#id' },
+     *   { appId: 'https://acme.com/app#id' }
+     * );
+     * ```
+     */
+    async discoverTablesFor(rdfClass, options, tableOptions) {
+        const locations = await this.discover(rdfClass, options);
+        const tables = [];
+        for (const location of locations) {
+            const table = await this.locationToTable(location, tableOptions);
+            tables.push(table);
+        }
+        return tables;
+    }
+    /**
+     * 从 RDF 类型 URI 提取类名
+     */
+    extractClassName(rdfClass) {
+        const hashIndex = rdfClass.lastIndexOf('#');
+        if (hashIndex >= 0) {
+            return rdfClass.substring(hashIndex + 1).toLowerCase();
+        }
+        const slashIndex = rdfClass.lastIndexOf('/');
+        if (slashIndex >= 0) {
+            return rdfClass.substring(slashIndex + 1).toLowerCase();
+        }
+        return rdfClass.toLowerCase();
+    }
+    // 数据源管理方法
+    addSource(source) {
+        this.dialect.addSource(source);
+    }
+    removeSource(source) {
+        this.dialect.removeSource(source);
+    }
+    getSources() {
+        return this.dialect.getSources();
+    }
+    async addSourcesFromTypeIndex() {
+        return await this.dialect.addSourcesFromTypeIndex();
+    }
+    async init(...args) {
+        // 解析参数：最后一个参数可能是 options
+        let options;
+        let tableArgs;
+        const lastArg = args[args.length - 1];
+        if (lastArg && typeof lastArg === 'object' && !Array.isArray(lastArg) && !('columns' in lastArg)) {
+            // 最后一个参数是 options
+            options = lastArg;
+            tableArgs = args.slice(0, -1);
+        }
+        else {
+            tableArgs = args;
+        }
+        const flattened = [];
+        for (const entry of tableArgs) {
+            if (!entry)
+                continue;
+            if (Array.isArray(entry)) {
+                for (const table of entry) {
+                    if (table) {
+                        flattened.push(table);
+                    }
+                }
+            }
+            else {
+                flattened.push(entry);
+            }
+        }
+        for (const table of flattened) {
+            if (typeof table.init === 'function') {
+                await table.init(this.dialect);
+            }
+            else {
+                await this.dialect.registerTable(table);
+            }
+            // 如果需要生成 Shape
+            if (options?.generateShape || options?.saveShape) {
+                const shapeManager = this.dialect.getShapeManager();
+                const shape = shapeManager.generateShape(table);
+                // 如果需要保存 Shape
+                if (options?.saveShape) {
+                    const podUrl = this.dialect.getPodUrl();
+                    let shapeLocation = options.shapeLocation;
+                    if (!shapeLocation) {
+                        // 默认保存到 /shapes/ 目录
+                        shapeLocation = `${podUrl}shapes/`;
+                    }
+                    else if (!shapeLocation.startsWith('http')) {
+                        // 相对路径转绝对路径
+                        shapeLocation = `${podUrl}${shapeLocation.replace(/^\//, '')}`;
+                    }
+                    // 确保以 / 结尾（容器）
+                    if (!shapeLocation.endsWith('/')) {
+                        shapeLocation += '/';
+                    }
+                    const shapeUrl = `${shapeLocation}${table.config.name}Shape.ttl`;
+                    try {
+                        await shapeManager.saveShape(shape, shapeUrl);
+                        console.log(`[init] Shape saved to: ${shapeUrl}`);
+                    }
+                    catch (error) {
+                        console.warn(`[init] Failed to save Shape to ${shapeUrl}:`, error);
+                    }
+                }
+            }
+        }
+    }
+    get query() {
+        if (!this.queryProxy) {
+            this.queryProxy = this.buildQueryProxy();
+        }
+        return this.queryProxy;
+    }
+    buildQueryProxy() {
+        const schemaEntries = (this.schema && typeof this.schema === 'object')
+            ? Object.entries(this.schema)
+            : [];
+        const tableMap = new Map();
+        for (const [key, value] of schemaEntries) {
+            if (isPodTable(value)) {
+                tableMap.set(key, value);
+            }
+        }
+        const createHelper = (_tableName, table) => {
+            const createLazy = (executor) => {
+                let promise = null;
+                const run = () => {
+                    if (!promise) {
+                        promise = executor();
+                    }
+                    return promise;
+                };
+                return {
+                    then: (onfulfilled, onrejected) => run().then(onfulfilled, onrejected),
+                    catch: (onrejected) => run().catch(onrejected),
+                    finally: (onfinally) => run().finally(onfinally),
+                    [Symbol.toStringTag]: 'Promise',
+                };
+            };
+            const projectColumns = (row, columns, withOption) => {
+                const projected = {};
+                for (const [alias, field] of Object.entries(columns)) {
+                    if (field instanceof schema_1.PodColumnBase) {
+                        projected[alias] = row[field.name];
+                        continue;
+                    }
+                    if (typeof field === 'string') {
+                        projected[alias] = row[field] ?? row[field.split('.').pop() ?? field];
+                        continue;
+                    }
+                    const name = field?.name;
+                    if (typeof name === 'string') {
+                        projected[alias] = row[name];
+                        continue;
+                    }
+                    projected[alias] = row[alias];
+                }
+                if (withOption) {
+                    for (const relationName of Object.keys(withOption)) {
+                        projected[relationName] = row[relationName] ?? [];
+                    }
+                }
+                return projected;
+            };
+            const executeFindMany = async (options) => {
+                this.clearFederatedErrors();
+                let builder = this.session.select().from(table);
+                if (options?.where) {
+                    builder = builder.where(options.where);
+                }
+                if (options?.orderBy) {
+                    const orderItems = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+                    orderItems.forEach((item) => {
+                        builder = builder.orderBy(item.column, item.direction ?? 'asc');
+                    });
+                }
+                if (typeof options?.limit === 'number') {
+                    builder = builder.limit(options.limit);
+                }
+                if (typeof options?.offset === 'number') {
+                    builder = builder.offset(options.offset);
+                }
+                let rows = await builder;
+                if (options?.with && Object.keys(options.with).length > 0) {
+                    rows = await this.eagerLoadWith(rows, table, options.with, tableMap);
+                }
+                const columns = options?.columns;
+                if (columns) {
+                    rows = rows.map((row) => projectColumns(row, columns, options.with));
+                }
+                return rows;
+            };
+            const findMany = (options) => createLazy(() => executeFindMany(options));
+            const applyExactOptions = async (row, options) => {
+                if (!row) {
+                    return null;
+                }
+                let rows = [row];
+                if (options?.with && Object.keys(options.with).length > 0) {
+                    rows = await this.eagerLoadWith(rows, table, options.with, tableMap);
+                }
+                const columns = options?.columns;
+                if (columns) {
+                    rows = rows.map((item) => projectColumns(item, columns, options.with));
+                }
+                return (rows[0] ?? null);
+            };
+            const findFirst = (options) => createLazy(async () => {
+                const rows = await executeFindMany({ ...options, limit: 1 });
+                return rows[0] ?? null;
+            });
+            const count = (options) => createLazy(async () => {
+                const rows = await executeFindMany({ where: options?.where, columns: undefined, limit: undefined, offset: undefined });
+                return rows.length;
+            });
+            const createFindByLocator = () => (locator, options) => createLazy(async () => await applyExactOptions(await this.findByLocator(table, locator), options));
+            const createFindByIri = () => (iri, options) => createLazy(async () => await applyExactOptions(await this.findByIri(table, iri), options));
+            return {
+                findMany,
+                findFirst,
+                findByLocator: createFindByLocator(),
+                findByIri: createFindByIri(),
+                count
+            };
+        };
+        const proxyTarget = {};
+        return new Proxy(proxyTarget, {
+            get: (_, prop) => {
+                if (typeof prop !== 'string') {
+                    return undefined;
+                }
+                const table = tableMap.get(prop);
+                if (table) {
+                    return createHelper(prop, table);
+                }
+                return undefined;
+            }
+        });
+    }
+    async eagerLoadWith(rows, parentTable, withOption, tableMap) {
+        if (!rows || rows.length === 0) {
+            return rows;
+        }
+        const dedupedRows = this.dedupeBySubject(rows);
+        for (const [key, entry] of Object.entries(withOption)) {
+            if (!entry)
+                continue;
+            const relationDef = parentTable.relations?.[key];
+            const targetTable = (typeof entry === 'object' && entry.table)
+                ? entry.table
+                : relationDef?.table ?? tableMap.get(key);
+            if (!targetTable)
+                continue;
+            // 联邦查询：使用 FederatedQueryExecutor
+            if ((0, schema_1.isSolidSchema)(targetTable) || relationDef?.isFederated) {
+                if (relationDef && relationDef.discover) {
+                    try {
+                        const executor = this.getFederatedExecutor();
+                        const result = await executor.execute(dedupedRows, {
+                            ...relationDef,
+                            relationName: key,
+                        });
+                        // 收集错误
+                        if (result.errors && result.errors.length > 0) {
+                            this.lastFederatedErrors.push(...result.errors);
+                        }
+                        // 结果已经被添加到 dedupedRows 中
+                    }
+                    catch (error) {
+                        console.warn(`Federated relation "${key}" failed:`, error);
+                        // 设置空数组作为默认值
+                        dedupedRows.forEach((row) => {
+                            row[key] = [];
+                        });
+                    }
+                }
+                else {
+                    console.warn(`Federated relation "${key}" missing discover function, skipping.`);
+                    dedupedRows.forEach((row) => {
+                        row[key] = [];
+                    });
+                }
+                continue;
+            }
+            // 此时 targetTable 一定是 PodTable
+            const targetPodTable = targetTable;
+            const targetType = targetPodTable.config.type;
+            const candidateColumns = relationDef?.fields && relationDef.fields.length > 0
+                ? relationDef.fields
+                : Object.values(targetPodTable.columns ?? {});
+            const matchesParentLink = (col) => Boolean(col && (col.options?.linkTarget === parentTable.config.type ||
+                col.options?.linkTable === parentTable ||
+                col.getLinkTable?.() === parentTable));
+            const matchesTargetLink = (col) => Boolean(col && (col.options?.linkTarget === targetType ||
+                col.options?.linkTable === targetPodTable ||
+                col.getLinkTable?.() === targetPodTable));
+            const linkColumns = relationDef?.fields && relationDef.fields.length > 0
+                ? candidateColumns
+                : candidateColumns.filter((col) => matchesParentLink(col) && !col.isInverse?.());
+            if (linkColumns.length === 0) {
+                const relationReferenceFields = relationDef?.references ?? [];
+                const explicitInverse = relationReferenceFields.filter((col) => Boolean(col &&
+                    typeof col.isInverse === 'function' &&
+                    col.isInverse() &&
+                    matchesTargetLink(col)));
+                const parentColumns = Object.values(parentTable.columns ?? {});
+                const inverseCandidates = (explicitInverse.length > 0 ? explicitInverse : parentColumns).filter((col) => typeof col.isInverse === 'function' &&
+                    col.isInverse() &&
+                    matchesTargetLink(col));
+                if (inverseCandidates.length === 0) {
+                    continue;
+                }
+                const inverseValuesPerRow = dedupedRows.map((row) => this.collectInverseLinkValues(row, inverseCandidates));
+                const uniqueIris = Array.from(new Set(inverseValuesPerRow
+                    .flat()
+                    .filter((iri) => typeof iri === 'string' && iri.length > 0)));
+                if (uniqueIris.length === 0) {
+                    rows.forEach((row) => {
+                        row[key] = [];
+                    });
+                    continue;
+                }
+                let childBuilder = this.session.select().from(targetPodTable);
+                childBuilder = childBuilder.whereByIri(uniqueIris);
+                const childRows = await childBuilder;
+                const groupedByIri = this.groupRowsByIri(childRows);
+                dedupedRows.forEach((row, index) => {
+                    const iris = inverseValuesPerRow[index];
+                    const related = [];
+                    iris.forEach((iri) => {
+                        const matches = groupedByIri.get(iri);
+                        if (matches && matches.length > 0) {
+                            related.push(...matches);
+                        }
+                    });
+                    row[key] = related;
+                });
+                continue;
+            }
+            const refColumn = linkColumns[0];
+            const linkColumn = relationDef?.references && relationDef.references[0];
+            const useLinkIri = refColumn.isLink();
+            const parentKeys = dedupedRows
+                .map((row) => this.resolveParentKey(row, linkColumn, useLinkIri))
+                .filter((value) => typeof value === 'string' && value.length > 0);
+            if (parentKeys.length === 0) {
+                continue;
+            }
+            let childBuilder = this.session.select().from(targetPodTable);
+            if (useLinkIri) {
+                childBuilder = childBuilder.where((0, query_conditions_1.inArray)(refColumn, parentKeys));
+            }
+            else {
+                childBuilder = childBuilder.where({ [refColumn.name]: parentKeys });
+            }
+            const childRows = await childBuilder;
+            const grouped = new Map();
+            for (const child of childRows) {
+                const fkValue = child[refColumn.name];
+                const normalizedFkValue = this.normalizeLiteralValue(fkValue);
+                const lookupKeys = useLinkIri
+                    ? this.collectLinkLookupKeys(fkValue)
+                    : (normalizedFkValue ? [normalizedFkValue] : []);
+                for (const lookupKey of lookupKeys) {
+                    const arr = grouped.get(lookupKey) ?? [];
+                    arr.push(child);
+                    grouped.set(lookupKey, arr);
+                }
+            }
+            dedupedRows.forEach((row) => {
+                const parentKeys = useLinkIri
+                    ? Array.from(new Set([
+                        this.resolveParentKey(row, linkColumn, true),
+                        this.resolveIdFromRow(row),
+                    ].filter((value) => typeof value === 'string' && value.length > 0)))
+                    : [this.resolveParentKey(row, linkColumn, false)].filter((value) => typeof value === 'string' && value.length > 0);
+                const related = [];
+                for (const parentKey of parentKeys) {
+                    const matches = grouped.get(parentKey) ?? [];
+                    for (const match of matches) {
+                        if (!related.includes(match)) {
+                            related.push(match);
+                        }
+                    }
+                }
+                row[key] = related;
+            });
+        }
+        return dedupedRows;
+    }
+    dedupeBySubject(rows) {
+        const merged = new Map();
+        const order = [];
+        for (const row of rows) {
+            const key = this.resolveIriFromRow(row) ?? this.resolveIdFromRow(row);
+            if (!key) {
+                order.push(`__anon_${order.length}`);
+                merged.set(order[order.length - 1], { ...row });
+                continue;
+            }
+            if (!merged.has(key)) {
+                merged.set(key, { ...row });
+                order.push(key);
+                continue;
+            }
+            const target = merged.get(key);
+            if (!target) {
+                continue;
+            }
+            for (const [col, value] of Object.entries(row)) {
+                if (value === undefined)
+                    continue;
+                const existing = target[col];
+                if (existing === undefined) {
+                    target[col] = value;
+                    continue;
+                }
+                const existingArr = Array.isArray(existing) ? existing : [existing];
+                const incomingArr = Array.isArray(value) ? value : [value];
+                const mergedArr = [...existingArr];
+                for (const incoming of incomingArr) {
+                    if (!mergedArr.some((item) => item === incoming)) {
+                        mergedArr.push(incoming);
+                    }
+                }
+                target[col] = mergedArr.length === 1 ? mergedArr[0] : mergedArr;
+            }
+        }
+        return order
+            .map((key) => merged.get(key))
+            .filter((row) => row !== undefined);
+    }
+    resolveIdFromRow(row) {
+        if (!row)
+            return undefined;
+        if (typeof row.id === 'string' && row.id.length > 0) {
+            return row.id;
+        }
+        const iri = typeof row['@id'] === 'string' ? row['@id'] : undefined;
+        if (iri) {
+            return this.extractFragment(iri);
+        }
+        return undefined;
+    }
+    resolveParentKey(row, linkColumn, useLinkIri) {
+        if (linkColumn) {
+            const value = row[linkColumn.name];
+            return useLinkIri ? this.normalizeLinkValue(value) : this.normalizeLiteralValue(value);
+        }
+        return useLinkIri ? this.resolveIriFromRow(row) : this.resolveIdFromRow(row);
+    }
+    resolveIriFromRow(row) {
+        if (!row)
+            return undefined;
+        if (typeof row['@id'] === 'string' && row['@id'].length > 0) {
+            return row['@id'];
+        }
+        if (typeof row.subject === 'string' && row.subject.length > 0) {
+            return row.subject;
+        }
+        return undefined;
+    }
+    collectLinkLookupKeys(value) {
+        const keys = [];
+        const normalized = this.normalizeLinkValue(value) ?? this.normalizeLiteralValue(value);
+        if (normalized) {
+            keys.push(normalized);
+            const fragment = this.extractFragment(normalized);
+            if (fragment && !keys.includes(fragment)) {
+                keys.push(fragment);
+            }
+        }
+        return keys;
+    }
+    normalizeLinkValue(value) {
+        if (!value)
+            return undefined;
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (hasStringValue(value)) {
+            return value.value;
+        }
+        return undefined;
+    }
+    normalizeLiteralValue(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (hasStringValue(value)) {
+            return value.value;
+        }
+        return undefined;
+    }
+    collectInverseLinkValues(row, columns) {
+        if (!columns.length) {
+            return [];
+        }
+        const collected = [];
+        for (const column of columns) {
+            const raw = row[column.name];
+            if (raw === undefined || raw === null) {
+                continue;
+            }
+            const appendValue = (entry) => {
+                const normalized = this.normalizeLinkValue(entry) ?? (typeof entry === 'string' ? entry : undefined);
+                if (normalized) {
+                    collected.push(normalized);
+                }
+            };
+            if (Array.isArray(raw)) {
+                raw.forEach(appendValue);
+            }
+            else {
+                appendValue(raw);
+            }
+        }
+        return collected;
+    }
+    groupRowsByIri(rows) {
+        const grouped = new Map();
+        for (const row of rows) {
+            const iri = this.normalizeLinkValue(row['@id']) ??
+                this.normalizeLinkValue(row.uri) ??
+                (typeof row['@id'] === 'string' ? row['@id'] : undefined);
+            if (!iri) {
+                continue;
+            }
+            const bucket = grouped.get(iri) ?? [];
+            bucket.push(row);
+            grouped.set(iri, bucket);
+        }
+        return grouped;
+    }
+    extractFragment(value) {
+        const hashPart = value.includes('#') ? value.split('#').pop() : undefined;
+        if (hashPart && hashPart.length > 0) {
+            return hashPart;
+        }
+        const parts = value.split('/');
+        return parts.pop() ?? value;
+    }
+}
+exports.PodDatabase = PodDatabase;
+_a = drizzle_orm_1.entityKind;
+PodDatabase[_a] = 'PodDatabase';
+//# sourceMappingURL=pod-database.js.map