@milaboratories/pframes-rs-node 1.1.2 → 1.1.4

package/README.md

@@ -1,11 +1,11 @@
 # PFrames Node.js native addon
 
 ## Usage
->
+
 > [!TIP]
 > Install using `pnpm install @milaboratories/pframes-rs-node` command.
 > Check [tests](tests/pframes.test.ts) for usage examples.
->
+
 ## Build instructions
 
 ### Build steps
@@ -47,7 +47,7 @@ Debugging is only supported using VSCode with the following extencions installed
 4. Launch VSCode task (Cmd+Shift+P -> Tasks: Run Task -> Perf-profile platforma-desktop) for profiling
 5. Execute the test scenario and quite platforma-desktop
 6. Firefox profiler with recorded performance profile would automatically open in you browser of choice
-    (Warning! Firefox profiler does not work in Safari and with AdBlock enabled)
+   (Warning! Firefox profiler does not work in Safari and with AdBlock enabled)
 
 ### Dump pframes requests
 

package/export/addon-def.ts

@@ -12,110 +12,98 @@ import type {
   UniqueValuesRequest,
   UniqueValuesResponse,
   QueryData,
-  AxisId,
-  PColumnIdAndSpec
-} from '@milaboratories/pl-model-common';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+} from "@milaboratories/pl-model-common";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 
-export interface NodeFrameSymbol extends Symbol {}
+export interface NodeFrameSymbol
+  // oxlint-disable-next-line
+  extends Symbol {}
 
-export interface NodeTableSymbol extends Symbol {}
+export interface NodeTableSymbol
+  // oxlint-disable-next-line
+  extends Symbol {}
 
 interface HeapProfiler {
   pprofDump: () => Promise<Uint8Array>;
 }
 
 interface NodeFrame {
-  pFrameCreate: (
-    spillPath: string,
-    logger: PFrameInternal.Logger | undefined
-  ) => NodeFrameSymbol;
+  pFrameCreate: (spillPath: string, logger: PFrameInternal.Logger | undefined) => NodeFrameSymbol;
   pFrameAddColumnSpec: (
     pFrame: NodeFrameSymbol,
     columnId: PObjectId,
-    columnSpec: PColumnSpec
+    columnSpec: PColumnSpec,
   ) => void;
   pFrameSetDataSource: (
     pFrame: NodeFrameSymbol,
-    dataSource: PFrameInternal.PFrameDataSourceV2
+    dataSource: PFrameInternal.PFrameDataSourceV2,
   ) => void;
   pFrameSetColumnData: (
     pFrame: NodeFrameSymbol,
     columnId: PObjectId,
     dataInfo: PFrameInternal.DataInfo<PFrameInternal.PFrameBlobId>,
-    signal: AbortSignal | undefined
+    signal: AbortSignal | undefined,
   ) => Promise<void>;
   pFrameDispose: (pFrame: NodeFrameSymbol) => void;
   pFrameFindColumns: (
     pFrame: NodeFrameSymbol,
-    request: PFrameInternal.FindColumnsRequest
+    request: PFrameInternal.FindColumnsRequest,
   ) => Promise<PFrameInternal.FindColumnsResponse>;
   pFrameDeleteColumn: (
     pFrame: NodeFrameSymbol,
-    request: PFrameInternal.DeleteColumnFromColumnsRequest
+    request: PFrameInternal.DeleteColumnFromColumnsRequest,
   ) => Promise<PFrameInternal.DeleteColumnFromColumnsResponse>;
   pFrameGetColumnSpec: (
     pFrame: NodeFrameSymbol,
-    columnId: PObjectId
+    columnId: PObjectId,
   ) => Promise<PColumnSpec | null>;
   pFrameListColumns: (pFrame: NodeFrameSymbol) => Promise<PColumnInfo[]>;
   pFrameCreateTable: (
     pFrame: NodeFrameSymbol,
     id: PFrameInternal.PTableId,
-    request: PFrameInternal.CreateTableRequestV4
+    request: PFrameInternal.CreateTableRequestV4,
   ) => NodeTableSymbol;
-  pFrameCreateTableByDataQuery: (
+  pFrameCreateTableV2: (
     pFrame: NodeFrameSymbol,
     id: PFrameInternal.PTableId,
     request: {
-      tableSpec: {
-        axes: AxisId[];
-        columns: PColumnIdAndSpec[];
-      };
+      tableSpec: PTableColumnSpec[];
       dataQuery: QueryData;
-    }
+    },
   ) => NodeTableSymbol;
   pFrameGetUniqueValues: (
     pFrame: NodeFrameSymbol,
     id: PFrameInternal.PTableId,
     request: UniqueValuesRequest,
-    signal: AbortSignal | undefined
+    signal: AbortSignal | undefined,
   ) => Promise<UniqueValuesResponse>;
 }
 
 interface NodeTable {
   pTableGetSpec: (boxed: NodeTableSymbol) => PTableColumnSpec[];
-  pTableGetColumnIndices: (
-    boxed: NodeTableSymbol,
-    columnIds: PTableColumnId[]
-  ) => number[];
-  pTableGetFootprint: (
-    boxed: NodeTableSymbol,
-    signal: AbortSignal | undefined
-  ) => Promise<number>;
-  pTableGetShape: (
-    boxed: NodeTableSymbol,
-    signal: AbortSignal | undefined
-  ) => Promise<PTableShape>;
+  pTableGetColumnIndices: (boxed: NodeTableSymbol, columnIds: PTableColumnId[]) => number[];
+  pTableGetFootprint: (boxed: NodeTableSymbol, signal: AbortSignal | undefined) => Promise<number>;
+  pTableGetShape: (boxed: NodeTableSymbol, signal: AbortSignal | undefined) => Promise<PTableShape>;
   pTableGetData: (
     boxed: NodeTableSymbol,
     id: PFrameInternal.PTableId,
     columnIndices: number[],
     range: TableRange | undefined,
-    signal: AbortSignal | undefined
+    signal: AbortSignal | undefined,
   ) => Promise<PTableVector[]>;
   pTableFilter: (
     boxed: NodeTableSymbol,
     id: PFrameInternal.PTableId,
-    request: PTableRecordFilter[]
+    request: PTableRecordFilter[],
   ) => NodeTableSymbol;
   pTableSort: (
     boxed: NodeTableSymbol,
     id: PFrameInternal.PTableId,
-    request: PTableSorting[]
+    request: PTableSorting[],
   ) => NodeTableSymbol;
   pTableDispose: (boxed: NodeTableSymbol) => void;
 }
 
 export interface AddonSymbol
+  // oxlint-disable-next-line
   extends Symbol, HeapProfiler, NodeFrame, NodeTable {}

package/export/addon.ts

@@ -1,8 +1,8 @@
-import { createRequire } from 'node:module';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import gyp from '@mapbox/node-pre-gyp';
-import type { AddonSymbol } from './addon-def';
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import gyp from "@mapbox/node-pre-gyp";
+import type { AddonSymbol } from "./addon-def";
 
 const nodeFileUrl = import.meta.url;
 const nodeDirname = dirname(fileURLToPath(nodeFileUrl));
@@ -18,8 +18,6 @@ const { find: findAddon } = gyp;
 // https://github.com/search?q=repo%3Anodejs%2Fnode%20NAPI_MODULE_INITIALIZER&type=code
 // And neon exports napi_register_module_v1 from #[neon::main]
 // https://github.com/neon-bindings/neon/blob/b1728fa21e968ccde9611ac9955cf6d638be16e6/crates/neon/src/context/internal.rs#L76
-const AddonSymbol = nodeRequire(
-  findAddon(resolve(nodeDirname, '../package.json'))
-) as AddonSymbol;
+const AddonSymbol = nodeRequire(findAddon(resolve(nodeDirname, "../package.json"))) as AddonSymbol;
 
 export { AddonSymbol };

package/export/dump.ts

@@ -1,97 +1,91 @@
-import { createHash } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import { join } from 'node:path';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 import type {
   PObjectId,
   PTableColumnId,
   PTableRecordFilter,
   PTableSorting,
-  UniqueValuesRequest
-} from '@milaboratories/pl-model-common';
+  UniqueValuesRequest,
+} from "@milaboratories/pl-model-common";
 
 export function hashColumnId(columnId: PObjectId): PObjectId {
-  return createHash('sha256').update(columnId).digest('hex') as PObjectId;
+  return createHash("sha256").update(columnId).digest("hex") as PObjectId;
 }
 
 export function hashTableColumnId(tableId: PTableColumnId): PTableColumnId {
-  if (tableId.type === 'column') {
+  if (tableId.type === "column") {
     return {
       ...tableId,
-      id: hashColumnId(tableId.id)
+      id: hashColumnId(tableId.id),
     };
   }
   return tableId;
 }
 
-export function hashFilterColumnId(
-  filter: PTableRecordFilter
-): PTableRecordFilter {
+export function hashFilterColumnId(filter: PTableRecordFilter): PTableRecordFilter {
   return {
     ...filter,
-    column: hashTableColumnId(filter.column)
+    column: hashTableColumnId(filter.column),
   };
 }
 
-export function hashUniqueValuesRequestColumnId(
-  request: UniqueValuesRequest
-): UniqueValuesRequest {
+export function hashUniqueValuesRequestColumnId(request: UniqueValuesRequest): UniqueValuesRequest {
   return {
     ...request,
     columnId: hashColumnId(request.columnId),
-    filters: request.filters.map(hashFilterColumnId)
+    filters: request.filters.map(hashFilterColumnId),
   };
 }
 
 export function hashSortingColumnId(sorting: PTableSorting): PTableSorting {
   return {
     ...sorting,
-    column: hashTableColumnId(sorting.column)
+    column: hashTableColumnId(sorting.column),
   };
 }
 
-function hashJoinEntryColumnId(
-  entry: PFrameInternal.JoinEntryV4
-): PFrameInternal.JoinEntryV4 {
+function hashJoinEntryColumnId(entry: PFrameInternal.JoinEntryV4): PFrameInternal.JoinEntryV4 {
   const type = entry.type;
   switch (type) {
-    case 'column':
+    case "column":
       return {
         ...entry,
-        columnId: hashColumnId(entry.columnId)
+        columnId: hashColumnId(entry.columnId),
       };
-    case 'slicedColumn':
+    case "slicedColumn":
       return {
         ...entry,
         columnId: hashColumnId(entry.columnId),
-        newId: hashColumnId(entry.newId)
+        newId: hashColumnId(entry.newId),
       };
-    case 'artificialColumn':
+    case "artificialColumn":
       return {
         ...entry,
         columnId: hashColumnId(entry.columnId),
-        newId: hashColumnId(entry.newId)
+        newId: hashColumnId(entry.newId),
       };
-    case 'inlineColumn':
+    case "inlineColumn":
       return {
         ...entry,
-        newId: hashColumnId(entry.newId)
+        newId: hashColumnId(entry.newId),
       };
-    case 'inner':
+    case "inner":
       return {
         ...entry,
-        entries: entry.entries.map(hashJoinEntryColumnId)
+        entries: entry.entries.map(hashJoinEntryColumnId),
       };
-    case 'full':
+    case "full":
       return {
         ...entry,
-        entries: entry.entries.map(hashJoinEntryColumnId)
+        entries: entry.entries.map(hashJoinEntryColumnId),
       };
-    case 'outer':
+    case "outer":
       return {
         ...entry,
         primary: hashJoinEntryColumnId(entry.primary),
-        secondary: entry.secondary.map(hashJoinEntryColumnId)
+        secondary: entry.secondary.map(hashJoinEntryColumnId),
       };
     default:
       throw new Error(`Unsupported join entry type: ${type}`);
@@ -99,35 +93,30 @@ function hashJoinEntryColumnId(
 }
 
 export function hashCreateTableRequestColumnId(
-  request: PFrameInternal.CreateTableRequestV4
+  request: PFrameInternal.CreateTableRequestV4,
 ): PFrameInternal.CreateTableRequestV4 {
   return {
     ...request,
     src: hashJoinEntryColumnId(request.src),
-    filters: request.filters.map(hashFilterColumnId)
+    filters: request.filters.map(hashFilterColumnId),
   };
 }
 
 export async function dump(
   relativePath: string[],
-  data: { [key: string]: Object } | Uint8Array,
-  logger?: PFrameInternal.Logger
+  data: { [key: string]: string | number | boolean | object } | Uint8Array,
+  logger?: PFrameInternal.Logger,
 ): Promise<void> {
   if (!process.env.MI_DUMP_PFRAMES_RS) return;
   try {
     const relativeUri = relativePath.map((part) => encodeURIComponent(part));
-    const fileDir = join(
-      process.env.MI_DUMP_PFRAMES_RS,
-      ...relativeUri.slice(0, -1)
-    );
+    const fileDir = join(process.env.MI_DUMP_PFRAMES_RS, ...relativeUri.slice(0, -1));
     await fs.mkdir(fileDir, { recursive: true });
 
     const filePath = join(process.env.MI_DUMP_PFRAMES_RS, ...relativeUri);
-    const fileData = ArrayBuffer.isView(data)
-      ? data
-      : JSON.stringify(data, null, 2);
-    await fs.writeFile(filePath, fileData, { flag: 'wx' });
+    const fileData = ArrayBuffer.isView(data) ? data : JSON.stringify(data, null, 2);
+    await fs.writeFile(filePath, fileData, { flag: "wx" });
   } catch (error: unknown) {
-    logger?.('warn', `error while dumping PFrames data: ${error}`);
+    logger?.("warn", `error while dumping PFrames data: ${error}`);
   }
 }

package/export/export.ts

@@ -1,13 +1,11 @@
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import { PFrame, pprofDump } from './wrapper';
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { PFrame, pprofDump } from "./wrapper";
 
 export const PFrameFactory: PFrameInternal.PFrameFactoryV4 = {
-  createPFrame: (
-    options: PFrameInternal.PFrameOptionsV2
-  ): PFrameInternal.PFrameV13 => {
+  createPFrame: (options: PFrameInternal.PFrameOptionsV2): PFrameInternal.PFrameV13 => {
     return new PFrame(options);
   },
   pprofDump: async (): Promise<Uint8Array> => {
     return await pprofDump();
-  }
+  },
 };

package/export/index.ts

@@ -1,2 +1,2 @@
-export { PFrameFactory } from './export';
-export { HttpHelpers } from '@milaboratories/pframes-rs-serv';
+export { PFrameFactory } from "./export";
+export { HttpHelpers } from "@milaboratories/pframes-rs-serv";

package/export/node-pre-gyp.d.ts

@@ -1,3 +1,3 @@
-declare module '@mapbox/node-pre-gyp' {
+declare module "@mapbox/node-pre-gyp" {
   function find(packageRoot: string): string;
 }