@delali/narsil 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,386 @@
+import { L as LanguageModule } from './language-ClUGLuoC.js';
+import { P as PersistenceAdapter, I as InvalidationAdapter } from './adapters-XODT2F3h.js';
+export { a as InvalidationEvent, b as PartitionStatistics } from './adapters-XODT2F3h.js';
+
+declare const ErrorCodes: {
+    readonly SCHEMA_INVALID_TYPE: "SCHEMA_INVALID_TYPE";
+    readonly SCHEMA_MISSING_FIELD: "SCHEMA_MISSING_FIELD";
+    readonly SCHEMA_DEPTH_EXCEEDED: "SCHEMA_DEPTH_EXCEEDED";
+    readonly SCHEMA_INVALID_VECTOR_DIMENSION: "SCHEMA_INVALID_VECTOR_DIMENSION";
+    readonly SCHEMA_INVALID_GEOPOINT: "SCHEMA_INVALID_GEOPOINT";
+    readonly DOC_NOT_FOUND: "DOC_NOT_FOUND";
+    readonly DOC_ALREADY_EXISTS: "DOC_ALREADY_EXISTS";
+    readonly DOC_VALIDATION_FAILED: "DOC_VALIDATION_FAILED";
+    readonly INDEX_NOT_FOUND: "INDEX_NOT_FOUND";
+    readonly INDEX_ALREADY_EXISTS: "INDEX_ALREADY_EXISTS";
+    readonly PARTITION_CORRUPTED: "PARTITION_CORRUPTED";
+    readonly PARTITION_REBALANCING_BACKPRESSURE: "PARTITION_REBALANCING_BACKPRESSURE";
+    readonly WORKER_CRASHED: "WORKER_CRASHED";
+    readonly WORKER_BUSY: "WORKER_BUSY";
+    readonly WORKER_TIMEOUT: "WORKER_TIMEOUT";
+    readonly PERSISTENCE_SAVE_FAILED: "PERSISTENCE_SAVE_FAILED";
+    readonly PERSISTENCE_LOAD_FAILED: "PERSISTENCE_LOAD_FAILED";
+    readonly PERSISTENCE_DELETE_FAILED: "PERSISTENCE_DELETE_FAILED";
+    readonly PERSISTENCE_CRC_MISMATCH: "PERSISTENCE_CRC_MISMATCH";
+    readonly SEARCH_INVALID_FIELD: "SEARCH_INVALID_FIELD";
+    readonly SEARCH_INVALID_VECTOR_SIZE: "SEARCH_INVALID_VECTOR_SIZE";
+    readonly SEARCH_INVALID_FILTER: "SEARCH_INVALID_FILTER";
+    readonly SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE";
+    readonly SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR";
+    readonly LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED";
+    readonly ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH";
+    readonly ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC";
+};
+type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+declare class NarsilError extends Error {
+    readonly code: ErrorCode;
+    readonly details: Record<string, unknown>;
+    constructor(code: ErrorCode, message: string, details?: Record<string, unknown>);
+}
+
+declare function registerLanguage(module: LanguageModule): void;
+declare function getLanguage(name: string): LanguageModule;
+
+type AnyDocument = Record<string, unknown> & {
+    id?: string;
+};
+type FieldType = 'string' | 'number' | 'boolean' | 'enum' | 'geopoint' | `vector[${number}]` | 'string[]' | 'number[]' | 'boolean[]' | 'enum[]';
+type SchemaDefinition = {
+    [field: string]: FieldType | SchemaDefinition;
+};
+interface IndexConfig {
+    schema: SchemaDefinition;
+    language?: string;
+    partitions?: PartitionConfig;
+    defaultScoring?: ScoringMode;
+    bm25?: BM25Params;
+    stopWords?: Set<string> | ((defaults: Set<string>) => Set<string>);
+    tokenizer?: CustomTokenizer;
+}
+interface BM25Params {
+    k1?: number;
+    b?: number;
+}
+interface CustomTokenizer {
+    tokenize(text: string): Array<{
+        token: string;
+        position: number;
+    }>;
+}
+interface PartitionConfig {
+    maxDocsPerPartition?: number;
+    maxPartitions?: number;
+}
+type ScoringMode = 'local' | 'dfs' | 'broadcast';
+
+interface QueryResult<T = AnyDocument> {
+    hits: Array<Hit<T>>;
+    count: number;
+    elapsed: number;
+    cursor?: string;
+    facets?: Record<string, FacetResult>;
+    groups?: GroupResult[];
+}
+interface Hit<T = AnyDocument> {
+    id: string;
+    score: number;
+    document: T;
+    scoreComponents?: ScoreComponents;
+    highlights?: Record<string, HighlightMatch>;
+}
+interface ScoreComponents {
+    termFrequencies: Record<string, number>;
+    fieldLengths: Record<string, number>;
+    idf: Record<string, number>;
+}
+interface HighlightMatch {
+    snippet: string;
+    positions: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+interface FacetResult {
+    values: Record<string, number>;
+    count: number;
+}
+interface GroupResult {
+    values: Record<string, unknown>;
+    hits: Array<Hit>;
+}
+interface PreflightResult {
+    count: number;
+    elapsed: number;
+}
+interface BatchResult {
+    succeeded: string[];
+    failed: Array<{
+        docId: string;
+        error: NarsilError;
+    }>;
+}
+interface IndexStats {
+    documentCount: number;
+    partitionCount: number;
+    memoryBytes: number;
+    indexSizeBytes: number;
+    language: string;
+    schema: SchemaDefinition;
+}
+interface IndexInfo {
+    name: string;
+    documentCount: number;
+    partitionCount: number;
+    language: string;
+}
+interface MemoryStats {
+    totalBytes: number;
+    workers: Array<{
+        workerId: number;
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+    }>;
+}
+
+type ComparisonFilter = {
+    eq?: number | string | boolean;
+    ne?: number | string | boolean;
+    gt?: number;
+    lt?: number;
+    gte?: number;
+    lte?: number;
+    between?: [number, number];
+};
+type StringFilter = ComparisonFilter & {
+    in?: string[];
+    nin?: string[];
+    startsWith?: string;
+    endsWith?: string;
+};
+type ArrayFilter = {
+    containsAll?: (string | number | boolean)[];
+    matchesAny?: (string | number | boolean)[];
+    size?: ComparisonFilter;
+};
+type PresenceFilter = {
+    exists?: boolean;
+    notExists?: boolean;
+    isEmpty?: boolean;
+    isNotEmpty?: boolean;
+};
+type GeoRadiusFilter = {
+    radius: {
+        lat: number;
+        lon: number;
+        distance: number;
+        unit: 'km' | 'mi' | 'm';
+        inside?: boolean;
+        highPrecision?: boolean;
+    };
+};
+type GeoPolygonFilter = {
+    polygon: {
+        points: Array<{
+            lat: number;
+            lon: number;
+        }>;
+        inside?: boolean;
+    };
+};
+type GeoFilter = GeoRadiusFilter | GeoPolygonFilter;
+type FieldFilter = ComparisonFilter | StringFilter | ArrayFilter | PresenceFilter | GeoFilter;
+type FilterExpression = {
+    fields?: Record<string, FieldFilter>;
+    and?: FilterExpression[];
+    or?: FilterExpression[];
+    not?: FilterExpression;
+};
+
+type SearchMode = 'fulltext' | 'vector' | 'hybrid';
+type TermMatchPolicy = 'all' | 'any' | number;
+interface QueryParams {
+    term?: string;
+    fields?: string[];
+    filters?: FilterExpression;
+    boost?: Record<string, number>;
+    scoring?: ScoringMode;
+    minScore?: number;
+    termMatch?: TermMatchPolicy;
+    tolerance?: number;
+    prefixLength?: number;
+    exact?: boolean;
+    facets?: FacetConfig;
+    sort?: Record<string, 'asc' | 'desc'>;
+    group?: GroupConfig;
+    limit?: number;
+    offset?: number;
+    searchAfter?: string;
+    highlight?: HighlightConfig;
+    pinned?: Array<{
+        docId: string;
+        position: number;
+    }>;
+    mode?: SearchMode;
+    vector?: VectorQueryConfig;
+    hybrid?: HybridConfig;
+}
+interface VectorQueryConfig {
+    field: string;
+    value: number[];
+    similarity?: number;
+    metric?: 'cosine' | 'dotProduct' | 'euclidean';
+    efSearch?: number;
+}
+interface HybridConfig {
+    alpha?: number;
+}
+interface FacetConfig {
+    [field: string]: {
+        limit?: number;
+        sort?: 'asc' | 'desc';
+        ranges?: Array<{
+            from: number;
+            to: number;
+        }>;
+    };
+}
+interface GroupConfig {
+    fields: string[];
+    maxPerGroup?: number;
+    reduce?: GroupReducer;
+}
+type GroupReducer = {
+    reducer: (accumulator: unknown, doc: AnyDocument, score: number) => unknown;
+    initialValue: () => unknown;
+};
+interface HighlightConfig {
+    fields: string[];
+    preTag?: string;
+    postTag?: string;
+    maxSnippetLength?: number;
+}
+
+interface NarsilPlugin {
+    name: string;
+    beforeInsert?(ctx: InsertContext): void | Promise<void>;
+    afterInsert?(ctx: InsertContext): void | Promise<void>;
+    beforeRemove?(ctx: RemoveContext): void | Promise<void>;
+    afterRemove?(ctx: RemoveContext): void | Promise<void>;
+    beforeUpdate?(ctx: UpdateContext): void | Promise<void>;
+    afterUpdate?(ctx: UpdateContext): void | Promise<void>;
+    beforeSearch?(ctx: SearchContext): void | Promise<void>;
+    afterSearch?(ctx: SearchContext): void | Promise<void>;
+    onIndexCreate?(ctx: IndexContext): void | Promise<void>;
+    onIndexDrop?(ctx: IndexContext): void | Promise<void>;
+    onPartitionSplit?(ctx: PartitionContext): void | Promise<void>;
+    onWorkerPromote?(ctx: WorkerContext): void | Promise<void>;
+}
+interface InsertContext {
+    indexName: string;
+    docId: string;
+    document: AnyDocument;
+}
+interface RemoveContext {
+    indexName: string;
+    docId: string;
+}
+interface UpdateContext {
+    indexName: string;
+    docId: string;
+    oldDocument: AnyDocument;
+    newDocument: AnyDocument;
+}
+interface SearchContext {
+    indexName: string;
+    params: QueryParams;
+    results?: QueryResult;
+}
+interface IndexContext {
+    indexName: string;
+    config: IndexConfig;
+}
+interface PartitionContext {
+    indexName: string;
+    oldPartitionCount: number;
+    newPartitionCount: number;
+}
+interface WorkerContext {
+    workerCount: number;
+    reason: string;
+}
+
+interface NarsilConfig {
+    persistence?: PersistenceAdapter;
+    invalidation?: InvalidationAdapter;
+    plugins?: NarsilPlugin[];
+    idGenerator?: () => string;
+    workers?: WorkerConfig;
+    flush?: FlushConfig;
+    eagerLoad?: boolean;
+}
+interface WorkerConfig {
+    enabled?: boolean;
+    count?: number;
+    promotionThreshold?: number;
+    totalPromotionThreshold?: number;
+}
+interface FlushConfig {
+    interval?: number;
+    mutationThreshold?: number;
+}
+
+type NarsilEventMap = {
+    persistenceError: {
+        indexName: string;
+        partitionId: number;
+        error: Error;
+        retriesExhausted: boolean;
+    };
+    workerCrash: {
+        workerId: number;
+        indexNames: string[];
+        error: Error;
+    };
+    workerPromote: {
+        workerCount: number;
+        reason: string;
+    };
+    partitionRebalance: {
+        indexName: string;
+        oldCount: number;
+        newCount: number;
+    };
+};
+
+interface Narsil {
+    createIndex(name: string, config: IndexConfig): Promise<void>;
+    dropIndex(name: string): Promise<void>;
+    listIndexes(): IndexInfo[];
+    getStats(indexName: string): IndexStats;
+    insert(indexName: string, document: AnyDocument, docId?: string): Promise<string>;
+    insertBatch(indexName: string, documents: AnyDocument[]): Promise<BatchResult>;
+    remove(indexName: string, docId: string): Promise<void>;
+    removeBatch(indexName: string, docIds: string[]): Promise<BatchResult>;
+    update(indexName: string, docId: string, document: AnyDocument): Promise<void>;
+    updateBatch(indexName: string, updates: Array<{
+        docId: string;
+        document: AnyDocument;
+    }>): Promise<BatchResult>;
+    get(indexName: string, docId: string): Promise<AnyDocument | undefined>;
+    getMultiple(indexName: string, docIds: string[]): Promise<Map<string, AnyDocument>>;
+    has(indexName: string, docId: string): Promise<boolean>;
+    countDocuments(indexName: string): Promise<number>;
+    query<T = AnyDocument>(indexName: string, params: QueryParams): Promise<QueryResult<T>>;
+    preflight(indexName: string, params: QueryParams): Promise<PreflightResult>;
+    clear(indexName: string): Promise<void>;
+    getMemoryStats(): MemoryStats;
+    on<K extends keyof NarsilEventMap>(event: K, handler: (payload: NarsilEventMap[K]) => void): void;
+    off<K extends keyof NarsilEventMap>(event: K, handler: (payload: NarsilEventMap[K]) => void): void;
+    shutdown(): Promise<void>;
+}
+declare function createNarsil(config?: NarsilConfig): Promise<Narsil>;
+
+declare const VERSION = "0.1.0";
+
+export { type AnyDocument, type ArrayFilter, type BM25Params, type BatchResult, type ComparisonFilter, type CustomTokenizer, type ErrorCode, ErrorCodes, type FacetConfig, type FacetResult, type FieldType, type FilterExpression, type FlushConfig, type GeoPolygonFilter, type GeoRadiusFilter, type GroupConfig, type GroupReducer, type GroupResult, type HighlightConfig, type HighlightMatch, type Hit, type HybridConfig, type IndexConfig, type IndexContext, type IndexInfo, type IndexStats, type InsertContext, InvalidationAdapter, LanguageModule, type MemoryStats, type Narsil, type NarsilConfig, NarsilError, type NarsilEventMap, type NarsilPlugin, type PartitionConfig, type PartitionContext, PersistenceAdapter, type PreflightResult, type PresenceFilter, type QueryParams, type QueryResult, type RemoveContext, type SchemaDefinition, type ScoreComponents, type ScoringMode, type SearchContext, type SearchMode, type StringFilter, type TermMatchPolicy, type UpdateContext, VERSION, type VectorQueryConfig, type WorkerConfig, type WorkerContext, createNarsil, getLanguage, registerLanguage };