@undefineds.co/xpod 0.4.14 → 0.4.16

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

@@ -1,150 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,60 +0,0 @@
-/**
- * 查询条件构建器
- * 提供类似 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

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,141 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,27 +0,0 @@
-/**
- * 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