@milaboratories/pf-driver 1.0.43 → 1.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pf-driver",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "PFrameDriver implementation abstracted from Middle Layer",
   "keywords": [],
   "license": "UNLICENSED",
@@ -20,22 +20,22 @@
     }
   },
   "dependencies": {
-    "@milaboratories/pframes-rs-node": "1.1.2",
-    "@milaboratories/pframes-rs-wasm": "0.1.0",
+    "@milaboratories/pframes-rs-node": "1.1.3",
+    "@milaboratories/pframes-rs-wasm": "0.1.2",
     "es-toolkit": "^1.39.10",
     "lru-cache": "^11.2.2",
+    "@platforma-sdk/model": "1.54.7",
     "@milaboratories/ts-helpers": "1.7.2",
-    "@platforma-sdk/model": "1.53.15",
-    "@milaboratories/pl-model-middle-layer": "1.11.7"
+    "@milaboratories/pl-model-middle-layer": "1.11.9"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",
     "@vitest/coverage-istanbul": "^4.0.16",
     "typescript": "~5.6.3",
     "vitest": "^4.0.16",
-    "@milaboratories/build-configs": "1.4.3",
+    "@milaboratories/build-configs": "1.4.4",
     "@milaboratories/ts-configs": "1.2.1",
-    "@milaboratories/ts-builder": "1.2.8"
+    "@milaboratories/ts-builder": "1.2.10"
   },
   "engines": {
     "node": ">=22.19.0"

package/src/driver_decl.ts

@@ -7,6 +7,7 @@ import type {
   PFrameHandle,
   PObjectId,
   PTableDef,
+  PTableDefV2,
   PTableHandle,
   PTableShape,
   PTableVector,
@@ -40,7 +41,7 @@ export interface AbstractInternalPFrameDriver<PColumnData> extends PFrameDriver,
   createPTable(def: PTableDef<PColumn<PColumnData>>): PoolEntry<PTableHandle>;
 
   /** Create a new PTable by new Pframe-rs api */
-  createPTableV2(def: PTableDef<PColumn<PColumnData>>): PoolEntry<PTableHandle>;
+  createPTableV2(def: PTableDefV2<PColumn<PColumnData>>): PoolEntry<PTableHandle>;
 
   /** Calculates data for the table and returns complete data representation of it */
   calculateTableData(

package/src/driver_double.test.ts

@@ -1,8 +1,14 @@
 import {
   pTableValue,
+  canonicalizeJson,
+  filterSpecToSpecQueryExpr,
   type CalculateTableDataResponse,
   type PFrameDriver,
   type PObjectId,
+  type PTableColumnId,
+  type SpecQuery,
+  type SpecQueryExpression,
+  SpecQueryBooleanExpression,
 } from "@platforma-sdk/model";
 import { readJson, PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 import { test } from "vitest";
@@ -143,7 +149,7 @@ test.for([{ testCase: "01_json" }, { testCase: "02_binary" }, { testCase: "03_pa
   },
 );
 
-test.skip("createTableV2 support", async ({ expect }) => {
+test("createTableV2 support", async ({ expect }) => {
   await using driver = await createPFrameDriverDouble({});
 
   const columnId = "column1" as PObjectId;
@@ -159,33 +165,144 @@ test.skip("createTableV2 support", async ({ expect }) => {
     valueType: "Int" as const,
   };
 
-  using pTable = driver.createPTableV2({
-    src: {
-      type: "column",
-      column: {
-        id: columnId,
-        spec: columnSpec,
-        data: [
-          { key: ["a"], val: 10 },
-          { key: ["b"], val: 20 },
+  const axisColumnStr = canonicalizeJson<PTableColumnId>({
+    type: "axis",
+    id: { name: "axis1", type: "String" },
+  }) as string;
+
+  const valueColumnStr = canonicalizeJson<PTableColumnId>({
+    type: "column",
+    id: columnId,
+  }) as string;
+
+  const inlineData = [
+    { key: ["a"], val: 10 },
+    { key: ["b"], val: 20 },
+    { key: ["c"], val: 30 },
+    { key: ["d"], val: 5 },
+  ];
+
+  const column = { id: columnId, spec: columnSpec, data: inlineData };
+
+  const columnRef: SpecQueryExpression = { type: "columnRef", value: columnId };
+
+  const baseQuery: SpecQuery<typeof column> = { type: "column", column };
+
+  const uiDriver: PFrameDriver = driver;
+
+  // --- No filters, no sorting ---
+  {
+    using pTable = driver.createPTableV2({
+      query: baseQuery,
+    });
+
+    const shape = await uiDriver.getShape(pTable.key);
+    expect(shape.rows).toBe(4);
+    expect(shape.columns).toBe(2); // 1 axis + 1 value column
+
+    const data = await uiDriver.getData(pTable.key, [0, 1]);
+    expect(data[0].type).toBe("String");
+    expect([...data[0].data]).toEqual(["a", "b", "c", "d"]);
+    expect(data[1].type).toBe("Int");
+    expect([...data[1].data]).toEqual([10, 20, 30, 5]);
+  }
+
+  // --- With patternEquals filter on axis ---
+  {
+    using pTable = driver.createPTableV2({
+      query: {
+        type: "filter",
+        input: baseQuery,
+        predicate: filterSpecToSpecQueryExpr({
+          type: "patternEquals",
+          column: axisColumnStr,
+          value: "b",
+        }) as SpecQueryBooleanExpression,
+      },
+    });
+
+    const shape = await uiDriver.getShape(pTable.key);
+    expect(shape.rows).toBe(1);
+
+    const data = await uiDriver.getData(pTable.key, [0, 1]);
+    expect([...data[0].data]).toEqual(["b"]);
+    expect([...data[1].data]).toEqual([20]);
+  }
+
+  // --- With greaterThan filter on value column ---
+  {
+    using pTable = driver.createPTableV2({
+      query: {
+        type: "filter",
+        input: baseQuery,
+        predicate: filterSpecToSpecQueryExpr({
+          type: "greaterThan",
+          column: valueColumnStr,
+          x: 15,
+        }) as SpecQueryBooleanExpression,
+      },
+    });
+
+    const shape = await uiDriver.getShape(pTable.key);
+    expect(shape.rows).toBe(2);
+
+    const data = await uiDriver.getData(pTable.key, [0, 1]);
+    expect([...data[0].data]).toEqual(["b", "c"]);
+    expect([...data[1].data]).toEqual([20, 30]);
+  }
+
+  // --- With sorting descending by value column ---
+  {
+    using pTable = driver.createPTableV2({
+      query: {
+        type: "sort",
+        input: baseQuery,
+        sortBy: [
+          {
+            expression: columnRef,
+            ascending: false,
+            nullsFirst: true,
+          },
         ],
       },
-    },
-    partitionFilters: [],
-    filters: [],
-    sorting: [],
-  });
+    });
 
-  const uiDriver: PFrameDriver = driver;
-  const shape = await uiDriver.getShape(pTable.key);
-  expect(shape.rows).toBe(2);
-  expect(shape.columns).toBe(2); // 1 axis + 1 value column
-
-  const data = await uiDriver.getData(pTable.key, [0, 1]);
-  // axis column
-  expect(data[0].type).toBe("String");
-  expect([...data[0].data]).toEqual(["a", "b"]);
-  // value column
-  expect(data[1].type).toBe("Int");
-  expect([...data[1].data]).toEqual([10, 20]);
+    const data = await uiDriver.getData(pTable.key, [0, 1]);
+    expect([...data[0].data]).toEqual(["c", "b", "a", "d"]);
+    expect([...data[1].data]).toEqual([30, 20, 10, 5]);
+  }
+
+  // --- With combined filter + sorting ---
+  {
+    using pTable = driver.createPTableV2({
+      query: {
+        type: "sort",
+        input: {
+          type: "filter",
+          input: baseQuery,
+          predicate: filterSpecToSpecQueryExpr({
+            type: "and",
+            filters: [
+              { type: "greaterThan", column: valueColumnStr, x: 5 },
+              { type: "patternNotEquals", column: axisColumnStr, value: "c" },
+            ],
+          }) as SpecQueryBooleanExpression,
+        },
+        sortBy: [
+          {
+            expression: columnRef,
+            ascending: false,
+            nullsFirst: true,
+          },
+        ],
+      },
+    });
+
+    const shape = await uiDriver.getShape(pTable.key);
+    expect(shape.rows).toBe(2);
+
+    const data = await uiDriver.getData(pTable.key, [0, 1]);
+    expect([...data[0].data]).toEqual(["b", "a"]);
+    expect([...data[1].data]).toEqual([20, 10]);
+  }
 });

package/src/driver_impl.ts

@@ -3,7 +3,6 @@ import {
   mapPTableDef,
   extractAllColumns,
   uniqueBy,
-  getAxisId,
   canonicalizeJson,
   bigintReplacer,
   ValueType,
@@ -24,11 +23,16 @@ import {
   type UniqueValuesResponse,
   type PColumn,
   type PFrameDef,
-  type JoinEntry,
   type PTableDef,
   type PTableRecordSingleValueFilterV2,
   type PTableRecordFilter,
   type JsonSerializable,
+  type PTableDefV2,
+  type SpecQuery,
+  mapQuerySpec,
+  collectQueryColumns,
+  sortQuerySpec,
+  sortPTableDef,
 } from "@platforma-sdk/model";
 import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 import {
@@ -57,9 +61,8 @@ import {
   PTableCachePlainOpsDefaults,
   type PTableCachePlainOps,
 } from "./ptable_cache_plain";
-// import { createPFrame as createSpecFrame } from "@milaboratories/pframes-rs-wasm";
+import { createPFrame as createSpecFrame } from "@milaboratories/pframes-rs-wasm";
 
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface LocalBlobProvider<
   TreeEntry extends JsonSerializable,
 > extends PoolLocalBlobProvider<TreeEntry> {}
@@ -206,50 +209,47 @@ export class AbstractPFrameDriver<
     };
   }
 
-  public createPTableV2(_rawDef: PTableDef<PColumn<PColumnData>>): PoolEntry<PTableHandle> {
-    throw new Error("createPTableV2 is not implemented yet");
-    // const columns = extractAllColumns(rawDef.src);
-    // const pFrameEntry = this.createPFrame(columns);
-
-    // const columnsMap = columns.reduce(
-    //   (acc, col) => ((acc[col.id] = col.spec), acc),
-    //   {} as Record<string, PColumnSpec>,
-    // );
-    // const sortedDef = sortPTableDef(
-    //   migratePTableFilters(
-    //     mapPTableDef(rawDef, (c) => c.id),
-    //     this.logger,
-    //   ),
-    // );
-    // const specFrame = createSpecFrame(columnsMap);
-    // const specQuery = specFrame.rewriteLegacyQuery(sortedDef);
-    // const { tableSpec, dataQuery } = specFrame.evaluateQuery(specQuery);
-
-    // const pTableEntry = this.pTableDefs.acquire({
-    //   type: "v2",
-    //   pFrameHandle: pFrameEntry.key,
-    //   def: {
-    //     tableSpec,
-    //     dataQuery,
-    //   },
-    // });
-    // if (logPFrames()) {
-    //   this.logger(
-    //     "info",
-    //     `Create PTable call (pFrameHandle = ${pFrameEntry.key}; pTableHandle = ${pTableEntry.key})`,
-    //   );
-    // }
-
-    // const unref = () => {
-    //   pTableEntry.unref();
-    //   pFrameEntry.unref();
-    // };
-    // return {
-    //   key: pTableEntry.key,
-    //   resource: pTableEntry.resource,
-    //   unref,
-    //   [Symbol.dispose]: unref,
-    // };
+  public createPTableV2(def: PTableDefV2<PColumn<PColumnData>>): PoolEntry<PTableHandle> {
+    const columns = uniqueBy(collectQueryColumns(def.query), (c) => c.id);
+    const columnsMap = columns.reduce(
+      (acc, col) => ((acc[col.id] = col.spec), acc),
+      {} as Record<string, PColumnSpec>,
+    );
+
+    const pFrameEntry = this.createPFrame(columns);
+    const specFrame = createSpecFrame(columnsMap);
+    const sortedQuery = sortQuerySpec(mapQuerySpec(def.query, (c) => c.id));
+    const { tableSpec, dataQuery } = specFrame.evaluateQuery(
+      // WASM crate expects `columnId` field name, our types use `column`
+      // @todo: remove it after update wasm package
+      querySpecToWasm(sortedQuery) as SpecQuery,
+    );
+
+    const pTableEntry = this.pTableDefs.acquire({
+      type: "v2",
+      pFrameHandle: pFrameEntry.key,
+      def: {
+        tableSpec,
+        dataQuery,
+      },
+    });
+    if (logPFrames()) {
+      this.logger(
+        "info",
+        `Create PTable call (pFrameHandle = ${pFrameEntry.key}; pTableHandle = ${pTableEntry.key})`,
+      );
+    }
+
+    const unref = () => {
+      pTableEntry.unref();
+      pFrameEntry.unref();
+    };
+    return {
+      key: pTableEntry.key,
+      resource: pTableEntry.resource,
+      unref,
+      [Symbol.dispose]: unref,
+    };
   }
 
   //
@@ -459,110 +459,47 @@ export class AbstractPFrameDriver<
   }
 }
 
-function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId> {
-  function cmpJoinEntries(lhs: JoinEntry<PObjectId>, rhs: JoinEntry<PObjectId>): number {
-    if (lhs.type !== rhs.type) {
-      return lhs.type < rhs.type ? -1 : 1;
-    }
-    const type = lhs.type;
-    switch (type) {
-      case "column":
-        return lhs.column < (rhs as typeof lhs).column ? -1 : 1;
-      case "slicedColumn":
-      case "artificialColumn":
-        return lhs.newId < (rhs as typeof lhs).newId ? -1 : 1;
-      case "inlineColumn": {
-        return lhs.column.id < (rhs as typeof lhs).column.id ? -1 : 1;
-      }
-      case "inner":
-      case "full": {
-        const rhsInner = rhs as typeof lhs;
-        if (lhs.entries.length !== rhsInner.entries.length) {
-          return lhs.entries.length - rhsInner.entries.length;
-        }
-        for (let i = 0; i < lhs.entries.length; i++) {
-          const cmp = cmpJoinEntries(lhs.entries[i], rhsInner.entries[i]);
-          if (cmp !== 0) {
-            return cmp;
-          }
-        }
-        return 0;
-      }
-      case "outer": {
-        const rhsOuter = rhs as typeof lhs;
-        const cmp = cmpJoinEntries(lhs.primary, rhsOuter.primary);
-        if (cmp !== 0) {
-          return cmp;
-        }
-        if (lhs.secondary.length !== rhsOuter.secondary.length) {
-          return lhs.secondary.length - rhsOuter.secondary.length;
-        }
-        for (let i = 0; i < lhs.secondary.length; i++) {
-          const cmp = cmpJoinEntries(lhs.secondary[i], rhsOuter.secondary[i]);
-          if (cmp !== 0) {
-            return cmp;
-          }
-        }
-        return 0;
-      }
-      default:
-        assertNever(type);
+/**
+ * Converts a SpecQuery to the format expected by the WASM crate.
+ * Renames `column` → `columnId` in leaf nodes (QueryColumn, QuerySparseToDenseColumn).
+ */
+function querySpecToWasm(query: SpecQuery): unknown {
+  switch (query.type) {
+    case "column":
+      return { type: "column", columnId: query.column };
+    case "sparseToDenseColumn": {
+      const { column, ...rest } = query;
+      return { ...rest, columnId: column };
     }
+    case "inlineColumn":
+      return query;
+    case "innerJoin":
+    case "fullJoin":
+      return {
+        ...query,
+        entries: query.entries.map((e) => ({
+          ...e,
+          entry: querySpecToWasm(e.entry),
+        })),
+      };
+    case "outerJoin":
+      return {
+        ...query,
+        primary: { ...query.primary, entry: querySpecToWasm(query.primary.entry) },
+        secondary: query.secondary.map((e) => ({
+          ...e,
+          entry: querySpecToWasm(e.entry),
+        })),
+      };
+    case "filter":
+      return { ...query, input: querySpecToWasm(query.input) };
+    case "sort":
+      return { ...query, input: querySpecToWasm(query.input) };
+    case "sliceAxes":
+      return { ...query, input: querySpecToWasm(query.input) };
+    default:
+      assertNever(query);
   }
-  function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId> {
-    switch (entry.type) {
-      case "column":
-      case "slicedColumn":
-      case "inlineColumn":
-        return entry;
-      case "artificialColumn": {
-        const sortedAxesIndices = entry.axesIndices.toSorted((lhs, rhs) => lhs - rhs);
-        return {
-          ...entry,
-          axesIndices: sortedAxesIndices,
-        };
-      }
-      case "inner":
-      case "full": {
-        const sortedEntries = entry.entries.map(sortJoinEntry);
-        sortedEntries.sort(cmpJoinEntries);
-        return {
-          ...entry,
-          entries: sortedEntries,
-        };
-      }
-      case "outer": {
-        const sortedSecondary = entry.secondary.map(sortJoinEntry);
-        sortedSecondary.sort(cmpJoinEntries);
-        return {
-          ...entry,
-          primary: sortJoinEntry(entry.primary),
-          secondary: sortedSecondary,
-        };
-      }
-      default:
-        assertNever(entry);
-    }
-  }
-  function sortFilters(filters: PTableRecordFilter[]): PTableRecordFilter[] {
-    return filters.toSorted((lhs, rhs) => {
-      if (lhs.column.type === "axis" && rhs.column.type === "axis") {
-        const lhsId = canonicalizeJson(getAxisId(lhs.column.id));
-        const rhsId = canonicalizeJson(getAxisId(rhs.column.id));
-        return lhsId < rhsId ? -1 : 1;
-      } else if (lhs.column.type === "column" && rhs.column.type === "column") {
-        return lhs.column.id < rhs.column.id ? -1 : 1;
-      } else {
-        return lhs.column.type === "axis" ? -1 : 1;
-      }
-    });
-  }
-  return {
-    src: sortJoinEntry(def.src),
-    partitionFilters: sortFilters(def.partitionFilters),
-    filters: sortFilters(def.filters),
-    sorting: def.sorting,
-  };
 }
 
 function migrateFilters(

package/src/ptable_pool.ts

@@ -152,7 +152,7 @@ export class PTablePool<TreeEntry extends JsonSerializable> extends RefCountPool
     const defDisposeSignal = this.pTableDefs.tryGetByKey(key)?.disposeSignal;
     const combinedSignal = AbortSignal.any([disposeSignal, defDisposeSignal].filter((s) => !!s));
 
-    const table = pFramePromise.then((pFrame) => pFrame.createTableByV2(key, params.def));
+    const table = pFramePromise.then((pFrame) => pFrame.createTableV2(key, params.def));
     return new PTableHolder(pFrameHandle, combinedSignal, table);
   }
 
@@ -237,7 +237,6 @@ function joinEntryToInternal(entry: JoinEntry<PObjectId>): PFrameInternal.JoinEn
         secondary: entry.secondary.map((col) => joinEntryToInternal(col)),
       };
     default:
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
       throw new PFrameDriverError(`unsupported PFrame join entry type: ${type satisfies never}`);
   }
 }

package/src/ptable_shared.ts

@@ -3,7 +3,7 @@ import type {
   PFrameHandle,
   PTableDef,
   PTableHandle,
-  QueryData,
+  DataQuery,
   PTableColumnSpec,
 } from "@platforma-sdk/model";
 import { hashJson } from "@milaboratories/pl-model-middle-layer";
@@ -19,7 +19,7 @@ export type FullPTableDefV2 = {
   pFrameHandle: PFrameHandle;
   def: {
     tableSpec: PTableColumnSpec[];
-    dataQuery: QueryData;
+    dataQuery: DataQuery;
   };
 };