dataply 0.0.26-alpha.0 → 0.0.26-alpha.2

package/dist/cjs/index.js

@@ -1954,30 +1954,22 @@ var BPTreeTransaction = class _BPTreeTransaction {
    */
   _insertValueIntoLeaf(leaf, key, value) {
     if (leaf.values.length) {
-      for (let i = 0, len = leaf.values.length; i < len; i++) {
-        const nValue = leaf.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          if (leaf.keys[i].includes(key)) {
-            return false;
-          }
-          leaf.keys[i].push(key);
-          return true;
-        } else if (this.comparator.isLower(value, nValue)) {
-          leaf.values.splice(i, 0, value);
-          leaf.keys.splice(i, 0, [key]);
-          return true;
-        } else if (i + 1 === leaf.values.length) {
-          leaf.values.push(value);
-          leaf.keys.push([key]);
-          return true;
+      const { index, found } = this._binarySearchValues(leaf.values, value);
+      if (found) {
+        if (leaf.keys[index].includes(key)) {
+          return false;
         }
+        leaf.keys[index].push(key);
+        return true;
       }
+      leaf.values.splice(index, 0, value);
+      leaf.keys.splice(index, 0, [key]);
+      return true;
     } else {
       leaf.values = [value];
       leaf.keys = [[key]];
       return true;
     }
-    return false;
   }
   _cloneNode(node) {
     return JSON.parse(JSON.stringify(node));
@@ -2268,12 +2260,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
-      for (const k of parentNode.keys) {
-        const n = this._cloneNode(this.getNode(k));
-        n.parent = parentNode.id;
-        this._updateNode(n);
-      }
-      for (const k of newSiblingNodeRecursive.keys) {
+      for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+        const k = newSiblingNodeRecursive.keys[i];
         const n = this._cloneNode(this.getNode(k));
         n.parent = newSiblingNodeRecursive.id;
         this._updateNode(n);
@@ -2355,7 +2343,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
             yield [keys[j], nValue];
           }
         }
@@ -2434,7 +2422,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     while (true) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const keys = node.keys[i];
-        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+        for (let j = 0, len2 = keys.length; j < len2; j++) {
           if (keys[j] === key) {
             return node.values[i];
           }
@@ -2543,8 +2531,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
     let currentLeaf = null;
     let modified = false;
-    for (const [key, value] of sorted) {
-      const targetLeaf = this.locateLeaf(value);
+    let cachedLeafId = null;
+    let cachedLeafMaxValue = null;
+    for (let i = 0, len = sorted.length; i < len; i++) {
+      const [key, value] = sorted[i];
+      let targetLeaf;
+      if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+        targetLeaf = currentLeaf;
+      } else {
+        targetLeaf = this.locateLeaf(value);
+      }
       if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
       } else {
         if (currentLeaf !== null && modified) {
@@ -2553,8 +2549,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         currentLeaf = this._cloneNode(targetLeaf);
         modified = false;
       }
+      cachedLeafId = currentLeaf.id;
       const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
       modified = modified || changed;
+      cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
       if (currentLeaf.values.length === this.order) {
         this._updateNode(currentLeaf);
         let after = this._createNode(
@@ -2575,6 +2573,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         this._updateNode(after);
         this._insertInParent(currentLeaf, after.values[0], after);
         currentLeaf = null;
+        cachedLeafId = null;
+        cachedLeafMaxValue = null;
         modified = false;
       }
     }
@@ -2582,6 +2582,85 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._updateNode(currentLeaf);
     }
   }
+  bulkLoad(entries) {
+    if (entries.length === 0) return;
+    const root = this.getNode(this.rootId);
+    if (!root.leaf || root.values.length > 0) {
+      throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+    }
+    const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+    const grouped = [];
+    for (let i = 0, len = sorted.length; i < len; i++) {
+      const [key, value] = sorted[i];
+      const last = grouped[grouped.length - 1];
+      if (last && this.comparator.isSame(last.value, value)) {
+        if (!last.keys.includes(key)) {
+          last.keys.push(key);
+        }
+      } else {
+        grouped.push({ keys: [key], value });
+      }
+    }
+    this._deleteNode(root);
+    const maxLeafSize = this.order - 1;
+    const leaves = [];
+    for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+      const chunk = grouped.slice(i, i + maxLeafSize);
+      const leafKeys = chunk.map((g) => g.keys);
+      const leafValues = chunk.map((g) => g.value);
+      const leaf = this._createNode(
+        true,
+        leafKeys,
+        leafValues,
+        null,
+        null,
+        null
+      );
+      leaves.push(leaf);
+    }
+    for (let i = 0, len = leaves.length; i < len; i++) {
+      if (i > 0) {
+        leaves[i].prev = leaves[i - 1].id;
+      }
+      if (i < len - 1) {
+        leaves[i].next = leaves[i + 1].id;
+      }
+      this._updateNode(leaves[i]);
+    }
+    let currentLevel = leaves;
+    while (currentLevel.length > 1) {
+      const nextLevel = [];
+      for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+        const children = currentLevel.slice(i, i + this.order);
+        const childIds = children.map((c) => c.id);
+        const separators = [];
+        for (let j = 1, len2 = children.length; j < len2; j++) {
+          separators.push(children[j].values[0]);
+        }
+        const internalNode = this._createNode(
+          false,
+          childIds,
+          separators,
+          null,
+          null,
+          null
+        );
+        for (let j = 0, len2 = children.length; j < len2; j++) {
+          const child = children[j];
+          child.parent = internalNode.id;
+          this._updateNode(child);
+        }
+        nextLevel.push(internalNode);
+      }
+      currentLevel = nextLevel;
+    }
+    const newRoot = currentLevel[0];
+    this._writeHead({
+      root: newRoot.id,
+      order: this.order,
+      data: this.strategy.head.data
+    });
+  }
   _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -2685,7 +2764,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         siblingNode.values.push(...node.values);
         if (!siblingNode.leaf) {
           const keys = siblingNode.keys;
-          for (const key2 of keys) {
+          for (let i = 0, len = keys.length; i < len; i++) {
+            const key2 = keys[i];
             const node2 = this._cloneNode(this.getNode(key2));
             node2.parent = siblingNode.id;
             this._updateNode(node2);
@@ -2753,21 +2833,24 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
           this._updateNode(siblingNode);
         }
         if (!siblingNode.leaf) {
-          for (const key2 of siblingNode.keys) {
+          for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+            const key2 = siblingNode.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = siblingNode.id;
             this._updateNode(n);
           }
         }
         if (!node.leaf) {
-          for (const key2 of node.keys) {
+          for (let i = 0, len = node.keys.length; i < len; i++) {
+            const key2 = node.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = node.id;
             this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
-          for (const key2 of parentNode.keys) {
+          for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+            const key2 = parentNode.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = parentNode.id;
             this._updateNode(n);
@@ -2941,6 +3024,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  bulkLoad(entries) {
+    const tx = this.createTransaction();
+    tx.bulkLoad(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
 };
 var Ryoiki2 = class _Ryoiki2 {
   readings;
@@ -3354,12 +3445,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
-      for (const k of parentNode.keys) {
-        const n = this._cloneNode(await this.getNode(k));
-        n.parent = parentNode.id;
-        await this._updateNode(n);
-      }
-      for (const k of newSiblingNodeRecursive.keys) {
+      for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+        const k = newSiblingNodeRecursive.keys[i];
         const n = this._cloneNode(await this.getNode(k));
         n.parent = newSiblingNodeRecursive.id;
         await this._updateNode(n);
@@ -3451,7 +3538,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
             yield [keys[j], nValue];
           }
         }
@@ -3529,7 +3616,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     while (true) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const keys = node.keys[i];
-        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+        for (let j = 0, len2 = keys.length; j < len2; j++) {
           if (keys[j] === key) {
             return node.values[i];
           }
@@ -3641,8 +3728,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
       let currentLeaf = null;
       let modified = false;
-      for (const [key, value] of sorted) {
-        const targetLeaf = await this.locateLeaf(value);
+      let cachedLeafId = null;
+      let cachedLeafMaxValue = null;
+      for (let i = 0, len = sorted.length; i < len; i++) {
+        const [key, value] = sorted[i];
+        let targetLeaf;
+        if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+          targetLeaf = currentLeaf;
+        } else {
+          targetLeaf = await this.locateLeaf(value);
+        }
         if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
         } else {
           if (currentLeaf !== null && modified) {
@@ -3651,8 +3746,10 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           currentLeaf = this._cloneNode(targetLeaf);
           modified = false;
         }
+        cachedLeafId = currentLeaf.id;
         const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
         modified = modified || changed;
+        cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
         if (currentLeaf.values.length === this.order) {
           await this._updateNode(currentLeaf);
           let after = await this._createNode(
@@ -3673,6 +3770,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           await this._updateNode(after);
           await this._insertInParent(currentLeaf, after.values[0], after);
           currentLeaf = null;
+          cachedLeafId = null;
+          cachedLeafMaxValue = null;
           modified = false;
         }
       }
@@ -3681,6 +3780,87 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     });
   }
+  async bulkLoad(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      const root = await this.getNode(this.rootId);
+      if (!root.leaf || root.values.length > 0) {
+        throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+      }
+      const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+      const grouped = [];
+      for (let i = 0, len = sorted.length; i < len; i++) {
+        const [key, value] = sorted[i];
+        const last = grouped[grouped.length - 1];
+        if (last && this.comparator.isSame(last.value, value)) {
+          if (!last.keys.includes(key)) {
+            last.keys.push(key);
+          }
+        } else {
+          grouped.push({ keys: [key], value });
+        }
+      }
+      await this._deleteNode(root);
+      const maxLeafSize = this.order - 1;
+      const leaves = [];
+      for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+        const chunk = grouped.slice(i, i + maxLeafSize);
+        const leafKeys = chunk.map((g) => g.keys);
+        const leafValues = chunk.map((g) => g.value);
+        const leaf = await this._createNode(
+          true,
+          leafKeys,
+          leafValues,
+          null,
+          null,
+          null
+        );
+        leaves.push(leaf);
+      }
+      for (let i = 0, len = leaves.length; i < len; i++) {
+        if (i > 0) {
+          leaves[i].prev = leaves[i - 1].id;
+        }
+        if (i < len - 1) {
+          leaves[i].next = leaves[i + 1].id;
+        }
+        await this._updateNode(leaves[i]);
+      }
+      let currentLevel = leaves;
+      while (currentLevel.length > 1) {
+        const nextLevel = [];
+        for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+          const children = currentLevel.slice(i, i + this.order);
+          const childIds = children.map((c) => c.id);
+          const separators = [];
+          for (let j = 1, len2 = children.length; j < len2; j++) {
+            separators.push(children[j].values[0]);
+          }
+          const internalNode = await this._createNode(
+            false,
+            childIds,
+            separators,
+            null,
+            null,
+            null
+          );
+          for (let j = 0, len2 = children.length; j < len2; j++) {
+            const child = children[j];
+            child.parent = internalNode.id;
+            await this._updateNode(child);
+          }
+          nextLevel.push(internalNode);
+        }
+        currentLevel = nextLevel;
+      }
+      const newRoot = currentLevel[0];
+      await this._writeHead({
+        root: newRoot.id,
+        order: this.order,
+        data: this.strategy.head.data
+      });
+    });
+  }
   async _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -3784,7 +3964,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         siblingNode.values.push(...node.values);
         if (!siblingNode.leaf) {
           const keys = siblingNode.keys;
-          for (const key2 of keys) {
+          for (let i = 0, len = keys.length; i < len; i++) {
+            const key2 = keys[i];
             const node2 = this._cloneNode(await this.getNode(key2));
             node2.parent = siblingNode.id;
             await this._updateNode(node2);
@@ -3852,21 +4033,24 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           await this._updateNode(siblingNode);
         }
         if (!siblingNode.leaf) {
-          for (const key2 of siblingNode.keys) {
+          for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+            const key2 = siblingNode.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = siblingNode.id;
             await this._updateNode(n);
           }
         }
         if (!node.leaf) {
-          for (const key2 of node.keys) {
+          for (let i = 0, len = node.keys.length; i < len; i++) {
+            const key2 = node.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = node.id;
             await this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
-          for (const key2 of parentNode.keys) {
+          for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+            const key2 = parentNode.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = parentNode.id;
             await this._updateNode(n);
@@ -4048,6 +4232,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async bulkLoad(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.bulkLoad(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
 };
 var SerializeStrategy = class {
   order;
@@ -8053,6 +8247,14 @@ var HookallSync = class _HookallSync {
 // src/core/WALManager.ts
 var import_node_fs = __toESM(require("node:fs"));
 var WALManager = class {
+  fd = null;
+  walFilePath;
+  pageSize;
+  entrySize;
+  buffer;
+  view;
+  totalWrittenPages = 0;
+  logger;
   /**
    * Constructor
    * @param walFilePath WAL file path
@@ -8060,7 +8262,6 @@ var WALManager = class {
    * @param logger Logger instance
    */
   constructor(walFilePath, pageSize, logger) {
-    this.logger = logger;
     if ((pageSize & pageSize - 1) !== 0) {
       throw new Error("Page size must be a power of 2");
     }
@@ -8069,14 +8270,8 @@ var WALManager = class {
     this.entrySize = 4 + pageSize;
     this.buffer = new Uint8Array(this.entrySize);
     this.view = new DataView(this.buffer.buffer);
+    this.logger = logger;
   }
-  fd = null;
-  walFilePath;
-  pageSize;
-  entrySize;
-  buffer;
-  view;
-  totalWrittenPages = 0;
   /**
    * Opens the log file.
    */
@@ -8424,21 +8619,22 @@ var PageFileSystem = class {
    * @param pageCacheCapacity 페이지 캐시 크기
    * @param options 데이터플라이 옵션
    */
-  constructor(fileHandle, pageSize, pageCacheCapacity, options, logger) {
+  constructor(fileHandle, pageSize, pageCacheCapacity, options, logger, walLogger) {
     this.fileHandle = fileHandle;
     this.pageSize = pageSize;
     this.pageCacheCapacity = pageCacheCapacity;
     this.options = options;
-    this.logger = logger;
     const walPath = options.wal;
-    this.walManager = walPath ? new WALManager(walPath, pageSize, this.logger) : null;
+    this.walManager = walPath && walLogger ? new WALManager(walPath, pageSize, walLogger) : null;
     this.pageManagerFactory = new PageManagerFactory();
     this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize, pageCacheCapacity);
+    this.logger = logger;
   }
   pageFactory = new PageManagerFactory();
   walManager;
   pageManagerFactory;
   pageStrategy;
+  logger;
   /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
   lockPromise = Promise.resolve();
   /**
@@ -9052,13 +9248,13 @@ var RowTableEngine = class {
     this.pfs = pfs;
     this.txContext = txContext;
     this.options = options;
-    this.logger = logger;
     this.factory = new PageManagerFactory();
     this.metadataPageManager = this.factory.getManagerFromType(MetadataPageManager.CONSTANT.PAGE_TYPE_METADATA);
     this.dataPageManager = this.factory.getManagerFromType(DataPageManager.CONSTANT.PAGE_TYPE_DATA);
     this.overflowPageManager = this.factory.getManagerFromType(OverflowPageManager.CONSTANT.PAGE_TYPE_OVERFLOW);
     this.rowManager = new Row();
     this.keyManager = new KeyManager();
+    this.logger = logger;
     this.ridBuffer = new Uint8Array(Row.CONSTANT.SIZE_RID);
     this.pageIdBuffer = new Uint8Array(DataPageManager.CONSTANT.SIZE_PAGE_ID);
     this.maxBodySize = this.pfs.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER;
@@ -9087,6 +9283,7 @@ var RowTableEngine = class {
   maxBodySize;
   ridBuffer;
   pageIdBuffer;
+  logger;
   initialized = false;
   /**
    * Retrieves the BPTree transaction associated with the given transaction.
@@ -9860,12 +10057,11 @@ var Colors = {
   white: "\x1B[37m",
   // White
   grey: "\x1B[90m"
+  // Grey
 };
-var Logger = class {
+var LoggerManager = class {
   level;
-  moduleName;
-  constructor(moduleName, level = 2 /* Info */) {
-    this.moduleName = moduleName;
+  constructor(level = 2 /* Info */) {
     this.level = level;
   }
   setLevel(level) {
@@ -9875,23 +10071,32 @@ var Logger = class {
     if (this.level === 0 /* None */) return false;
     return level >= this.level;
   }
+  create(moduleName) {
+    return new Logger(this, moduleName);
+  }
+};
+var Logger = class {
+  constructor(parent, moduleName) {
+    this.parent = parent;
+    this.moduleName = moduleName;
+  }
   debug(message, ...args) {
-    if (this.shouldLog(1 /* Debug */)) {
+    if (this.parent.shouldLog(1 /* Debug */)) {
       console.debug(`${Colors.debug}[DEBUG] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
     }
   }
   info(message, ...args) {
-    if (this.shouldLog(2 /* Info */)) {
+    if (this.parent.shouldLog(2 /* Info */)) {
       console.info(`${Colors.info}[INFO] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
     }
   }
   warn(message, ...args) {
-    if (this.shouldLog(3 /* Warning */)) {
+    if (this.parent.shouldLog(3 /* Warning */)) {
       console.warn(`${Colors.warn}[WARN] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
     }
   }
   error(message, ...args) {
-    if (this.shouldLog(4 /* Error */)) {
+    if (this.parent.shouldLog(4 /* Error */)) {
       console.error(`${Colors.error}[ERROR] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
     }
   }
@@ -9903,7 +10108,8 @@ var DataplyAPI = class {
     this.file = file;
     this.hook = useHookall(this);
     this.options = this.verboseOptions(options);
-    this.logger = new Logger("DataplyAPI", this.options.logLevel);
+    this.loggerManager = new LoggerManager(this.options.logLevel);
+    this.logger = this.loggerManager.create("DataplyAPI");
     this.isNewlyCreated = !import_node_fs3.default.existsSync(file);
     this.fileHandle = this.createOrOpen(file, this.options);
     this.pfs = new PageFileSystem(
@@ -9911,12 +10117,13 @@ var DataplyAPI = class {
       this.options.pageSize,
       this.options.pageCacheCapacity,
       this.options,
-      this.logger
+      this.loggerManager.create("PageFileSystem"),
+      options.wal ? this.loggerManager.create("WALManager") : void 0
     );
     this.textCodec = new TextCodec();
     this.txContext = new TransactionContext();
     this.lockManager = new LockManager();
-    this.rowTableEngine = new RowTableEngine(this.pfs, this.txContext, this.options, this.logger);
+    this.rowTableEngine = new RowTableEngine(this.pfs, this.txContext, this.options, this.loggerManager.create("RowTableEngine"));
     this.initialized = false;
     this.txIdCounter = 0;
     this.logger.debug(`DataplyAPI instance created with file: ${file}`);
@@ -9941,7 +10148,9 @@ var DataplyAPI = class {
   txContext;
   /** Hook */
   hook;
-  /** Logger */
+  /** Base Logger */
+  loggerManager;
+  /** Logger module for DataplyAPI */
   logger;
   /** Whether the database was initialized via `init()` */
   initialized;

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

@@ -6,7 +6,7 @@ import { TextCodec } from '../utils/TextCodec';
 import { LockManager } from './transaction/LockManager';
 import { Transaction } from './transaction/Transaction';
 import { TransactionContext } from './transaction/TxContext';
-import { Logger } from './Logger';
+import { LoggerManager, Logger } from './Logger';
 interface DataplyAPIAsyncHook {
     init: (tx: Transaction, isNewlyCreated: boolean) => Promise<Transaction>;
     close: () => Promise<void>;
@@ -36,7 +36,9 @@ export declare class DataplyAPI {
     protected readonly txContext: TransactionContext;
     /** Hook */
     protected readonly hook: IHookall<DataplyAPIAsyncHook>;
-    /** Logger */
+    /** Base Logger */
+    protected readonly loggerManager: LoggerManager;
+    /** Logger module for DataplyAPI */
     protected readonly logger: Logger;
     /** Whether the database was initialized via `init()` */
     protected initialized: boolean;

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

@@ -1,10 +1,15 @@
 import { LogLevel } from '../types';
-export declare class Logger {
+export declare class LoggerManager {
     private level;
-    private moduleName;
-    constructor(moduleName: string, level?: LogLevel);
+    constructor(level?: LogLevel);
     setLevel(level: LogLevel): void;
-    private shouldLog;
+    shouldLog(level: LogLevel): boolean;
+    create(moduleName: string): Logger;
+}
+export declare class Logger {
+    private readonly parent;
+    private readonly moduleName;
+    constructor(parent: LoggerManager, moduleName: string);
     debug(message: string, ...args: any[]): void;
     info(message: string, ...args: any[]): void;
     warn(message: string, ...args: any[]): void;

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

@@ -13,18 +13,18 @@ export declare class PageFileSystem {
     readonly pageSize: number;
     readonly pageCacheCapacity: number;
     readonly options: Required<DataplyOptions>;
-    protected readonly logger: Logger;
     protected readonly pageFactory: PageManagerFactory;
     protected readonly walManager: WALManager | null;
     protected readonly pageManagerFactory: PageManagerFactory;
     protected readonly pageStrategy: PageMVCCStrategy;
+    protected readonly logger: Logger;
     /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
     private lockPromise;
     /**
      * @param pageCacheCapacity 페이지 캐시 크기
      * @param options 데이터플라이 옵션
      */
-    constructor(fileHandle: number, pageSize: number, pageCacheCapacity: number, options: Required<DataplyOptions>, logger: Logger);
+    constructor(fileHandle: number, pageSize: number, pageCacheCapacity: number, options: Required<DataplyOptions>, logger: Logger, walLogger?: Logger);
     /**
      * 글로벌 동기화 범위 내에서 작업을 실행합니다.
      * @param task 수행할 비동기 작업

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

@@ -12,7 +12,6 @@ export declare class RowTableEngine {
     protected readonly pfs: PageFileSystem;
     protected readonly txContext: TransactionContext;
     protected readonly options: Required<DataplyOptions>;
-    protected readonly logger: Logger;
     protected readonly bptree: BPTreeAsync<number, number>;
     protected readonly strategy: RowIdentifierStrategy;
     protected readonly order: number;
@@ -25,6 +24,7 @@ export declare class RowTableEngine {
     protected readonly maxBodySize: number;
     private readonly ridBuffer;
     private readonly pageIdBuffer;
+    private readonly logger;
     private initialized;
     constructor(pfs: PageFileSystem, txContext: TransactionContext, options: Required<DataplyOptions>, logger: Logger);
     /**

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

@@ -5,7 +5,6 @@ import { Logger } from './Logger';
  * Handles commit phases and crash recovery.
  */
 export declare class WALManager {
-    private readonly logger;
     private fd;
     private readonly walFilePath;
     private readonly pageSize;
@@ -13,6 +12,7 @@ export declare class WALManager {
     private buffer;
     private view;
     private totalWrittenPages;
+    private readonly logger;
     /**
      * Constructor
      * @param walFilePath WAL file path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.26-alpha.0",
+  "version": "0.0.26-alpha.2",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -49,6 +49,6 @@
     "hookall": "^2.2.0",
     "mvcc-api": "^1.3.5",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^8.3.5"
+    "serializable-bptree": "^8.4.0"
   }
-}
+}