@milaboratories/pf-driver 1.0.39 → 1.0.41

package/src/ptable_cache_plain.ts

@@ -1,9 +1,9 @@
-import type { PTableHandle } from '@platforma-sdk/model';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import type { PoolEntry } from '@milaboratories/ts-helpers';
-import { LRUCache } from 'lru-cache';
-import { logPFrames } from './logging';
-import type { PTableHolder } from './ptable_pool';
+import type { PTableHandle } from "@platforma-sdk/model";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import type { PoolEntry } from "@milaboratories/ts-helpers";
+import { LRUCache } from "lru-cache";
+import { logPFrames } from "./logging";
+import type { PTableHolder } from "./ptable_pool";
 
 export type PTableCachePlainOps = {
   /**
@@ -31,16 +31,20 @@ export class PTableCachePlain {
       dispose: (resource, key, reason) => {
         resource.unref();
         if (logPFrames()) {
-          logger('info', `createPTable cache - removed PTable ${key} (reason: ${reason})`);
+          logger("info", `createPTable cache - removed PTable ${key} (reason: ${reason})`);
         }
       },
     });
   }
 
-  public cache(resource: PoolEntry<PTableHandle, PTableHolder>, size: number, defDisposeSignal: AbortSignal): void {
+  public cache(
+    resource: PoolEntry<PTableHandle, PTableHolder>,
+    size: number,
+    defDisposeSignal: AbortSignal,
+  ): void {
     const key = resource.key;
     if (logPFrames()) {
-      this.logger('info', `createPTable cache - added PTable ${key} with size ${size}`);
+      this.logger("info", `createPTable cache - added PTable ${key} with size ${size}`);
     }
 
     const status: LRUCache.Status<PoolEntry<PTableHandle, PTableHolder>> = {};
@@ -49,7 +53,7 @@ export class PTableCachePlain {
     if (status.maxEntrySizeExceeded) {
       resource.unref();
       if (logPFrames()) {
-        this.logger('info', `createPTable cache - removed PTable ${key} (maxEntrySizeExceeded)`);
+        this.logger("info", `createPTable cache - removed PTable ${key} (maxEntrySizeExceeded)`);
       }
     } else {
       if (!this.disposeListeners.has(key)) {
@@ -57,10 +61,10 @@ export class PTableCachePlain {
           this.global.delete(key);
 
           this.disposeListeners.delete(key);
-          defDisposeSignal.removeEventListener('abort', disposeListener);
+          defDisposeSignal.removeEventListener("abort", disposeListener);
         };
         this.disposeListeners.add(key);
-        defDisposeSignal.addEventListener('abort', disposeListener);
+        defDisposeSignal.addEventListener("abort", disposeListener);
       }
     }
   }

package/src/ptable_def_pool.ts

@@ -1,8 +1,8 @@
-import { PFrameDriverError, type PTableHandle } from '@platforma-sdk/model';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import { RefCountPoolBase } from '@milaboratories/ts-helpers';
-import { logPFrames } from './logging';
-import { stableKeyFromFullPTableDef, type FullPTableDef } from './ptable_shared';
+import { PFrameDriverError, type PTableHandle } from "@platforma-sdk/model";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { RefCountPoolBase } from "@milaboratories/ts-helpers";
+import { logPFrames } from "./logging";
+import { stableKeyFromFullPTableDef, type FullPTableDef } from "./ptable_shared";
 
 export class PTableDefHolder implements Disposable {
   private readonly abortController = new AbortController();
@@ -13,7 +13,7 @@ export class PTableDefHolder implements Disposable {
     private readonly logger: PFrameInternal.Logger,
   ) {
     if (logPFrames()) {
-      this.logger('info', `PTable definition saved (pTableHandle = ${this.pTableHandle})`);
+      this.logger("info", `PTable definition saved (pTableHandle = ${this.pTableHandle})`);
     }
   }
 
@@ -24,7 +24,7 @@ export class PTableDefHolder implements Disposable {
   [Symbol.dispose](): void {
     this.abortController.abort();
     if (logPFrames()) {
-      this.logger('info', `PTable definition disposed (pTableHandle = ${this.pTableHandle})`);
+      this.logger("info", `PTable definition disposed (pTableHandle = ${this.pTableHandle})`);
     }
   }
 }

package/src/ptable_pool.ts

@@ -8,13 +8,13 @@ import {
   type JsonSerializable,
   type PColumnValue,
   type PObjectId,
-} from '@platforma-sdk/model';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import { RefCountPoolBase, type PoolEntry } from '@milaboratories/ts-helpers';
-import { logPFrames } from './logging';
-import type { PFramePool } from './pframe_pool';
-import { stableKeyFromFullPTableDef, type FullPTableDef } from './ptable_shared';
-import type { PTableDefPool } from './ptable_def_pool';
+} from "@platforma-sdk/model";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { RefCountPoolBase, type PoolEntry } from "@milaboratories/ts-helpers";
+import { logPFrames } from "./logging";
+import type { PFramePool } from "./pframe_pool";
+import { stableKeyFromFullPTableDef, type FullPTableDef } from "./ptable_shared";
+import type { PTableDefPool } from "./ptable_def_pool";
 
 export class PTableHolder implements Disposable {
   private readonly abortController = new AbortController();
@@ -26,7 +26,10 @@ export class PTableHolder implements Disposable {
     public readonly pTablePromise: Promise<PFrameInternal.PTableV8>,
     private readonly predecessor?: PoolEntry<PTableHandle, PTableHolder>,
   ) {
-    this.combinedDisposeSignal = AbortSignal.any([pFrameDisposeSignal, this.abortController.signal]);
+    this.combinedDisposeSignal = AbortSignal.any([
+      pFrameDisposeSignal,
+      this.abortController.signal,
+    ]);
   }
 
   public get disposeSignal(): AbortSignal {
@@ -38,12 +41,17 @@ export class PTableHolder implements Disposable {
     this.predecessor?.unref();
     void this.pTablePromise
       .then((pTable) => pTable.dispose())
-      .catch(() => { /* mute error */ });
+      .catch(() => {
+        /* mute error */
+      });
   }
 }
 
-export class PTablePool<TreeEntry extends JsonSerializable>
-  extends RefCountPoolBase<FullPTableDef, PTableHandle, PTableHolder> {
+export class PTablePool<TreeEntry extends JsonSerializable> extends RefCountPoolBase<
+  FullPTableDef,
+  PTableHandle,
+  PTableHolder
+> {
   constructor(
     private readonly pFrames: PFramePool<TreeEntry>,
     private readonly pTableDefs: PTableDefPool,
@@ -58,9 +66,9 @@ export class PTablePool<TreeEntry extends JsonSerializable>
 
   protected createNewResource(params: FullPTableDef, key: PTableHandle): PTableHolder {
     if (logPFrames()) {
-      this.logger('info',
-        `PTable creation (pTableHandle = ${key}): `
-        + `${JSON.stringify(params, bigintReplacer)}`,
+      this.logger(
+        "info",
+        `PTable creation (pTableHandle = ${key}): ` + `${JSON.stringify(params, bigintReplacer)}`,
       );
     }
 
@@ -79,7 +87,9 @@ export class PTablePool<TreeEntry extends JsonSerializable>
           sorting: [],
         },
       });
-      const { resource: { pTablePromise } } = predecessor;
+      const {
+        resource: { pTablePromise },
+      } = predecessor;
       const sortedTable = pTablePromise.then((pTable) => pTable.sort(key, params.def.sorting));
       return new PTableHolder(handle, combinedSignal, sortedTable, predecessor);
     }
@@ -93,17 +103,21 @@ export class PTablePool<TreeEntry extends JsonSerializable>
           filters: [],
         },
       });
-      const { resource: { pTablePromise } } = predecessor;
+      const {
+        resource: { pTablePromise },
+      } = predecessor;
       const filteredTable = pTablePromise.then((pTable) => pTable.filter(key, params.def.filters));
       return new PTableHolder(handle, combinedSignal, filteredTable, predecessor);
     }
 
     // 1. Join
-    const table = pFramePromise.then((pFrame) => pFrame.createTable(key, {
-      src: joinEntryToInternal(params.def.src),
-      // `params.def.filters` would be non-empty only when join has artificial columns
-      filters: [...params.def.partitionFilters, ...params.def.filters],
-    }));
+    const table = pFramePromise.then((pFrame) =>
+      pFrame.createTable(key, {
+        src: joinEntryToInternal(params.def.src),
+        // `params.def.filters` would be non-empty only when join has artificial columns
+        filters: [...params.def.partitionFilters, ...params.def.filters],
+      }),
+    );
     return new PTableHolder(handle, combinedSignal, table);
   }
 
@@ -120,16 +134,16 @@ export class PTablePool<TreeEntry extends JsonSerializable>
 
 function hasArtificialColumns<T>(entry: JoinEntry<T>): boolean {
   switch (entry.type) {
-    case 'column':
-    case 'slicedColumn':
-    case 'inlineColumn':
+    case "column":
+    case "slicedColumn":
+    case "inlineColumn":
       return false;
-    case 'artificialColumn':
+    case "artificialColumn":
       return true;
-    case 'full':
-    case 'inner':
+    case "full":
+    case "inner":
       return entry.entries.some(hasArtificialColumns);
-    case 'outer':
+    case "outer":
       return hasArtificialColumns(entry.primary) || entry.secondary.some(hasArtificialColumns);
     default:
       assertNever(entry);
@@ -139,48 +153,51 @@ function hasArtificialColumns<T>(entry: JoinEntry<T>): boolean {
 function joinEntryToInternal(entry: JoinEntry<PObjectId>): PFrameInternal.JoinEntryV4 {
   const type = entry.type;
   switch (type) {
-    case 'column':
+    case "column":
       return {
-        type: 'column',
+        type: "column",
         columnId: entry.column,
       };
-    case 'slicedColumn':
+    case "slicedColumn":
       return {
-        type: 'slicedColumn',
+        type: "slicedColumn",
         columnId: entry.column,
         newId: entry.newId,
         axisFilters: entry.axisFilters,
       };
-    case 'artificialColumn':
+    case "artificialColumn":
       return {
-        type: 'artificialColumn',
+        type: "artificialColumn",
         columnId: entry.column,
         newId: entry.newId,
         axesIndices: entry.axesIndices,
       };
-    case 'inlineColumn':
+    case "inlineColumn":
       return {
-        type: 'inlineColumn',
+        type: "inlineColumn",
         newId: entry.column.id,
         spec: entry.column.spec,
         dataInfo: {
-          type: 'Json',
+          type: "Json",
           keyLength: entry.column.spec.axesSpec.length,
-          data: entry.column.data.reduce((acc, row) => {
-            acc[JSON.stringify(row.key)] = row.val;
-            return acc;
-          }, {} as Record<string, PColumnValue>),
+          data: entry.column.data.reduce(
+            (acc, row) => {
+              acc[JSON.stringify(row.key)] = row.val;
+              return acc;
+            },
+            {} as Record<string, PColumnValue>,
+          ),
         },
       };
-    case 'inner':
-    case 'full':
+    case "inner":
+    case "full":
       return {
         type: entry.type,
         entries: entry.entries.map((col) => joinEntryToInternal(col)),
       };
-    case 'outer':
+    case "outer":
       return {
-        type: 'outer',
+        type: "outer",
         primary: joinEntryToInternal(entry.primary),
         secondary: entry.secondary.map((col) => joinEntryToInternal(col)),
       };

package/src/ptable_shared.ts

@@ -1,5 +1,5 @@
-import type { PObjectId, PFrameHandle, PTableDef, PTableHandle } from '@platforma-sdk/model';
-import { hashJson } from '@milaboratories/pl-model-middle-layer';
+import type { PObjectId, PFrameHandle, PTableDef, PTableHandle } from "@platforma-sdk/model";
+import { hashJson } from "@milaboratories/pl-model-middle-layer";
 
 export type FullPTableDef = {
   pFrameHandle: PFrameHandle;