@undefineds.co/xpod 0.4.18 → 0.4.20

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

@@ -0,0 +1,36 @@
+import { PodTable } from '../schema';
+import { DataDiscovery, DataLocation, DiscoverOptions, DataRegistrationInfo, RegisterOptions } from './types';
+export declare class InteropDiscovery implements DataDiscovery {
+    private webId;
+    private fetchFn;
+    private clientId?;
+    private shapeTreeCache;
+    constructor(webId: string, fetchFn: typeof fetch, clientId?: string | undefined);
+    private ensureRegistrySet;
+    register(table: PodTable, options?: RegisterOptions): Promise<void>;
+    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
+    /**
+     * 按 container 合并原始结果
+     * 同一个 container 的多个 Shape 合并到 shapes 数组中
+     */
+    private mergeByContainer;
+    private discoverDataRegistrationsRaw;
+    private discoverAccessGrantsRaw;
+    isRegistered(rdfClass: string): Promise<boolean>;
+    /**
+     * 按应用 ID 发现所有数据位置
+     * @param appId 应用标识符
+     */
+    discoverByApp(appId: string): Promise<DataLocation[]>;
+    /**
+     * 获取所有数据注册
+     */
+    discoverAll(): Promise<DataRegistrationInfo[]>;
+    private checkShapeTreeMatchesClass;
+    /**
+     * 解析 ShapeTree，获取 expectsType 和 shape URL
+     * 结果会被缓存以提高性能
+     */
+    private resolveShapeTree;
+}
+//# sourceMappingURL=interop-discovery.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/interop-tables.d.ts

@@ -0,0 +1,37 @@
+export declare const registrySetSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    hasDataRegistry: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+    hasAgentRegistry: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+}>>;
+export declare const dataRegistrySchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    hasDataRegistration: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+}>>;
+export declare const dataRegistrationSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    registeredShapeTree: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    registeredBy: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    registeredAt: import("../schema").ColumnBuilder<"string", null, false, false>;
+    subjectTemplate: import("../schema").ColumnBuilder<"string", null, false, false>;
+}>>;
+export declare const applicationRegistrationSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    registeredAgent: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    hasAccessGrant: import("../schema").ColumnBuilder<"uri", null, false, false>;
+}>>;
+export declare const accessGrantSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    grantedBy: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    grantedAt: import("../schema").ColumnBuilder<"string", null, false, false>;
+    grantee: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    hasDataGrant: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+}>>;
+export declare const dataGrantSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    registeredShapeTree: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    hasDataRegistration: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    scopeOfGrant: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    accessMode: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+    dataOwner: import("../schema").ColumnBuilder<"uri", null, false, false>;
+}>>;
+//# sourceMappingURL=interop-tables.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * Solid Application Interoperability (SAI) 相关的常量和类型定义
+ */
+export declare const INTEROP: {
+    readonly NS: "http://www.w3.org/ns/solid/interop#";
+    readonly ApplicationRegistration: "http://www.w3.org/ns/solid/interop#ApplicationRegistration";
+    readonly DataRegistration: "http://www.w3.org/ns/solid/interop#DataRegistration";
+    readonly AccessGrant: "http://www.w3.org/ns/solid/interop#AccessGrant";
+    readonly DataGrant: "http://www.w3.org/ns/solid/interop#DataGrant";
+    readonly RegistrySet: "http://www.w3.org/ns/solid/interop#RegistrySet";
+    readonly DataRegistry: "http://www.w3.org/ns/solid/interop#DataRegistry";
+    readonly hasRegistrySet: "http://www.w3.org/ns/solid/interop#hasRegistrySet";
+    readonly hasDataRegistry: "http://www.w3.org/ns/solid/interop#hasDataRegistry";
+    readonly hasDataRegistration: "http://www.w3.org/ns/solid/interop#hasDataRegistration";
+    readonly registeredShapeTree: "http://www.w3.org/ns/solid/interop#registeredShapeTree";
+    readonly registeredBy: "http://www.w3.org/ns/solid/interop#registeredBy";
+    readonly hasAccessGrant: "http://www.w3.org/ns/solid/interop#hasAccessGrant";
+    readonly hasDataGrant: "http://www.w3.org/ns/solid/interop#hasDataGrant";
+    readonly scopeOfGrant: "http://www.w3.org/ns/solid/interop#scopeOfGrant";
+    readonly dataOwner: "http://www.w3.org/ns/solid/interop#dataOwner";
+    readonly registeredShapeTreeProp: "http://www.w3.org/ns/solid/interop#registeredShapeTree";
+};
+export declare const SHAPETREES: {
+    readonly NS: "http://www.w3.org/ns/shapetrees#";
+    readonly ShapeTree: "http://www.w3.org/ns/shapetrees#ShapeTree";
+    readonly expectsType: "http://www.w3.org/ns/shapetrees#expectsType";
+    readonly shape: "http://www.w3.org/ns/shapetrees#shape";
+};
+/**
+ * Undefineds.co vocabulary extensions for Solid
+ */
+export declare const UDFS: {
+    readonly NS: "https://vocab.undefineds.co/";
+    readonly subjectTemplate: "https://vocab.undefineds.co/subjectTemplate";
+};
+//# sourceMappingURL=interop-types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/provider-cache.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Provider Cache
+ *
+ * 缓存 Pod 供应商的 .well-known/solid 响应
+ * 同一供应商的用户共享缓存，减少重复请求
+ */
+/**
+ * .well-known/solid 响应内容
+ */
+export interface WellKnownResponse {
+    /** 公开 TypeIndex 位置 */
+    typeIndex?: string;
+    /** 私有 TypeIndex 位置 */
+    privateTypeIndex?: string;
+    /** SAI Registry Set 位置 */
+    registrySet?: string;
+    /** OIDC Issuer */
+    oidcIssuer?: string;
+    /** 原始响应（保留未来扩展字段） */
+    raw?: Record<string, string>;
+}
+export declare class ProviderCache {
+    private cache;
+    private ttl;
+    private fetchFn;
+    constructor(options?: {
+        ttl?: number;
+        fetch?: typeof fetch;
+    });
+    /**
+     * 获取 Pod 的 .well-known 信息
+     * 优先使用缓存
+     */
+    getWellKnown(podUrl: string): Promise<WellKnownResponse>;
+    /**
+     * 发现指定类型的数据位置
+     * SAI 优先，TypeIndex 兜底
+     */
+    discover(podUrl: string, type: string, discoverFromSAI: (registrySet: string, type: string) => Promise<string | null>, discoverFromTypeIndex: (typeIndex: string, type: string) => Promise<string | null>): Promise<string | null>;
+    /**
+     * 设置 TTL
+     */
+    setTTL(ms: number): void;
+    /**
+     * 清除缓存
+     */
+    clear(): void;
+    /**
+     * 清除指定供应商的缓存
+     */
+    clearProvider(provider: string): void;
+    /**
+     * 从 Pod URL 提取供应商标识
+     * https://bob.solidcommunity.net/ → solidcommunity.net
+     * https://alice.inrupt.net/ → inrupt.net
+     */
+    private extractProvider;
+    /**
+     * 请求 .well-known/solid
+     */
+    private fetchWellKnown;
+    /**
+     * 解析 Turtle 格式的 .well-known/solid
+     */
+    private parseTurtle;
+    /**
+     * 从行中提取 URL
+     */
+    private extractUrl;
+    /**
+     * 解析 JSON-LD 格式
+     */
+    private parseJsonLd;
+    /**
+     * 从 JSON-LD 值中提取 URL
+     */
+    private extractJsonLdValue;
+    /**
+     * 解析 URL（处理相对路径）
+     */
+    private resolveUrl;
+    /**
+     * 从完整 URL 提取相对路径
+     */
+    private extractPaths;
+    /**
+     * 将完整 URL 转换为相对路径
+     */
+    private toRelativePath;
+    /**
+     * 将缓存的相对路径应用到指定 Pod
+     */
+    private applyToPod;
+    /**
+     * 将相对路径转换为完整 URL
+     */
+    private toAbsoluteUrl;
+}
+//# sourceMappingURL=provider-cache.d.ts.map

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

@@ -0,0 +1,32 @@
+import { PodTable } from '../schema';
+import { TypeIndexManager } from '../typeindex-manager';
+import { DataDiscovery, DataLocation, DiscoverOptions, RegisterOptions } from './types';
+import type { UriResolver } from '../uri';
+/**
+ * 基于 TypeIndex 的数据发现实现
+ */
+export declare class TypeIndexDiscovery implements DataDiscovery {
+    private manager;
+    private podUrl;
+    private uriResolver;
+    constructor(manager: TypeIndexManager, podUrl: string, uriResolver?: UriResolver);
+    setPodUrl(podUrl: string): void;
+    private getPodUrl;
+    /**
+     * 注册表的类型到 TypeIndex
+     */
+    register(table: PodTable, _options?: RegisterOptions): Promise<void>;
+    /**
+     * 发现某类型数据的位置
+     */
+    discover(rdfClass: string, _options?: DiscoverOptions): Promise<DataLocation[]>;
+    /**
+     * 检查类型是否已注册
+     */
+    isRegistered(rdfClass: string): Promise<boolean>;
+    private getRdfClass;
+    private resolveTableResource;
+    private toAbsolute;
+    private handleRegistrationError;
+}
+//# sourceMappingURL=typeindex-discovery.d.ts.map

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

@@ -0,0 +1,132 @@
+import { PodTable } from '../schema';
+/**
+ * 数据注册选项
+ */
+export interface RegisterOptions {
+    /** RegistrySet 基础路径（用于自动创建 SAI registry） */
+    registryPath?: string;
+    /** Shape URL - 如果提供，会在 ShapeTree 中引用此 Shape */
+    shapeUrl?: string;
+    /** 自定义容器路径（相对于 DataRegistry） */
+    containerSlug?: string;
+    /** 是否强制重新注册（即使已存在） */
+    force?: boolean;
+}
+/**
+ * Shape 信息
+ */
+export interface ShapeInfo {
+    /** Shape URL - 实际的 SHACL Shape 定义位置 */
+    url: string;
+    /** ShapeTree URL - SAI 发现时的 ShapeTree 位置 */
+    shapeTree?: string;
+    /** 注册此 Shape 的应用 ID (clientId/appId) */
+    registeredBy?: string;
+    /** 发现来源 */
+    source: 'typeindex' | 'interop' | 'config';
+}
+/**
+ * 数据位置信息 - 以 container 为准
+ *
+ * 一个 container 可能有多个 Shape 描述（来自不同 app 的注册）
+ * 数据在同一个位置，但可以用不同的 Shape 来解释
+ */
+export interface DataLocation {
+    /** 数据容器 URL - 唯一标识数据位置 */
+    container: string;
+    /** 主体 URI 模式 (可选) - deprecated, use subjectTemplate */
+    subjectPattern?: string;
+    /**
+     * @deprecated Legacy/explicit Subject URI template. Prefer exact base-relative ids.
+     */
+    subjectTemplate?: string;
+    /** 可用的 Shape 列表（按注册顺序） */
+    shapes: ShapeInfo[];
+    /** 发现来源（取第一个注册的来源） */
+    source: 'typeindex' | 'interop' | 'config';
+}
+/**
+ * 发现选项
+ */
+export interface DiscoverOptions {
+    /** 只查找自己注册的 */
+    selfOnly?: boolean;
+    /** 按应用 origin 过滤 */
+    origin?: string;
+    /** 按应用 ID 过滤 */
+    appId?: string;
+}
+/**
+ * locationToTable 转换选项
+ *
+ * 三种选择 Shape 的方式（按优先级）：
+ * 1. shape - 直接传入 ShapeInfo 对象或 Shape URL
+ * 2. appId - 选择该 app 注册的 Shape
+ * 3. 都不传 - 使用第一个可用的 Shape
+ */
+export interface LocationToTableOptions {
+    /** 直接指定 Shape（ShapeInfo 对象或 Shape URL 字符串） */
+    shape?: ShapeInfo | string;
+    /** 按 appId 选择该 app 注册的 Shape */
+    appId?: string;
+}
+/**
+ * 数据注册信息 - 包含完整的注册元数据
+ */
+export interface DataRegistrationInfo {
+    /** 注册资源的 URL */
+    registrationUrl: string;
+    /** 数据容器 URL */
+    container: string;
+    /** RDF 类型 */
+    rdfClass: string;
+    /** ShapeTree URL */
+    shapeTree: string;
+    /** Shape URL - 实际的 SHACL Shape 定义 */
+    shape?: string;
+    /**
+     * @deprecated Legacy/explicit Subject URI template. Prefer exact base-relative ids.
+     */
+    subjectTemplate?: string;
+    /** 注册此数据的应用/代理 */
+    registeredBy?: string;
+    /** 注册时间 */
+    registeredAt?: Date;
+}
+/**
+ * 数据发现接口
+ *
+ * 负责：
+ * 1. 注册表的类型到发现机制 (TypeIndex / Interop Registry)
+ * 2. 发现某类型数据的存储位置
+ * 3. 检查类型是否已注册
+ */
+export interface DataDiscovery {
+    /**
+     * 注册表的类型
+     * @param table PodTable 定义
+     * @param options 注册选项
+     */
+    register(table: PodTable, options?: RegisterOptions): Promise<void>;
+    /**
+     * 发现某类型数据的位置
+     * @param rdfClass RDF 类型 URI
+     * @param options 可选的过滤选项
+     */
+    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
+    /**
+     * 检查类型是否已注册
+     * @param rdfClass RDF 类型 URI
+     */
+    isRegistered(rdfClass: string): Promise<boolean>;
+    /**
+     * 获取所有数据注册 (可选实现)
+     */
+    discoverAll?(): Promise<DataRegistrationInfo[]>;
+    /**
+     * 按应用 ID 发现数据位置 (可选实现)
+     * @param appId 应用标识符
+     */
+    discoverByApp?(appId: string): Promise<DataLocation[]>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { PodTable } from './schema';
+type ExactRecordTarget = string | Record<string, unknown> | null | undefined;
+type ExactRecordResolvedTarget = string | Record<string, unknown>;
+type ExactPodTable = PodTable<any>;
+export type ExactRecordDatabase = {
+    findByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget) => Promise<unknown | null>;
+    updateByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget, data: any) => Promise<unknown | null>;
+    deleteByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget) => Promise<unknown>;
+    insert?: <TResource extends ExactPodTable>(resource: TResource) => {
+        values(value: any): {
+            execute(): Promise<unknown>;
+        };
+    };
+};
+export declare function findExactRecord<T>(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget): Promise<T | null>;
+export declare function updateExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, updates: Record<string, unknown>): Promise<void>;
+export declare function upsertExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, row: Record<string, unknown>, updates: Record<string, unknown>): Promise<'inserted' | 'updated'>;
+export declare function insertExactRecordOnce(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, row: Record<string, unknown>): Promise<boolean>;
+export declare function deleteExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget): Promise<void>;
+export {};
+//# sourceMappingURL=exact-records.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * Execution Module
+ *
+ * Provides execution strategies for different modes (LDP, SPARQL)
+ */
+export type { ExecutionStrategy, ExecutionStrategyFactory, ExecutionResult, ExecutionContext, InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from './types';
+export { LdpStrategy } from './ldp-strategy';
+export type { LdpStrategyDependencies } from './ldp-strategy';
+export { SparqlStrategy } from './sparql-strategy';
+export type { SparqlStrategyDependencies } from './sparql-strategy';
+export { ExecutionStrategyFactoryImpl } from './strategy-factory';
+export type { StrategyFactoryDependencies } from './strategy-factory';
+export { LdpExecutor } from './ldp-executor';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/ldp-executor.d.ts

@@ -0,0 +1,76 @@
+/**
+ * LDP Executor Implementation
+ *
+ * 负责 LDP 模式下的写操作 (N3 Patch)，剥离自 PodDialect
+ */
+import type { PodTable } from '../schema';
+import type { ComunicaSPARQLExecutor } from '../sparql-executor';
+import type { UriResolver } from '../uri';
+export declare class LdpExecutor {
+    private sparqlExecutor;
+    private fetchFn;
+    private tripleBuilder;
+    private uriResolver;
+    constructor(sparqlExecutor: ComunicaSPARQLExecutor, fetchFn: typeof fetch, uriResolver: UriResolver);
+    /**
+     * 设置表注册表（用于 URI 引用自动补全）
+     * @param classRegistry rdfClass -> tables[] 的映射
+     * @param nameRegistry tableName -> table 的映射
+     */
+    setTableRegistry(classRegistry: Map<string, PodTable[]>, nameRegistry: Map<string, PodTable>): void;
+    /**
+     * 设置基础 URI
+     */
+    setBaseUri(uri: string): void;
+    /**
+     * 执行 INSERT 操作
+     */
+    executeInsert(rows: any[], table: PodTable, resourceUrl: string, options?: {
+        ensureContainerExists?: (containerUrl: string) => Promise<void>;
+        repairContainerOnWriteFailure?: (containerUrl: string) => Promise<void>;
+        skipResourceExistenceCheck?: boolean;
+        tableRegistry?: Map<string, PodTable[]>;
+        tableNameRegistry?: Map<string, PodTable>;
+    }): Promise<any[]>;
+    private repairContainerAndRetryPutIfNeeded;
+    private isMissingParentContainerResponse;
+    /**
+     * 执行 UPDATE 操作
+     */
+    executeUpdate(table: PodTable, data: Record<string, any>, subjects: string[], resourceUrl: string): Promise<any[]>;
+    /**
+     * 执行 DELETE 操作
+     */
+    executeDelete(subjects: string[], table: PodTable, resourceUrl: string): Promise<any[]>;
+    /**
+     * Execute a function with exponential backoff retry on server errors
+     */
+    private retryWithBackoff;
+    /**
+     * Build error from failed response
+     */
+    private buildPatchError;
+    private buildUpdatePatchPayload;
+    private sameTripleSet;
+    /**
+     * 执行更新操作
+     *
+     * 优先尝试 SPARQL UPDATE (application/sparql-update)，
+     * xpod 内部使用 SPARQL，标准 CSS 也支持。
+     * 如果失败，回退到 N3 Patch。
+     */
+    private executeN3Patch;
+    /**
+     * 构建 SPARQL UPDATE 查询
+     */
+    private buildSparqlUpdate;
+    /**
+     * 内部 N3 Patch 实现（作为 SPARQL UPDATE 的回退）
+     */
+    private executeN3PatchInternal;
+    private formatTerm;
+    private fetchRecursiveTriplesToDelete;
+    private fetchExistingObjects;
+    private fetchInverseSubjects;
+}
+//# sourceMappingURL=ldp-executor.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/ldp-strategy.d.ts

@@ -0,0 +1,53 @@
+/**
+ * LDP Execution Strategy
+ *
+ * Implements ExecutionStrategy for LDP mode.
+ * - SELECT: Uses Comunica to query RDF resources
+ * - INSERT/UPDATE/DELETE: Uses N3 Patch or PUT
+ */
+import type { PodTable } from '../schema';
+import type { ComunicaSPARQLExecutor } from '../sparql-executor';
+import type { ASTToSPARQLConverter } from '../ast-to-sparql';
+import type { ResourceResolver } from '../resource-resolver';
+import type { QueryCondition } from '../query-conditions';
+import type { SelectQueryPlan } from '../select-plan';
+import type { ExecutionStrategy, ExecutionResult, InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from './types';
+import { LdpExecutor } from './ldp-executor';
+export interface LdpStrategyDependencies {
+    sparqlExecutor: ComunicaSPARQLExecutor;
+    sparqlConverter: ASTToSPARQLConverter;
+    fetchFn: typeof fetch;
+    ldpExecutor: LdpExecutor;
+    getResolver: (table: PodTable) => ResourceResolver;
+    listContainerResources: (containerUrl: string) => Promise<string[]>;
+    findSubjectsForCondition: (condition: QueryCondition, table: PodTable, resourceUrl: string) => Promise<string[]>;
+}
+export declare class LdpStrategy implements ExecutionStrategy {
+    readonly mode: "ldp";
+    private sparqlExecutor;
+    private sparqlConverter;
+    private fetchFn;
+    private ldpExecutor;
+    private getResolver;
+    private listContainerResources;
+    private findSubjectsForCondition;
+    constructor(deps: LdpStrategyDependencies);
+    /**
+     * Execute SELECT query in LDP mode
+     * Uses ResourceResolver to determine which sources to query
+     */
+    executeSelect(plan: SelectQueryPlan, containerUrl: string, _resourceUrl: string): Promise<any[]>;
+    /**
+     * Execute INSERT operation in LDP mode
+     */
+    executeInsert(plan: InsertQueryPlan, _containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
+    /**
+     * Execute UPDATE operation in LDP mode
+     */
+    executeUpdate(plan: UpdateQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
+    /**
+     * Execute DELETE operation in LDP mode
+     */
+    executeDelete(plan: DeleteQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
+}
+//# sourceMappingURL=ldp-strategy.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/pod-executor-types.d.ts

@@ -0,0 +1,9 @@
+export type TableResourceDescriptor = {
+    mode: 'ldp';
+    containerUrl: string;
+    resourceUrl: string;
+} | {
+    mode: 'sparql';
+    endpoint: string;
+};
+//# sourceMappingURL=pod-executor-types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/pod-executor.d.ts

@@ -0,0 +1,73 @@
+import type { PodTable } from '../schema';
+import type { PodOperation } from '../pod-dialect';
+import type { QueryCondition } from '../query-conditions';
+import type { SelectQueryPlan } from '../select-plan';
+import type { InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from '../pod-session';
+import type { ASTToSPARQLConverter } from '../ast-to-sparql';
+import type { ComunicaSPARQLExecutor } from '../sparql-executor';
+import type { ExecutionStrategy } from './types';
+import type { TableResourceDescriptor } from './pod-executor-types';
+export interface PodExecutorDeps {
+    ensureConnected: () => Promise<void>;
+    ensureTableResourcePath: (table: PodTable) => Promise<void>;
+    resolveTableResource: (table: PodTable) => TableResourceDescriptor;
+    resolveTableUrls: (table: PodTable) => {
+        containerUrl: string;
+        resourceUrl: string;
+    };
+    normalizeResourceUrl: (resourceUrl: string) => string;
+    normalizeContainerKey: (containerUrl: string) => string;
+    normalizeResourceKey: (resourceUrl: string) => string;
+    ensureContainerExists: (containerUrl: string) => Promise<void>;
+    ensureResourceExists: (resourceUrl: string, options?: {
+        createIfMissing?: boolean;
+    }) => Promise<void>;
+    shouldSkipResourcePreparation?: () => boolean;
+    shouldUseWriteTimeResourcePreparation?: () => boolean;
+    shouldContinueAfterResourcePreparationError?: () => boolean;
+    getTableRegistries?: () => {
+        tableRegistry: Map<string, PodTable[]>;
+        tableNameRegistry: Map<string, PodTable>;
+    };
+    ensureIdentifierCondition: (condition: QueryCondition | undefined, table: PodTable, resourceUrl: string) => Promise<QueryCondition | undefined>;
+    resourceExists: (resourceUrl: string) => Promise<boolean>;
+    getStrategy: (table: PodTable) => ExecutionStrategy;
+    getLdpStrategy: () => ExecutionStrategy;
+    preparedContainers: Set<string>;
+    preparedResources: Set<string>;
+    sparqlConverter: ASTToSPARQLConverter;
+    sparqlExecutor: ComunicaSPARQLExecutor;
+    isSelectPlan: (plan: unknown) => plan is SelectQueryPlan;
+    isInsertPlan: (plan: unknown) => plan is InsertQueryPlan;
+    isUpdatePlan: (plan: unknown) => plan is UpdateQueryPlan;
+    isDeletePlan: (plan: unknown) => plan is DeleteQueryPlan;
+}
+export declare class PodExecutor {
+    private deps;
+    constructor(deps: PodExecutorDeps);
+    query(operation: PodOperation): Promise<unknown[]>;
+    private shouldSkipResourcePreparation;
+    private shouldUseWriteTimeResourcePreparation;
+    private shouldContinueAfterResourcePreparationError;
+    private prepareResource;
+    /**
+     * Execute SELECT operation via ExecutionStrategy
+     */
+    private executeSelect;
+    private getSelectStrategy;
+    private isExactIriSelect;
+    private getExactSelectResourceUrl;
+    /**
+     * Execute INSERT operation via ExecutionStrategy
+     */
+    private executeInsert;
+    /**
+     * Execute UPDATE operation via ExecutionStrategy
+     */
+    private executeUpdate;
+    /**
+     * Execute DELETE operation via ExecutionStrategy
+     */
+    private executeDelete;
+}
+//# sourceMappingURL=pod-executor.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/execution/sparql-strategy.d.ts

@@ -0,0 +1,31 @@
+import type { ASTToSPARQLConverter } from '../ast-to-sparql';
+import type { SelectQueryPlan } from '../select-plan';
+import type { ComunicaSPARQLExecutor } from '../sparql-executor';
+import type { SPARQLQueryEngineFactory } from '../sparql-engine';
+import type { UriResolver } from '../uri';
+import type { ExecutionStrategy } from './types';
+export interface SparqlStrategyDependencies {
+    sparqlExecutor: ComunicaSPARQLExecutor;
+    sparqlConverter: ASTToSPARQLConverter;
+    sessionFetch: typeof fetch;
+    podUrl: string;
+    uriResolver: UriResolver;
+    createQueryEngine?: SPARQLQueryEngineFactory;
+}
+export declare class SparqlStrategy implements ExecutionStrategy {
+    readonly mode: "sparql";
+    private sparqlExecutor;
+    private sparqlConverter;
+    private podUrl;
+    private uriResolver;
+    private createQueryEngine?;
+    constructor(deps: SparqlStrategyDependencies);
+    setPodUrl(podUrl: string): void;
+    private resolvePodResourceIri;
+    private resolveTargetGraph;
+    executeSelect(plan: SelectQueryPlan, _containerUrl: string, resourceUrl: string): Promise<any[]>;
+    executeInsert(): Promise<any[]>;
+    executeUpdate(): Promise<any[]>;
+    executeDelete(): Promise<any[]>;
+}
+//# sourceMappingURL=sparql-strategy.d.ts.map