document-dataply 0.0.4-alpha.3 → 0.0.4-alpha.4

package/dist/cjs/index.js

@@ -7434,9 +7434,6 @@ var require_cjs = __commonJS({
           promises.push(writePage(pageId, data));
         }
         await Promise.all(promises);
-        if (restoredPages.size > 0) {
-          await this.clear();
-        }
       }
       /**
        * WAL에 페이지 데이터를 기록합니다 (Phase 1: Prepare).
@@ -7595,6 +7592,8 @@ var require_cjs = __commonJS({
       }
       /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
       cache;
+      /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
+      dirtyPages = /* @__PURE__ */ new Map();
       /** 파일 크기 (논리적) */
       fileSize;
       /**
@@ -7604,6 +7603,12 @@ var require_cjs = __commonJS({
        * @returns 페이지 데이터
        */
       async read(pageId) {
+        const dirty = this.dirtyPages.get(pageId);
+        if (dirty) {
+          const copy = new Uint8Array(this.pageSize);
+          copy.set(dirty);
+          return copy;
+        }
         const cached = this.cache.get(pageId);
         if (cached) {
           const copy = new Uint8Array(this.pageSize);
@@ -7631,21 +7636,50 @@ var require_cjs = __commonJS({
         if (pageStartPos + this.pageSize > 512 * 1024 * 1024) {
           throw new Error(`[Safety Limit] File write exceeds 512MB limit at position ${pageStartPos}`);
         }
-        await this._writeToDisk(data, pageStartPos);
-        const cacheCopy = new Uint8Array(this.pageSize);
-        cacheCopy.set(data);
-        this.cache.set(pageId, cacheCopy);
+        const dataCopy = new Uint8Array(this.pageSize);
+        dataCopy.set(data);
+        this.dirtyPages.set(pageId, dataCopy);
+        this.cache.set(pageId, dataCopy);
         const endPosition = pageStartPos + this.pageSize;
         if (endPosition > this.fileSize) {
           this.fileSize = endPosition;
         }
       }
+      /**
+       * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
+       * WAL 체크포인트 시점에 호출되어야 합니다.
+       */
+      async flush() {
+        if (this.dirtyPages.size === 0) {
+          return;
+        }
+        const snapshot = new Map(this.dirtyPages);
+        const sortedPageIds = Array.from(snapshot.keys()).sort((a, b) => a - b);
+        for (const pageId of sortedPageIds) {
+          const data = snapshot.get(pageId);
+          const position = pageId * this.pageSize;
+          await this._writeToDisk(data, position);
+          this.dirtyPages.delete(pageId);
+        }
+      }
+      /**
+       * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
+       */
+      async sync() {
+        return new Promise((resolve, reject) => {
+          import_node_fs2.default.fsync(this.fileHandle, (err) => {
+            if (err) return reject(err);
+            resolve();
+          });
+        });
+      }
       /**
        * 페이지 삭제 (실제로는 캐시에서만 제거)
        * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
        * @param pageId 페이지 ID
        */
       async delete(pageId) {
+        this.dirtyPages.delete(pageId);
         this.cache.delete(pageId);
       }
       /**
@@ -7654,6 +7688,9 @@ var require_cjs = __commonJS({
        * @returns 존재하면 true
        */
       async exists(pageId) {
+        if (this.dirtyPages.has(pageId)) {
+          return true;
+        }
         const pageStartPos = pageId * this.pageSize;
         return pageStartPos < this.fileSize;
       }
@@ -7708,6 +7745,25 @@ var require_cjs = __commonJS({
       walManager;
       pageManagerFactory;
       pageStrategy;
+      /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
+      lockPromise = Promise.resolve();
+      /**
+       * 글로벌 동기화 범위 내에서 작업을 실행합니다.
+       * @param task 수행할 비동기 작업
+       */
+      async runGlobalLock(task) {
+        const previous = this.lockPromise;
+        let resolveLock;
+        this.lockPromise = new Promise((resolve) => {
+          resolveLock = resolve;
+        });
+        await previous;
+        try {
+          return await task();
+        } finally {
+          resolveLock();
+        }
+      }
       /**
        * Initializes the page file system.
        * Performs WAL recovery if necessary.
@@ -7717,6 +7773,7 @@ var require_cjs = __commonJS({
           await this.walManager.recover(async (pageId, data) => {
             await this.pageStrategy.write(pageId, data);
           });
+          await this.checkpoint();
         }
       }
       /**
@@ -8016,15 +8073,30 @@ var require_cjs = __commonJS({
       async commitToWAL(dirtyPages) {
         if (this.walManager) {
           await this.walManager.prepareCommit(dirtyPages);
-          await this.walManager.finalizeCommit(false);
+          await this.walManager.finalizeCommit(true);
         }
       }
+      /**
+       * 체크포인트를 수행합니다.
+       * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
+       * 2. DB 파일 물리적 동기화 (Sync/fsync)
+       * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+       */
+      async checkpoint() {
+        await this.runGlobalLock(async () => {
+          await this.pageStrategy.flush();
+          await this.pageStrategy.sync();
+          if (this.walManager) {
+            await this.walManager.clear();
+          }
+        });
+      }
       /**
        * Closes the page file system.
        */
       async close() {
+        await this.checkpoint();
         if (this.walManager) {
-          await this.walManager.clear();
           this.walManager.close();
         }
       }
@@ -8836,18 +8908,24 @@ var require_cjs = __commonJS({
             await hook();
           }
         });
-        if (this.pfs.wal && this.dirtyPages.size > 0) {
-          await this.pfs.wal.prepareCommit(this.dirtyPages);
-          await this.pfs.wal.writeCommitMarker();
-        }
-        for (const [pageId, data] of this.dirtyPages) {
-          await this.pageStrategy.write(pageId, data);
-        }
-        if (this.pfs.wal) {
-          this.pfs.wal.incrementWrittenPages(this.dirtyPages.size);
-          if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
-            await this.pfs.wal.clear();
+        let shouldTriggerCheckpoint = false;
+        await this.pfs.runGlobalLock(async () => {
+          if (this.pfs.wal && this.dirtyPages.size > 0) {
+            await this.pfs.wal.prepareCommit(this.dirtyPages);
+            await this.pfs.wal.writeCommitMarker();
           }
+          for (const [pageId, data] of this.dirtyPages) {
+            await this.pageStrategy.write(pageId, data);
+          }
+          if (this.pfs.wal) {
+            this.pfs.wal.incrementWrittenPages(this.dirtyPages.size);
+            if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
+              shouldTriggerCheckpoint = true;
+            }
+          }
+        });
+        if (shouldTriggerCheckpoint) {
+          await this.pfs.checkpoint();
         }
         this.dirtyPages.clear();
         this.undoPages.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.4-alpha.3",
+  "version": "0.0.4-alpha.4",
   "description": "Simple and powerful JSON document database supporting complex queries and flexible indexing policies.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -42,7 +42,7 @@
     "dataply"
   ],
   "dependencies": {
-    "dataply": "^0.0.20-alpha.2"
+    "dataply": "^0.0.20-alpha.4"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",