plug-n-play-ws/dist/adapters/index.d.mts

A plug-and-play WebSocket layer on top of Socket.IO with full TypeScript support, zero manual wiring, and production-ready features

import { a as SearchQuery, c as SearchResponse, I as IAdapter, S as SessionMetadata, L as Logger } from '../types-BQpUMSaB.mjs';
import { Redis } from 'ioredis';
import 'zod';

interface SearchConfig {
    ngramSize: number;
    minEdgegram: number;
    maxEdgegram: number;
    exactMatchBoost: number;
    ngramWeight: number;
    edgegramWeight: number;
    minScore: number;
}
declare const DEFAULT_SEARCH_CONFIG: SearchConfig;
interface DocumentData {
    content: string;
    metadata?: Record<string, unknown>;
}
declare abstract class BaseSearchAdapter {
    protected searchConfig: SearchConfig;
    constructor(searchConfig?: Partial<SearchConfig>);
    protected generateSearchTerms(content: string): {
        ngrams: string[];
        edgegrams: string[];
    };
    protected calculateRelevanceScore(documentContent: string, searchTerms: string[], ngramMatches: number, edgegramMatches: number): number;
    protected processSearchResults(query: SearchQuery, searchTerms: string[], documentScores: Map<string, {
        score: number;
        data: DocumentData;
    }>, startTime: number): SearchResponse;
    protected normalizeSearchQuery(query: SearchQuery): {
        searchTerms: string[];
        isValid: boolean;
    };
    protected createEmptyResponse(query: SearchQuery, startTime: number): SearchResponse;
}

interface MemoryAdapterConfig {
    searchConfig?: Partial<SearchConfig>;
    maxDocuments?: number;
    sessionCleanupInterval?: number;
}
declare class MemoryAdapter extends BaseSearchAdapter implements IAdapter {
    private sessions;
    private documents;
    private documentAccessOrder;
    private ngramIndex;
    private edgegramIndex;
    private maxDocuments;
    private sessionCleanupHours;
    private accessCounter;
    constructor(config?: MemoryAdapterConfig);
    setSession(sessionId: string, metadata: SessionMetadata): Promise<void>;
    getSession(sessionId: string): Promise<SessionMetadata | null>;
    deleteSession(sessionId: string): Promise<void>;
    getAllSessions(): Promise<SessionMetadata[]>;
    updateLastSeen(sessionId: string): Promise<void>;
    indexDocument(id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
    private findLRUDocument;
    private updateDocumentAccess;
    removeDocument(id: string): Promise<void>;
    private removeFromIndex;
    search(query: SearchQuery): Promise<SearchResponse>;
    cleanup(): Promise<void>;
    disconnect(): Promise<void>;
}

interface UnifiedRedisInterface {
    hset(key: string, field: string, value: string): Promise<void>;
    hset(key: string, ...args: string[]): Promise<void>;
    hgetall(key: string): Promise<Record<string, string>>;
    del(key: string): Promise<void>;
    exists(key: string): Promise<number>;
    expire(key: string, seconds: number): Promise<void>;
    sadd(key: string, member: string): Promise<void>;
    smembers(key: string): Promise<string[]>;
    srem(key: string, member: string): Promise<void>;
    pipeline(commands: Array<[string, ...string[]]>): Promise<unknown[]>;
    keys(pattern: string): Promise<string[]>;
    disconnect(): Promise<void>;
}
declare class IoRedisAdapter implements UnifiedRedisInterface {
    private redis;
    constructor(redis: Redis);
    hset(key: string, ...args: string[]): Promise<void>;
    hgetall(key: string): Promise<Record<string, string>>;
    del(key: string): Promise<void>;
    exists(key: string): Promise<number>;
    expire(key: string, seconds: number): Promise<void>;
    sadd(key: string, member: string): Promise<void>;
    smembers(key: string): Promise<string[]>;
    srem(key: string, member: string): Promise<void>;
    pipeline(commands: Array<[string, ...string[]]>): Promise<unknown[]>;
    keys(pattern: string): Promise<string[]>;
    disconnect(): Promise<void>;
}
declare class UpstashRedisAdapter implements UnifiedRedisInterface {
    private baseUrl;
    private token;
    constructor(config: {
        url: string;
        token: string;
    });
    private request;
    hset(key: string, ...args: string[]): Promise<void>;
    hgetall(key: string): Promise<Record<string, string>>;
    del(key: string): Promise<void>;
    exists(key: string): Promise<number>;
    expire(key: string, seconds: number): Promise<void>;
    sadd(key: string, member: string): Promise<void>;
    smembers(key: string): Promise<string[]>;
    srem(key: string, member: string): Promise<void>;
    pipeline(commands: Array<[string, ...string[]]>): Promise<unknown[]>;
    keys(pattern: string): Promise<string[]>;
    disconnect(): Promise<void>;
}

interface UnifiedRedisAdapterConfig {
    redis: UnifiedRedisInterface;
    keyPrefix?: string;
    searchConfig?: Partial<SearchConfig>;
    logger?: Logger;
    ttl?: {
        session: number;
        document: number;
        index: number;
    };
}
declare class UnifiedRedisAdapter extends BaseSearchAdapter implements IAdapter {
    private redis;
    private keyPrefix;
    private logger;
    private ttl;
    constructor(config: UnifiedRedisAdapterConfig);
    private getKey;
    setSession(sessionId: string, metadata: SessionMetadata): Promise<void>;
    getSession(sessionId: string): Promise<SessionMetadata | null>;
    deleteSession(sessionId: string): Promise<void>;
    getAllSessions(): Promise<SessionMetadata[]>;
    updateLastSeen(sessionId: string): Promise<void>;
    indexDocument(id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
    removeDocument(id: string): Promise<void>;
    private removeDocumentFromIndexesFallback;
    search(query: SearchQuery): Promise<SearchResponse>;
    private performSearch;
    cleanup(): Promise<void>;
    disconnect(): Promise<void>;
}

interface RedisAdapterConfig {
    host?: string;
    port?: number;
    password?: string;
    db?: number;
    url?: string;
    keyPrefix?: string;
    searchConfig?: Partial<SearchConfig>;
    ttl?: {
        session?: number;
        document?: number;
        index?: number;
    };
}
interface UpstashRedisConfig {
    url: string;
    token: string;
    keyPrefix?: string;
    searchConfig?: Partial<SearchConfig>;
    ttl?: {
        session?: number;
        document?: number;
        index?: number;
    };
}
declare function createRedisAdapter(config: RedisAdapterConfig): UnifiedRedisAdapter;
declare function createUpstashRedisAdapter(config: UpstashRedisConfig): UnifiedRedisAdapter;
declare function createRedisAdapterFromEnv(keyPrefix?: string, searchConfig?: Partial<SearchConfig>): UnifiedRedisAdapter;

declare function buildNGrams(text: string, n: number): string[];
declare function buildEdgeGrams(text: string, minGram: number, maxGram: number): string[];
declare function generateHighlights(content: string, searchTerms: string[], maxHighlights?: number, contextLength?: number): string[];

export { BaseSearchAdapter, DEFAULT_SEARCH_CONFIG, type RedisAdapterConfig as FactoryRedisConfig, type UpstashRedisConfig as FactoryUpstashConfig, IAdapter, IoRedisAdapter, MemoryAdapter, type MemoryAdapterConfig, type SearchConfig, UnifiedRedisAdapter, type UnifiedRedisAdapterConfig, UpstashRedisAdapter as UpstashRedisClient, buildEdgeGrams, buildNGrams, createRedisAdapter, createRedisAdapterFromEnv, createUpstashRedisAdapter, generateHighlights };