@milaboratories/pf-driver 1.0.39 → 1.0.41

package/src/driver_double.test.ts

@@ -3,40 +3,38 @@ import {
   type CalculateTableDataResponse,
   type PFrameDriver,
   type PObjectId,
-} from '@platforma-sdk/model';
-import {
-  readJson,
-  PFrameInternal,
-} from '@milaboratories/pl-model-middle-layer';
-import { test } from 'vitest';
-import { join } from 'node:path';
-import {
-  createPFrameDriverDouble,
-  makeFolderPath,
-} from './driver_double';
+} from "@platforma-sdk/model";
+import { readJson, PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { test } from "vitest";
+import { join } from "node:path";
+import { createPFrameDriverDouble, makeFolderPath } from "./driver_double";
 
-test('inline column support', async ({ expect }) => {
+test("inline column support", async ({ expect }) => {
   // Model context
 
   await using driver = await createPFrameDriverDouble({});
-  using pFrame = driver.createPFrame([{
-    id: 'column1' as PObjectId,
-    spec: {
-      kind: 'PColumn',
-      axesSpec: [{
-        name: 'axis1',
-        type: 'String',
-      }],
-      name: 'column1',
-      valueType: 'Int',
-    },
-    data: [
-      {
-        key: ['axis1'],
-        val: 1,
+  using pFrame = driver.createPFrame([
+    {
+      id: "column1" as PObjectId,
+      spec: {
+        kind: "PColumn",
+        axesSpec: [
+          {
+            name: "axis1",
+            type: "String",
+          },
+        ],
+        name: "column1",
+        valueType: "Int",
       },
-    ],
-  }]);
+      data: [
+        {
+          key: ["axis1"],
+          val: 1,
+        },
+      ],
+    },
+  ]);
 
   // UI context
 
@@ -45,8 +43,8 @@ test('inline column support', async ({ expect }) => {
 
   const data = await uiDriver.calculateTableData(pFrameHandle, {
     src: {
-      type: 'column',
-      column: 'column1' as PObjectId,
+      type: "column",
+      column: "column1" as PObjectId,
     },
     filters: [],
     sorting: [],
@@ -55,39 +53,41 @@ test('inline column support', async ({ expect }) => {
   expect(data).toEqual([
     {
       spec: {
-        type: 'axis',
+        type: "axis",
         id: {
-          name: 'axis1',
-          type: 'String',
+          name: "axis1",
+          type: "String",
         },
         spec: {
-          name: 'axis1',
-          type: 'String',
+          name: "axis1",
+          type: "String",
         },
       },
       data: {
-        type: 'String',
-        data: ['axis1'],
+        type: "String",
+        data: ["axis1"],
         isNA: new Uint8Array(),
         absent: new Uint8Array(),
       },
     },
     {
       spec: {
-        type: 'column',
-        id: 'column1' as PObjectId,
+        type: "column",
+        id: "column1" as PObjectId,
         spec: {
-          kind: 'PColumn',
-          axesSpec: [{
-            name: 'axis1',
-            type: 'String',
-          }],
-          name: 'column1',
-          valueType: 'Int',
+          kind: "PColumn",
+          axesSpec: [
+            {
+              name: "axis1",
+              type: "String",
+            },
+          ],
+          name: "column1",
+          valueType: "Int",
         },
       },
       data: {
-        type: 'Int',
+        type: "Int",
         data: new Int32Array([1]),
         isNA: new Uint8Array(),
         absent: new Uint8Array(),
@@ -96,43 +96,49 @@ test('inline column support', async ({ expect }) => {
   ] satisfies CalculateTableDataResponse);
 });
 
-test.for([
-  { testCase: '01_json' },
-  { testCase: '02_binary' },
-  { testCase: '03_parquet' },
-])(`stored column support - $testCase`, async ({ testCase }, { expect }) => {
-  const dataFolder = makeFolderPath(join(__dirname, '..', 'assets', testCase));
+test.for([{ testCase: "01_json" }, { testCase: "02_binary" }, { testCase: "03_parquet" }])(
+  `stored column support - $testCase`,
+  async ({ testCase }, { expect }) => {
+    const dataFolder = makeFolderPath(join(__dirname, "..", "assets", testCase));
 
-  // Model context
+    // Model context
 
-  await using driver = await createPFrameDriverDouble({ dataFolder });
-  const pFrame = driver.createPFrame([{
-    id: 'column' as PObjectId,
-    spec: await readJson(join(dataFolder, `column${PFrameInternal.SpecExtension}`)),
-    data: await readJson(join(dataFolder, `column${PFrameInternal.DataInfoExtension}`)),
-  }]);
+    await using driver = await createPFrameDriverDouble({ dataFolder });
+    const pFrame = driver.createPFrame([
+      {
+        id: "column" as PObjectId,
+        spec: await readJson(join(dataFolder, `column${PFrameInternal.SpecExtension}`)),
+        data: await readJson(join(dataFolder, `column${PFrameInternal.DataInfoExtension}`)),
+      },
+    ]);
 
-  // UI context
+    // UI context
 
-  const uiDriver: PFrameDriver = driver;
-  const pFrameHandle = pFrame.key;
+    const uiDriver: PFrameDriver = driver;
+    const pFrameHandle = pFrame.key;
 
-  const data = await uiDriver.calculateTableData(pFrameHandle, {
-    src: {
-      type: 'column',
-      column: 'column' as PObjectId,
-    },
-    filters: [],
-    sorting: [],
-  });
-  const result = {
-    spec: data.map((d) => d.spec),
-    data: data.map((d) => d.data)
-      .map((d) => [...d.data.keys()].map((i) => pTableValue(d, i, {
-        absent: '|~|',
-        na: null,
-      }))),
-  };
-  const expected = await readJson(join(dataFolder, 'response.json'));
-  expect(result).toEqual(expected);
-});
+    const data = await uiDriver.calculateTableData(pFrameHandle, {
+      src: {
+        type: "column",
+        column: "column" as PObjectId,
+      },
+      filters: [],
+      sorting: [],
+    });
+    const result = {
+      spec: data.map((d) => d.spec),
+      data: data
+        .map((d) => d.data)
+        .map((d) =>
+          [...d.data.keys()].map((i) =>
+            pTableValue(d, i, {
+              absent: "|~|",
+              na: null,
+            }),
+          ),
+        ),
+    };
+    const expected = await readJson(join(dataFolder, "response.json"));
+    expect(result).toEqual(expected);
+  },
+);

package/src/driver_double.ts

@@ -4,24 +4,24 @@ import {
   type Branded,
   type PColumnSpec,
   type PColumnValues,
-} from '@platforma-sdk/model';
-import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import { RefCountPoolBase, type PoolEntry } from '@milaboratories/ts-helpers';
-import { HttpHelpers } from '@milaboratories/pframes-rs-node';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import type { AbstractInternalPFrameDriver } from './driver_decl';
+} from "@platforma-sdk/model";
+import { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { RefCountPoolBase, type PoolEntry } from "@milaboratories/ts-helpers";
+import { HttpHelpers } from "@milaboratories/pframes-rs-node";
+import fs from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import type { AbstractInternalPFrameDriver } from "./driver_decl";
 import {
   AbstractPFrameDriver,
   type LocalBlobProvider,
   type RemoteBlobProvider,
-} from './driver_impl';
-import { makeJsonDataInfo } from './data_info_helpers';
+} from "./driver_impl";
+import { makeJsonDataInfo } from "./data_info_helpers";
 
-export type FileName = Branded<string, 'FileName'>;
-export type FilePath = Branded<string, 'FilePath'>;
-export type FolderPath = Branded<string, 'FolderPath'>;
+export type FileName = Branded<string, "FileName">;
+export type FilePath = Branded<string, "FilePath">;
+export type FolderPath = Branded<string, "FolderPath">;
 
 export function makeFolderPath(dataFolder: string): FolderPath {
   if (!fs.statSync(dataFolder, { throwIfNoEntry: false })?.isDirectory()) {
@@ -38,7 +38,8 @@ function makeBlobId(res: FileName): PFrameInternal.PFrameBlobId {
 
 class LocalBlobProviderImpl
   extends RefCountPoolBase<FileName, PFrameInternal.PFrameBlobId, FilePath>
-  implements LocalBlobProvider<FileName> {
+  implements LocalBlobProvider<FileName>
+{
   constructor(private readonly dataFolder: FolderPath) {
     super();
   }
@@ -67,7 +68,9 @@ class LocalBlobProviderImpl
     return resource;
   }
 
-  public makeDataSource(signal: AbortSignal): Omit<PFrameInternal.PFrameDataSourceV2, 'parquetServer'> {
+  public makeDataSource(
+    signal: AbortSignal,
+  ): Omit<PFrameInternal.PFrameDataSourceV2, "parquetServer"> {
     return {
       preloadBlob: async (_blobIds: PFrameInternal.PFrameBlobId[]) => {},
       resolveBlobContent: async (blobId: PFrameInternal.PFrameBlobId) => {
@@ -87,7 +90,7 @@ class RemoteBlobProviderImpl implements RemoteBlobProvider<FileName> {
   public static async init(
     dataFolder: FolderPath,
     logger: PFrameInternal.Logger,
-    serverOptions: Omit<PFrameInternal.HttpServerOptions, 'handler'>,
+    serverOptions: Omit<PFrameInternal.HttpServerOptions, "handler">,
   ): Promise<RemoteBlobProviderImpl> {
     const pool = new LocalBlobProviderImpl(dataFolder);
 
@@ -118,8 +121,9 @@ class RemoteBlobProviderImpl implements RemoteBlobProvider<FileName> {
   }
 }
 
-export type InternalPFrameDriverDouble =
-  AbstractInternalPFrameDriver<PFrameInternal.DataInfo<FileName> | PColumnValues>;
+export type InternalPFrameDriverDouble = AbstractInternalPFrameDriver<
+  PFrameInternal.DataInfo<FileName> | PColumnValues
+>;
 
 export async function createPFrameDriverDouble({
   dataFolder = tmpdir() as FolderPath,
@@ -134,7 +138,7 @@ export async function createPFrameDriverDouble({
   const resolveDataInfo = (
     spec: PColumnSpec,
     data: PFrameInternal.DataInfo<FileName> | PColumnValues,
-  ) => isDataInfo(data) ? data : makeJsonDataInfo(spec, data);
+  ) => (isDataInfo(data) ? data : makeJsonDataInfo(spec, data));
 
   return new AbstractPFrameDriver({
     logger,