@andrejs1979/document/dist/edge-document-db.d.ts

MongoDB-compatible document database for NoSQL

/**
 * NoSQL - Main Document Database Class
 * MongoDB-compatible document database with vector integration
 */
import { Document, DocumentDatabaseConfig, QueryFilter, FindOptions, UpdateOperators, UpdateOptions, InsertOneResult, InsertManyResult, UpdateResult, DeleteResult, AggregationPipeline, AggregationOptions, BulkWriteOperation, BulkWriteOptions, BulkWriteResult, IndexSpec, IndexInfo, PopulateOptions, RelationshipResult, Relationship, HybridSearchQuery, HybridSearchResult, VectorDocumentResult, DocumentStreamConfig, StreamingInsertOptions, TaggingConfig, DocumentDatabaseStats } from './types';
import { DocumentStream } from './operations/bulk-operations';
/**
 * Main NoSQL Document Database class
 */
export declare class EdgeDocumentDB {
    private storage;
    private queryEngine;
    private indexManager;
    private relationshipManager;
    private hybridSearchEngine;
    private bulkOperationsManager;
    private taggingSystem;
    private config;
    private initialized;
    constructor(config: DocumentDatabaseConfig);
    /**
     * Initialize the document database
     */
    initialize(): Promise<void>;
    /**
     * Insert a single document
     */
    insertOne(collection: string, document: Document): Promise<InsertOneResult>;
    /**
     * Insert multiple documents
     */
    insertMany(collection: string, documents: Document[]): Promise<InsertManyResult>;
    /**
     * Find documents by filter
     */
    find(collection: string, filter?: QueryFilter, options?: FindOptions): Promise<Document[]>;
    /**
     * Find a single document
     */
    findOne(collection: string, filter?: QueryFilter, options?: FindOptions): Promise<Document | null>;
    /**
     * Update a single document
     */
    updateOne(collection: string, filter: QueryFilter, update: UpdateOperators | Document, options?: UpdateOptions): Promise<UpdateResult>;
    /**
     * Update multiple documents
     */
    updateMany(collection: string, filter: QueryFilter, update: UpdateOperators | Document, options?: UpdateOptions): Promise<UpdateResult>;
    /**
     * Replace a single document
     */
    replaceOne(collection: string, filter: QueryFilter, replacement: Document, options?: UpdateOptions): Promise<UpdateResult>;
    /**
     * Delete a single document
     */
    deleteOne(collection: string, filter: QueryFilter): Promise<DeleteResult>;
    /**
     * Delete multiple documents
     */
    deleteMany(collection: string, filter: QueryFilter): Promise<DeleteResult>;
    /**
     * Count documents matching filter
     */
    countDocuments(collection: string, filter?: QueryFilter): Promise<number>;
    /**
     * Execute aggregation pipeline
     */
    aggregate(collection: string, pipeline: AggregationPipeline, options?: AggregationOptions): Promise<Document[]>;
    /**
     * Explain query execution plan
     */
    explain(collection: string, filter: QueryFilter, options?: FindOptions): Promise<any>;
    /**
     * Hybrid search combining text, vector, and metadata
     */
    hybridSearch(collection: string, query: HybridSearchQuery): Promise<HybridSearchResult>;
    /**
     * Text search with optional vector boost
     */
    textSearch(collection: string, searchText: string, options?: {
        vectorBoost?: boolean;
        filters?: QueryFilter;
        limit?: number;
        threshold?: number;
    }): Promise<VectorDocumentResult[]>;
    /**
     * Vector similarity search
     */
    vectorSearch(collection: string, queryVector: Float32Array | number[], options?: {
        textBoost?: boolean;
        filters?: QueryFilter;
        limit?: number;
        threshold?: number;
    }): Promise<VectorDocumentResult[]>;
    /**
     * Semantic search using text embedding
     */
    semanticSearch(collection: string, searchText: string, options?: {
        embeddingModel?: string;
        filters?: QueryFilter;
        limit?: number;
        threshold?: number;
        textWeight?: number;
        vectorWeight?: number;
    }): Promise<VectorDocumentResult[]>;
    /**
     * Find similar documents
     */
    findSimilarDocuments(collection: string, documentId: string, options?: {
        useText?: boolean;
        useVector?: boolean;
        useMetadata?: boolean;
        filters?: QueryFilter;
        limit?: number;
        threshold?: number;
    }): Promise<VectorDocumentResult[]>;
    /**
     * Get personalized recommendations
     */
    getRecommendations(collection: string, userHistory: {
        viewedDocuments?: string[];
        likedDocuments?: string[];
        searchQueries?: string[];
    }, options?: {
        limit?: number;
        diversityFactor?: number;
        filters?: QueryFilter;
    }): Promise<VectorDocumentResult[]>;
    /**
     * Define a relationship between collections
     */
    defineRelationship(sourceCollection: string, targetCollection: string, relationship: Relationship): Promise<void>;
    /**
     * Populate document with related data
     */
    populate<T extends Document>(collection: string, document: T, populateOptions: PopulateOptions | PopulateOptions[]): Promise<RelationshipResult<T>>;
    /**
     * Find documents with automatic population
     */
    findWithPopulate<T extends Document>(collection: string, filter: QueryFilter, populateOptions: PopulateOptions | PopulateOptions[], findOptions?: FindOptions): Promise<RelationshipResult<T>[]>;
    /**
     * Execute bulk write operations
     */
    bulkWrite(collection: string, operations: BulkWriteOperation[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
    /**
     * Stream insert large datasets
     */
    streamInsert(collection: string, documentStream: AsyncIterable<Document>, options?: StreamingInsertOptions): Promise<{
        insertedCount: number;
        failedCount: number;
        errors: Array<{
            document: Document;
            error: string;
        }>;
    }>;
    /**
     * Create a document stream for real-time processing
     */
    createDocumentStream(collection: string, config: DocumentStreamConfig): DocumentStream;
    /**
     * Create an index
     */
    createIndex(collection: string, indexSpec: IndexSpec): Promise<void>;
    /**
     * Drop an index
     */
    dropIndex(collection: string, indexName: string): Promise<void>;
    /**
     * List all indexes for a collection
     */
    listIndexes(collection: string): Promise<IndexInfo[]>;
    /**
     * Get index recommendations
     */
    getIndexRecommendations(collection: string): Promise<{
        recommended: IndexSpec[];
        reasons: string[];
        priority: 'high' | 'medium' | 'low';
    }>;
    /**
     * Auto-create indexes based on query patterns
     */
    autoCreateIndexes(collection: string): Promise<void>;
    /**
     * Auto-tag a document
     */
    autoTag(collection: string, document: Document, config?: TaggingConfig): Promise<string[]>;
    /**
     * Tag a document
     */
    tagDocument(collection: string, documentId: string, tags: string[], options?: {
        merge?: boolean;
        validate?: boolean;
    }): Promise<void>;
    /**
     * Find documents by tags
     */
    findByTags(collection: string, tags: string[], options?: {
        operator?: 'and' | 'or';
        includeHierarchy?: boolean;
        findOptions?: FindOptions;
    }): Promise<Document[]>;
    /**
     * Get tag suggestions
     */
    getTagSuggestions(collection: string, document: Document, options?: {
        limit?: number;
        includePopular?: boolean;
        includeSimilar?: boolean;
        threshold?: number;
    }): Promise<string[]>;
    /**
     * Get tag statistics
     */
    getTagStats(collection: string, options?: {
        limit?: number;
        sortBy?: 'count' | 'name' | 'recent';
        includeUnused?: boolean;
    }): Promise<Array<{
        tag: string;
        count: number;
        lastUsed: Date;
        percentage: number;
    }>>;
    /**
     * Get database statistics
     */
    stats(): Promise<DocumentDatabaseStats>;
    /**
     * Health check
     */
    ping(): Promise<boolean>;
    /**
     * Close database connections
     */
    close(): Promise<void>;
    /**
     * Create a document database with simplified configuration
     */
    static create(config: {
        name: string;
        d1Database: any;
        kvStore?: any;
        r2Bucket?: any;
        options?: Partial<DocumentDatabaseConfig>;
    }): Promise<EdgeDocumentDB>;
    private ensureInitialized;
}
//# sourceMappingURL=edge-document-db.d.ts.map