@undefineds.co/xpod 0.4.18 → 0.4.20

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

@@ -0,0 +1,42 @@
+/**
+ * ExecutionStrategy Factory
+ *
+ * Creates the appropriate execution strategy based on table configuration.
+ * - Tables with sparqlEndpoint -> SparqlStrategy
+ * - Tables without sparqlEndpoint -> LdpStrategy
+ */
+import type { ASTToSPARQLConverter } from '../ast-to-sparql';
+import type { QueryCondition } from '../query-conditions';
+import type { ResourceResolver } from '../resource-resolver';
+import type { PodTable } from '../schema';
+import type { ComunicaSPARQLExecutor } from '../sparql-executor';
+import type { SPARQLQueryEngineFactory } from '../sparql-engine';
+import type { UriResolver } from '../uri';
+import { LdpStrategy } from './ldp-strategy';
+import type { LdpExecutor } from './ldp-executor';
+import type { ExecutionStrategy, ExecutionStrategyFactory } from './types';
+export interface StrategyFactoryDependencies {
+    sparqlExecutor: ComunicaSPARQLExecutor;
+    sparqlConverter: ASTToSPARQLConverter;
+    sessionFetch: typeof fetch;
+    podUrl: string;
+    createQueryEngine?: SPARQLQueryEngineFactory;
+    ldpExecutor: LdpExecutor;
+    uriResolver: UriResolver;
+    getResolver: (table: PodTable) => ResourceResolver;
+    listContainerResources: (containerUrl: string) => Promise<string[]>;
+    findSubjectsForCondition: (condition: QueryCondition, table: PodTable, resourceUrl: string) => Promise<string[]>;
+}
+export declare class ExecutionStrategyFactoryImpl implements ExecutionStrategyFactory {
+    private deps;
+    private ldpStrategy;
+    private sparqlStrategy;
+    constructor(deps: StrategyFactoryDependencies);
+    setPodUrl(podUrl: string): void;
+    getStrategy(table: PodTable): ExecutionStrategy;
+    getLdpStrategy(): LdpStrategy;
+    private getLdpStrategyInternal;
+    private getSparqlStrategy;
+    static getMode(table: PodTable): 'ldp' | 'sparql';
+}
+//# sourceMappingURL=strategy-factory.d.ts.map

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

@@ -0,0 +1,85 @@
+/**
+ * ExecutionStrategy Types
+ *
+ * Defines the interface for different execution modes (LDP, SPARQL)
+ */
+import type { PodTable } from '../schema';
+import type { QueryCondition } from '../query-conditions';
+import type { SelectQueryPlan } from '../select-plan';
+export interface InsertQueryPlan {
+    table: PodTable;
+    rows: any[];
+    ensureContainerExists?: (containerUrl: string) => Promise<void>;
+    repairContainerOnWriteFailure?: (containerUrl: string) => Promise<void>;
+    skipResourceExistenceCheck?: boolean;
+    tableRegistry?: Map<string, PodTable[]>;
+    tableNameRegistry?: Map<string, PodTable>;
+}
+export interface UpdateQueryPlan {
+    table: PodTable;
+    data: Record<string, any>;
+    where: QueryCondition;
+}
+export interface DeleteQueryPlan {
+    table: PodTable;
+    where?: QueryCondition;
+}
+/**
+ * Result of an execution operation
+ */
+export interface ExecutionResult {
+    success: boolean;
+    source: string;
+    status: number;
+    via?: string;
+    error?: string;
+    retried?: boolean;
+}
+/**
+ * Context passed to execution strategies
+ */
+export interface ExecutionContext {
+    /** Pod base URL */
+    podUrl: string;
+    /** Authenticated fetch function */
+    fetch: typeof fetch;
+    /** WebID of the current user */
+    webId: string;
+}
+/**
+ * ExecutionStrategy interface
+ *
+ * Abstracts the difference between LDP and SPARQL execution modes.
+ * SELECT is required; write operations are optional since SPARQL mode
+ * only supports SELECT (writes are routed to LDP for Solid Notifications compatibility).
+ */
+export interface ExecutionStrategy {
+    /** Mode identifier */
+    readonly mode: 'ldp' | 'sparql';
+    /**
+     * Execute a SELECT query
+     */
+    executeSelect(plan: SelectQueryPlan, containerUrl: string, resourceUrl: string): Promise<any[]>;
+    /**
+     * Execute an INSERT operation (optional - SPARQL mode does not support writes)
+     */
+    executeInsert?(plan: InsertQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
+    /**
+     * Execute an UPDATE operation (optional - SPARQL mode does not support writes)
+     */
+    executeUpdate?(plan: UpdateQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
+    /**
+     * Execute a DELETE operation (optional - SPARQL mode does not support writes)
+     */
+    executeDelete?(plan: DeleteQueryPlan, containerUrl: string, resourceUrl: string): Promise<ExecutionResult[]>;
+}
+/**
+ * Factory interface for creating execution strategies
+ */
+export interface ExecutionStrategyFactory {
+    /**
+     * Get the appropriate execution strategy for a table
+     */
+    getStrategy(table: PodTable): ExecutionStrategy;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,40 @@
+import { PodColumnBase } from './schema';
+type AnyColumn = PodColumnBase<any, any, any, any>;
+type ExpressionValue = unknown;
+/**
+ * SPARQL 表达式基类
+ * 不再实现 drizzle-orm 的 SQLWrapper 接口，避免假 SQL 对象导致的问题
+ */
+export declare abstract class SPARQLExpression {
+    readonly [Symbol.toStringTag] = "SPARQLExpression";
+}
+export declare class BinaryExpression extends SPARQLExpression {
+    left: AnyColumn | SPARQLExpression | string;
+    operator: string;
+    right: ExpressionValue;
+    readonly type = "binary_expr";
+    constructor(left: AnyColumn | SPARQLExpression | string, operator: string, right: ExpressionValue);
+}
+export declare class LogicalExpression extends SPARQLExpression {
+    operator: 'AND' | 'OR';
+    expressions: (SPARQLExpression | ExpressionValue)[];
+    readonly type = "logical_expr";
+    constructor(operator: 'AND' | 'OR', expressions: (SPARQLExpression | ExpressionValue)[]);
+}
+export declare class UnaryExpression extends SPARQLExpression {
+    operator: string;
+    value: ExpressionValue;
+    readonly type = "unary_expr";
+    constructor(operator: string, value: ExpressionValue);
+}
+export declare class SelectionAliasExpression extends SPARQLExpression {
+    alias: string;
+    constructor(alias: string);
+}
+export declare class FunctionExpression extends SPARQLExpression {
+    functionName: string;
+    args: ExpressionValue[];
+    constructor(functionName: string, args: ExpressionValue[]);
+}
+export {};
+//# sourceMappingURL=expressions.d.ts.map

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

@@ -0,0 +1,98 @@
+/**
+ * Federated Query Executor
+ *
+ * 执行跨 Pod 的联邦查询
+ */
+import type { RelationDefinition } from '../schema';
+import { ProviderCache } from '../discovery/provider-cache';
+import type { FederatedResult, FederatedQueryOptions } from './types';
+/**
+ * 联邦查询执行器
+ */
+export declare class FederatedQueryExecutor {
+    private providerCache;
+    private fetchFn;
+    private defaultTimeout;
+    constructor(options?: {
+        providerCache?: ProviderCache;
+        fetch?: typeof fetch;
+        timeout?: number;
+    });
+    /**
+     * 执行联邦查询
+     *
+     * @param parentRows 父表的查询结果
+     * @param relationDef 关系定义
+     * @param options 查询选项
+     */
+    execute<T extends Record<string, unknown>>(parentRows: T[], relationDef: RelationDefinition, options?: FederatedQueryOptions): Promise<FederatedResult<T[]>>;
+    /**
+     * 并行执行发现和查询
+     */
+    private executeParallel;
+    /**
+     * 顺序执行发现和查询
+     */
+    private executeSequential;
+    /**
+     * 发现并查询数据
+     */
+    private discoverAndQuery;
+    /**
+     * 从 WebID 提取 Pod URL
+     */
+    private extractPodUrl;
+    /**
+     * 发现数据容器位置
+     */
+    private discoverContainer;
+    /**
+     * 从 SAI Registry 发现数据位置
+     *
+     * 简化版本：直接解析 RegistrySet -> DataRegistry -> DataRegistration
+     */
+    private discoverFromSAI;
+    /**
+     * 解析相对 URL
+     */
+    private resolveUrl;
+    /**
+     * 从 TypeIndex 发现数据位置
+     */
+    private discoverFromTypeIndex;
+    /**
+     * 查询容器中的数据
+     *
+     * 使用 LDP 获取容器内容并解析
+     */
+    private queryContainer;
+    /**
+     * 解析 Turtle 内容，提取匹配类型的资源
+     */
+    private parseTurtleResources;
+    /**
+     * 从 Turtle 中提取特定主语的所有属性
+     */
+    private extractResourceProperties;
+    /**
+     * 从 URI 提取 ID
+     *
+     * 注意：这里是 fallback 逻辑，没有 table 上下文时使用
+     * 返回包含 # 的 fragment 部分，与新的 id 规则一致
+     */
+    private extractIdFromUri;
+    /**
+     * 从 URI 提取本地名称（作为属性名）
+     */
+    private extractLocalName;
+    /**
+     * 转义正则表达式特殊字符
+     */
+    private escapeRegex;
+    /**
+     * 创建错误对象
+     */
+    private createError;
+}
+export declare const federatedQueryExecutor: FederatedQueryExecutor;
+//# sourceMappingURL=executor.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './executor';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,69 @@
+/**
+ * Federated Query Types
+ *
+ * 联邦查询的类型定义
+ */
+import type { SolidSchema } from '../schema';
+/**
+ * 联邦查询错误
+ */
+export interface FederatedError {
+    /** 错误路径，如 [0, 'posts'] 表示第一个元素的 posts 字段 */
+    path: (string | number)[];
+    /** 错误代码 */
+    code: 'FORBIDDEN' | 'NOT_FOUND' | 'TIMEOUT' | 'NETWORK_ERROR' | 'DISCOVERY_FAILED';
+    /** 错误消息 */
+    message: string;
+    /** 相关的 URL（可选） */
+    url?: string;
+}
+/**
+ * 联邦查询结果
+ * 遵循 GraphQL 风格：data 和 errors 分开
+ */
+export interface FederatedResult<T> {
+    /** 查询结果数据 */
+    data: T;
+    /** 错误列表（如果有） */
+    errors?: FederatedError[];
+}
+/**
+ * 联邦查询选项
+ */
+export interface FederatedQueryOptions {
+    /** 超时时间（毫秒） */
+    timeout?: number;
+    /** 是否并行查询多个 Pod */
+    parallel?: boolean;
+    /** 最大并发数 */
+    maxConcurrency?: number;
+}
+/**
+ * 发现的数据位置
+ */
+export interface DiscoveredLocation {
+    /** WebID 来源 */
+    webId: string;
+    /** Pod URL */
+    podUrl: string;
+    /** 数据容器 URL */
+    containerUrl: string;
+    /** 发现来源 */
+    source: 'sai' | 'typeindex';
+}
+/**
+ * 联邦查询上下文
+ */
+export interface FederatedQueryContext {
+    /** 父记录 */
+    parentRecord: Record<string, unknown>;
+    /** 父记录在结果中的索引 */
+    parentIndex: number;
+    /** 关系名称 */
+    relationName: string;
+    /** 目标 schema */
+    targetSchema: SolidSchema<any>;
+    /** 发现到的位置列表 */
+    locations: DiscoveredLocation[];
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/notifications/channels/base-channel.d.ts

@@ -0,0 +1,29 @@
+import type { NotificationChannel, ChannelConfig, NotificationEvent } from '../types';
+/**
+ * 解析 Activity Streams 2.0 消息为 NotificationEvent
+ */
+export declare function parseActivityStreamsMessage(data: string): NotificationEvent;
+/**
+ * Channel 抽象基类
+ */
+export declare abstract class BaseChannel implements NotificationChannel {
+    protected _connected: boolean;
+    protected readonly config: ChannelConfig;
+    constructor(config: ChannelConfig);
+    get connected(): boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): void;
+    /**
+     * 处理收到的消息
+     */
+    protected handleMessage(data: string): void;
+    /**
+     * 处理错误
+     */
+    protected handleError(error: Error): void;
+    /**
+     * 处理连接关闭
+     */
+    protected handleClose(): void;
+}
+//# sourceMappingURL=base-channel.d.ts.map

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

@@ -0,0 +1,4 @@
+export { BaseChannel, parseActivityStreamsMessage } from './base-channel';
+export { SSEChannel } from './sse-channel';
+export { WebSocketChannel } from './websocket-channel';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/notifications/channels/sse-channel.d.ts

@@ -0,0 +1,50 @@
+import { BaseChannel } from './base-channel';
+import type { ChannelConfig } from '../types';
+/**
+ * SSE (Server-Sent Events) 通道实现
+ * 对应 Solid Notifications Protocol 的 StreamingHTTPChannel2023
+ *
+ * 支持两种模式：
+ * 1. 标准 SSE (text/event-stream): data: 前缀的 JSON-LD
+ * 2. CSS 直接模式 (text/turtle): 直接返回 Turtle 格式的通知
+ */
+export declare class SSEChannel extends BaseChannel {
+    private abortController;
+    private reader;
+    private contentType;
+    constructor(config: ChannelConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    /**
+     * 读取流
+     */
+    private readStream;
+    /**
+     * 处理 Turtle 格式的缓冲区
+     * CSS 返回的 Turtle 通知以空行分隔
+     */
+    private processTurtleBuffer;
+    /**
+     * 处理标准 SSE 格式的缓冲区
+     */
+    private processSSEBuffer;
+    /**
+     * 解析 Turtle 格式的通知 (CSS 模式)
+     *
+     * 示例：
+     * <urn:xxx:topic> <https://www.w3.org/ns/activitystreams#object> <http://localhost:3000/test/>;
+     *     <http://www.w3.org/ns/solid/notifications#state> "\"etag\"";
+     *     <https://www.w3.org/ns/activitystreams#published> "2025-12-13T00:54:11.531Z"^^<xsd:dateTime>;
+     *     a <https://www.w3.org/ns/activitystreams#Update>.
+     */
+    private parseTurtleNotification;
+    /**
+     * 解析通知（自动检测格式）
+     */
+    private parseNotification;
+    /**
+     * 解析标准 SSE 消息
+     */
+    private parseSSEMessage;
+}
+//# sourceMappingURL=sse-channel.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/notifications/channels/websocket-channel.d.ts

@@ -0,0 +1,16 @@
+import { BaseChannel } from './base-channel';
+import type { ChannelConfig } from '../types';
+/**
+ * WebSocket 通道实现
+ * 对应 Solid Notifications Protocol 的 WebSocketChannel2023
+ */
+export declare class WebSocketChannel extends BaseChannel {
+    private ws;
+    private reconnectAttempts;
+    private readonly maxReconnectAttempts;
+    private readonly reconnectDelay;
+    constructor(config: ChannelConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+}
+//# sourceMappingURL=websocket-channel.d.ts.map

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

@@ -0,0 +1,3 @@
+export { NotificationsClient, type NotificationsClientConfig } from './notifications-client';
+export type { Activity, ActivityObject, NotificationEvent, NotificationType, ChannelType, SubscribeOptions, TableSubscribeOptions, EntitySubscribeOptions, Subscription, SubscriptionFeature, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,88 @@
+import type { ChannelType, SubscribeOptions, Subscription, NotificationChannel } from './types';
+interface DiscoveredService {
+    baseEndpoint: string;
+    supportedChannels: ChannelType[];
+}
+export interface NotificationsClientConfig {
+    /** 通道偏好顺序，默认 ['streaming-http', 'websocket'] */
+    preferredChannels?: ChannelType[];
+}
+/**
+ * Solid Notifications 客户端
+ *
+ * 支持两种通道：
+ * - streaming-http (SSE): CSS 直接连接模式，无需订阅
+ * - websocket: 标准订阅模式，POST 获取 receiveFrom
+ *
+ * 特性：
+ * - 自动重连：当连接断开时（如 xpod node_id 切换），自动重新订阅
+ * - 指数退避：重连延迟采用指数退避策略，避免服务器过载
+ */
+export declare class NotificationsClient {
+    private readonly fetch;
+    private readonly subscriptions;
+    private readonly preferredChannels;
+    constructor(authenticatedFetch: typeof globalThis.fetch, config?: NotificationsClientConfig);
+    /**
+     * 订阅资源变化
+     */
+    subscribe(topic: string, options: SubscribeOptions): Promise<Subscription>;
+    /**
+     * 重新订阅（内部方法，用于自动重连）
+     * @internal
+     */
+    resubscribe(topic: string, channelType: ChannelType, discovery: DiscoveredService, options: SubscribeOptions): Promise<NotificationChannel>;
+    /**
+     * 连接到指定通道
+     */
+    private connectChannel;
+    /**
+     * 构建 SSE 直接连接 URL (CSS 模式)
+     * 格式: /.notifications/StreamingHTTPChannel2023/{encodeURIComponent(topic)}
+     */
+    private buildSSEDirectUrl;
+    /**
+     * 取消所有订阅
+     */
+    unsubscribeAll(): void;
+    /**
+     * 发现资源的 notifications 服务
+     *
+     * 发现顺序:
+     * 1. 从 HEAD 请求的 Link header 直接获取通知端点
+     * 2. 从 storage description (.well-known/solid) 获取
+     * 3. 回退到默认的 /.notifications/ 路径
+     */
+    private discoverNotificationService;
+    /**
+     * 从 HEAD 请求的 Link header 发现通知端点
+     *
+     * CSS 在 Link header 中提供:
+     * - solid:updatesViaStreamingHttp2023 - SSE 端点
+     * - (WebSocket 通常也可用，但不在 Link header 中公开)
+     */
+    private discoverFromLinkHeader;
+    private discoverLinkHeader;
+    /**
+     * 查找资源的存储根 URL
+     */
+    private findStorageRoot;
+    /**
+     * 获取 storage description 并提取 notifications 端点
+     */
+    private fetchStorageDescription;
+    /**
+     * 创建 WebSocket 订阅（POST 请求）
+     */
+    private createSubscription;
+    /**
+     * 创建通道实例
+     */
+    private createChannel;
+    /**
+     * 创建带自动重连支持的通道实例
+     */
+    private createChannelWithReconnect;
+}
+export {};
+//# sourceMappingURL=notifications-client.d.ts.map