dataply 0.0.20-alpha.2 → 0.0.20-alpha.4

package/dist/cjs/index.js

@@ -7427,9 +7427,6 @@ var WALManager = class {
       promises.push(writePage(pageId, data));
     }
     await Promise.all(promises);
-    if (restoredPages.size > 0) {
-      await this.clear();
-    }
   }
   /**
    * WAL에 페이지 데이터를 기록합니다 (Phase 1: Prepare).
@@ -7590,6 +7587,8 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
   }
   /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
   cache;
+  /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
+  dirtyPages = /* @__PURE__ */ new Map();
   /** 파일 크기 (논리적) */
   fileSize;
   /**
@@ -7599,6 +7598,12 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
    * @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);
@@ -7626,21 +7631,50 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
     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);
   }
   /**
@@ -7649,6 +7683,9 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
    * @returns 존재하면 true
    */
   async exists(pageId) {
+    if (this.dirtyPages.has(pageId)) {
+      return true;
+    }
     const pageStartPos = pageId * this.pageSize;
     return pageStartPos < this.fileSize;
   }
@@ -7705,6 +7742,25 @@ var PageFileSystem = class {
   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.
@@ -7714,6 +7770,7 @@ var PageFileSystem = class {
       await this.walManager.recover(async (pageId, data) => {
         await this.pageStrategy.write(pageId, data);
       });
+      await this.checkpoint();
     }
   }
   /**
@@ -8013,15 +8070,30 @@ var PageFileSystem = class {
   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();
     }
   }
@@ -8847,18 +8919,24 @@ var Transaction = class {
         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/dist/types/core/PageFileSystem.d.ts

@@ -16,11 +16,18 @@ export declare class PageFileSystem {
     protected readonly walManager: WALManager | null;
     protected readonly pageManagerFactory: PageManagerFactory;
     protected readonly pageStrategy: PageMVCCStrategy;
+    /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
+    private lockPromise;
     /**
      * @param pageCacheCapacity 페이지 캐시 크기
      * @param options 데이터플라이 옵션
      */
     constructor(fileHandle: number, pageSize: number, pageCacheCapacity: number, options: Required<DataplyOptions>);
+    /**
+     * 글로벌 동기화 범위 내에서 작업을 실행합니다.
+     * @param task 수행할 비동기 작업
+     */
+    runGlobalLock<T>(task: () => Promise<T>): Promise<T>;
     /**
      * Initializes the page file system.
      * Performs WAL recovery if necessary.
@@ -130,6 +137,13 @@ export declare class PageFileSystem {
      * @param dirtyPages 변경된 페이지들
      */
     commitToWAL(dirtyPages: Map<number, Uint8Array>): Promise<void>;
+    /**
+     * 체크포인트를 수행합니다.
+     * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
+     * 2. DB 파일 물리적 동기화 (Sync/fsync)
+     * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+     */
+    checkpoint(): Promise<void>;
     /**
      * Closes the page file system.
      */

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

@@ -11,6 +11,8 @@ export declare class PageMVCCStrategy extends AsyncMVCCStrategy<number, Uint8Arr
     private readonly pageSize;
     /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
     private readonly cache;
+    /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
+    private readonly dirtyPages;
     /** 파일 크기 (논리적) */
     private fileSize;
     constructor(fileHandle: number, pageSize: number, cacheCapacity: number);
@@ -27,6 +29,15 @@ export declare class PageMVCCStrategy extends AsyncMVCCStrategy<number, Uint8Arr
      * @param data 페이지 데이터
      */
     write(pageId: number, data: Uint8Array): Promise<void>;
+    /**
+     * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
+     * WAL 체크포인트 시점에 호출되어야 합니다.
+     */
+    flush(): Promise<void>;
+    /**
+     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
+     */
+    sync(): Promise<void>;
     /**
      * 페이지 삭제 (실제로는 캐시에서만 제거)
      * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.20-alpha.2",
+  "version": "0.0.20-alpha.4",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",