@milaboratories/pframes-rs-node 1.1.3 → 1.1.5

package/export/wrapper.ts

@@ -1,4 +1,4 @@
-import { ulid } from 'ulid';
+import { ulid } from "ulid";
 import {
   AbortError,
   type PColumnInfo,
@@ -14,14 +14,14 @@ import {
   type TableRange,
   type UniqueValuesRequest,
   type UniqueValuesResponse,
-  type QueryData,
+  type DataQuery,
   ensureError,
-  isAbortError
-} from '@milaboratories/pl-model-common';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import { PerfTimer } from '@milaboratories/helpers';
-import type { NodeFrameSymbol, NodeTableSymbol } from './addon-def';
-import { AddonSymbol } from './addon';
+  isAbortError,
+} from "@milaboratories/pl-model-common";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { PerfTimer } from "@milaboratories/helpers";
+import type { NodeFrameSymbol, NodeTableSymbol } from "./addon-def";
+import { AddonSymbol } from "./addon";
 import {
   dump,
   hashColumnId,
@@ -29,8 +29,8 @@ import {
   hashFilterColumnId,
   hashUniqueValuesRequestColumnId,
   hashSortingColumnId,
-  hashCreateTableRequestColumnId
-} from './dump';
+  hashCreateTableRequestColumnId,
+} from "./dump";
 
 export async function pprofDump(): Promise<Uint8Array> {
   try {
@@ -61,21 +61,21 @@ export class PFrame implements PFrameInternal.PFrameV13 {
       [`${this.id}`, `${this.id}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'create'
+        requestType: "create",
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
       this.#frame = AddonSymbol.pFrameCreate(options.spillPath, options.logger);
-      this.#logger('info', `PFrame ${this.id} created`);
+      this.#logger("info", `PFrame ${this.id} created`);
     } catch (err: unknown) {
       const error = new PFrameError(`PFrame creation failed`);
       error.cause = new Error(
         `PFrame ${this.id} creation failed, ` +
           `logger: ${this.#logger?.toString()}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -87,21 +87,21 @@ export class PFrame implements PFrameInternal.PFrameV13 {
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'addColumnSpec',
+        requestType: "addColumnSpec",
         requestData: {
           columnId: hashColumnId(columnId),
-          columnSpec
-        }
+          columnSpec,
+        },
       },
-      this.#logger
+      this.#logger,
     );
 
     dump(
       [`${this.id}`, `data`, `${hashColumnId(columnId)}.spec`],
       {
-        ...columnSpec
+        ...columnSpec,
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
@@ -113,7 +113,7 @@ export class PFrame implements PFrameInternal.PFrameV13 {
           `columnId: ${JSON.stringify(columnId)}, ` +
           `columnSpec: ${JSON.stringify(columnSpec)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -125,65 +125,61 @@ export class PFrame implements PFrameInternal.PFrameV13 {
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'setDataSource'
+        requestType: "setDataSource",
       },
-      this.#logger
+      this.#logger,
     );
 
     const wrappedDataSource = {
-      preloadBlob: async (
-        blobIds: PFrameInternal.PFrameBlobId[]
-      ): Promise<void> => {
+      preloadBlob: async (blobIds: PFrameInternal.PFrameBlobId[]): Promise<void> => {
         const requestId = ulid();
         dump(
           [`${this.id}`, `${requestId}.json`],
           {
             timeStamp: Date.now(),
-            requestType: 'preloadBlob',
+            requestType: "preloadBlob",
             requestData: {
-              blobIds
-            }
+              blobIds,
+            },
           },
-          this.#logger
+          this.#logger,
         );
 
         this.#logger(
-          'info',
-          `PFrame ${this.id} preloadBlob started, blobIds: ${JSON.stringify(blobIds)}`
+          "info",
+          `PFrame ${this.id} preloadBlob started, blobIds: ${JSON.stringify(blobIds)}`,
         );
         const timer = PerfTimer.start();
         try {
           return await dataSource.preloadBlob(blobIds);
         } finally {
           this.#logger(
-            'info',
-            `PFrame ${this.id} preloadBlob finished, took ${timer.elapsed()} (${blobIds.length} blobs)`
+            "info",
+            `PFrame ${this.id} preloadBlob finished, took ${timer.elapsed()} (${blobIds.length} blobs)`,
           );
         }
       },
-      resolveBlobContent: async (
-        blobId: PFrameInternal.PFrameBlobId
-      ): Promise<Uint8Array> => {
+      resolveBlobContent: async (blobId: PFrameInternal.PFrameBlobId): Promise<Uint8Array> => {
         const requestId = ulid();
         dump(
           [`${this.id}`, `${requestId}.json`],
           {
             timeStamp: Date.now(),
-            requestType: 'resolveBlobContent',
+            requestType: "resolveBlobContent",
             requestData: {
-              blobId
-            }
+              blobId,
+            },
           },
-          this.#logger
+          this.#logger,
         );
 
         const blob = await dataSource.resolveBlobContent(blobId);
-        this.#logger('info', `PFrame ${this.id} resolved blob ${blobId}`);
+        this.#logger("info", `PFrame ${this.id} resolved blob ${blobId}`);
         dump([`${this.id}`, `data`, `${blobId}`], blob, this.#logger);
 
         return blob;
       },
-      parquetServer: dataSource.parquetServer
+      parquetServer: dataSource.parquetServer,
     };
 
     try {
@@ -194,7 +190,7 @@ export class PFrame implements PFrameInternal.PFrameV13 {
         `PFrame ${this.id} setDataSource request ${requestId} failed, ` +
           `dataSource: ${dataSource.toString()}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -205,38 +201,33 @@ export class PFrame implements PFrameInternal.PFrameV13 {
     dataInfo: PFrameInternal.DataInfo<PFrameInternal.PFrameBlobId>,
     ops?: {
       signal?: AbortSignal;
-    }
+    },
   ): Promise<void> {
     const requestId = ulid();
     dump(
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'setColumnData',
+        requestType: "setColumnData",
         requestData: {
           columnId: hashColumnId(columnId),
-          dataInfo
-        }
+          dataInfo,
+        },
       },
-      this.#logger
+      this.#logger,
     );
 
     dump(
       [`${this.id}`, `data`, `${hashColumnId(columnId)}.datainfo`],
       {
-        ...dataInfo
+        ...dataInfo,
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
       ops?.signal?.throwIfAborted();
-      return AddonSymbol.pFrameSetColumnData(
-        this.#frame,
-        columnId,
-        dataInfo,
-        ops?.signal
-      );
+      return AddonSymbol.pFrameSetColumnData(this.#frame, columnId, dataInfo, ops?.signal);
     } catch (err: unknown) {
       const error = new PFrameError(`PFrame setColumnData request failed`);
       error.cause = new Error(
@@ -244,7 +235,7 @@ export class PFrame implements PFrameInternal.PFrameV13 {
           `columnId: ${JSON.stringify(columnId)}, ` +
           `dataInfo: ${JSON.stringify(dataInfo)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -256,20 +247,20 @@ export class PFrame implements PFrameInternal.PFrameV13 {
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'dispose'
+        requestType: "dispose",
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
       AddonSymbol.pFrameDispose(this.#frame);
-      this.#logger('info', `PFrame ${this.id} disposed`);
+      this.#logger("info", `PFrame ${this.id} disposed`);
     } catch (err: unknown) {
       const error = new PFrameError(`PFrame dispose request failed`);
       error.cause = new Error(
         `PFrame ${this.id} dispose request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -280,17 +271,17 @@ export class PFrame implements PFrameInternal.PFrameV13 {
   }
 
   async findColumns(
-    request: PFrameInternal.FindColumnsRequest
+    request: PFrameInternal.FindColumnsRequest,
   ): Promise<PFrameInternal.FindColumnsResponse> {
     const requestId = ulid();
     dump(
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'findColumns',
-        requestData: request
+        requestType: "findColumns",
+        requestData: request,
       },
-      this.#logger
+      this.#logger,
     );
 
     const timer = PerfTimer.start();
@@ -302,29 +293,29 @@ export class PFrame implements PFrameInternal.PFrameV13 {
         `PFrame ${this.id} findColumns request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
       this.#logger(
-        'info',
-        `PFrame ${this.id} findColumns request ${requestId} took ${timer.elapsed()}`
+        "info",
+        `PFrame ${this.id} findColumns request ${requestId} took ${timer.elapsed()}`,
       );
     }
   }
 
   async deleteColumn(
-    request: PFrameInternal.DeleteColumnFromColumnsRequest
+    request: PFrameInternal.DeleteColumnFromColumnsRequest,
   ): Promise<PFrameInternal.DeleteColumnFromColumnsResponse> {
     const requestId = ulid();
     dump(
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'deleteColumn',
-        requestData: request
+        requestType: "deleteColumn",
+        requestData: request,
       },
-      this.#logger
+      this.#logger,
     );
 
     const timer = PerfTimer.start();
@@ -336,13 +327,13 @@ export class PFrame implements PFrameInternal.PFrameV13 {
         `PFrame ${this.id} deleteColumn request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
       this.#logger(
-        'info',
-        `PFrame ${this.id} deleteColumn request ${requestId} took ${timer.elapsed()}`
+        "info",
+        `PFrame ${this.id} deleteColumn request ${requestId} took ${timer.elapsed()}`,
       );
     }
   }
@@ -353,12 +344,12 @@ export class PFrame implements PFrameInternal.PFrameV13 {
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'getColumnSpec',
+        requestType: "getColumnSpec",
         requestData: {
-          columnId: hashColumnId(columnId)
-        }
+          columnId: hashColumnId(columnId),
+        },
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
@@ -369,7 +360,7 @@ export class PFrame implements PFrameInternal.PFrameV13 {
         `PFrame ${this.id} getColumnSpec request ${requestId} failed, ` +
           `columnId: ${JSON.stringify(columnId)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -381,9 +372,9 @@ export class PFrame implements PFrameInternal.PFrameV13 {
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'listColumns'
+        requestType: "listColumns",
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
@@ -393,7 +384,7 @@ export class PFrame implements PFrameInternal.PFrameV13 {
       error.cause = new Error(
         `PFrame ${this.id} listColumns request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -401,27 +392,19 @@ export class PFrame implements PFrameInternal.PFrameV13 {
 
   createTable(
     requestId: PFrameInternal.PTableId,
-    request: PFrameInternal.CreateTableRequestV4
+    request: PFrameInternal.CreateTableRequestV4,
   ): PTable {
     const dumpData = {
       timeStamp: Date.now(),
-      requestType: 'createTable',
-      requestData: hashCreateTableRequestColumnId(request)
+      requestType: "createTable",
+      requestData: hashCreateTableRequestColumnId(request),
     };
     dump([`${this.id}`, `${requestId}.json`], dumpData, this.#logger);
-    dump(
-      [`${this.id}`, `${requestId}`, `${requestId}.json`],
-      dumpData,
-      this.#logger
-    );
+    dump([`${this.id}`, `${requestId}`, `${requestId}.json`], dumpData, this.#logger);
 
     const timer = PerfTimer.start();
     try {
-      const boxed = AddonSymbol.pFrameCreateTable(
-        this.#frame,
-        requestId,
-        request
-      );
+      const boxed = AddonSymbol.pFrameCreateTable(this.#frame, requestId, request);
       return new PTable(this, requestId, boxed, this.#logger);
     } catch (err: unknown) {
       const error = new PFrameError(`PFrame createTable request failed`);
@@ -429,13 +412,13 @@ export class PFrame implements PFrameInternal.PFrameV13 {
         `PFrame ${this.id} createTable request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
       this.#logger(
-        'info',
-        `PFrame ${this.id} createTable request ${requestId} took ${timer.elapsed()}`
+        "info",
+        `PFrame ${this.id} createTable request ${requestId} took ${timer.elapsed()}`,
       );
     }
   }
@@ -444,29 +427,25 @@ export class PFrame implements PFrameInternal.PFrameV13 {
     requestId: PFrameInternal.PTableId,
     request: {
       tableSpec: PTableColumnSpec[];
-      dataQuery: QueryData;
-    }
+      dataQuery: DataQuery;
+    },
   ): PTable {
     const timer = PerfTimer.start();
     try {
-      const boxed = AddonSymbol.pFrameCreateTableV2(
-        this.#frame,
-        requestId,
-        request
-      );
+      const boxed = AddonSymbol.pFrameCreateTableV2(this.#frame, requestId, request);
       return new PTable(this, requestId, boxed, this.#logger);
     } catch (err: unknown) {
       const error = new PFrameError(`PFrame createTableV2 request failed`);
       error.cause = new Error(
         `PFrame ${this.id} createTableV2 request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
       this.#logger(
-        'info',
-        `PFrame ${this.id} createTableV2 request ${requestId} took ${timer.elapsed()}`
+        "info",
+        `PFrame ${this.id} createTableV2 request ${requestId} took ${timer.elapsed()}`,
       );
     }
   }
@@ -475,50 +454,40 @@ export class PFrame implements PFrameInternal.PFrameV13 {
     request: UniqueValuesRequest,
     ops?: {
       signal?: AbortSignal;
-    }
+    },
   ): Promise<UniqueValuesResponse> {
     const requestId = ulid() as PFrameInternal.PTableId;
     dump(
       [`${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'getUniqueValues',
-        requestData: hashUniqueValuesRequestColumnId(request)
+        requestType: "getUniqueValues",
+        requestData: hashUniqueValuesRequestColumnId(request),
       },
-      this.#logger
+      this.#logger,
     );
 
-    this.#logger(
-      'info',
-      `PFrame ${this.id} getUniqueValues request ${requestId} started`
-    );
+    this.#logger("info", `PFrame ${this.id} getUniqueValues request ${requestId} started`);
     const timer = PerfTimer.start();
     try {
       ops?.signal?.throwIfAborted();
-      return await AddonSymbol.pFrameGetUniqueValues(
-        this.#frame,
-        requestId,
-        request,
-        ops?.signal
-      );
+      return await AddonSymbol.pFrameGetUniqueValues(this.#frame, requestId, request, ops?.signal);
     } catch (err: unknown) {
       if (isAbortError(err)) {
-        throw new AbortError(
-          `PFrame ${this.id} getUniqueValues request ${requestId} cancelled`
-        );
+        throw new AbortError(`PFrame ${this.id} getUniqueValues request ${requestId} cancelled`);
       }
       const error = new PFrameError(`PFrame getUniqueValues request failed`);
       error.cause = new Error(
         `PFrame ${this.id} getUniqueValues request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
       this.#logger(
-        'info',
-        `PFrame ${this.id} getUniqueValues request ${requestId} finished, took ${timer.elapsed()}`
+        "info",
+        `PFrame ${this.id} getUniqueValues request ${requestId} finished, took ${timer.elapsed()}`,
       );
     }
   }
@@ -536,17 +505,12 @@ class PTable implements PFrameInternal.PTableV8 {
 
   readonly #logger: PFrameInternal.Logger;
 
-  constructor(
-    frame: PFrame,
-    id: string,
-    table: NodeTableSymbol,
-    logger: PFrameInternal.Logger
-  ) {
+  constructor(frame: PFrame, id: string, table: NodeTableSymbol, logger: PFrameInternal.Logger) {
     this.#frame = frame;
     this.#table = table;
     this.#id = id;
     this.#logger = logger;
-    this.#logger('info', `PTable ${this.id} created`);
+    this.#logger("info", `PTable ${this.id} created`);
   }
 
   getSpec(): PTableColumnSpec[] {
@@ -555,9 +519,9 @@ class PTable implements PFrameInternal.PTableV8 {
       [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'getSpec'
+        requestType: "getSpec",
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
@@ -567,7 +531,7 @@ class PTable implements PFrameInternal.PTableV8 {
       error.cause = new Error(
         `PTable ${this.id} getSpec request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -579,12 +543,12 @@ class PTable implements PFrameInternal.PTableV8 {
       [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'getColumnIndices',
+        requestType: "getColumnIndices",
         requestData: {
-          columnIds: columnIds.map(hashTableColumnId)
-        }
+          columnIds: columnIds.map(hashTableColumnId),
+        },
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
@@ -595,7 +559,7 @@ class PTable implements PFrameInternal.PTableV8 {
         `PTable ${this.id} getColumnIndices request ${requestId} failed, ` +
           `columnIds: ${JSON.stringify(columnIds)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -607,9 +571,9 @@ class PTable implements PFrameInternal.PTableV8 {
       [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'getFootprint'
+        requestType: "getFootprint",
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
@@ -617,15 +581,13 @@ class PTable implements PFrameInternal.PTableV8 {
       return await AddonSymbol.pTableGetFootprint(this.#table, ops?.signal);
     } catch (err: unknown) {
       if (!isAbortError(err)) {
-        throw new AbortError(
-          `PTable ${this.id} getFootprint request ${requestId} cancelled`
-        );
+        throw new AbortError(`PTable ${this.id} getFootprint request ${requestId} cancelled`);
       }
       const error = new PFrameError(`PTable getFootprint request failed`);
       error.cause = new Error(
         `PTable ${this.id} getFootprint request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }
@@ -637,36 +599,31 @@ class PTable implements PFrameInternal.PTableV8 {
       [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'getShape'
+        requestType: "getShape",
       },
-      this.#logger
+      this.#logger,
     );
 
-    this.#logger(
-      'info',
-      `PTable ${this.id} getShape request ${requestId} started`
-    );
+    this.#logger("info", `PTable ${this.id} getShape request ${requestId} started`);
     const timer = PerfTimer.start();
     try {
       ops?.signal?.throwIfAborted();
       return await AddonSymbol.pTableGetShape(this.#table, ops?.signal);
     } catch (err: unknown) {
       if (isAbortError(err)) {
-        throw new AbortError(
-          `PTable ${this.id} getShape request ${requestId} cancelled`
-        );
+        throw new AbortError(`PTable ${this.id} getShape request ${requestId} cancelled`);
       }
       const error = new PFrameError(`PTable getShape request failed`);
       error.cause = new Error(
         `PTable ${this.id} getShape request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
       this.#logger(
-        'info',
-        `PTable ${this.id} getShape request ${requestId} finished, took ${timer.elapsed()}`
+        "info",
+        `PTable ${this.id} getShape request ${requestId} finished, took ${timer.elapsed()}`,
       );
     }
   }
@@ -676,26 +633,23 @@ class PTable implements PFrameInternal.PTableV8 {
     ops?: {
       range?: TableRange | undefined;
       signal?: AbortSignal | undefined;
-    }
+    },
   ): Promise<PTableVector[]> {
     const requestId = ulid() as PFrameInternal.PTableId;
     dump(
       [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'getData',
+        requestType: "getData",
         requestData: {
           columnIndices,
-          range: ops?.range ?? null
-        }
+          range: ops?.range ?? null,
+        },
       },
-      this.#logger
+      this.#logger,
     );
 
-    this.#logger(
-      'info',
-      `PTable ${this.id} getData request ${requestId} started`
-    );
+    this.#logger("info", `PTable ${this.id} getData request ${requestId} started`);
     let rowCount = 0;
     const timer = PerfTimer.start();
     try {
@@ -705,15 +659,13 @@ class PTable implements PFrameInternal.PTableV8 {
         requestId,
         columnIndices,
         ops?.range,
-        ops?.signal
+        ops?.signal,
       );
       rowCount = result[0].data.length;
       return result;
     } catch (err: unknown) {
       if (isAbortError(err)) {
-        throw new AbortError(
-          `PTable ${this.id} getData request ${requestId} cancelled`
-        );
+        throw new AbortError(`PTable ${this.id} getData request ${requestId} cancelled`);
       }
       const error = new PFrameError(`PTable getData request failed`);
       error.cause = new Error(
@@ -721,35 +673,28 @@ class PTable implements PFrameInternal.PTableV8 {
           `columnIndices: ${JSON.stringify(columnIndices)}, ` +
           `range: ${ops?.range ? JSON.stringify(ops.range) : undefined}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
       this.#logger(
-        'info',
-        `PTable ${this.id} getData request ${requestId} finished, took ${timer.elapsed()} (${rowCount} rows)`
+        "info",
+        `PTable ${this.id} getData request ${requestId} finished, took ${timer.elapsed()} (${rowCount} rows)`,
       );
     }
   }
 
-  filter(
-    requestId: PFrameInternal.PTableId,
-    request: PTableRecordFilter[]
-  ): PTable {
+  filter(requestId: PFrameInternal.PTableId, request: PTableRecordFilter[]): PTable {
     const dumpData = {
       timeStamp: Date.now(),
       table: this.id,
-      requestType: 'filter',
+      requestType: "filter",
       requestData: {
-        filters: request.map(hashFilterColumnId)
-      }
+        filters: request.map(hashFilterColumnId),
+      },
     };
     dump([`${this.#frame.id}`, `${requestId}.json`], dumpData, this.#logger);
-    dump(
-      [`${this.#frame.id}`, `${requestId}`, `${requestId}.json`],
-      dumpData,
-      this.#logger
-    );
+    dump([`${this.#frame.id}`, `${requestId}`, `${requestId}.json`], dumpData, this.#logger);
 
     const timer = PerfTimer.start();
     try {
@@ -761,14 +706,11 @@ class PTable implements PFrameInternal.PTableV8 {
         `PTable ${this.id} filter request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
-      this.#logger(
-        'info',
-        `PTable ${this.id} filter request ${requestId} took ${timer.elapsed()}`
-      );
+      this.#logger("info", `PTable ${this.id} filter request ${requestId} took ${timer.elapsed()}`);
     }
   }
 
@@ -776,15 +718,11 @@ class PTable implements PFrameInternal.PTableV8 {
     const dumpData = {
       timeStamp: Date.now(),
       table: this.id,
-      requestType: 'sort',
-      requestData: request.map(hashSortingColumnId)
+      requestType: "sort",
+      requestData: request.map(hashSortingColumnId),
     };
     dump([`${this.#frame.id}`, `${requestId}.json`], dumpData, this.#logger);
-    dump(
-      [`${this.#frame.id}`, `${requestId}`, `${requestId}.json`],
-      dumpData,
-      this.#logger
-    );
+    dump([`${this.#frame.id}`, `${requestId}`, `${requestId}.json`], dumpData, this.#logger);
 
     const timer = PerfTimer.start();
     try {
@@ -796,14 +734,11 @@ class PTable implements PFrameInternal.PTableV8 {
         `PTable ${this.id} sort request ${requestId} failed, ` +
           `request: ${JSON.stringify(request)}, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     } finally {
-      this.#logger(
-        'info',
-        `PTable ${this.id} sort request ${requestId} took ${timer.elapsed()}`
-      );
+      this.#logger("info", `PTable ${this.id} sort request ${requestId} took ${timer.elapsed()}`);
     }
   }
 
@@ -813,20 +748,20 @@ class PTable implements PFrameInternal.PTableV8 {
       [`${this.#frame.id}`, `${this.id}`, `${requestId}.json`],
       {
         timeStamp: Date.now(),
-        requestType: 'dispose'
+        requestType: "dispose",
       },
-      this.#logger
+      this.#logger,
     );
 
     try {
       AddonSymbol.pTableDispose(this.#table);
-      this.#logger('info', `PTable ${this.id} disposed`);
+      this.#logger("info", `PTable ${this.id} disposed`);
     } catch (err: unknown) {
       const error = new PFrameError(`PTable dispose request failed`);
       error.cause = new Error(
         `PTable ${this.id} dispose request ${requestId} failed, ` +
           `error:\n` +
-          `${ensureError(err)}`
+          `${ensureError(err)}`,
       );
       throw error;
     }