@undefineds.co/drizzle-solid 0.2.6

package/dist/esm/core/pod-table.js

@@ -0,0 +1,1249 @@
+var _a, _b;
+import { entityKind } from 'drizzle-orm';
+// NanoID-like ID Generator (URL-friendly, cryptographically strong)
+const urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+const generateNanoId = (size = 21) => {
+    let id = '';
+    // Use crypto for randomness (browser & modern Node)
+    let bytes;
+    if (typeof globalThis.crypto !== 'undefined' && typeof globalThis.crypto.getRandomValues === 'function') {
+        bytes = globalThis.crypto.getRandomValues(new Uint8Array(size));
+    }
+    else {
+        // Fallback for older Node.js or environments without Web Crypto API (less secure)
+        // For Node.js, require('crypto') might be an option but we avoid dynamic require for bundling.
+        // This fallback is less secure but prevents crashes.
+        console.warn("Using Math.random fallback for NanoID generation. Consider polyfilling crypto or upgrading Node.js for production.");
+        bytes = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            bytes[i] = Math.floor(Math.random() * 256); // Fill with pseudo-random bytes
+        }
+    }
+    for (let i = 0; i < size; i++) {
+        id += urlAlphabet[bytes[i] % urlAlphabet.length];
+    }
+    return id;
+};
+const hasStringValue = (input) => typeof input === 'object' && input !== null && typeof input.value === 'string';
+const hasTermValue = (input) => typeof input === 'object' && input !== null &&
+    typeof input.term === 'object' &&
+    input.term !== null &&
+    typeof input.term?.value === 'string';
+const resolveTermIri = (input) => {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (hasStringValue(input)) {
+        return input.value;
+    }
+    if (hasTermValue(input)) {
+        return input.term.value;
+    }
+    throw new Error('Term must be a string or VocabTerm with a string value');
+};
+export class ColumnBuilder {
+    constructor(name, dataType, options = {}, predicate, elementType) {
+        this.name = name;
+        this.dataType = dataType;
+        this.options = { ...options }; // 复制options避免引用问题
+        this._predicateUri = predicate;
+        this.elementType = elementType ?? null;
+    }
+    // 统一的值格式化方法 - Column 层负责类型转换
+    formatValue(value) {
+        if (value === null || value === undefined) {
+            throw new Error('Cannot format null or undefined value');
+        }
+        // 处理数组类型 - 使用多重属性
+        if (this.options.isArray) {
+            if (!Array.isArray(value)) {
+                throw new Error('Array column requires array value');
+            }
+            // 返回字符串数组，每个元素会作为单独的三元组
+            return value.map(item => this.formatSingleValue(item));
+        }
+        return this.formatSingleValue(value);
+    }
+    // 格式化单个值
+    formatSingleValue(value) {
+        const effectiveType = this.options.isArray && this.elementType ? this.elementType : this.dataType;
+        // 处理引用类型
+        if (this.options.referenceTarget && typeof value === 'string') {
+            return `<${value}>`;
+        }
+        // 根据数据类型格式化
+        switch (effectiveType) {
+            case 'string':
+                return `"${String(value).replace(/"/g, '\\"')}"`;
+            case 'integer':
+                return String(Number(value));
+            case 'boolean':
+                return `"${value}"^^<http://www.w3.org/2001/XMLSchema#boolean>`;
+            case 'datetime': {
+                const date = value instanceof Date ? value : new Date(value);
+                return `"${date.toISOString()}"^^<http://www.w3.org/2001/XMLSchema#dateTime>`;
+            }
+            case 'json':
+            case 'object': {
+                const jsonString = JSON.stringify(value);
+                return `"${jsonString.replace(/"/g, '\\"')}"^^<http://www.w3.org/2001/XMLSchema#json>`;
+            }
+            case 'uri':
+                // URI 类型直接作为 NamedNode，不需要引号
+                if (typeof value !== 'string' || (!value.startsWith('http://') && !value.startsWith('https://'))) {
+                    throw new Error(`URI column requires valid HTTP(S) URL, got: ${value}`);
+                }
+                return `<${value}>`;
+            default:
+                return `"${String(value).replace(/"/g, '\\"')}"`;
+        }
+    }
+    // 统一的值解析方法 - Column 层负责类型解析
+    parseValue(rdfValue, datatypeIri) {
+        // 处理数组类型在 SPARQL 执行层会返回多个值的数组
+        if (this.options.isArray) {
+            // 这个方法主要用于解析单个 RDF 值，数组会在查询层处理
+            return this.parseSingleValue(rdfValue, datatypeIri);
+        }
+        return this.parseSingleValue(rdfValue, datatypeIri);
+    }
+    // 解析单个值
+    parseSingleValue(rdfValue, datatypeIri) {
+        if (!datatypeIri) {
+            return rdfValue;
+        }
+        // 根据数据类型和 RDF 类型解析
+        if (datatypeIri.includes('#integer') || datatypeIri.includes('#int')) {
+            return parseInt(rdfValue, 10);
+        }
+        else if (datatypeIri.includes('#decimal') || datatypeIri.includes('#double')) {
+            return parseFloat(rdfValue);
+        }
+        else if (datatypeIri.includes('#boolean')) {
+            return rdfValue === 'true';
+        }
+        else if (datatypeIri.includes('#dateTime')) {
+            return new Date(rdfValue);
+        }
+        else if (datatypeIri.includes('#json')) {
+            try {
+                return JSON.parse(rdfValue);
+            }
+            catch (error) {
+                console.warn('Failed to parse JSON value:', rdfValue);
+                return rdfValue;
+            }
+        }
+        // URI 类型检测 - 如果看起来像 URI 就直接返回
+        if (rdfValue.startsWith('http://') || rdfValue.startsWith('https://')) {
+            return rdfValue;
+        }
+        return rdfValue;
+    }
+    primaryKey() {
+        const predicate = this.name === 'id'
+            ? '@id'
+            : this.options.predicate;
+        this.options = {
+            ...this.options,
+            primaryKey: true,
+            required: true,
+            predicate
+        };
+        if (predicate) {
+            this._predicateUri = predicate;
+        }
+        return this;
+    }
+    notNull() {
+        this.options = { ...this.options, required: true, notNull: true };
+        return this;
+    }
+    predicate(uri) {
+        const resolved = resolveTermIri(uri);
+        this._predicateUri = resolved;
+        this.options = { ...this.options, predicate: resolved };
+        return this;
+    }
+    default(value) {
+        this.options = { ...this.options, defaultValue: value };
+        return this;
+    }
+    defaultNow() {
+        this.options = { ...this.options, defaultValue: () => new Date() };
+        return this;
+    }
+    inverse(value = true) {
+        this.options = { ...this.options, inverse: value };
+        return this;
+    }
+    /**
+     * 设置引用目标
+     *
+     * 支持三种输入格式：
+     * 1. class URI 字符串 (https://...) - 从 tableRegistry 按 class 查找
+     * 2. 表名字符串 (非 URL 格式) - 从 tableNameRegistry 按表名查找
+     * 3. PodTable 对象 - 直接使用，优先级最高
+     *
+     * @example
+     * // 使用 class URI（自动推导表）
+     * author: uri('author').reference('https://schema.org/Person')
+     *
+     * // 使用表名（解决同 class 多表歧义）
+     * author: uri('author').reference('users_public')
+     *
+     * // 使用表对象（类型安全，但注意循环依赖）
+     * author: uri('author').reference(usersTable)
+     */
+    reference(target) {
+        if (typeof target === 'string') {
+            // 字符串：根据格式判断是 class URI 还是表名
+            if (target.startsWith('http://') || target.startsWith('https://')) {
+                // class URI
+                this.options = { ...this.options, referenceTarget: target };
+            }
+            else {
+                // 表名
+                this.options = { ...this.options, referenceTableName: target };
+            }
+        }
+        else {
+            // PodTable 对象
+            this.options = { ...this.options, referenceTable: target };
+        }
+        return this;
+    }
+    // Array support - similar to Drizzle ORM PostgreSQL
+    array() {
+        const arrayBuilder = new ColumnBuilder(this.name, 'array', {
+            ...this.options,
+            baseType: this.dataType,
+            isArray: true
+        }, this._predicateUri, this.dataType);
+        return arrayBuilder;
+    }
+    // method to get predicate URI
+    getPredicateUri() {
+        return this._predicateUri;
+    }
+}
+// 列类型基类
+export class PodColumnBase {
+    constructor(name, dataType, options = {}, tableName) {
+        this.name = name;
+        this.dataType = dataType;
+        this.options = options;
+        this.tableName = tableName;
+    }
+    // 获取 RDF 谓词
+    getPredicate(tableNamespace) {
+        if (this.options.predicate) {
+            return this.options.predicate;
+        }
+        if (tableNamespace) {
+            return `${tableNamespace.uri}${this.name}`;
+        }
+        throw new Error(`Missing predicate for column "${this.name}"; please set namespace or predicate explicitly.`);
+    }
+    // 检查是否是引用类型
+    isReference() {
+        return !!(this.options.referenceTarget || this.options.referenceTableName || this.options.referenceTable);
+    }
+    // 获取引用目标 class URI
+    getReferenceTarget() {
+        return this.options.referenceTarget;
+    }
+    // 获取引用的目标表名
+    getReferenceTableName() {
+        return this.options.referenceTableName;
+    }
+    // 获取引用的目标表对象
+    getReferenceTable() {
+        return this.options.referenceTable;
+    }
+    // 链式方法 - 简化版本，直接返回 this
+    primaryKey() {
+        this.options.primaryKey = true;
+        this.options.required = true; // 主键自动为 required
+        if (!this.options.predicate && this.name === 'id') {
+            this.options.predicate = '@id';
+        }
+        return this;
+    }
+    notNull() {
+        this.options.required = true;
+        return this;
+    }
+    default(value) {
+        this.options.defaultValue = value;
+        return this;
+    }
+    predicate(uri) {
+        this.options.predicate = resolveTermIri(uri);
+        return this;
+    }
+    /**
+     * 设置引用目标
+     *
+     * 支持三种输入格式：
+     * 1. class URI 字符串 (https://...) - 从 tableRegistry 按 class 查找
+     * 2. 表名字符串 (非 URL 格式) - 从 tableNameRegistry 按表名查找
+     * 3. PodTable 对象 - 直接使用，优先级最高
+     */
+    reference(target) {
+        if (typeof target === 'string') {
+            if (target.startsWith('http://') || target.startsWith('https://')) {
+                this.options.referenceTarget = target;
+            }
+            else {
+                this.options.referenceTableName = target;
+            }
+        }
+        else {
+            this.options.referenceTable = target;
+        }
+        return this;
+    }
+    inverse(value = true) {
+        this.options.inverse = value;
+        return this;
+    }
+    isInverse() {
+        return this.options.inverse === true;
+    }
+    // 统一的值格式化方法 - Column 层负责类型转换
+    formatValue(value) {
+        if (value === null || value === undefined) {
+            throw new Error('Cannot format null or undefined value');
+        }
+        // 处理数组类型 - 使用多重属性
+        if (this.options.isArray) {
+            if (!Array.isArray(value)) {
+                throw new Error('Array column requires array value');
+            }
+            // 返回字符串数组，每个元素会作为单独的三元组
+            return value.map(item => this.formatSingleValue(item));
+        }
+        return this.formatSingleValue(value);
+    }
+    // 格式化单个值
+    formatSingleValue(value) {
+        // 处理引用类型
+        if (this.options.referenceTarget && typeof value === 'string') {
+            return `<${value}>`;
+        }
+        // 根据数据类型格式化
+        switch (this.dataType) {
+            case 'string':
+                return `"${String(value).replace(/"/g, '\\"')}"`;
+            case 'integer':
+                return `"${Number(value)}"^^<http://www.w3.org/2001/XMLSchema#integer>`;
+            case 'boolean':
+                return `"${value}"^^<http://www.w3.org/2001/XMLSchema#boolean>`;
+            case 'datetime': {
+                const date = value instanceof Date ? value : new Date(value);
+                return `"${date.toISOString()}"^^<http://www.w3.org/2001/XMLSchema#dateTime>`;
+            }
+            case 'json':
+            case 'object': {
+                const jsonString = JSON.stringify(value);
+                return `"${jsonString.replace(/"/g, '\\"')}"^^<http://www.w3.org/2001/XMLSchema#json>`;
+            }
+            case 'uri':
+                // URI 类型直接作为 NamedNode，不需要引号
+                // 简单的 URI 校验：必须包含 scheme (即包含冒号)
+                // 这可以排除像 "xpod_123" 这样的普通字符串，同时支持 http, https, urn, mailto 等
+                if (typeof value !== 'string' || !value.includes(':')) {
+                    throw new Error(`URI column requires valid IRI (must contain scheme), got: ${value}`);
+                }
+                return `<${value}>`;
+            default:
+                return `"${String(value).replace(/"/g, '\\"')}"`;
+        }
+    }
+}
+_a = entityKind;
+PodColumnBase[_a] = 'PodColumn';
+// 具体的列类型
+export class PodStringColumn extends PodColumnBase {
+    constructor(name, options = {}) {
+        super(name, 'string', options);
+    }
+}
+export class PodIntegerColumn extends PodColumnBase {
+    constructor(name, options = {}) {
+        super(name, 'integer', options);
+    }
+}
+export class PodBooleanColumn extends PodColumnBase {
+    constructor(name, options = {}) {
+        super(name, 'boolean', options);
+    }
+}
+export class PodDateTimeColumn extends PodColumnBase {
+    constructor(name, options = {}) {
+        super(name, 'datetime', options);
+    }
+}
+export class PodJsonColumn extends PodColumnBase {
+    constructor(name, options = {}) {
+        super(name, 'json', options);
+    }
+}
+export class PodObjectColumn extends PodColumnBase {
+    constructor(name, options = {}) {
+        super(name, 'object', options);
+    }
+}
+export class PodUriColumn extends PodColumnBase {
+    constructor(name, options = {}) {
+        super(name, 'uri', options);
+    }
+}
+export class PodArrayColumn extends PodColumnBase {
+    constructor(name, elementType, options = {}) {
+        super(name, 'array', options);
+        this.elementType = elementType;
+    }
+}
+// ============ Schema 继承工具函数 ============
+/**
+ * 验证子类列不能修改父类的 predicate
+ * @internal
+ */
+function validateColumnOverride(childColumn, parentColumn, columnName, childSchemaName, parentSchemaName) {
+    const childPredicate = childColumn.getPredicateUri?.() ?? childColumn.options?.predicate;
+    const parentPredicate = parentColumn.options?.predicate;
+    if (childPredicate && parentPredicate && childPredicate !== parentPredicate) {
+        throw new Error(`Schema 继承错误: 不能修改 "${columnName}" 列的 predicate。` +
+            `父 schema "${parentSchemaName}" 定义为 "${parentPredicate}"，` +
+            `子 schema "${childSchemaName}" 尝试改为 "${childPredicate}"。` +
+            `子类只能添加约束（notNull, default），不能更改 predicate。`);
+    }
+}
+/**
+ * 合并父子 schema 的列定义
+ * @internal
+ */
+function mergeSchemaColumns(parentSchema, childColumns, childSchemaName) {
+    const mergedColumns = {};
+    // 先复制父类所有列
+    for (const [name, col] of Object.entries(parentSchema.columns)) {
+        mergedColumns[name] = col;
+    }
+    // 处理子类列
+    for (const [name, childCol] of Object.entries(childColumns)) {
+        const parentCol = parentSchema.columns[name];
+        if (parentCol) {
+            // 覆盖父类列 - 验证 predicate 不变
+            if (!(childCol instanceof PodColumnBase)) {
+                validateColumnOverride(childCol, parentCol, name, childSchemaName, parentSchema.name);
+                // 继承父类的 predicate（如果子类没有指定）
+                const builder = childCol;
+                if (!builder.getPredicateUri?.() && !builder.options?.predicate) {
+                    builder.options = { ...builder.options, predicate: parentCol.options?.predicate };
+                }
+            }
+        }
+        mergedColumns[name] = childCol;
+    }
+    return mergedColumns;
+}
+/**
+ * SolidSchema - 独立的 schema 定义类
+ *
+ * 只包含表的结构信息（列、类型、谓词映射），不包含 base。
+ * 可以通过 .at(base) 方法绑定到具体位置，生成 PodTable。
+ *
+ * @example
+ * // 定义 schema（不绑定位置）
+ * const profileSchema = solidSchema('profile', {
+ *   name: string('name').predicate(FOAF.name),
+ *   avatar: uri('avatar').predicate(FOAF.img),
+ * }, {
+ *   type: FOAF.Person,
+ * });
+ *
+ * // 绑定到具体位置
+ * const myProfile = profileSchema.at('/profile/card.ttl');
+ * const aliceProfile = profileSchema.at('https://alice.pod/profile/card.ttl');
+ */
+export class SolidSchema {
+    constructor(name, columns, options) {
+        this.name = name;
+        this.columns = columns;
+        this.options = options;
+        this.$kind = 'SolidSchema';
+        this.namespace = options.namespace;
+        this.subjectTemplate = options.subjectTemplate;
+        this.subClassOf = options.subClassOf
+            ? (Array.isArray(options.subClassOf)
+                ? options.subClassOf.map(resolveTermIri)
+                : [resolveTermIri(options.subClassOf)])
+            : undefined;
+    }
+    /**
+     * 绑定到具体位置，生成 PodTable
+     *
+     * @param base 资源路径（相对路径或绝对 IRI）
+     * @example
+     * const myProfile = profileSchema.at('/profile/card.ttl');
+     * const aliceProfile = profileSchema.at('https://alice.pod/profile/card.ttl');
+     */
+    at(base) {
+        return new PodTable(this.name, this.columns, {
+            ...this.options,
+            base,
+        });
+    }
+    /**
+     * 创建继承当前 schema 的子 schema
+     *
+     * 子类会继承父类的所有列，并可以：
+     * - 添加新的属性
+     * - 给继承的属性添加约束（如 notNull、default）
+     * - 但不能修改继承属性的 predicate
+     *
+     * @param name - 子 schema 名称
+     * @param columns - 子类新增或覆盖的列
+     * @param options - 子 schema 选项（必须提供 type）
+     * @returns 包含所有继承列和新列的子 schema
+     *
+     * @example
+     * const secretSchema = solidSchema('secret', {
+     *   id: id(),
+     *   name: string('name').predicate(VOCAB.name),
+     *   createdAt: datetime('createdAt').predicate(VOCAB.createdAt),
+     * }, {
+     *   type: 'https://vocab.example/Secret',
+     * });
+     *
+     * // 创建子 schema
+     * const apiKeySchema = secretSchema.extend('apiKey', {
+     *   // 新增属性
+     *   apiKey: string('apiKey').notNull().predicate(VOCAB.apiKey),
+     *   // 增强父类属性（添加约束，但不能改 predicate）
+     *   name: string('name').notNull(),
+     * }, {
+     *   type: 'https://vocab.example/APIKey',
+     * });
+     *
+     * // apiKeySchema 包含: id, name(notNull), createdAt, apiKey
+     * // apiKeySchema.subClassOf 自动包含 'https://vocab.example/Secret'
+     */
+    extend(name, columns, options) {
+        // 合并列
+        const mergedColumnDefs = mergeSchemaColumns(this, columns, name);
+        // 处理 subClassOf - 自动包含父类 type
+        const subClassOf = [this.type];
+        if (this.subClassOf) {
+            subClassOf.push(...this.subClassOf);
+        }
+        // 创建子 schema（使用 solidSchema 函数处理列转换）
+        return solidSchema(name, mergedColumnDefs, {
+            ...options,
+            subClassOf,
+        });
+    }
+    /**
+     * 获取 RDF 类型
+     */
+    get type() {
+        return resolveTermIri(this.options.type);
+    }
+}
+/**
+ * 创建 SolidSchema（不绑定位置的 schema 定义）
+ *
+ * @example
+ * const profileSchema = solidSchema('profile', {
+ *   name: string('name').predicate(FOAF.name),
+ * }, {
+ *   type: FOAF.Person,
+ * });
+ *
+ * // 使用时绑定位置
+ * const myProfile = profileSchema.at('/profile/card.ttl');
+ */
+export function solidSchema(name, columns, options) {
+    // 复用 podTable 的列处理逻辑
+    const processedColumns = {};
+    for (const [key, value] of Object.entries(columns)) {
+        if (value instanceof PodColumnBase) {
+            processedColumns[key] = value;
+            continue;
+        }
+        let column;
+        switch (value.dataType) {
+            case 'integer':
+                column = new PodIntegerColumn(value.name, value.options);
+                break;
+            case 'datetime':
+                column = new PodDateTimeColumn(value.name, value.options);
+                break;
+            case 'boolean':
+                column = new PodBooleanColumn(value.name, value.options);
+                break;
+            case 'json':
+                column = new PodJsonColumn(value.name, value.options);
+                break;
+            case 'object':
+                column = new PodObjectColumn(value.name, value.options);
+                break;
+            case 'array': {
+                const elementType = (value.elementType ?? value.options.baseType ?? 'string');
+                column = new PodArrayColumn(value.name, elementType, value.options);
+                break;
+            }
+            case 'uri':
+                column = new PodUriColumn(value.name, value.options);
+                break;
+            case 'string':
+            default:
+                column = new PodStringColumn(value.name, value.options);
+                break;
+        }
+        const predicateUri = value.getPredicateUri();
+        if (predicateUri) {
+            column.predicate(predicateUri);
+        }
+        processedColumns[key] = column;
+    }
+    return new SolidSchema(name, processedColumns, options);
+}
+/**
+ * 检查目标是否为 SolidSchema
+ */
+export function isSolidSchema(target) {
+    return target instanceof SolidSchema || target?.$kind === 'SolidSchema';
+}
+// 表定义类 - 支持泛型以进行类型推断
+export class PodTable {
+    constructor(name, columns, options) {
+        this.initialized = false;
+        const typeInput = options.type;
+        if (!typeInput) {
+            throw new Error('podTable requires a type (RDF class) via options.type');
+        }
+        const typeIndexOption = options.typeIndex;
+        const validTypeIndex = typeIndexOption === 'private' || typeIndexOption === 'public';
+        if (typeIndexOption && !validTypeIndex) {
+            console.warn(`Invalid typeIndex value "${typeIndexOption}", disabling TypeIndex registration.`);
+        }
+        const baseConfig = this.resolveBase(options.base, name);
+        this.resourcePath = baseConfig.resourcePath;
+        this.containerPath = baseConfig.containerPath;
+        const subjectTemplateInfo = this.resolveSubjectTemplate(options.subjectTemplate, baseConfig.resourcePath, baseConfig.containerPath, name);
+        this.subjectTemplate = subjectTemplateInfo.template;
+        this.hasCustomSubjectTemplate = subjectTemplateInfo.isCustom;
+        this.resourceMode = options.resourceMode ?? (options.sparqlEndpoint ? 'sparql' : undefined);
+        this.sparqlEndpoint = options.sparqlEndpoint;
+        // TypeIndex 注册默认取决于是否提供 typeIndex，且 autoRegister 未显式禁用
+        this.registerTypeIndexEnabled = validTypeIndex && options.autoRegister !== false;
+        this.config = {
+            name,
+            base: baseConfig.resourcePath,
+            type: resolveTermIri(typeInput),
+            namespace: options.namespace,
+            typeIndex: validTypeIndex ? typeIndexOption : undefined,
+            saiRegistryPath: options.saiRegistryPath,
+            subjectTemplate: this.subjectTemplate,
+            autoRegister: options.autoRegister,
+            containerPath: baseConfig.containerPath,
+            hooks: options.hooks,
+        };
+        this.parentClasses = this.normalizeParents(options.subClassOf ?? []);
+        if (this.parentClasses.length > 0) {
+            this.config.subClassOf = [...this.parentClasses];
+        }
+        this.columns = columns;
+        // 将列直接添加到表对象上，以便直接访问
+        Object.assign(this, columns);
+        // 记录列所属的表，便于 JOIN/分组等语义解析，并检查主键数量
+        let primaryKeyCount = 0;
+        for (const column of Object.values(columns)) {
+            if (column.options.primaryKey) {
+                primaryKeyCount++;
+            }
+            column.table = this;
+            column.tableName = name;
+            // 检查所有列是否都有有效的 predicate 或表级 namespace
+            if (!column.options.predicate && // 没有明确的 predicate
+                !(column._virtualId) && // 不是虚拟 ID 列 (@id)
+                !options.namespace // 表没有定义 namespace
+            ) {
+                throw new Error(`Column "${column.name}" in table "${name}" is missing a predicate. Please set a 'predicate' option for the column or a 'namespace' for the table.`);
+            }
+        }
+        if (primaryKeyCount !== 1) {
+            throw new Error(`PodTable "${name}" must have exactly one primary key column. Found ${primaryKeyCount}.`);
+        }
+        // 初始化 drizzle-zod 兼容的属性
+        this.$inferSelect = {};
+        this.$inferInsert = {};
+        this.$inferUpdate = {};
+        // 初始化 _ 属性
+        this._ = {
+            brand: 'Table',
+            config: this.config,
+            name,
+            schema: undefined,
+            columns,
+            inferSelect: {},
+            inferInsert: {},
+            inferUpdate: {}
+        };
+        this.mapping = this.buildTableMapping();
+    }
+    // 获取容器路径
+    getContainerPath() {
+        return this.containerPath;
+    }
+    // 获取 RDF 类
+    getType() {
+        return this.config.type;
+    }
+    /**
+     * @deprecated 使用 getType()
+     */
+    getRdfClass() {
+        return this.getType();
+    }
+    // 获取命名空间
+    getNamespace() {
+        return this.config.namespace;
+    }
+    getSubjectTemplate() {
+        return this.subjectTemplate;
+    }
+    /**
+     * 检查是否有用户提供的 subjectTemplate
+     */
+    hasCustomTemplate() {
+        return this.hasCustomSubjectTemplate;
+    }
+    getSubClassOf() {
+        return [...this.parentClasses];
+    }
+    getMapping() {
+        return this.mapping;
+    }
+    /**
+     * 获取表的 schema 定义（用于联邦查询）
+     *
+     * 返回只包含结构信息的 SolidSchema，不包含 base
+     * 用于 relations() 中的联邦查询，数据位置通过 discover 动态发现
+     *
+     * @example
+     * const friendsRelations = relations(friends, ({ many }) => ({
+     *   posts: many(posts.$schema, {
+     *     discover: (friend) => friend.webId,
+     *   }),
+     * }));
+     */
+    get $schema() {
+        return new SolidSchema(this.config.name, this.columns, {
+            type: this.config.type,
+            namespace: this.config.namespace,
+            subjectTemplate: this.subjectTemplate,
+            subClassOf: this.parentClasses.length > 0 ? [...this.parentClasses] : undefined,
+        });
+    }
+    /**
+     * Generate a relative URI for a record by ID
+     *
+     * This returns a Pod-relative URI that drizzle-solid will automatically
+     * resolve to an absolute URI using the Pod URL at runtime.
+     *
+     * @param id - The record ID (typically a nanoid or user-defined identifier)
+     * @returns Relative URI like '/.data/agents/xK9mN2.ttl' or '/.data/tags.ttl#abc123'
+     *
+     * @example
+     * // Generate URI for a record by its ID
+     * const agentUri = agentTable.resolveUri('xK9mN2pL');
+     * // => '/.data/agents/xK9mN2pL.ttl'
+     *
+     * // Prefer using @id from query results when available
+     * const msg = { maker: existingAgent['@id'], content: 'Hello!' }
+     */
+    resolveUri(id) {
+        // Apply subjectTemplate
+        const template = this.subjectTemplate;
+        const resolved = template.replace(/\{id\}/g, id);
+        // Build relative URI based on mode
+        if (resolved.startsWith('#')) {
+            // Fragment mode: /.data/tags.ttl#id
+            const resourcePath = this.resourcePath;
+            return `${resourcePath}${resolved}`;
+        }
+        // Document mode: /.data/agents/openrouter.ttl
+        const normalizedContainer = this.containerPath.endsWith('/')
+            ? this.containerPath
+            : `${this.containerPath}/`;
+        return `${normalizedContainer}${resolved}`;
+    }
+    resolveBase(base, tableName) {
+        if (!base || base.trim().length === 0) {
+            throw new Error(`podTable '${tableName}' requires a 'base' option.\n` +
+                `Examples:\n` +
+                `  base: '/data/${tableName}.ttl'  // relative path for your Pod\n` +
+                `  base: '/data/${tableName}/'     // container path\n` +
+                `  base: 'https://other.pod/data/${tableName}.ttl'  // absolute IRI for other Pods`);
+        }
+        const normalizedInput = this.normalizeBaseInput(base);
+        const normalizedPath = this.normalizeResourcePath(normalizedInput);
+        if (normalizedPath.endsWith('/')) {
+            // Container/directory path - for Document mode
+            const containerPath = this.ensureTrailingSlash(normalizedPath);
+            return {
+                resourcePath: containerPath,
+                containerPath
+            };
+        }
+        // File path - for Fragment mode
+        const containerPath = this.ensureTrailingSlash(this.deriveContainerPath(normalizedPath));
+        return {
+            resourcePath: normalizedPath,
+            containerPath,
+        };
+    }
+    normalizeBaseInput(rawBase) {
+        const trimmed = rawBase.trim();
+        if (trimmed.length === 0) {
+            throw new Error('podTable requires a non-empty base');
+        }
+        const schemeMatch = trimmed.match(/^([a-zA-Z][\w+.-]*):\/\/(.*)$/);
+        if (schemeMatch) {
+            const [, scheme, remainder] = schemeMatch;
+            const normalizedScheme = scheme.toLowerCase();
+            const remainderTrimmed = remainder.trim();
+            if (normalizedScheme === 'http' || normalizedScheme === 'https') {
+                const rest = remainderTrimmed.length === 0 ? '' : remainderTrimmed;
+                return `${normalizedScheme}://${rest}`;
+            }
+            const normalizedRemainder = remainderTrimmed.length === 0 ? '/' : remainderTrimmed;
+            return normalizedRemainder.startsWith('/') ? normalizedRemainder : `/${normalizedRemainder}`;
+        }
+        return trimmed;
+    }
+    normalizeResourcePath(resourcePath) {
+        if (typeof resourcePath !== 'string' || resourcePath.trim().length === 0) {
+            throw new Error('podTable requires a non-empty base');
+        }
+        if (/^[a-zA-Z][\w+.-]*:\/\//.test(resourcePath)) {
+            return resourcePath;
+        }
+        const trimmed = resourcePath.trim().replace(/^(\.\/)+/, '');
+        const normalized = trimmed.replace(/\/+/g, '/');
+        if (normalized.startsWith('/')) {
+            return normalized;
+        }
+        return `/${normalized}`;
+    }
+    deriveContainerPath(resourcePath) {
+        const withoutTrailingSlash = resourcePath.endsWith('/')
+            ? resourcePath.slice(0, -1)
+            : resourcePath;
+        const lastSlash = withoutTrailingSlash.lastIndexOf('/');
+        if (lastSlash === -1) {
+            return '/';
+        }
+        return withoutTrailingSlash.slice(0, lastSlash + 1);
+    }
+    ensureTrailingSlash(path) {
+        return path.endsWith('/') ? path : `${path}/`;
+    }
+    getResourcePath() {
+        return this.resourcePath;
+    }
+    getResourceMode() {
+        return this.resourceMode;
+    }
+    getSparqlEndpoint() {
+        return this.sparqlEndpoint;
+    }
+    shouldRegisterTypeIndex() {
+        return this.registerTypeIndexEnabled;
+    }
+    async init(initializer) {
+        await initializer.registerTable(this);
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    markInitialized(initialized = true) {
+        this.initialized = initialized;
+    }
+    /**
+     * 动态更新 base（TypeIndex 自动发现等场景）
+     */
+    setBase(base) {
+        const resolved = this.resolveBase(base, this.config.name);
+        this.resourcePath = resolved.resourcePath;
+        this.containerPath = resolved.containerPath;
+        this.config.base = resolved.resourcePath;
+        this.config.containerPath = resolved.containerPath; // Sync config.containerPath
+        if (this._?.config) {
+            this._.config.base = this.config.base;
+            this._.config.containerPath = this.config.containerPath;
+        }
+        if (!this.hasCustomSubjectTemplate) {
+            this.subjectTemplate = this.buildDefaultSubjectTemplate(this.config.base, this.config.containerPath, this.config.name);
+            this.config.subjectTemplate = this.subjectTemplate;
+            if (this._?.config) {
+                this._.config.subjectTemplate = this.subjectTemplate;
+            }
+        }
+        this.mapping = this.buildTableMapping();
+    }
+    /**
+     * 动态更新 subjectTemplate（SAI DataRegistration 自动发现等场景）
+     */
+    setSubjectTemplate(template) {
+        this.subjectTemplate = template;
+        this.hasCustomSubjectTemplate = true;
+        this.config.subjectTemplate = template;
+        if (this._?.config) {
+            this._.config.subjectTemplate = template;
+        }
+        this.mapping = this.buildTableMapping();
+    }
+    /**
+     * 动态设置 SPARQL endpoint（自动发现等场景）
+     */
+    setSparqlEndpoint(endpoint) {
+        this.sparqlEndpoint = endpoint;
+        if (!this.resourceMode) {
+            this.resourceMode = 'sparql';
+        }
+    }
+    // 获取所有列
+    getColumns() {
+        return this.columns;
+    }
+    getColumn(name) {
+        return this.columns[name];
+    }
+    // 检查列是否存在
+    hasColumn(name) {
+        return name in this.columns;
+    }
+    resolveSubjectTemplate(template, resourcePath, containerPath, tableName) {
+        if (template && template.trim().length > 0) {
+            return { template: template.trim(), isCustom: true };
+        }
+        return {
+            template: this.buildDefaultSubjectTemplate(resourcePath, containerPath, tableName),
+            isCustom: false
+        };
+    }
+    buildDefaultSubjectTemplate(resourcePath, containerPath, tableName = 'resource') {
+        const normalizedContainer = this.ensureTrailingSlash(containerPath || '');
+        // If the table base is a container (document mode), containerPath should end with `${tableName}/`.
+        // Otherwise, assume fragment mode.
+        const isDocumentMode = normalizedContainer.endsWith(`${tableName}/`);
+        if (isDocumentMode) {
+            return '{id}.ttl';
+        }
+        // Fragment mode: all rows in one resource, distinguished by fragment.
+        // resourcePath is expected to be the concrete document path (e.g. `/data/tags.ttl`).
+        if (resourcePath && resourcePath.includes('{')) {
+            return resourcePath;
+        }
+        return '#{id}';
+    }
+    buildTableMapping() {
+        const mappedColumns = {};
+        for (const column of Object.values(this.columns)) {
+            mappedColumns[column.name] = this.buildColumnMapping(column);
+        }
+        return {
+            name: this.config.name,
+            type: this.config.type,
+            subjectTemplate: this.subjectTemplate,
+            namespace: this.config.namespace,
+            subClassOf: this.parentClasses.length > 0 ? [...this.parentClasses] : undefined,
+            columns: mappedColumns,
+            relations: this.relations
+        };
+    }
+    buildColumnMapping(column) {
+        const predicate = column._virtualId
+            ? '@id'
+            : column.getPredicate(this.config.namespace);
+        return {
+            column: column.name,
+            predicate,
+            kind: column.isReference() ? 'object' : 'datatype',
+            datatype: this.inferColumnDatatype(column),
+            referenceTarget: column.getReferenceTarget(),
+            isArray: column.options.isArray ?? false,
+            inverse: column.isInverse()
+        };
+    }
+    inferColumnDatatype(column) {
+        switch (column.dataType) {
+            case 'string':
+                return 'http://www.w3.org/2001/XMLSchema#string';
+            case 'integer':
+                return 'http://www.w3.org/2001/XMLSchema#integer';
+            case 'boolean':
+                return 'http://www.w3.org/2001/XMLSchema#boolean';
+            case 'datetime':
+                return 'http://www.w3.org/2001/XMLSchema#dateTime';
+            case 'json':
+            case 'object':
+                return 'http://www.w3.org/2001/XMLSchema#json';
+            case 'uri':
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+    normalizeParents(value) {
+        if (!value) {
+            return [];
+        }
+        const entries = Array.isArray(value) ? value : [value];
+        const normalized = entries
+            .map((entry) => resolveTermIri(entry))
+            .filter((entry) => entry && entry.length > 0);
+        return Array.from(new Set(normalized));
+    }
+}
+_b = entityKind;
+PodTable[_b] = 'PodTable';
+export function boolean(name, options = {}) {
+    return new ColumnBuilder(name, 'boolean', options);
+}
+export function timestamp(name, options = {}) {
+    return new ColumnBuilder(name, 'datetime', options);
+}
+export function json(name, options = {}) {
+    return new ColumnBuilder(name, 'json', options);
+}
+export function object(name, options = {}) {
+    return new ColumnBuilder(name, 'object', options);
+}
+export function uri(name, options = {}) {
+    return new ColumnBuilder(name, 'uri', options);
+}
+// IRI 别名，方便习惯使用 IRI 术语的场景
+export function iri(name, options = {}) {
+    return uri(name, options);
+}
+// Pod 专用的列定义函数（保留向后兼容）
+export function podString(name, options = {}) {
+    return new PodStringColumn(name, options);
+}
+export function podInteger(name, options = {}) {
+    return new PodIntegerColumn(name, options);
+}
+export function podBoolean(name, options = {}) {
+    return new PodBooleanColumn(name, options);
+}
+export function podDateTime(name, options = {}) {
+    return new PodDateTimeColumn(name, options);
+}
+export function podJson(name, options = {}) {
+    return new PodJsonColumn(name, options);
+}
+export function podObject(name, options = {}) {
+    return new PodObjectColumn(name, options);
+}
+// 专用 ID 列，自动 predicate 为 @id，便于构造 subject IRI
+// 特殊 ID 列：不单独存储谓词，只用于生成/解析 subject/@id（最多一个）
+export function id(name = 'id', options = {}) {
+    const col = new PodStringColumn(name, {
+        ...options,
+        predicate: '@id',
+        primaryKey: true,
+        required: true,
+        defaultValue: options.defaultValue ?? generateNanoId // Default to NanoID generation
+    });
+    // 标记为"虚拟 ID 列"，生成/解析 subject 时使用，但不额外输出三元组
+    col._virtualId = true;
+    return col;
+}
+// 创建类型安全的builder函数
+export function string(name, options = {}) {
+    return new ColumnBuilder(name, 'string', options);
+}
+export function int(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function integer(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function date(name, options = {}) {
+    return new ColumnBuilder(name, 'datetime', options);
+}
+// 时间相关列类型别名
+export function datetime(name, options = {}) {
+    return new ColumnBuilder(name, 'datetime', options);
+}
+// 文本相关列类型别名
+export function text(name, options = {}) {
+    return new ColumnBuilder(name, 'string', options);
+}
+export function varchar(name, options = {}) {
+    return new ColumnBuilder(name, 'string', options);
+}
+export function char(name, options = {}) {
+    return new ColumnBuilder(name, 'string', options);
+}
+// 数字相关列类型别名  
+export function bigint(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function smallint(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function tinyint(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function mediumint(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function serial(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+// 浮点数相关列类型别名
+export function real(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function decimal(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function numeric(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function float(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+export function double(name, options = {}) {
+    return new ColumnBuilder(name, 'integer', options);
+}
+// JSON相关别名
+export function jsonb(name, options = {}) {
+    return new ColumnBuilder(name, 'json', options);
+}
+export function podTable(name, columns, options) {
+    const processedColumns = {};
+    for (const [key, value] of Object.entries(columns)) {
+        if (value instanceof PodColumnBase) {
+            processedColumns[key] = value;
+            continue;
+        }
+        let column;
+        switch (value.dataType) {
+            case 'integer':
+                column = new PodIntegerColumn(value.name, value.options);
+                break;
+            case 'datetime':
+                column = new PodDateTimeColumn(value.name, value.options);
+                break;
+            case 'boolean':
+                column = new PodBooleanColumn(value.name, value.options);
+                break;
+            case 'json':
+                column = new PodJsonColumn(value.name, value.options);
+                break;
+            case 'object':
+                column = new PodObjectColumn(value.name, value.options);
+                break;
+            case 'array': {
+                const elementType = (value.elementType ?? value.options.baseType ?? 'string');
+                column = new PodArrayColumn(value.name, elementType, value.options);
+                break;
+            }
+            case 'uri':
+                column = new PodUriColumn(value.name, value.options);
+                break;
+            case 'string':
+            default:
+                column = new PodStringColumn(value.name, value.options);
+                break;
+        }
+        const predicateUri = value.getPredicateUri();
+        if (predicateUri) {
+            column.predicate(predicateUri);
+        }
+        processedColumns[key] = column;
+    }
+    return new PodTable(name, processedColumns, options);
+}
+export function relations(table, builder) {
+    const helpers = {
+        one: (target, options = {}) => {
+            const isFederated = isSolidSchema(target);
+            return {
+                type: 'one',
+                table: target,
+                fields: options.fields,
+                references: options.references,
+                relationName: options.relationName,
+                discover: options.discover,
+                isFederated,
+            };
+        },
+        many: (target, options = {}) => {
+            const isFederated = isSolidSchema(target);
+            return {
+                type: 'many',
+                table: target,
+                fields: options.fields,
+                references: options.references,
+                relationName: options.relationName,
+                discover: options.discover,
+                isFederated,
+            };
+        }
+    };
+    const defs = builder(helpers);
+    table.relations = defs;
+    return defs;
+}
+// 常用的 RDF 谓词常量
+export const RDF_PREDICATES = {
+    // Schema.org 常用谓词
+    SCHEMA_NAME: 'https://schema.org/name',
+    SCHEMA_EMAIL: 'https://schema.org/email',
+    SCHEMA_IDENTIFIER: 'https://schema.org/identifier',
+    SCHEMA_DATE_CREATED: 'https://schema.org/dateCreated',
+    SCHEMA_DATE_MODIFIED: 'https://schema.org/dateModified',
+    SCHEMA_DESCRIPTION: 'https://schema.org/description',
+    SCHEMA_URL: 'https://schema.org/url',
+    SCHEMA_TITLE: 'https://schema.org/title',
+    SCHEMA_TEXT: 'https://schema.org/text',
+    SCHEMA_AUTHOR: 'https://schema.org/author',
+    SCHEMA_DATE_PUBLISHED: 'https://schema.org/datePublished',
+    // FOAF 常用谓词
+    FOAF_NAME: 'http://xmlns.com/foaf/0.1/name',
+    FOAF_MBOX: 'http://xmlns.com/foaf/0.1/mbox',
+    FOAF_HOMEPAGE: 'http://xmlns.com/foaf/0.1/homepage',
+    // Dublin Core 常用谓词
+    DC_TITLE: 'http://purl.org/dc/terms/title',
+    DC_DESCRIPTION: 'http://purl.org/dc/terms/description',
+    DC_CREATED: 'http://purl.org/dc/terms/created',
+    DC_MODIFIED: 'http://purl.org/dc/terms/modified',
+};
+// 常用的 RDF 类型常量
+export const RDF_CLASSES = {
+    // Schema.org 常用类型
+    SCHEMA_PERSON: 'https://schema.org/Person',
+    SCHEMA_BLOG_POSTING: 'https://schema.org/BlogPosting',
+    SCHEMA_ARTICLE: 'https://schema.org/Article',
+    SCHEMA_ORGANIZATION: 'https://schema.org/Organization',
+    SCHEMA_EVENT: 'https://schema.org/Event',
+    SCHEMA_PLACE: 'https://schema.org/Place',
+    // FOAF 常用类型
+    FOAF_PERSON: 'http://xmlns.com/foaf/0.1/Person',
+    FOAF_ORGANIZATION: 'http://xmlns.com/foaf/0.1/Organization',
+    // 自定义应用类型示例
+    APP_USER: 'https://myapp.com/vocab#User',
+    APP_POST: 'https://myapp.com/vocab#Post',
+    APP_COMMENT: 'https://myapp.com/vocab#Comment',
+    APP_TAG: 'https://myapp.com/vocab#Tag',
+};
+//# sourceMappingURL=pod-table.js.map