@andrejs1979/document/dist/types.d.ts

MongoDB-compatible document database for NoSQL

/**
 * NoSQL - Document Types and Interfaces
 * MongoDB-compatible document storage types with vector integration
 */
import { Vector, VectorSearchOptions } from '../vector/types';
export type ObjectId = string;
export interface BaseDocument {
    _id?: ObjectId;
    _version?: number;
    _createdAt?: Date;
    _updatedAt?: Date;
    _vector?: Vector;
    [key: string]: any;
}
export type DocumentValue = string | number | boolean | Date | null | undefined | DocumentValue[] | {
    [key: string]: DocumentValue;
};
export interface Document extends Record<string, DocumentValue> {
    _id?: ObjectId;
    _vector?: Vector;
}
export interface QueryFilter {
    [key: string]: any;
}
export interface SortOptions {
    [field: string]: 1 | -1 | 'text';
}
export interface ProjectionOptions {
    [field: string]: 0 | 1;
}
export interface QueryOptions {
    limit?: number;
    skip?: number;
    sort?: SortOptions;
    projection?: ProjectionOptions;
    hint?: string | Record<string, 1 | -1>;
    explain?: boolean;
    maxTimeMS?: number;
}
export interface FindOptions extends QueryOptions {
    batchSize?: number;
    comment?: string;
    readPreference?: string;
}
export interface ComparisonOperators<T = any> {
    $eq?: T;
    $ne?: T;
    $gt?: T;
    $gte?: T;
    $lt?: T;
    $lte?: T;
    $in?: T[];
    $nin?: T[];
}
export interface LogicalOperators {
    $and?: QueryFilter[];
    $or?: QueryFilter[];
    $not?: QueryFilter;
    $nor?: QueryFilter[];
}
export interface ElementOperators {
    $exists?: boolean;
    $type?: string | number;
}
export interface EvaluationOperators {
    $regex?: string | RegExp;
    $options?: string;
    $text?: {
        $search: string;
        $language?: string;
        $caseSensitive?: boolean;
        $diacriticSensitive?: boolean;
    };
    $where?: string | Function;
    $expr?: any;
    $jsonSchema?: any;
    $mod?: [number, number];
}
export interface ArrayOperators<T = any> {
    $all?: T[];
    $elemMatch?: QueryFilter;
    $size?: number;
}
export interface GeospatialOperators {
    $geoWithin?: any;
    $geoIntersects?: any;
    $near?: any;
    $nearSphere?: any;
}
export interface VectorOperators {
    $vectorSearch?: {
        vector: Float32Array | number[];
        limit?: number;
        threshold?: number;
        metadataFilter?: Record<string, any>;
    };
    $hybridSearch?: {
        text?: string;
        vector?: Float32Array | number[];
        weights?: {
            text: number;
            vector: number;
            metadata: number;
        };
    };
}
export type QueryOperators<T = any> = ComparisonOperators<T> | LogicalOperators | ElementOperators | EvaluationOperators | ArrayOperators<T> | GeospatialOperators | VectorOperators;
export interface UpdateOperators {
    $set?: Record<string, any>;
    $unset?: Record<string, any>;
    $inc?: Record<string, number>;
    $mul?: Record<string, number>;
    $rename?: Record<string, string>;
    $min?: Record<string, any>;
    $max?: Record<string, any>;
    $currentDate?: Record<string, boolean | {
        $type: 'date' | 'timestamp';
    }>;
    $addToSet?: Record<string, any>;
    $pop?: Record<string, 1 | -1>;
    $pull?: Record<string, any>;
    $push?: Record<string, any | {
        $each?: any[];
        $position?: number;
        $slice?: number;
        $sort?: any;
    }>;
    $pullAll?: Record<string, any[]>;
    $vectorSet?: Vector;
    $vectorUnset?: boolean;
}
export interface ReplaceOptions {
    upsert?: boolean;
}
export interface UpdateOptions extends ReplaceOptions {
    multi?: boolean;
    arrayFilters?: any[];
}
export interface AggregationStage {
    $match?: QueryFilter;
    $project?: Record<string, any>;
    $group?: Record<string, any>;
    $sort?: SortOptions;
    $limit?: number;
    $skip?: number;
    $unwind?: string | {
        path: string;
        includeArrayIndex?: string;
        preserveNullAndEmptyArrays?: boolean;
    };
    $lookup?: {
        from: string;
        localField: string;
        foreignField: string;
        as: string;
        pipeline?: AggregationStage[];
    };
    $addFields?: Record<string, any>;
    $replaceRoot?: {
        newRoot: any;
    };
    $facet?: Record<string, AggregationStage[]>;
    $bucket?: {
        groupBy: any;
        boundaries: any[];
        default?: any;
        output?: Record<string, any>;
    };
    $bucketAuto?: {
        groupBy: any;
        buckets: number;
        output?: Record<string, any>;
        granularity?: string;
    };
    $count?: string;
    $sample?: {
        size: number;
    };
    $geoNear?: any;
    $graphLookup?: any;
    $vectorSearch?: {
        queryVector: number[];
        path: string;
        numCandidates: number;
        limit: number;
        index?: string;
        filter?: QueryFilter;
    };
    $vectorKnnBeta?: {
        vector: number[];
        path: string;
        k: number;
        filter?: QueryFilter;
    };
    [key: string]: any;
}
export type AggregationPipeline = AggregationStage[];
export interface AggregationOptions {
    allowDiskUse?: boolean;
    cursor?: {
        batchSize?: number;
    };
    maxTimeMS?: number;
    bypassDocumentValidation?: boolean;
    readConcern?: any;
    collation?: any;
    hint?: string | Record<string, any>;
    comment?: string;
}
export interface IndexKey {
    [key: string]: 1 | -1 | 'text' | '2d' | '2dsphere' | 'hashed' | 'vector';
}
export interface IndexOptions {
    unique?: boolean;
    sparse?: boolean;
    background?: boolean;
    name?: string;
    partialFilterExpression?: QueryFilter;
    expireAfterSeconds?: number;
    textIndexVersion?: number;
    weights?: Record<string, number>;
    default_language?: string;
    language_override?: string;
    '2dsphereIndexVersion'?: number;
    bits?: number;
    min?: number;
    max?: number;
    bucketSize?: number;
    collation?: any;
    wildcardProjection?: Record<string, 0 | 1>;
    vectorOptions?: {
        dimensions?: number;
        similarity?: 'cosine' | 'euclidean' | 'dotProduct';
        type?: 'hnsw' | 'ivf' | 'flat';
        parameters?: Record<string, any>;
    };
}
export interface IndexSpec {
    key: IndexKey;
    options?: IndexOptions;
}
export interface IndexInfo {
    name: string;
    key: IndexKey;
    options: IndexOptions;
    size: number;
    stats?: {
        accesses: number;
        lastAccessed: Date;
        usage: number;
    };
}
export interface CollectionOptions {
    capped?: boolean;
    size?: number;
    max?: number;
    validator?: {
        $jsonSchema?: any;
        $or?: any[];
    };
    validationLevel?: 'off' | 'strict' | 'moderate';
    validationAction?: 'error' | 'warn';
    indexOptionDefaults?: IndexOptions;
    viewOn?: string;
    pipeline?: AggregationPipeline;
    collation?: any;
    writeConcern?: any;
    readConcern?: any;
    comment?: string;
    vectorConfig?: {
        defaultEmbeddingModel?: string;
        autoVectorize?: boolean;
        vectorField?: string;
        textFields?: string[];
    };
}
export interface CollectionInfo {
    name: string;
    type: 'collection' | 'view';
    options: CollectionOptions;
    info: {
        readOnly: boolean;
        uuid?: string;
    };
    idIndex?: IndexInfo;
    vectorIndex?: IndexInfo;
}
export interface BulkWriteOperation {
    insertOne?: {
        document: Document;
    };
    updateOne?: {
        filter: QueryFilter;
        update: UpdateOperators | Document;
        upsert?: boolean;
        arrayFilters?: any[];
    };
    updateMany?: {
        filter: QueryFilter;
        update: UpdateOperators | Document;
        upsert?: boolean;
        arrayFilters?: any[];
    };
    replaceOne?: {
        filter: QueryFilter;
        replacement: Document;
        upsert?: boolean;
    };
    deleteOne?: {
        filter: QueryFilter;
    };
    deleteMany?: {
        filter: QueryFilter;
    };
}
export interface BulkWriteOptions {
    ordered?: boolean;
    bypassDocumentValidation?: boolean;
}
export interface BulkWriteResult {
    acknowledged: boolean;
    insertedCount: number;
    insertedIds: Record<number, ObjectId>;
    matchedCount: number;
    modifiedCount: number;
    deletedCount: number;
    upsertedCount: number;
    upsertedIds: Record<number, ObjectId>;
}
export interface ChangeStreamOptions {
    fullDocument?: 'default' | 'updateLookup';
    resumeAfter?: any;
    startAfter?: any;
    startAtOperationTime?: Date;
    maxAwaitTimeMS?: number;
    batchSize?: number;
    collation?: any;
}
export interface ChangeEvent<T = Document> {
    _id: any;
    operationType: 'insert' | 'update' | 'replace' | 'delete' | 'invalidate' | 'drop' | 'rename' | 'dropDatabase';
    fullDocument?: T;
    fullDocumentBeforeChange?: T;
    ns: {
        db: string;
        coll: string;
    };
    to?: {
        db: string;
        coll: string;
    };
    documentKey?: {
        _id: ObjectId;
    };
    updateDescription?: {
        updatedFields: Record<string, any>;
        removedFields: string[];
    };
    clusterTime?: Date;
    txnNumber?: number;
    lsid?: any;
}
export interface HybridSearchQuery {
    text?: string;
    vector?: Float32Array | number[];
    filter?: QueryFilter;
    weights?: {
        text: number;
        vector: number;
        metadata: number;
    };
    options?: FindOptions & VectorSearchOptions;
}
export interface HybridSearchResult {
    documents: Document[];
    scores: {
        text?: number;
        vector?: number;
        combined: number;
    }[];
    metadata: {
        totalMatches: number;
        searchType: 'text' | 'vector' | 'hybrid';
        executionTime: number;
    };
}
export interface VectorDocumentResult extends Document {
    _vectorScore?: number;
    _textScore?: number;
    _hybridScore?: number;
}
export interface Relationship {
    type: 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany';
    localField: string;
    foreignField: string;
    foreignCollection: string;
    foreignDatabase?: string;
}
export interface PopulateOptions {
    path: string;
    select?: string | string[];
    match?: QueryFilter;
    options?: FindOptions;
    populate?: PopulateOptions | PopulateOptions[];
}
export interface RelationshipResult<T = Document> {
    document: T;
    populated: Record<string, Document | Document[]>;
}
export interface DocumentStreamConfig {
    batchSize: number;
    flushInterval: number;
    compression?: boolean;
    errorHandler?: (error: Error, batch: Document[]) => void;
    transform?: (document: Document) => Document;
}
export interface StreamingInsertOptions {
    ordered?: boolean;
    bypassDocumentValidation?: boolean;
    batchSize?: number;
    onProgress?: (processed: number, total: number) => void;
    onError?: (error: Error, document: Document) => void;
}
export interface DocumentMetadata {
    tags: string[];
    category?: string;
    source?: string;
    confidence?: number;
    lastProcessed?: Date;
    processingVersion?: string;
    customFields?: Record<string, any>;
}
export interface TaggingConfig {
    autoTag?: boolean;
    tagSources?: ('content' | 'metadata' | 'filename' | 'custom')[];
    customTagger?: (document: Document) => string[];
    tagMapping?: Record<string, string[]>;
}
export interface TransactionOptions {
    readConcern?: any;
    writeConcern?: any;
    readPreference?: any;
    maxCommitTimeMS?: number;
}
export interface ClientSession {
    id: string;
    inTransaction: boolean;
    transactionOptions?: TransactionOptions;
}
export interface QueryPlan {
    stage: string;
    executionStats: {
        totalExamined: number;
        totalDocsReturned: number;
        executionTimeMillis: number;
        indexesUsed: string[];
    };
    children?: QueryPlan[];
}
export interface QueryExplain {
    queryPlanner: {
        plannerVersion: number;
        namespace: string;
        indexFilterSet: boolean;
        parsedQuery: any;
        winningPlan: QueryPlan;
        rejectedPlans: QueryPlan[];
    };
    executionStats: QueryPlan;
}
export interface DocumentDatabaseStats {
    totalDocuments: number;
    totalSize: number;
    averageDocumentSize: number;
    indexCount: number;
    totalIndexSize: number;
    collections: number;
    vectorDocuments: number;
    lastOptimized: Date;
}
export interface QueryMetrics {
    queryId: string;
    timestamp: Date;
    queryType: 'find' | 'insert' | 'update' | 'delete' | 'aggregate' | 'vectorSearch';
    latency: number;
    documentsExamined: number;
    documentsReturned: number;
    indexHits: number;
    cacheHit: boolean;
}
export declare class DocumentError extends Error {
    code: string;
    details?: any;
    constructor(message: string, code: string, details?: any);
}
export declare class ValidationError extends DocumentError {
    constructor(message: string, details?: any);
}
export declare class DuplicateKeyError extends DocumentError {
    constructor(message: string, details?: any);
}
export declare class IndexError extends DocumentError {
    constructor(message: string, details?: any);
}
export declare class RelationshipError extends DocumentError {
    constructor(message: string, details?: any);
}
export interface InsertOneResult {
    acknowledged: boolean;
    insertedId: ObjectId;
}
export interface InsertManyResult {
    acknowledged: boolean;
    insertedCount: number;
    insertedIds: ObjectId[];
}
export interface UpdateResult {
    acknowledged: boolean;
    matchedCount: number;
    modifiedCount: number;
    upsertedId?: ObjectId;
    upsertedCount: number;
}
export interface DeleteResult {
    acknowledged: boolean;
    deletedCount: number;
}
export interface ReplaceOneResult {
    acknowledged: boolean;
    matchedCount: number;
    modifiedCount: number;
    upsertedId?: ObjectId;
    upsertedCount: number;
}
export type Flatten<T> = T extends (infer U)[] ? U : T;
export type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;
export interface PaginationResult<T> {
    documents: T[];
    totalCount: number;
    hasMore: boolean;
    nextCursor?: string;
}
export interface AggregationCursor<T = any> {
    hasNext(): Promise<boolean>;
    next(): Promise<T | null>;
    toArray(): Promise<T[]>;
    close(): Promise<void>;
}
export interface ChangeStream<T = Document> {
    on(event: 'change', listener: (change: ChangeEvent<T>) => void): this;
    on(event: 'error', listener: (error: Error) => void): this;
    on(event: 'close', listener: () => void): this;
    close(): Promise<void>;
    isClosed(): boolean;
}
export interface DocumentDatabaseConfig {
    name: string;
    d1Database?: any;
    kvStore?: any;
    r2Bucket?: any;
    maxDocumentSize?: number;
    queryTimeout?: number;
    batchSize?: number;
    enableQueryCache?: boolean;
    queryCacheTTL?: number;
    cacheSize?: number;
    enableAutoIndexing?: boolean;
    autoIndexThreshold?: number;
    maxIndexedFields?: number;
    vectorConfig?: {
        enabled?: boolean;
        defaultDimensions?: number;
        defaultModel?: string;
        autoEmbedding?: boolean;
        embeddingFields?: string[];
    };
    enableValidation?: boolean;
    enableSchemaEvolution?: boolean;
    enableChangeStreams?: boolean;
    maxChangeStreamConnections?: number;
    enableQueryLogging?: boolean;
    enablePerformanceMetrics?: boolean;
    enableRelationships?: boolean;
    populateDepth?: number;
    bulkWriteBatchSize?: number;
    bulkWriteParallelism?: number;
}
//# sourceMappingURL=types.d.ts.map