document-dataply 0.0.14-alpha.1 → 0.0.14-alpha.3

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

@@ -1,7 +1,7 @@
 import type { AnalysisHeader, DocumentJSON, FlattenedDocumentJSON } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
 import type { AnalysisProvider } from './AnalysisProvider';
-import { Transaction } from 'dataply';
+import { Transaction, Logger } from 'dataply';
 export declare class AnalysisManager<T extends DocumentJSON> {
     private api;
     readonly sampleSize: number;
@@ -9,7 +9,7 @@ export declare class AnalysisManager<T extends DocumentJSON> {
     private providers;
     private cron;
     private flushing;
-    constructor(api: DocumentDataplyAPI<T>, schedule: string, sampleSize: number, logger: any);
+    constructor(api: DocumentDataplyAPI<T>, schedule: string, sampleSize: number, logger: Logger);
     /**
      * Stop the background analysis cron job.
      */

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

@@ -1,11 +1,11 @@
 import type { DataplyTreeValue, DocumentDataplyInnerMetadata, Primitive, CreateIndexOption, IndexMetaConfig, FTSConfig, DocumentJSON, FlattenedDocumentJSON } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
-import { BPTreeAsync, Transaction } from 'dataply';
+import { BPTreePureAsync, Transaction, Logger } from 'dataply';
 export declare class IndexManager<T extends DocumentJSON> {
     private api;
     private logger;
     indices: DocumentDataplyInnerMetadata['indices'];
-    readonly trees: Map<string, BPTreeAsync<string | number, DataplyTreeValue<Primitive>>>;
+    readonly trees: Map<string, BPTreePureAsync<string | number, DataplyTreeValue<Primitive>>>;
     readonly indexedFields: Set<string>;
     /**
      * Registered indices via createIndex() (before init)
@@ -23,7 +23,7 @@ export declare class IndexManager<T extends DocumentJSON> {
      */
     fieldToIndices: Map<string, string[]>;
     pendingBackfillFields: string[];
-    constructor(api: DocumentDataplyAPI<T>, logger: any);
+    constructor(api: DocumentDataplyAPI<T>, logger: Logger);
     /**
      * Validate and apply indices from DB metadata and pending indices.
      * Called during database initialization.

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

@@ -1,10 +1,10 @@
 import type { DocumentDataplyMetadata, DocumentDataplyInnerMetadata, DocumentJSON } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
-import { Transaction } from 'dataply';
+import { Transaction, Logger } from 'dataply';
 export declare class MetadataManager<T extends DocumentJSON> {
     private api;
     private logger;
-    constructor(api: DocumentDataplyAPI<T>, logger: any);
+    constructor(api: DocumentDataplyAPI<T>, logger: Logger);
     getDocumentMetadata(tx: Transaction): Promise<DocumentDataplyMetadata>;
     getDocumentInnerMetadata(tx: Transaction): Promise<DocumentDataplyInnerMetadata>;
     updateDocumentInnerMetadata(metadata: DocumentDataplyInnerMetadata, tx: Transaction): Promise<void>;

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

@@ -1,10 +1,10 @@
 import type { DocumentJSON, DataplyDocument, DocumentDataplyQuery } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
-import { Transaction } from 'dataply';
+import { Transaction, Logger } from 'dataply';
 export declare class MutationManager<T extends DocumentJSON> {
     private api;
     private logger;
-    constructor(api: DocumentDataplyAPI<T>, logger: any);
+    constructor(api: DocumentDataplyAPI<T>, logger: Logger);
     private isTreeEmpty;
     private insertDocumentInternal;
     insertSingleDocument(document: T, tx?: Transaction): Promise<number>;

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

@@ -1,14 +1,14 @@
 import type { DataplyTreeValue, DocumentDataplyQuery, DocumentDataplyCondition } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
-import { BPTreeAsync } from 'dataply';
+import { BPTreePureAsync } 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>;
+    evaluateBTreeCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(indexName: string, config: any, query: Partial<DocumentDataplyQuery<V>>, queryFields: Set<string>, treeTx: BPTreePureAsync<string | number, V>, orderByField?: string): {
+        readonly tree: BPTreePureAsync<string | number, V>;
         readonly condition: any;
         readonly field: any;
         readonly indexName: string;
@@ -22,8 +22,8 @@ export declare class Optimizer<T extends Record<string, any>> {
      * FTS 타입 인덱스의 선택도를 평가합니다.
      * FTSTermCount 통계가 있으면 실측 데이터 기반으로 선택도를 산출합니다.
      */
-    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>): {
-        tree: BPTreeAsync<string | number, V>;
+    evaluateFTSCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(indexName: string, config: any, query: Partial<DocumentDataplyQuery<V>>, queryFields: Set<string>, tree: BPTreePureAsync<string | number, V>): {
+        tree: BPTreePureAsync<string | number, V>;
         condition: any;
         field: any;
         indexName: string;
@@ -49,14 +49,14 @@ export declare class Optimizer<T extends Record<string, any>> {
      */
     getSelectivityCandidate<U extends Partial<DocumentDataplyQuery<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<V>>, orderByField?: string, limit?: number, offset?: number): Promise<{
         driver: ({
-            tree: BPTreeAsync<number, V>;
+            tree: BPTreePureAsync<number, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
             indexName: string;
             isFtsMatch: false;
             isIndexOrderSupported: boolean;
         } | {
-            tree: BPTreeAsync<string, V>;
+            tree: BPTreePureAsync<string, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
             indexName: string;
@@ -65,14 +65,14 @@ export declare class Optimizer<T extends Record<string, any>> {
             isIndexOrderSupported: boolean;
         });
         others: ({
-            tree: BPTreeAsync<number, V>;
+            tree: BPTreePureAsync<number, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
             indexName: string;
             isFtsMatch: false;
             isIndexOrderSupported: boolean;
         } | {
-            tree: BPTreeAsync<string, V>;
+            tree: BPTreePureAsync<string, V>;
             condition: Partial<DocumentDataplyCondition<U>>;
             field: string;
             indexName: string;
@@ -84,6 +84,5 @@ export declare class Optimizer<T extends Record<string, any>> {
             field: string;
             condition: any;
         }[];
-        rollback: () => void;
     } | null>;
 }

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

@@ -1,13 +1,13 @@
 import type { DataplyTreeValue, DocumentDataplyQuery, DocumentDataplyQueryOptions, DataplyDocument, Primitive, DocumentJSON } from '../types';
 import type { DocumentDataplyAPI } from './documentAPI';
 import type { Optimizer } from './Optimizer';
-import { BPTreeAsync } from 'dataply';
+import { BPTreePureAsync, Logger } from 'dataply';
 export declare class QueryManager<T extends DocumentJSON> {
     private api;
     private optimizer;
     private logger;
     private readonly operatorConverters;
-    constructor(api: DocumentDataplyAPI<T>, optimizer: Optimizer<T>, logger: any);
+    constructor(api: DocumentDataplyAPI<T>, optimizer: Optimizer<T>, logger: Logger);
     /**
      * Transforms a query object into a verbose query object
      */
@@ -22,7 +22,7 @@ export declare class QueryManager<T extends DocumentJSON> {
     getDriverKeys(query: Partial<DocumentDataplyQuery<T>>, orderBy?: string, sortOrder?: 'asc' | 'desc', limit?: number, offset?: number): Promise<{
         keysStream: AsyncIterableIterator<number>;
         others: {
-            tree: BPTreeAsync<string | number, DataplyTreeValue<Primitive>>;
+            tree: BPTreePureAsync<string | number, DataplyTreeValue<Primitive>>;
             condition: any;
             field: string;
             indexName: string;
@@ -35,7 +35,6 @@ export declare class QueryManager<T extends DocumentJSON> {
             condition: any;
         }[];
         isDriverOrderByField: boolean;
-        rollback: () => void;
     } | null>;
     verifyFts(doc: DataplyDocument<T>, ftsConditions: {
         field: string;
@@ -62,7 +61,7 @@ export declare class QueryManager<T extends DocumentJSON> {
         field: string;
         condition: any;
     }[], others: {
-        tree: BPTreeAsync<string | number, DataplyTreeValue<Primitive>>;
+        tree: BPTreePureAsync<string | number, DataplyTreeValue<Primitive>>;
         condition: any;
         field: string;
         indexName: string;

package/dist/types/core/bptree/documentStrategy.d.ts

@@ -1,5 +1,5 @@
 import type { DataplyTreeValue, Primitive } from '../../types';
-import { BPTreeNode, SerializeStrategyAsync, type SerializeStrategyHead } from 'dataply';
+import { type SerializeStrategyHead, type BPTreeNode, SerializeStrategyAsync } from 'dataply';
 import { DocumentDataplyAPI } from '../documentAPI';
 export declare class DocumentSerializeStrategyAsync<T extends Primitive> extends SerializeStrategyAsync<number, DataplyTreeValue<T>> {
     protected readonly api: DocumentDataplyAPI<any>;
@@ -15,6 +15,11 @@ export declare class DocumentSerializeStrategyAsync<T extends Primitive> extends
     read(id: string): Promise<BPTreeNode<number, DataplyTreeValue<T>>>;
     write(id: string, node: BPTreeNode<number, DataplyTreeValue<T>>): Promise<void>;
     delete(id: string): Promise<void>;
+    /**
+     * headPk 행이 가리키는 B+Tree의 모든 노드 행과 head 행 자체를 삭제합니다.
+     * dropIndex 시 행을 회수하기 위해 사용합니다.
+     */
+    clearAllNodes(headPk: number): Promise<void>;
     readHead(): Promise<SerializeStrategyHead | null>;
     writeHead(head: SerializeStrategyHead): Promise<void>;
 }

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

@@ -30,6 +30,20 @@ export declare class DocumentDataply<T extends DocumentJSON> {
     private static Open;
     protected readonly api: DocumentDataplyAPI<T>;
     protected constructor(file: string, options?: DocumentDataplyOptions);
+    /**
+     * Method for reliably processing large batches (chunks) of data.
+     * Processes data in fragments to prevent blocking the event loop while handling large volumes of data.
+     * @param items The items to process
+     * @param callback The callback to process each chunk
+     * @param options The options for the chunk splitter
+     * @param options.firstChunkSize The size of the first chunk. Subsequent chunk sizes are determined based on this value and the processing time. If not specified or set to 0, 5% of the total data is used as the initial value.
+     * @param options.alpha A value that determines the weight given to recent processing times. Higher values weigh recent times more heavily. Lower values are recommended for stability, but excessively low values may impact performance. Default is 0.5.
+     * @returns The processed items
+     */
+    processInChunks<T>(items: T[], callback: (chunk: T[]) => Promise<void>, options?: {
+        firstChunkSize?: number;
+        alpha?: number;
+    }): Promise<void>;
     /**
      * Create a named index on the database.
      * Can be called before or after init().
@@ -80,9 +94,17 @@ export declare class DocumentDataply<T extends DocumentJSON> {
      */
     getMetadata(tx?: Transaction): Promise<DocumentDataplyMetadata>;
     /**
-     * Create a transaction
+     * Run a callback in a write transaction
+     * @param callback The callback to run
+     * @param tx Optional transaction
+     */
+    withWriteTransaction(callback: (tx: Transaction) => Promise<void>, tx?: Transaction): Promise<void>;
+    /**
+     * Run a callback in a read transaction
+     * @param callback The callback to run
+     * @param tx Optional transaction
      */
-    createTransaction(): Transaction;
+    withReadTransaction(callback: (tx: Transaction) => Promise<void>, tx?: Transaction): Promise<void>;
     /**
      * Insert a document into the database
      * @param document The document to insert

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

@@ -9,9 +9,6 @@ import { MetadataManager } from './MetadataManager';
 import { DocumentFormatter } from './DocumentFormatter';
 import { AnalysisManager } from './AnalysisManager';
 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>;
     readonly comparator: DocumentValueComparator<import("../types").DataplyTreeValue<import("../types").Primitive>, import("../types").Primitive>;
     private _initialized;
     readonly optimizer: Optimizer<T>;
@@ -29,8 +26,22 @@ export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyA
     get indices(): {
         [key: string]: [number, import("../types").IndexMetaConfig];
     };
-    get trees(): Map<string, import("dataply").BPTreeAsync<string | number, import("../types").DataplyTreeValue<import("../types").Primitive>>>;
+    get trees(): Map<string, import("dataply").BPTreePureAsync<string | number, import("../types").DataplyTreeValue<import("../types").Primitive>>>;
     get indexedFields(): Set<string>;
+    /**
+     * Method for reliably processing large batches (chunks) of data.
+     * Processes data in fragments to prevent blocking the event loop while handling large volumes of data.
+     * @param items The items to process
+     * @param callback The callback to process each chunk
+     * @param options The options for the chunk splitter
+     * @param options.firstChunkSize The size of the first chunk. Subsequent chunk sizes are determined based on this value and the processing time. If not specified or set to 0, 5% of the total data is used as the initial value.
+     * @param options.alpha A value that determines the weight given to recent processing times. Higher values weigh recent times more heavily. Lower values are recommended for stability, but excessively low values may impact performance. Default is 0.5.
+     * @returns The processed items
+     */
+    processInChunks<T>(items: T[], callback: (chunk: T[]) => Promise<void>, options?: {
+        firstChunkSize?: number;
+        alpha?: number;
+    }): Promise<void>;
     /**
      * Register an index.
      * @param name The name of the index

package/dist/types/utils/{DeadlineChunker.d.ts → eventLoopManager.d.ts}

@@ -1,3 +1,4 @@
+export declare function yieldEventLoop(): Promise<unknown>;
 /**
  * 이벤트 루프를 막지 않고 대량의 데이터를 처리하기 위한 유틸리티 클래스
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.14-alpha.1",
+  "version": "0.0.14-alpha.3",
   "description": "Simple and powerful JSON document database supporting complex queries and flexible indexing policies.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -43,7 +43,7 @@
   ],
   "dependencies": {
     "croner": "^10.0.1",
-    "dataply": "^0.0.26-alpha.2"
+    "dataply": "^0.0.26-alpha.15"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -52,4 +52,4 @@
     "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
   }
-}
+}