document-dataply 0.0.10-alpha.2 → 0.0.10-alpha.4

package/dist/types/core/DocumentFormatter.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentJSON, FlattenedDocumentJSON } from '../types';
+export declare class DocumentFormatter<T extends DocumentJSON> {
+    private flattenInternal;
+    /**
+     * returns flattened document
+     * @param document
+     * @returns
+     */
+    flattenDocument(document: T): FlattenedDocumentJSON;
+}

package/dist/types/core/IndexManager.d.ts

@@ -0,0 +1,68 @@
+import type { DataplyTreeValue, DocumentDataplyInnerMetadata, Primitive, CreateIndexOption, IndexMetaConfig, FTSConfig, DocumentJSON, FlattenedDocumentJSON } from '../types';
+import type { DocumentDataplyAPI } from './documentAPI';
+import { BPTreeAsync, Transaction } from 'dataply';
+export declare class IndexManager<T extends DocumentJSON> {
+    private api;
+    indices: DocumentDataplyInnerMetadata['indices'];
+    readonly trees: Map<string, BPTreeAsync<string | number, DataplyTreeValue<Primitive>>>;
+    readonly indexedFields: Set<string>;
+    /**
+     * Registered indices via createIndex() (before init)
+     * Key: index name, Value: index configuration
+     */
+    readonly pendingCreateIndices: Map<string, CreateIndexOption<T>>;
+    /**
+     * Resolved index configurations after init.
+     * Key: index name, Value: index config (from metadata)
+     */
+    registeredIndices: Map<string, IndexMetaConfig>;
+    /**
+     * Maps field name → index names that cover this field.
+     * Used for query resolution.
+     */
+    fieldToIndices: Map<string, string[]>;
+    pendingBackfillFields: string[];
+    constructor(api: DocumentDataplyAPI<T>);
+    /**
+     * Validate and apply indices from DB metadata and pending indices.
+     * Called during database initialization.
+     */
+    initializeIndices(metadata: DocumentDataplyInnerMetadata, isNewlyCreated: boolean, tx: Transaction): Promise<boolean>;
+    /**
+     * Register an index. If called before init(), queues it.
+     */
+    registerIndex(name: string, option: CreateIndexOption<T>, tx?: Transaction): Promise<void>;
+    /**
+     * Register an index at runtime (after init).
+     */
+    private registerIndexRuntime;
+    /**
+     * Drop (remove) a named index.
+     */
+    dropIndex(name: string, tx?: Transaction): Promise<void>;
+    /**
+     * Backfill indices for newly created indices after data was inserted.
+     */
+    backfillIndices(tx?: Transaction): Promise<number>;
+    /**
+     * Convert CreateIndexOption to IndexMetaConfig for metadata storage.
+     */
+    toIndexMetaConfig(option: CreateIndexOption<T>): IndexMetaConfig;
+    /**
+     * Get all field names from an IndexMetaConfig.
+     */
+    getFieldsFromConfig(config: IndexMetaConfig): string[];
+    /**
+     * Get the primary field of an index.
+     */
+    getPrimaryField(config: IndexMetaConfig): string;
+    /**
+     * Create B+Tree value string for indexing a document
+     */
+    getIndexValue(config: IndexMetaConfig, flatDoc: FlattenedDocumentJSON): Primitive | Primitive[] | undefined;
+    /**
+     * Get FTSConfig from IndexMetaConfig
+     */
+    getFtsConfig(config: IndexMetaConfig): FTSConfig | null;
+    getTokenKey(pk: number, token: string): string;
+}

package/dist/types/core/MetadataManager.d.ts

@@ -0,0 +1,18 @@
+import type { DocumentDataplyMetadata, DocumentDataplyInnerMetadata, DocumentJSON } from '../types';
+import type { DocumentDataplyAPI } from './documentAPI';
+import { Transaction } from 'dataply';
+export declare class MetadataManager<T extends DocumentJSON> {
+    private api;
+    constructor(api: DocumentDataplyAPI<T>);
+    getDocumentMetadata(tx: Transaction): Promise<DocumentDataplyMetadata>;
+    getDocumentInnerMetadata(tx: Transaction): Promise<DocumentDataplyInnerMetadata>;
+    updateDocumentInnerMetadata(metadata: DocumentDataplyInnerMetadata, tx: Transaction): Promise<void>;
+    /**
+     * Run a migration if the current schemeVersion is lower than the target version.
+     * After the callback completes, schemeVersion is updated to the target version.
+     * @param version The target scheme version
+     * @param callback The migration callback
+     * @param tx Optional transaction
+     */
+    migration(version: number, callback: (tx: Transaction) => Promise<void>, tx?: Transaction): Promise<void>;
+}

package/dist/types/core/MutationManager.d.ts

@@ -0,0 +1,53 @@
+import type { DocumentJSON, DataplyDocument, DocumentDataplyQuery } from '../types';
+import type { DocumentDataplyAPI } from './documentAPI';
+import { Transaction } from 'dataply';
+export declare class MutationManager<T extends DocumentJSON> {
+    private api;
+    constructor(api: DocumentDataplyAPI<T>);
+    private insertDocumentInternal;
+    /**
+     * Insert a document into the database
+     * @param document The document to insert
+     * @param tx The transaction to use
+     * @returns The primary key of the inserted document
+     */
+    insertSingleDocument(document: T, tx?: Transaction): Promise<number>;
+    /**
+     * Insert a batch of documents into the database
+     * @param documents The documents to insert
+     * @param tx The transaction to use
+     * @returns The primary keys of the inserted documents
+     */
+    insertBatchDocuments(documents: T[], tx?: Transaction): Promise<number[]>;
+    /**
+     * Internal update method used by both fullUpdate and partialUpdate
+     * @param query The query to use
+     * @param computeUpdatedDoc Function that computes the updated document from the original
+     * @param tx The transaction to use
+     * @returns The number of updated documents
+     */
+    private updateInternal;
+    /**
+     * Fully update documents from the database that match the query
+     * @param query The query to use
+     * @param newRecord Complete document to replace with, or function that receives current document and returns new document
+     * @param tx The transaction to use
+     * @returns The number of updated documents
+     */
+    fullUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: T | ((document: DataplyDocument<T>) => T), tx?: Transaction): Promise<number>;
+    /**
+     * Partially update documents from the database that match the query
+     * @param query The query to use
+     * @param newRecord Partial document to merge, or function that receives current document and returns partial update
+     * @param tx The transaction to use
+     * @returns The number of updated documents
+     */
+    partialUpdate(query: Partial<DocumentDataplyQuery<T>>, newRecord: Partial<DataplyDocument<T>> | ((document: DataplyDocument<T>) => Partial<DataplyDocument<T>>), tx?: Transaction): Promise<number>;
+    /**
+     * Delete documents from the database that match the query
+     * @param query The query to use
+     * @param tx The transaction to use
+     * @returns The number of deleted documents
+     */
+    deleteDocuments(query: Partial<DocumentDataplyQuery<T>>, tx?: Transaction): Promise<number>;
+}

package/dist/types/core/Optimizer.d.ts

@@ -0,0 +1,78 @@
+import type { DataplyTreeValue, DocumentDataplyQuery, DocumentDataplyCondition } from '../types';
+import type { DocumentDataplyAPI } from './documentAPI';
+import { BPTreeAsync } from 'dataply';
+export declare class Optimizer<T extends Record<string, any>> {
+    private api;
+    constructor(api: DocumentDataplyAPI<T>);
+    /**
+     * B-Tree 타입 인덱스의 선택도를 평가하고 트리에 부여할 조건을 산출합니다.
+     */
+    evaluateBTreeCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(indexName: string, config: any, query: Partial<DocumentDataplyQuery<V>>, queryFields: Set<string>, treeTx: BPTreeAsync<string | number, V>, orderByField?: string): {
+        readonly tree: BPTreeAsync<string | number, V>;
+        readonly condition: any;
+        readonly field: any;
+        readonly indexName: string;
+        readonly isFtsMatch: false;
+        readonly score: number;
+        readonly compositeVerifyFields: string[];
+        readonly coveredFields: string[];
+        readonly isIndexOrderSupported: boolean;
+    } | null;
+    /**
+     * FTS 타입 인덱스의 선택도를 평가합니다.
+     */
+    evaluateFTSCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(indexName: string, config: any, query: Partial<DocumentDataplyQuery<V>>, queryFields: Set<string>, treeTx: BPTreeAsync<string | number, V>): {
+        readonly tree: BPTreeAsync<string | number, V>;
+        readonly condition: any;
+        readonly field: any;
+        readonly indexName: string;
+        readonly isFtsMatch: true;
+        readonly matchTokens: string[];
+        readonly score: 90;
+        readonly compositeVerifyFields: readonly [];
+        readonly coveredFields: readonly [any];
+        readonly isIndexOrderSupported: false;
+    } | null;
+    /**
+     * 실행할 최적의 인덱스를 선택합니다. (최적 드라이버 선택)
+     */
+    getSelectivityCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<V>>, orderByField?: string): Promise<{
+        driver: ({
+            tree: BPTreeAsync<number, V>;
+            condition: Partial<DocumentDataplyCondition<U>>;
+            field: string;
+            indexName: string;
+            isFtsMatch: false;
+            isIndexOrderSupported: boolean;
+        } | {
+            tree: BPTreeAsync<string, V>;
+            condition: Partial<DocumentDataplyCondition<U>>;
+            field: string;
+            indexName: string;
+            isFtsMatch: true;
+            matchTokens: string[];
+            isIndexOrderSupported: boolean;
+        });
+        others: ({
+            tree: BPTreeAsync<number, V>;
+            condition: Partial<DocumentDataplyCondition<U>>;
+            field: string;
+            indexName: string;
+            isFtsMatch: false;
+            isIndexOrderSupported: boolean;
+        } | {
+            tree: BPTreeAsync<string, V>;
+            condition: Partial<DocumentDataplyCondition<U>>;
+            field: string;
+            indexName: string;
+            isFtsMatch: true;
+            matchTokens: string[];
+            isIndexOrderSupported: boolean;
+        })[];
+        compositeVerifyConditions: {
+            field: string;
+            condition: any;
+        }[];
+        rollback: () => void;
+    } | null>;
+}

package/dist/types/core/QueryManager.d.ts

@@ -0,0 +1,73 @@
+import type { DataplyTreeValue, DocumentDataplyQuery, DocumentDataplyQueryOptions, DataplyDocument, Primitive, DocumentJSON } from '../types';
+import type { DocumentDataplyAPI } from './documentAPI';
+import type { Optimizer } from './Optimizer';
+import { BPTreeAsync } from 'dataply';
+export declare class QueryManager<T extends DocumentJSON> {
+    private api;
+    private optimizer;
+    private readonly operatorConverters;
+    constructor(api: DocumentDataplyAPI<T>, optimizer: Optimizer<T>);
+    /**
+     * Transforms a query object into a verbose query object
+     */
+    verboseQuery<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<U>>): Partial<DocumentDataplyQuery<V>>;
+    getFreeMemoryChunkSize(): {
+        verySmallChunkSize: number;
+        smallChunkSize: number;
+    };
+    private applyCandidateByFTSStream;
+    private applyCandidateStream;
+    getKeys(query: Partial<DocumentDataplyQuery<T>>, orderBy?: string, sortOrder?: 'asc' | 'desc'): Promise<Float64Array>;
+    getDriverKeys(query: Partial<DocumentDataplyQuery<T>>, orderBy?: string, sortOrder?: 'asc' | 'desc'): Promise<{
+        keysStream: AsyncIterableIterator<number>;
+        others: {
+            tree: BPTreeAsync<string | number, DataplyTreeValue<Primitive>>;
+            condition: any;
+            field: string;
+            indexName: string;
+            isFtsMatch: boolean;
+            matchTokens?: string[];
+        }[];
+        compositeVerifyConditions: {
+            field: string;
+            condition: any;
+        }[];
+        isDriverOrderByField: boolean;
+        rollback: () => void;
+    } | null>;
+    verifyFts(doc: DataplyDocument<T>, ftsConditions: {
+        field: string;
+        matchTokens: string[];
+    }[]): boolean;
+    verifyCompositeConditions(doc: DataplyDocument<T>, conditions: {
+        field: string;
+        condition: any;
+    }[]): boolean;
+    verifyValue(value: Primitive, condition: any): boolean;
+    adjustChunkSize(currentChunkSize: number, chunkTotalSize: number): number;
+    processChunkedKeysWithVerify(keysStream: AsyncIterableIterator<number>, startIdx: number, initialChunkSize: number, limit: number, ftsConditions: {
+        field: string;
+        matchTokens: string[];
+    }[], compositeVerifyConditions: {
+        field: string;
+        condition: any;
+    }[], others: {
+        tree: BPTreeAsync<string | number, DataplyTreeValue<Primitive>>;
+        condition: any;
+        field: string;
+        indexName: string;
+        isFtsMatch: boolean;
+        matchTokens?: string[];
+    }[], tx: any): AsyncGenerator<DataplyDocument<T>>;
+    /**
+     * Count documents from the database that match the query
+     * @param query The query to use
+     * @param tx The transaction to use
+     * @returns The number of documents that match the query
+     */
+    countDocuments(query: Partial<DocumentDataplyQuery<T>>, tx?: any): Promise<number>;
+    selectDocuments(query: Partial<DocumentDataplyQuery<T>>, options?: DocumentDataplyQueryOptions, tx?: any): {
+        stream: () => AsyncIterableIterator<DataplyDocument<T>>;
+        drain: () => Promise<DataplyDocument<T>[]>;
+    };
+}

package/dist/types/core/documentAPI.d.ts

@@ -1,92 +1,48 @@
-import type { DataplyTreeValue, DocumentDataplyInnerMetadata, DocumentDataplyOptions, DocumentJSON, FlattenedDocumentJSON, Primitive, DataplyDocument, DocumentDataplyMetadata, DocumentDataplyQuery, DocumentDataplyCondition, DocumentDataplyQueryOptions, CreateIndexOption } from '../types';
-import { DataplyAPI, Transaction, BPTreeAsync } from 'dataply';
+import type { DocumentDataplyInnerMetadata, DocumentDataplyOptions, DocumentJSON, FlattenedDocumentJSON, DataplyDocument, DocumentDataplyMetadata, DocumentDataplyQuery, DocumentDataplyQueryOptions, CreateIndexOption } from '../types';
+import { DataplyAPI, Transaction } from 'dataply';
 import { DocumentValueComparator } from './bptree/documentComparator';
+import { Optimizer } from './Optimizer';
+import { QueryManager } from './QueryManager';
+import { IndexManager } from './IndexManager';
+import { MutationManager } from './MutationManager';
+import { MetadataManager } from './MetadataManager';
+import { DocumentFormatter } from './DocumentFormatter';
 export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyAPI {
     runWithDefault: <T_1>(callback: (tx: Transaction) => Promise<T_1>, tx?: Transaction) => Promise<T_1>;
     runWithDefaultWrite: <T_1>(callback: (tx: Transaction) => Promise<T_1>, tx?: Transaction) => Promise<T_1>;
     streamWithDefault: <T_1>(callback: (tx: Transaction) => AsyncGenerator<T_1>, tx?: Transaction) => AsyncGenerator<T_1>;
-    indices: DocumentDataplyInnerMetadata['indices'];
-    readonly trees: Map<string, BPTreeAsync<string | number, DataplyTreeValue<Primitive>>>;
-    readonly comparator: DocumentValueComparator<DataplyTreeValue<Primitive>, Primitive>;
-    private pendingBackfillFields;
+    readonly comparator: DocumentValueComparator<import("../types").DataplyTreeValue<import("../types").Primitive>, import("../types").Primitive>;
     private _initialized;
-    readonly indexedFields: Set<string>;
-    /**
-     * Registered indices via createIndex() (before init)
-     * Key: index name, Value: index configuration
-     */
-    private readonly pendingCreateIndices;
-    /**
-     * Resolved index configurations after init.
-     * Key: index name, Value: index config (from metadata)
-     */
-    private registeredIndices;
-    /**
-     * Maps field name → index names that cover this field.
-     * Used for query resolution.
-     */
-    private fieldToIndices;
-    private readonly operatorConverters;
+    readonly optimizer: Optimizer<T>;
+    readonly queryManager: QueryManager<T>;
+    readonly indexManager: IndexManager<T>;
+    readonly mutationManager: MutationManager<T>;
+    readonly metadataManager: MetadataManager<T>;
+    readonly documentFormatter: DocumentFormatter<T>;
     constructor(file: string, options: DocumentDataplyOptions);
     /**
      * Whether the document database has been initialized.
      */
     get isDocInitialized(): boolean;
-    /**
-     * Register an index. If called before init(), queues it for processing during init.
-     * If called after init(), immediately creates the tree, updates metadata, and backfills.
-     */
+    get indices(): {
+        [key: string]: [number, import("../types").IndexMetaConfig];
+    };
+    get trees(): Map<string, import("dataply").BPTreeAsync<string | number, import("../types").DataplyTreeValue<import("../types").Primitive>>>;
+    get indexedFields(): Set<string>;
     registerIndex(name: string, option: CreateIndexOption<T>, tx?: Transaction): Promise<void>;
-    /**
-     * Register an index at runtime (after init).
-     * Creates the tree, updates metadata, and backfills existing data.
-     */
-    private registerIndexRuntime;
     /**
      * Drop (remove) a named index.
-     * Removes the index from metadata, in-memory maps, and trees.
-     * The '_id' index cannot be dropped.
-     * @param name The name of the index to drop
      */
     dropIndex(name: string, tx?: Transaction): Promise<void>;
-    /**
-     * Convert CreateIndexOption to IndexMetaConfig for metadata storage.
-     */
-    private toIndexMetaConfig;
-    /**
-     * Get all field names from an IndexMetaConfig.
-     */
-    private getFieldsFromConfig;
-    /**
-     * Get the primary field of an index (the field used as tree key).
-     * For btree: first field in fields array.
-     * For fts: the single field.
-     */
-    private getPrimaryField;
-    /**
-     * 인덱스 config에 따라 B+tree에 저장할 v 값을 생성합니다.
-     * - 단일 필드 btree: Primitive (단일 값)
-     * - 복합 필드 btree: Primitive[] (필드 순서대로 배열)
-     * - fts: 별도 처리 (이 메서드 사용 안 함)
-     * @returns undefined면 해당 문서에 필수 필드가 없으므로 인덱싱 스킵
-     */
-    private getIndexValue;
-    /**
-     * Get FTSConfig from IndexMetaConfig (for tokenizer compatibility).
-     */
-    private getFtsConfig;
     getDocument(pk: number, tx?: Transaction): Promise<DataplyDocument<T>>;
     /**
      * Backfill indices for newly created indices after data was inserted.
-     * This method should be called after `init()`.
-     *
-     * @returns Number of documents that were backfilled
+     * Delegated to IndexManager.
      */
     backfillIndices(tx?: Transaction): Promise<number>;
     createDocumentInnerMetadata(indices: DocumentDataplyInnerMetadata['indices']): DocumentDataplyInnerMetadata;
     initializeDocumentFile(tx: Transaction): Promise<void>;
     verifyDocumentFile(tx: Transaction): Promise<boolean>;
-    private flatten;
     /**
      * returns flattened document
      * @param document
@@ -104,110 +60,6 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyA
      * @param tx Optional transaction
      */
     migration(version: number, callback: (tx: Transaction) => Promise<void>, tx?: Transaction): Promise<void>;
-    /**
-     * Transforms a query object into a verbose query object
-     * @param query The query object to transform
-     * @returns The verbose query object
-     */
-    verboseQuery<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<U>>): Partial<DocumentDataplyQuery<V>>;
-    /**
-     * B-Tree 타입 인덱스의 선택도를 평가하고 트리에 부여할 조건을 산출합니다.
-     * 필드 매칭 여부를 검사하고, 연속된(Prefix) 조건에 대해 점수를 부여하며 Start/End 바운드를 구성합니다.
-     *
-     * @param indexName 평가할 인덱스의 이름 (예: idx_nickname_createdat)
-     * @param config 등록된 인덱스의 설정 객체
-     * @param query 쿼리 객체
-     * @param queryFields 쿼리에 포함된 필드 목록 집합
-     * @param treeTx 조회를 수행할 B-Tree 트랜잭션 객체
-     * @param orderByField 정렬에 사용할 필드명 (옵션)
-     * @returns B-Tree 인덱스 후보 정보 (조건, 점수, 커버된 필드 등), 적합하지 않으면 null
-     */
-    private evaluateBTreeCandidate;
-    /**
-     * FTS (Full Text Search) 타입 인덱스의 선택도를 평가합니다.
-     * 'match' 연산자가 쿼리에 존재하는지 확인하고, 검색용 토큰으로 분해(tokenize)하여 점수를 매깁니다.
-     *
-     * @param indexName 평가할 인덱스의 이름
-     * @param config 등록된 인덱스의 설정 객체
-     * @param query 쿼리 객체
-     * @param queryFields 쿼리에 포함된 필드 목록 집합
-     * @param treeTx 조회를 수행할 B-Tree 트랜잭션 객체
-     * @returns FTS 인덱스 후보 정보 (조건, 점수, 분석된 토큰 등), 적합하지 않으면 null
-     */
-    private evaluateFTSCandidate;
-    /**
-     * Choose the best index (driver) for the given query.
-     * Scores each index based on field coverage and condition type.
-     *
-     * @param query The verbose query conditions
-     * @param orderByField Optional field name for orderBy optimization
-     * @returns Driver and other candidates for query execution
-     */
-    getSelectivityCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<V>>, orderByField?: string): Promise<{
-        driver: ({
-            tree: BPTreeAsync<number, V>;
-            condition: Partial<DocumentDataplyCondition<U>>;
-            field: string;
-            indexName: string;
-            isFtsMatch: false;
-            isIndexOrderSupported: boolean;
-        } | {
-            tree: BPTreeAsync<string, V>;
-            condition: Partial<DocumentDataplyCondition<U>>;
-            field: string;
-            indexName: string;
-            isFtsMatch: true;
-            matchTokens: string[];
-            isIndexOrderSupported: boolean;
-        });
-        others: ({
-            tree: BPTreeAsync<number, V>;
-            condition: Partial<DocumentDataplyCondition<U>>;
-            field: string;
-            indexName: string;
-            isFtsMatch: false;
-            isIndexOrderSupported: boolean;
-        } | {
-            tree: BPTreeAsync<string, V>;
-            condition: Partial<DocumentDataplyCondition<U>>;
-            field: string;
-            indexName: string;
-            isFtsMatch: true;
-            matchTokens: string[];
-            isIndexOrderSupported: boolean;
-        })[];
-        compositeVerifyConditions: {
-            field: string;
-            condition: any;
-        }[];
-        rollback: () => void;
-    } | null>;
-    /**
-     * Get Free Memory Chunk Size
-     * @returns { verySmallChunkSize, smallChunkSize }
-     */
-    getFreeMemoryChunkSize(): {
-        verySmallChunkSize: number;
-        smallChunkSize: number;
-    };
-    private getTokenKey;
-    private applyCandidateByFTSStream;
-    /**
-     * 특정 인덱스 후보를 조회하여 PK 집합을 필터링합니다.
-     */
-    private applyCandidateStream;
-    /**
-     * 쿼리와 인덱스 선택을 기반으로 기본 키(Primary Keys)를 가져옵니다.
-     * 쿼리 최적화를 통합하기 위한 내부 공통 메서드입니다.
-     */
-    getKeys(query: Partial<DocumentDataplyQuery<T>>, orderBy?: string, sortOrder?: 'asc' | 'desc'): Promise<Float64Array>;
-    /**
-     * 드라이버 인덱스만으로 PK 스트림을 가져옵니다. (교집합 없이)
-     * selectDocuments에서 사용하며, 나머지 조건(others)은 스트리밍 중 tree.verify()로 검증합니다.
-     * @returns 드라이버 키 스트림, others 후보 목록, rollback 함수. 또는 null.
-     */
-    private getDriverKeys;
-    private insertDocumentInternal;
     /**
      * Insert a document into the database
      * @param document The document to insert
@@ -222,14 +74,6 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyA
      * @returns The primary keys of the inserted documents
      */
     insertBatchDocuments(documents: T[], tx?: Transaction): Promise<number[]>;
-    /**
-     * Internal update method used by both fullUpdate and partialUpdate
-     * @param query The query to use
-     * @param computeUpdatedDoc Function that computes the updated document from the original
-     * @param tx The transaction to use
-     * @returns The number of updated documents
-     */
-    private updateInternal;
     /**
      * Fully update documents from the database that match the query
      * @param query The query to use
@@ -260,27 +104,6 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyA
      * @returns The number of documents that match the query
      */
     countDocuments(query: Partial<DocumentDataplyQuery<T>>, tx?: Transaction): Promise<number>;
-    /**
-     * FTS 조건에 대해 문서가 유효한지 검증합니다.
-     */
-    private verifyFts;
-    /**
-     * 복합 인덱스의 non-primary 필드에 대해 문서가 유효한지 검증합니다.
-     */
-    private verifyCompositeConditions;
-    /**
-     * 단일 값에 대해 verbose 조건을 검증합니다.
-     */
-    private verifyValue;
-    /**
-     * 메모리 기반으로 청크 크기를 동적 조절합니다.
-     */
-    private adjustChunkSize;
-    /**
-     * Prefetch 방식으로 키 스트림을 청크 단위로 조회하여 문서를 순회합니다.
-     * FTS 검증, 복합 인덱스 검증, others 후보에 대한 tree.verify() 검증을 통과한 문서만 yield 합니다.
-     */
-    private processChunkedKeysWithVerify;
     /**
      * Select documents from the database
      * @param query The query to use

package/dist/types/types/index.d.ts

@@ -53,6 +53,11 @@ export interface DocumentDataplyMetadata {
      * The total number of data rows in the dataply.
      */
     rowCount: number;
+    /**
+     * The usage of the dataply. It is calculated based on the remaining page capacity.
+     * The value is between 0 and 1.
+     */
+    usage: number;
     /**
      * The list of user-created index names (excludes internal '_id' index).
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.10-alpha.2",
+  "version": "0.0.10-alpha.4",
   "description": "Simple and powerful JSON document database supporting complex queries and flexible indexing policies.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",