@undefineds.co/xpod 0.4.18 → 0.4.20

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/select-query-builder.d.ts

@@ -0,0 +1,150 @@
+import { entityKind, SQL } from 'drizzle-orm';
+import { PodTable, PodColumnBase, InferTableData } from '../schema';
+import { QueryCondition, type PublicQueryCondition, type PublicWhereObject } from '../query-conditions';
+import { SelectQueryPlan } from '../select-plan';
+import { SelectFieldMap, SessionInterface } from './types';
+import { type OrderByExpression } from '../order-by';
+import { SelectionAliasExpression } from '../expressions';
+export declare class SelectQueryBuilder<TTable extends PodTable<any> = PodTable<any>> {
+    session: SessionInterface;
+    static readonly [entityKind] = "SelectQueryBuilder";
+    selectedTable?: TTable;
+    whereConditions?: Record<string, any>;
+    private conditionTree?;
+    sql?: SQL;
+    private joins;
+    private limitCount?;
+    private offsetCount?;
+    private orderByClauses;
+    private isDistinct;
+    private selectedFields?;
+    private tableAliases;
+    private aliasToTable;
+    private aliasUsage;
+    private primaryAlias?;
+    private joinFilters;
+    private groupByColumns;
+    private havingCondition?;
+    constructor(session: SessionInterface, fields?: SelectFieldMap);
+    from<TJoinTable extends PodTable<any>>(table: TJoinTable): SelectQueryBuilder<TJoinTable>;
+    columns(fields: SelectFieldMap): this;
+    private setSelectedFields;
+    /**
+     * Add WHERE conditions to the query
+     *
+     * Public where() is collection-oriented.
+     * Exact-target reads must use findById()/findByIri().
+     */
+    where(conditions: PublicWhereObject | SQL | PublicQueryCondition): this;
+    /**
+     * Add a stable cursor range that may use the virtual resource identifier as
+     * a tie-breaker. Exact identifier reads remain restricted to findById() and
+     * findByIri(); this API accepts only composite range cursors.
+     */
+    whereCursor(condition: PublicQueryCondition): this;
+    /**
+     * Internal method that allows @id in conditions.
+     * Used by *ByIri methods internally.
+     * @internal
+     */
+    whereByIri(iri: string | string[]): this;
+    private isQueryCondition;
+    private convertQueryConditionToSimple;
+    private extractTableFromCondition;
+    leftJoin<TJoinTable extends PodTable<any>>(table: TJoinTable, condition: any): SelectQueryBuilder<TTable>;
+    rightJoin<TJoinTable extends PodTable<any>>(table: TJoinTable, condition: any): SelectQueryBuilder<TTable>;
+    innerJoin<TJoinTable extends PodTable<any>>(table: TJoinTable, condition: any): SelectQueryBuilder<TTable>;
+    fullJoin<TJoinTable extends PodTable<any>>(table: TJoinTable, condition: any): SelectQueryBuilder<TTable>;
+    crossJoin<TJoinTable extends PodTable<any>>(table: TJoinTable): SelectQueryBuilder<TTable>;
+    groupBy(...fields: Array<PodColumnBase | string>): SelectQueryBuilder<TTable>;
+    having(condition: QueryCondition | ((fields: Record<string, SelectionAliasExpression>) => QueryCondition)): SelectQueryBuilder<TTable>;
+    private createSelectedFieldAliases;
+    private addJoin;
+    private ensureAliasForTable;
+    private resolveJoinConditions;
+    private resolveJoinConditionExpression;
+    private getConditionColumnReference;
+    private resolveColumnReference;
+    private parseColumnReferenceString;
+    private processWhereObject;
+    private processQueryCondition;
+    private applyInternalQueryCondition;
+    private normalizeWhereConditions;
+    toIR(): SelectQueryPlan;
+    private buildQueryPlan;
+    limit(count: number): this;
+    offset(count: number): this;
+    private addOrderByClause;
+    orderBy(...args: Array<PodColumnBase | string | OrderByExpression | 'asc' | 'desc'>): this;
+    distinct(enable?: boolean): this;
+    private buildSPARQLQuery;
+    toSPARQL(): any;
+    toSparql(): any;
+    execute(): Promise<InferTableData<TTable>[]>;
+    private projectSelectedRow;
+    private projectFieldMap;
+    private projectFieldValue;
+    private projectTableValue;
+    private isSelectFieldMap;
+    private collectSelectionAliases;
+    private isProjectedValueEmpty;
+    private resolveFieldBindingCandidates;
+    private shouldUseProjectionFallback;
+    private shouldUseAggregateFallback;
+    private buildAggregateRow;
+    private computeAggregateValue;
+    private resolveAggregateColumnRef;
+    private collectValuesForCount;
+    private collectNumericValues;
+    private countDistinctRows;
+    private handleAggregateFallback;
+    private buildGroupedAggregateRows;
+    private ensureGroupByValidity;
+    private resolveSelectFieldColumn;
+    private hasAggregateSelection;
+    private hasMixedAggregateSelection;
+    private applySubjectMetadata;
+    private extractSubjectValue;
+    private attachSubjectMetadata;
+    private normalizeBaseRows;
+    private hydrateInlineColumns;
+    private normalizeInlinePredicateKey;
+    private normalizeInlineObjectValue;
+    private normalizeInlineIri;
+    private applyDeferredOrderBy;
+    private applyDistinctRows;
+    private applyDeferredOffsetAndLimit;
+    private getOrderByValue;
+    private compareOrderByValues;
+    private mergeRowsBySubject;
+    private getColumnDefinitionForRowKey;
+    private inferSourceFromChild;
+    private isInlineObjectColumn;
+    private applyJoinFallback;
+    private fetchJoinRows;
+    private buildExactJoinLookupConditions;
+    private buildJoinLookupCondition;
+    private getRequiredSubjectTemplateVariables;
+    private isAbsoluteIri;
+    private buildMissingJoinLocatorError;
+    private normalizeJoinRows;
+    private mergeRowsWithJoin;
+    private joinRowMatchesAllConditions;
+    private createEmptyJoinRow;
+    private applyJoinFilters;
+    private applyHavingFilter;
+    private evaluateCondition;
+    private evaluateBinaryCondition;
+    private evaluateUnaryCondition;
+    private evaluateLogicalCondition;
+    private resolveConditionOperandValue;
+    private getColumnKeyCandidates;
+    private getRowValueForColumn;
+    private shouldUseSubjectIdentityColumn;
+    private serializeValueForKey;
+    private extractIdFromSubject;
+    private computeLikeMatch;
+    selectIdsByCondition(table: PodTable, condition: QueryCondition): Promise<string[]>;
+    then<TResult1 = Awaited<ReturnType<SelectQueryBuilder<TTable>['execute']>>, TResult2 = never>(onfulfilled?: ((value: Awaited<ReturnType<SelectQueryBuilder<TTable>['execute']>>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+//# sourceMappingURL=select-query-builder.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/types.d.ts

@@ -0,0 +1,40 @@
+import { PodColumnBase, type InferInsertData, type InferUpdateData, PodTable } from '../schema';
+import { QueryCondition } from '../query-conditions';
+import { AggregateExpression } from '../aggregates';
+import { PodOperation } from '../pod-dialect';
+import { SQL } from 'drizzle-orm';
+export type SelectField = PodColumnBase | PodTable<any> | string | AggregateExpression | SelectFieldMap;
+export interface SelectFieldMap {
+    [key: string]: SelectField;
+}
+export interface InsertQueryPlan<TTable extends PodTable<any> = PodTable<any>> {
+    table: TTable;
+    rows: InferInsertData<TTable>[];
+    skipResourceExistenceCheck?: boolean;
+}
+export interface UpdateQueryPlan<TTable extends PodTable<any> = PodTable<any>> {
+    table: TTable;
+    data: InferUpdateData<TTable>;
+    where: QueryCondition;
+}
+export interface DeleteQueryPlan<TTable extends PodTable<any> = PodTable<any>> {
+    table: TTable;
+    where?: QueryCondition;
+}
+export type JoinType = 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin' | 'crossJoin';
+export interface ColumnReference {
+    table: PodTable<any>;
+    alias: string;
+    column: string;
+}
+export interface ResolvedJoinCondition {
+    left: ColumnReference;
+    right: ColumnReference;
+}
+export interface SessionInterface {
+    execute(operation: PodOperation): Promise<any[]>;
+    executeSql(sql: SQL, table: PodTable): Promise<any[]>;
+    getDialect(): any;
+    select(fields?: SelectFieldMap): any;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-builders/update-query-builder.d.ts

@@ -0,0 +1,34 @@
+import { entityKind, SQL } from 'drizzle-orm';
+import { PodTable, InferUpdateData } from '../schema';
+import { PodAsyncSession } from '../pod-session';
+import { type PublicQueryCondition, type PublicWhereObject } from '../query-conditions';
+import { UpdateQueryPlan, type SelectFieldMap } from './types';
+export declare class UpdateQueryBuilder<TTable extends PodTable<any> = PodTable<any>> {
+    session: PodAsyncSession;
+    table: TTable;
+    static readonly [entityKind] = "UpdateQueryBuilder";
+    updateData?: InferUpdateData<TTable>;
+    whereConditions?: Record<string, any>;
+    sql?: SQL;
+    private conditionTree?;
+    private returningFields?;
+    constructor(session: PodAsyncSession, table: TTable);
+    set(data: InferUpdateData<TTable> | SQL): this;
+    returning(fields?: SelectFieldMap): this;
+    where(conditions: PublicWhereObject | SQL | PublicQueryCondition): this;
+    whereByIri(iri: string): this;
+    private isQueryCondition;
+    private convertQueryConditionToSimple;
+    private normalizeWhereConditionsForUpdate;
+    toIR: () => UpdateQueryPlan<TTable>;
+    private buildSPARQLQuery;
+    toSPARQL(): import("../ast-to-sparql").SPARQLQuery;
+    toSparql(): import("../ast-to-sparql").SPARQLQuery;
+    execute(): Promise<any[]>;
+    private fetchMatchedRows;
+    private fetchReturningRowsBySubjects;
+    private runAfterUpdateHooks;
+    private buildHookContext;
+    then<TResult1 = Awaited<ReturnType<UpdateQueryBuilder<TTable>['execute']>>, TResult2 = never>(onfulfilled?: ((value: Awaited<ReturnType<UpdateQueryBuilder<TTable>['execute']>>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+//# sourceMappingURL=update-query-builder.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-conditions.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 查询条件构建器
+ * 提供类似 Drizzle 的查询条件函数
+ */
+import { PodColumnBase } from './schema';
+import { BinaryExpression, LogicalExpression, UnaryExpression, SPARQLExpression } from './expressions';
+export type QueryCondition = BinaryExpression | LogicalExpression | UnaryExpression;
+export type PublicQueryCondition = QueryCondition;
+export type PublicWhereObject = Omit<Record<string, unknown>, 'id' | '@id'> & {
+    id?: never;
+    '@id'?: never;
+};
+export type PublicWhereInput = PublicWhereObject | PublicQueryCondition;
+export type AnyColumnOperand = PodColumnBase<any, any, any, any>;
+type ConditionOperand = AnyColumnOperand | SPARQLExpression | string;
+type ConditionValue = unknown;
+export declare function eq(column: ConditionOperand, value: ConditionValue): QueryCondition;
+export declare function ne(column: ConditionOperand, value: ConditionValue): QueryCondition;
+export declare function gt(column: ConditionOperand, value: ConditionValue): QueryCondition;
+export declare function gte(column: ConditionOperand, value: ConditionValue): QueryCondition;
+export declare function lt(column: ConditionOperand, value: ConditionValue): QueryCondition;
+export declare function lte(column: ConditionOperand, value: ConditionValue): QueryCondition;
+export declare function like(column: ConditionOperand, pattern: string): QueryCondition;
+export declare function ilike(column: ConditionOperand, pattern: string): QueryCondition;
+export declare function between(column: ConditionOperand, min: ConditionValue, max: ConditionValue): QueryCondition;
+export declare function notBetween(column: ConditionOperand, min: ConditionValue, max: ConditionValue): QueryCondition;
+export declare function regex(column: ConditionOperand, pattern: string, flags?: string): QueryCondition;
+export declare function inArray(column: ConditionOperand, values: ConditionValue[]): QueryCondition;
+export declare function notInArray(column: ConditionOperand, values: ConditionValue[]): QueryCondition;
+export declare function isNull(column: ConditionOperand): QueryCondition;
+export declare function isNotNull(column: ConditionOperand): QueryCondition;
+export declare function and(...conditions: (QueryCondition | undefined | null | false)[]): QueryCondition;
+export declare function or(...conditions: (QueryCondition | undefined | null | false)[]): QueryCondition;
+export declare function not(condition: QueryCondition): QueryCondition;
+export declare function exists(subquery: string): QueryCondition;
+export declare function notExists(subquery: string): QueryCondition;
+export declare const conditions: {
+    eq: typeof eq;
+    ne: typeof ne;
+    gt: typeof gt;
+    gte: typeof gte;
+    lt: typeof lt;
+    lte: typeof lte;
+    like: typeof like;
+    ilike: typeof ilike;
+    between: typeof between;
+    notBetween: typeof notBetween;
+    regex: typeof regex;
+    inArray: typeof inArray;
+    notInArray: typeof notInArray;
+    isNull: typeof isNull;
+    isNotNull: typeof isNotNull;
+    and: typeof and;
+    or: typeof or;
+    not: typeof not;
+    exists: typeof exists;
+    notExists: typeof notExists;
+};
+export default conditions;
+//# sourceMappingURL=query-conditions.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/query-where-policy.d.ts

@@ -0,0 +1,8 @@
+import type { QueryCondition } from './query-conditions';
+type PublicWhereAction = 'select' | 'update' | 'delete';
+export declare function conditionTargetsReservedIdentifier(condition: QueryCondition): boolean;
+export declare function assertPublicWhereObject(action: PublicWhereAction, conditions: Record<string, unknown> | undefined): void;
+export declare function assertPublicWhereCondition(action: PublicWhereAction, condition: QueryCondition): void;
+export declare function assertPublicCursorCondition(condition: QueryCondition): void;
+export {};
+//# sourceMappingURL=query-where-policy.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/rdf-constants.d.ts

@@ -0,0 +1,16 @@
+export declare const RDF_NAMESPACES: {
+    readonly RDF: "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+    readonly RDFS: "http://www.w3.org/2000/01/rdf-schema#";
+    readonly OWL: "http://www.w3.org/2002/07/owl#";
+    readonly XSD: "http://www.w3.org/2001/XMLSchema#";
+    readonly FOAF: "http://xmlns.com/foaf/0.1/";
+    readonly SCHEMA: "https://schema.org/";
+    readonly DC: "http://purl.org/dc/terms/";
+    readonly SOLID: "http://www.w3.org/ns/solid/terms#";
+    readonly LDP: "http://www.w3.org/ns/ldp#";
+    readonly PIM: "http://www.w3.org/ns/pim/space#";
+};
+export declare function buildURI(namespace: keyof typeof RDF_NAMESPACES, localName: string): string;
+export declare function getLocalName(uri: string): string;
+export declare function getNamespace(uri: string): string;
+//# sourceMappingURL=rdf-constants.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/rdf-schema-parser.d.ts

@@ -0,0 +1,34 @@
+export interface RDFSchemaDefinition {
+    predicate: string;
+    range?: string;
+    domain?: string;
+    type?: string;
+}
+export interface SchemaParseResult {
+    definitions: RDFSchemaDefinition[];
+    errors: string[];
+}
+/**
+ * 从 RDF Schema 文档中解析类型定义
+ */
+export declare function parseRDFSchema(schemaUrl: string, fetchFn?: typeof fetch): Promise<SchemaParseResult>;
+/**
+ * 从 RDF Schema 中查找特定 predicate 的类型定义
+ */
+export declare function findPredicateType(predicate: string, schemaDefinitions: RDFSchemaDefinition[]): string | null;
+/**
+ * 将 RDF 数据类型转换为 TypeScript 类型
+ */
+export declare function rdfTypeToTypeScript(rdfType: string): string;
+/**
+ * 获取 predicate 的 TypeScript 类型
+ */
+export declare function getPredicateTypeScriptType(predicate: string, schemaDefinitions: RDFSchemaDefinition[]): string;
+/**
+ * 验证 predicate 类型定义
+ */
+export declare function validatePredicateType(predicate: string, expectedType: string, schemaDefinitions: RDFSchemaDefinition[]): {
+    isValid: boolean;
+    message?: string;
+};
+//# sourceMappingURL=rdf-schema-parser.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/repository.d.ts

@@ -0,0 +1,78 @@
+import type { InferInsertData, InferTableData, InferUpdateData, PodTable } from './schema';
+import { type QueryCondition } from './query-conditions';
+import type { SolidDatabase } from '../driver';
+type RepositoryTable = PodTable<any>;
+export type AnyPodTable = RepositoryTable;
+export type AnyPodResource = RepositoryTable;
+export interface PodExecutableQuery<TRow = unknown> {
+    where(condition: unknown): PodExecutableQuery<TRow>;
+    whereByIri?(iri: string | string[]): PodExecutableQuery<TRow>;
+    orderBy(...args: unknown[]): PodExecutableQuery<TRow>;
+    execute(): Promise<TRow[]>;
+}
+export interface PodInsertQuery {
+    values(values: unknown): {
+        execute(): Promise<unknown[]>;
+    };
+}
+export interface PodUpdateQuery {
+    set(values: unknown): PodMutationQuery;
+}
+export interface PodMutationQuery {
+    where(condition: unknown): PodMutationQuery;
+    whereByIri?(iri: string): PodMutationQuery;
+    execute(): Promise<unknown[]>;
+}
+export declare function initSolidTables(db: Pick<SolidDatabase, 'init'>, tables: AnyPodTable[]): Promise<void>;
+export declare const initSolidResources: typeof initSolidTables;
+export interface RepositoryCacheOptions {
+    staleTime?: number;
+    gcTime?: number;
+}
+export type RepositoryScope = 'list' | 'detail' | string;
+export interface RepositoryInvalidations {
+    create?: RepositoryScope[];
+    update?: RepositoryScope[];
+    remove?: RepositoryScope[];
+}
+export interface RepositoryFilterContext<TTable extends RepositoryTable, Filters> {
+    table: TTable;
+    filters?: Filters;
+}
+export interface PodRepositoryDescriptor<TTable extends RepositoryTable, Row extends Record<string, unknown> = InferTableData<TTable>, Insert = InferInsertData<TTable>, Update = InferUpdateData<TTable>, Filters extends Record<string, unknown> = Record<string, unknown>> {
+    namespace: string;
+    resourcePath: string;
+    searchableFields?: (keyof Row & string)[];
+    defaultSort?: {
+        field: keyof Row & string;
+        direction: 'asc' | 'desc';
+    };
+    cache?: RepositoryCacheOptions;
+    invalidations: RepositoryInvalidations;
+    list: (db: SolidDatabase, filters?: Filters) => Promise<Row[]>;
+    detail: (db: SolidDatabase, id: string) => Promise<Row | null>;
+    create?: (db: SolidDatabase, input: Insert) => Promise<Row>;
+    update?: (db: SolidDatabase, id: string, input: Update) => Promise<Row>;
+    remove?: (db: SolidDatabase, id: string) => Promise<{
+        id: string;
+    }>;
+}
+export interface PodRepositoryOptions<TTable extends RepositoryTable, Row extends Record<string, unknown> = InferTableData<TTable>, Filters extends Record<string, unknown> = Record<string, unknown>> {
+    namespace: string;
+    table: TTable;
+    searchableFields?: (keyof Row & string)[];
+    searchAccessor?: (filters?: Filters) => string | undefined;
+    defaultSort?: {
+        field: keyof Row & string;
+        direction: 'asc' | 'desc';
+    };
+    cache?: RepositoryCacheOptions;
+    invalidations?: Partial<RepositoryInvalidations>;
+    transform?: (row: Row) => Row;
+    filter?: (context: RepositoryFilterContext<TTable, Filters>) => QueryCondition | undefined;
+    disableMutations?: Partial<Record<'create' | 'update' | 'remove', boolean>>;
+}
+export declare function createRepositoryDescriptor<TTable extends RepositoryTable, Row extends Record<string, unknown> = InferTableData<TTable>, Insert = InferInsertData<TTable>, Update = InferUpdateData<TTable>, Filters extends Record<string, unknown> = Record<string, unknown>>(options: PodRepositoryOptions<TTable, Row, Filters>): PodRepositoryDescriptor<TTable, Row, Insert, Update, Filters>;
+export declare const definePodRepository: typeof createRepositoryDescriptor;
+export {};
+//# sourceMappingURL=repository.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/resource-reference.d.ts

@@ -0,0 +1,31 @@
+import type { PodTable } from './schema';
+type AnyPodResource = PodTable<any> & {
+    resolveUri?: (id: string) => string;
+    getResourcePath?: () => string;
+    getSubjectTemplate?: () => string | undefined;
+    columns?: {
+        id?: {
+            options?: {
+                defaultValue?: unknown;
+            };
+        };
+    };
+};
+export interface PodResourceReference {
+    resourceId: string;
+    templateValues: Record<string, string>;
+}
+export type PodResourceTarget = string | Record<string, unknown>;
+export declare function parsePodResourceRef(resource: AnyPodResource, ref: string | null | undefined): PodResourceReference | null;
+export declare function extractPodResourceTemplateValue(resource: AnyPodResource, ref: string | null | undefined, field?: string): string | null;
+export declare function resolvePodBaseUrl(webIdOrPodUrl: string): string;
+export declare function resolvePodBaseUrlFromDatabase(database: unknown): string | null;
+export declare function normalizePodDataResourceId(ref: string): string;
+export declare function resolvePodResourceId(resource: AnyPodResource, target: PodResourceTarget): string;
+export declare function resolvePodResourceTemplateValue(resource: AnyPodResource, ref: string, field?: string): string | null;
+export declare function buildPodResourceIri(webIdOrPodUrl: string, resourceId: string): string;
+export declare function buildPodResourceIriForResource(webIdOrPodUrl: string, resource: AnyPodResource, target: PodResourceTarget): string;
+export declare function buildPodResourceIriForDatabase(database: unknown, resource: AnyPodResource, target: PodResourceTarget): string;
+export declare function resolvePodResourceIriForDatabase(database: unknown, resource: AnyPodResource, target: PodResourceTarget | null | undefined): string | null;
+export {};
+//# sourceMappingURL=resource-reference.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/resource-resolver/base-resolver.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Base ResourceResolver with shared logic
+ *
+ * 核心设计原则：
+ * - 用户写入时可以使用简单 local id（如 "alice", "tag-123"）
+ * - subjectTemplate 定义 local id 如何映射到 URI（如 "{id}.ttl#it", "#{id}"）
+ * - 写入时：local id + template → relativePath → baseUrl + relativePath
+ * - 读取时：row.id 是 base-relative resource id，可从 base 下精确定位资源
+ */
+import type { PodTable } from '../schema';
+import type { QueryCondition } from '../query-conditions';
+import type { ResourceResolver } from './types';
+interface TemplateVariable {
+    raw: string;
+    field: string;
+    transforms: string[];
+}
+export declare abstract class BaseResourceResolver implements ResourceResolver {
+    abstract readonly mode: 'fragment' | 'document';
+    protected podBaseUrl: string;
+    constructor(podBaseUrl: string);
+    abstract getContainerUrl(table: PodTable): string;
+    abstract getResourceUrl(table: PodTable): string;
+    abstract getResourceUrlForSubject(subjectUri: string): string;
+    abstract resolveSelectSources(table: PodTable, containerUrl: string, condition?: QueryCondition, listContainer?: (url?: string) => Promise<string[]>): Promise<string[]>;
+    abstract resolveSubjectsForMutation(table: PodTable, condition: QueryCondition, findSubjects: (resourceUrl: string) => Promise<string[]>, listContainer: () => Promise<string[]>): Promise<string[]>;
+    /**
+     * 从 subject URI 解析出 ORM row id。
+     *
+     * `id()` 是虚拟列，不写入 RDF 谓词；读取时它暴露 base-relative
+     * resource id，而不是 subjectTemplate 中的本地 `{id}` slot。需要本地
+     * slot 时使用 parsePodResourceRef(...).templateValues.id 或
+     * extractPodResourceTemplateValue。
+     *
+     * 例如：
+     * - uri = "http://pod/items/alice.ttl#it", template = "{id}.ttl#it" → id = "alice.ttl#it"
+     * - uri = "http://pod/tags.ttl#tag-1", template = "#{id}" → id = "tags.ttl#tag-1"
+     * - uri = "http://pod/a/2026/05/07.ttl#x", template = "{yyyy}/{MM}/{dd}.ttl#{id}" → id = "2026/05/07.ttl#x"
+     */
+    parseId(table: PodTable, subjectUri: string): string;
+    /**
+     * 从 id 构建完整的 subject URI
+     *
+     * 两步构建：
+     * 1. 根据 subjectTemplate 应用 id → relativePath
+     * 2. subjectUri = baseUrl + relativePath
+     */
+    resolveSubject(table: PodTable, record: Record<string, any>, index?: number): string;
+    /**
+     * Extract the local template `{id}` variable for template transforms and link
+     * normalization. This is distinct from the public `id()` resource locator.
+     */
+    protected parseTemplateId(table: PodTable, subjectUri: string): string | null;
+    protected extractRelativeSubjectId(table: PodTable, subjectUri: string): string;
+    protected extractBaseRelativeResourceId(table: PodTable, subjectUri: string): string;
+    private extractTemplateRelativeSubjectId;
+    protected isBaseRelativeSubjectId(value: string): boolean;
+    protected acceptsFragmentOnlyResourceId(table: PodTable): boolean;
+    protected resolveBaseRelativeSubjectId(table: PodTable, value: string): string | null;
+    protected hasVirtualIdColumn(table: PodTable): boolean;
+    /**
+     * 获取表的 base URL，用于 id 解析
+     */
+    protected getBaseUrlForTable(table: PodTable): string;
+    protected getSubjectBaseUrl(table: PodTable): string;
+    /**
+     * 获取有效的 subjectTemplate
+     */
+    protected getEffectiveTemplate(table: PodTable): string;
+    /**
+     * 获取默认模板
+     * 子类应该重写此方法
+     */
+    protected abstract getDefaultTemplate(): string;
+    /**
+     * 生成 UUID
+     */
+    protected generateUuid(): string;
+    /**
+     * 应用模板生成相对路径
+     *
+     * @param record 记录数据
+     * @param template 模板 (如 "{id}.ttl#it")
+     * @returns 相对路径 (如 "alice.ttl#it")
+     */
+    protected applyTemplate(record: Record<string, any>, template: string, table?: PodTable, index?: number): string;
+    /**
+     * 从相对路径反向解析出所有模板变量
+     *
+     * @param relativePath 相对路径 (如 "room1/index.ttl#alice")
+     * @param template 模板 (如 "{chatId}/index.ttl#{id}")
+     * @returns 所有变量的键值对，解析失败返回 null
+     */
+    protected extractVarsFromTemplate(relativePath: string, template: string): Record<string, string> | null;
+    /**
+     * 从相对路径反向解析出 id（向后兼容）
+     */
+    protected extractIdFromTemplate(relativePath: string, template: string): string | null;
+    /**
+     * Extract id values from a query condition
+     * Shared logic for both fragment and document mode
+     */
+    extractIdValues(condition: QueryCondition | Record<string, any> | undefined): string[];
+    /**
+     * Extract values for specific columns from a query condition
+     * Used for subjectTemplate variable resolution
+     */
+    extractTemplateValues(condition: QueryCondition | Record<string, any> | undefined, columns: string[]): Record<string, string>;
+    protected collectColumnValue(condition: any, targetCol: string): string | undefined;
+    protected collectIdValues(condition: any, ids: string[]): void;
+    protected normalizeConditionColumnName(target: unknown): string;
+    protected parseTemplateVariable(token: string): TemplateVariable;
+    protected getTemplateVariables(template: string): TemplateVariable[];
+    protected createTimeContext(record: Record<string, any>): {
+        yyyy: string;
+        MM: string;
+        dd: string;
+        HH: string;
+        mm: string;
+        ss: string;
+    };
+    protected applyTemplateTransforms(value: unknown, variable: TemplateVariable, table?: PodTable, field?: string): string;
+    protected normalizeTemplateValue(value: unknown, table?: PodTable, field?: string): string;
+    protected extractTemplateId(value: string, table?: PodTable, field?: string): string;
+    protected isLinkColumn(column: any): boolean;
+    protected slugifyValue(value: string): string;
+    /**
+     * Resolve base URL for a table's base configuration
+     */
+    protected resolveBaseUrl(table: PodTable): string;
+    /**
+     * 检查是否为绝对 URI
+     */
+    protected isAbsoluteUri(value: string): boolean;
+    /**
+     * Fallback id 提取（当 subjectUri 不以 baseUrl 开头时）
+     */
+    protected extractIdFallback(subjectUri: string): string;
+}
+export {};
+//# sourceMappingURL=base-resolver.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/resource-resolver/document-resolver.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Document Mode ResourceResolver
+ *
+ * In document mode, each record is stored in its own file (e.g., users/alice.ttl)
+ * The subject URI includes the document URL and possibly a fragment.
+ *
+ * 设计原则：
+ * - base = containerPath (如 http://pod/.data/items/)
+ * - 默认模板: {id}
+ * - 写入: id = "alice.ttl#it" → relativePath = "alice.ttl#it" → uri = base + relativePath
+ * - 读取: uri - base = "alice.ttl#it" → id = "alice.ttl#it"
+ */
+import type { PodTable } from '../schema';
+import type { QueryCondition } from '../query-conditions';
+import { BaseResourceResolver } from './base-resolver';
+export declare class DocumentResourceResolver extends BaseResourceResolver {
+    readonly mode: "document";
+    private buildUnsupportedCollectionReadError;
+    private buildUnsupportedCollectionMutationError;
+    /**
+     * 获取默认模板
+     */
+    protected getDefaultTemplate(): string;
+    getContainerUrl(table: PodTable): string;
+    getResourceUrl(table: PodTable): string;
+    /**
+     * 获取表的 base URL
+     *
+     * Document 模式下，base 是容器路径（以 / 结尾）
+     */
+    protected getBaseUrlForTable(table: PodTable): string;
+    getResourceUrlForSubject(subjectUri: string): string;
+    resolveSelectSources(table: PodTable, containerUrl: string, condition?: QueryCondition, listContainer?: (url?: string) => Promise<string[]>): Promise<string[]>;
+    resolveSubjectsForMutation(table: PodTable, condition: QueryCondition, findSubjects: (resourceUrl: string) => Promise<string[]>, listContainer: () => Promise<string[]>): Promise<string[]>;
+}
+//# sourceMappingURL=document-resolver.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/resource-resolver/factory.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ResourceResolver Factory
+ *
+ * Creates the appropriate resolver based on table configuration
+ */
+import type { PodTable } from '../schema';
+import type { ResourceResolver, ResourceResolverFactory } from './types';
+import type { UriResolver } from '../uri';
+export declare class ResourceResolverFactoryImpl implements ResourceResolverFactory {
+    private podBaseUrl;
+    private resolverCache;
+    private uriResolver;
+    constructor(podBaseUrl: string, uriResolver?: UriResolver);
+    /**
+     * Update the pod base URL (e.g., after WebID discovery)
+     */
+    setPodBaseUrl(url: string): void;
+    getResolver(table: PodTable): ResourceResolver;
+    private determineMode;
+}
+/**
+ * Determine the resource mode for a table
+ * Utility function for use outside of factory context
+ * @deprecated Prefer using a UriResolver instance directly
+ */
+export declare function getResourceMode(table: PodTable): 'fragment' | 'document';
+//# sourceMappingURL=factory.d.ts.map