@milaboratories/pframes-rs-node 1.1.3 → 1.1.5

package/export/tests/pframes.test.ts

@@ -1,26 +1,26 @@
 // Node.js core modules
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { tmpdir } from 'node:os';
-import type { Buffer } from 'node:buffer';
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { tmpdir } from "node:os";
+import type { Buffer } from "node:buffer";
 
 // Testing framework
-import { describe, test } from 'vitest';
+import { describe, test } from "vitest";
 
 // Project types and modules
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 import type {
   PObjectId,
   PTableColumnSpec,
   PTableSorting,
   PTableVector,
-  QueryData,
-  UniqueValuesResponse
-} from '@milaboratories/pl-model-common';
-import { PFrameFactory } from '..';
-import { PFrame } from '../wrapper';
-import { ulid } from 'ulid';
+  DataQuery,
+  UniqueValuesResponse,
+} from "@milaboratories/pl-model-common";
+import { PFrameFactory } from "..";
+import { PFrame } from "../wrapper";
+import { ulid } from "ulid";
 
 // ============================================================================
 // Test Utility Functions
@@ -30,8 +30,8 @@ import { ulid } from 'ulid';
  * Get the path to a test case directory
  */
 function getTestCaseDataPath(testCase: string): string {
-  const currentDirectoryPath = path.relative('.', __dirname);
-  const testDataPath = path.join(currentDirectoryPath, 'test_data');
+  const currentDirectoryPath = path.relative(".", __dirname);
+  const testDataPath = path.join(currentDirectoryPath, "test_data");
   return path.join(testDataPath, testCase);
 }
 
@@ -59,27 +59,21 @@ function readJsonTestFile(testCase: string, fileName: string): any {
 /**
  * Create a standard data source for tests that reads from test files
  */
-function createTestDataSource(
-  testCase: string
-): PFrameInternal.PFrameDataSourceV2 {
+function createTestDataSource(testCase: string): PFrameInternal.PFrameDataSourceV2 {
   return {
-    preloadBlob: function (
-      blobIds: PFrameInternal.PFrameBlobId[]
-    ): Promise<void> {
+    preloadBlob: function (blobIds: PFrameInternal.PFrameBlobId[]): Promise<void> {
       return new Promise((resolve) => {
         if (new Set(blobIds).size !== blobIds.length) {
-          throw new Error('preload requires array of unique values');
+          throw new Error("preload requires array of unique values");
         }
         resolve();
       });
     },
-    resolveBlobContent: function (
-      blobId: PFrameInternal.PFrameBlobId
-    ): Promise<Uint8Array> {
+    resolveBlobContent: function (blobId: PFrameInternal.PFrameBlobId): Promise<Uint8Array> {
       return new Promise((resolve) => {
         resolve(readTestFile(testCase, blobId));
       });
-    }
+    },
   };
 }
 
@@ -89,8 +83,7 @@ function createTestDataSource(
 function createFailingDataSource(): PFrameInternal.PFrameDataSourceV2 {
   return {
     preloadBlob: (): Promise<void> => Promise.resolve(),
-    resolveBlobContent: (): Promise<Uint8Array> =>
-      Promise.reject(new Error('fail'))
+    resolveBlobContent: (): Promise<Uint8Array> => Promise.reject(new Error("fail")),
   };
 }
 
@@ -102,7 +95,7 @@ async function readPFrame(testCase: string): Promise<PFrame> {
   const dataSource = createTestDataSource(testCase);
   const pframe = PFrameFactory.createPFrame({
     frameId: ulid() as PFrameInternal.PFrameId,
-    spillPath: tmpdir() /*, logger: console.log */
+    spillPath: tmpdir() /*, logger: console.log */,
   });
   pframe.setDataSource(dataSource);
 
@@ -110,12 +103,12 @@ async function readPFrame(testCase: string): Promise<PFrame> {
   const files = fs.readdirSync(testCasePath);
 
   for (const file of files) {
-    if (file.endsWith('.spec')) {
-      const columnId = file.replace('.spec', '') as PObjectId;
+    if (file.endsWith(".spec")) {
+      const columnId = file.replace(".spec", "") as PObjectId;
       const columnSpec = readJsonTestFile(testCase, file);
       pframe.addColumnSpec(columnId, columnSpec);
 
-      const dataInfoFile = file.replace('.spec', '.datainfo');
+      const dataInfoFile = file.replace(".spec", ".datainfo");
       if (files.includes(dataInfoFile)) {
         const dataInfo = readJsonTestFile(testCase, dataInfoFile);
         await pframe.setColumnData(columnId, dataInfo);
@@ -130,18 +123,18 @@ async function readPFrame(testCase: string): Promise<PFrame> {
 // Test Suites
 // ============================================================================
 
-describe('PFrame Column Operations', () => {
-  test.concurrent('find_columns_request', async ({ expect }) => {
-    const testCase = 'find_columns_request';
+describe("PFrame Column Operations", () => {
+  test.concurrent("find_columns_request", async ({ expect }) => {
+    const testCase = "find_columns_request";
 
-    const columnId = 'column1' as PObjectId;
-    const columnSpec = readJsonTestFile(testCase, 'column.spec');
-    const request = readJsonTestFile(testCase, 'request.json');
-    const expectedResponse = readJsonTestFile(testCase, 'response.json');
+    const columnId = "column1" as PObjectId;
+    const columnSpec = readJsonTestFile(testCase, "column.spec");
+    const request = readJsonTestFile(testCase, "request.json");
+    const expectedResponse = readJsonTestFile(testCase, "response.json");
 
     using pframe = PFrameFactory.createPFrame({
       frameId: ulid() as PFrameInternal.PFrameId,
-      spillPath: tmpdir()
+      spillPath: tmpdir(),
     });
     pframe.addColumnSpec(columnId, columnSpec);
 
@@ -149,58 +142,56 @@ describe('PFrame Column Operations', () => {
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('get_column_spec_request', async ({ expect }) => {
-    const testCase = 'get_column_spec_request';
+  test.concurrent("get_column_spec_request", async ({ expect }) => {
+    const testCase = "get_column_spec_request";
 
-    const columnId = 'column1' as PObjectId;
-    const columnSpec = readJsonTestFile(testCase, 'column.spec');
-    const expectedResponse = readJsonTestFile(testCase, 'response.json');
+    const columnId = "column1" as PObjectId;
+    const columnSpec = readJsonTestFile(testCase, "column.spec");
+    const expectedResponse = readJsonTestFile(testCase, "response.json");
 
     using pframe = PFrameFactory.createPFrame({
       frameId: ulid() as PFrameInternal.PFrameId,
-      spillPath: tmpdir()
+      spillPath: tmpdir(),
     });
     pframe.addColumnSpec(columnId, columnSpec);
 
     const actualResponse = await pframe.getColumnSpec(columnId);
     expect(actualResponse).toEqual(expectedResponse);
 
-    const unknownColumnId = 'unknown_column1' as PObjectId;
+    const unknownColumnId = "unknown_column1" as PObjectId;
     const unknownColumnSpec = await pframe.getColumnSpec(unknownColumnId);
     expect(unknownColumnSpec).toBeNull();
 
     const columnList = await pframe.listColumns();
-    expect(columnList).toEqual([
-      { columnId: columnId, spec: columnSpec, hasData: false }
-    ]);
+    expect(columnList).toEqual([{ columnId: columnId, spec: columnSpec, hasData: false }]);
   });
 
-  test.concurrent('delete_column_request', async ({ expect }) => {
-    const testCase = 'delete_column_request';
+  test.concurrent("delete_column_request", async ({ expect }) => {
+    const testCase = "delete_column_request";
 
-    const request = readJsonTestFile(testCase, 'request.json');
-    const expectedResponse = readJsonTestFile(testCase, 'response.json');
+    const request = readJsonTestFile(testCase, "request.json");
+    const expectedResponse = readJsonTestFile(testCase, "response.json");
 
     using pframe = PFrameFactory.createPFrame({
       frameId: ulid() as PFrameInternal.PFrameId,
-      spillPath: tmpdir()
+      spillPath: tmpdir(),
     });
 
     const actualResponse = await pframe.deleteColumn(request);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('set_column_data_request', async ({ expect }) => {
-    const testCase = 'set_column_data_request';
+  test.concurrent("set_column_data_request", async ({ expect }) => {
+    const testCase = "set_column_data_request";
 
-    const columnId = 'column1' as PObjectId;
-    const columnSpec = readJsonTestFile(testCase, 'column.spec');
-    const dataInfo = readJsonTestFile(testCase, 'column.datainfo');
+    const columnId = "column1" as PObjectId;
+    const columnSpec = readJsonTestFile(testCase, "column.spec");
+    const dataInfo = readJsonTestFile(testCase, "column.datainfo");
     const dataSource = createTestDataSource(testCase);
 
     using pframe = PFrameFactory.createPFrame({
       frameId: ulid() as PFrameInternal.PFrameId,
-      spillPath: tmpdir()
+      spillPath: tmpdir(),
     });
     pframe.setDataSource(dataSource);
 
@@ -208,33 +199,31 @@ describe('PFrame Column Operations', () => {
     await pframe.setColumnData(columnId, dataInfo);
 
     const columnList = await pframe.listColumns();
-    expect(columnList).toEqual([
-      { columnId: columnId, spec: columnSpec, hasData: true }
-    ]);
+    expect(columnList).toEqual([{ columnId: columnId, spec: columnSpec, hasData: true }]);
   });
 
-  test.concurrent('unique_values_request', async ({ expect }) => {
-    const testCase = 'unique_values_request';
+  test.concurrent("unique_values_request", async ({ expect }) => {
+    const testCase = "unique_values_request";
 
-    const columnId = 'column' as PObjectId;
-    const columnSpec = readJsonTestFile(testCase, 'column.spec');
-    const dataInfo = readJsonTestFile(testCase, 'column.datainfo');
+    const columnId = "column" as PObjectId;
+    const columnSpec = readJsonTestFile(testCase, "column.spec");
+    const dataInfo = readJsonTestFile(testCase, "column.datainfo");
     const dataSource = createTestDataSource(testCase);
-    const request = readJsonTestFile(testCase, 'request.json');
+    const request = readJsonTestFile(testCase, "request.json");
 
     const expectedResponse: UniqueValuesResponse = {
       values: {
-        type: 'Long',
+        type: "Long",
         data: new BigInt64Array([BigInt(10), BigInt(11), BigInt(12)]),
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
-      overflow: false
+      overflow: false,
     };
 
     using pframe = PFrameFactory.createPFrame({
       frameId: ulid() as PFrameInternal.PFrameId,
-      spillPath: tmpdir()
+      spillPath: tmpdir(),
     });
     pframe.setDataSource(dataSource);
 
@@ -246,448 +235,394 @@ describe('PFrame Column Operations', () => {
   });
 });
 
-describe('PFrame Table Creation', () => {
+describe("PFrame Table Creation", () => {
   // Expected responses for table creation tests
   const createTableExpectedResponses = {
     request1: [
       {
-        type: 'Int' as const,
+        type: "Int" as const,
         data: new Int32Array([10]),
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'Float' as const,
+        type: "Float" as const,
         data: new Float32Array([10.0]),
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
-      }
+        absent: new Uint8Array(),
+      },
     ] as PTableVector[],
     request2: [
       {
-        type: 'Long' as const,
+        type: "Long" as const,
         data: new BigInt64Array([BigInt(10)]),
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'Double' as const,
+        type: "Double" as const,
         data: new Float64Array([10.0]),
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
-      }
+        absent: new Uint8Array(),
+      },
     ] as PTableVector[],
     request3: [
       {
-        type: 'String' as const,
-        data: ['10'],
+        type: "String" as const,
+        data: ["10"],
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'Bytes' as const,
+        type: "Bytes" as const,
         data: [new Uint8Array([49, 48])],
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
-      }
+        absent: new Uint8Array(),
+      },
     ] as PTableVector[],
     request4: [
       {
-        type: 'String' as const,
-        data: ['10'],
+        type: "String" as const,
+        data: ["10"],
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'Float' as const,
+        type: "Float" as const,
         data: new Float32Array([NaN]),
         isNA: new Uint8Array([128]),
-        absent: new Uint8Array()
-      }
-    ] as PTableVector[]
+        absent: new Uint8Array(),
+      },
+    ] as PTableVector[],
   };
 
-  test.concurrent('create_table_request_1', async ({ expect }) => {
-    const testCase = 'create_table_request_1';
-    const request = readJsonTestFile(testCase, 'request.json');
+  test.concurrent("create_table_request_1", async ({ expect }) => {
+    const testCase = "create_table_request_1";
+    const request = readJsonTestFile(testCase, "request.json");
     const expectedResponse = createTableExpectedResponses.request1;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTable(
-      ulid() as PFrameInternal.PTableId,
-      request
-    );
+    using table = pframe.createTable(ulid() as PFrameInternal.PTableId, request);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_request_2', async ({ expect }) => {
-    const testCase = 'create_table_request_2';
-    const request = readJsonTestFile(testCase, 'request.json');
+  test.concurrent("create_table_request_2", async ({ expect }) => {
+    const testCase = "create_table_request_2";
+    const request = readJsonTestFile(testCase, "request.json");
     const expectedResponse = createTableExpectedResponses.request2;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTable(
-      ulid() as PFrameInternal.PTableId,
-      request
-    );
+    using table = pframe.createTable(ulid() as PFrameInternal.PTableId, request);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_request_3', async ({ expect }) => {
-    const testCase = 'create_table_request_3';
-    const request = readJsonTestFile(testCase, 'request.json');
+  test.concurrent("create_table_request_3", async ({ expect }) => {
+    const testCase = "create_table_request_3";
+    const request = readJsonTestFile(testCase, "request.json");
     const expectedResponse = createTableExpectedResponses.request3;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTable(
-      ulid() as PFrameInternal.PTableId,
-      request
-    );
+    using table = pframe.createTable(ulid() as PFrameInternal.PTableId, request);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_request_4', async ({ expect }) => {
-    const testCase = 'create_table_request_4';
-    const request = readJsonTestFile(testCase, 'request.json');
+  test.concurrent("create_table_request_4", async ({ expect }) => {
+    const testCase = "create_table_request_4";
+    const request = readJsonTestFile(testCase, "request.json");
     const expectedResponse = createTableExpectedResponses.request4;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTable(
-      ulid() as PFrameInternal.PTableId,
-      request
-    );
+    using table = pframe.createTable(ulid() as PFrameInternal.PTableId, request);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_request_fail', async ({ expect }) => {
-    const testCase = 'create_table_request_fail';
+  test.concurrent("create_table_request_fail", async ({ expect }) => {
+    const testCase = "create_table_request_fail";
 
-    const columnId = 'column' as PObjectId;
-    const columnSpec = readJsonTestFile(testCase, 'column.spec');
-    const dataInfo = readJsonTestFile(testCase, 'column.datainfo');
+    const columnId = "column" as PObjectId;
+    const columnSpec = readJsonTestFile(testCase, "column.spec");
+    const dataInfo = readJsonTestFile(testCase, "column.datainfo");
     const dataSource = createFailingDataSource();
-    const request = readJsonTestFile(testCase, 'request.json');
+    const request = readJsonTestFile(testCase, "request.json");
 
     using pframe = PFrameFactory.createPFrame({
       frameId: ulid() as PFrameInternal.PFrameId,
-      spillPath: tmpdir()
+      spillPath: tmpdir(),
     });
     pframe.setDataSource(dataSource);
 
     pframe.addColumnSpec(columnId, columnSpec);
     await pframe.setColumnData(columnId, dataInfo);
 
-    using table = pframe.createTable(
-      ulid() as PFrameInternal.PTableId,
-      request
-    );
+    using table = pframe.createTable(ulid() as PFrameInternal.PTableId, request);
 
     await expect(table.getShape()).rejects.toThrow();
   });
 
-  // QueryData requests for createTableV2 tests
+  // DataQuery requests for createTableV2 tests
   const createTableV2Requests = {
     request1: {
       tableSpec: [
         {
-          type: 'axis',
-          id: { name: 'axis', type: 'Int' },
-          spec: { name: 'axis', type: 'Int' }
+          type: "axis",
+          id: { name: "axis", type: "Int" },
+          spec: { name: "axis", type: "Int" },
         },
         {
-          type: 'column',
-          id: 'column',
+          type: "column",
+          id: "column",
           spec: {
-            kind: 'PColumn',
-            axesSpec: [{ name: 'axis', type: 'Int' }],
-            name: 'column',
-            valueType: 'Float'
-          }
-        }
+            kind: "PColumn",
+            axesSpec: [{ name: "axis", type: "Int" }],
+            name: "column",
+            valueType: "Float",
+          },
+        },
       ] as PTableColumnSpec[],
-      dataQuery: { type: 'column', columnId: 'column' } as QueryData
+      dataQuery: { type: "column", column: "column" } as DataQuery,
     },
     request2: {
       tableSpec: [
         {
-          type: 'axis',
-          id: { name: 'axis', type: 'Long' },
-          spec: { name: 'axis', type: 'Long' }
+          type: "axis",
+          id: { name: "axis", type: "Long" },
+          spec: { name: "axis", type: "Long" },
         },
         {
-          type: 'column',
-          id: 'column',
+          type: "column",
+          id: "column",
           spec: {
-            kind: 'PColumn',
-            axesSpec: [{ name: 'axis', type: 'Long' }],
-            name: 'column',
-            valueType: 'Double'
-          }
-        }
+            kind: "PColumn",
+            axesSpec: [{ name: "axis", type: "Long" }],
+            name: "column",
+            valueType: "Double",
+          },
+        },
       ] as PTableColumnSpec[],
-      dataQuery: { type: 'column', columnId: 'column' } as QueryData
+      dataQuery: { type: "column", column: "column" } as DataQuery,
     },
     request3: {
       tableSpec: [
         {
-          type: 'axis',
-          id: { name: 'axis', type: 'String' },
-          spec: { name: 'axis', type: 'String' }
+          type: "axis",
+          id: { name: "axis", type: "String" },
+          spec: { name: "axis", type: "String" },
         },
         {
-          type: 'column',
-          id: 'column',
+          type: "column",
+          id: "column",
           spec: {
-            kind: 'PColumn',
-            axesSpec: [{ name: 'axis', type: 'String' }],
-            name: 'column',
-            valueType: 'Bytes'
-          }
-        }
+            kind: "PColumn",
+            axesSpec: [{ name: "axis", type: "String" }],
+            name: "column",
+            valueType: "Bytes",
+          },
+        },
       ] as PTableColumnSpec[],
-      dataQuery: { type: 'column', columnId: 'column' } as QueryData
+      dataQuery: { type: "column", column: "column" } as DataQuery,
     },
     request4: {
       tableSpec: [
         {
-          type: 'axis',
-          id: { name: 'axis', type: 'String' },
-          spec: { name: 'axis', type: 'String' }
+          type: "axis",
+          id: { name: "axis", type: "String" },
+          spec: { name: "axis", type: "String" },
         },
         {
-          type: 'column',
-          id: 'column',
+          type: "column",
+          id: "column",
           spec: {
-            kind: 'PColumn',
-            axesSpec: [{ name: 'axis', type: 'String' }],
-            name: 'column',
-            valueType: 'Float'
-          }
-        }
+            kind: "PColumn",
+            axesSpec: [{ name: "axis", type: "String" }],
+            name: "column",
+            valueType: "Float",
+          },
+        },
       ] as PTableColumnSpec[],
-      dataQuery: { type: 'column', columnId: 'column' } as QueryData
-    }
+      dataQuery: { type: "column", column: "column" } as DataQuery,
+    },
   };
 
-  test.concurrent('create_table_by_data_query_1', async ({ expect }) => {
-    const testCase = 'create_table_request_1';
+  test.concurrent("create_table_by_data_query_1", async ({ expect }) => {
+    const testCase = "create_table_request_1";
     const expectedResponse = createTableExpectedResponses.request1;
-    const queryDataRequest = createTableV2Requests.request1;
+    const DataqueryRequest = createTableV2Requests.request1;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTableV2(
-      ulid() as PFrameInternal.PTableId,
-      queryDataRequest
-    );
+    using table = pframe.createTableV2(ulid() as PFrameInternal.PTableId, DataqueryRequest);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_by_data_query_2', async ({ expect }) => {
-    const testCase = 'create_table_request_2';
+  test.concurrent("create_table_by_data_query_2", async ({ expect }) => {
+    const testCase = "create_table_request_2";
     const expectedResponse = createTableExpectedResponses.request2;
-    const queryDataRequest = createTableV2Requests.request2;
+    const DataqueryRequest = createTableV2Requests.request2;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTableV2(
-      ulid() as PFrameInternal.PTableId,
-      queryDataRequest
-    );
+    using table = pframe.createTableV2(ulid() as PFrameInternal.PTableId, DataqueryRequest);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_by_data_query_3', async ({ expect }) => {
-    const testCase = 'create_table_request_3';
+  test.concurrent("create_table_by_data_query_3", async ({ expect }) => {
+    const testCase = "create_table_request_3";
     const expectedResponse = createTableExpectedResponses.request3;
-    const queryDataRequest = createTableV2Requests.request3;
+    const DataqueryRequest = createTableV2Requests.request3;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTableV2(
-      ulid() as PFrameInternal.PTableId,
-      queryDataRequest
-    );
+    using table = pframe.createTableV2(ulid() as PFrameInternal.PTableId, DataqueryRequest);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_by_data_query_4', async ({ expect }) => {
-    const testCase = 'create_table_request_4';
+  test.concurrent("create_table_by_data_query_4", async ({ expect }) => {
+    const testCase = "create_table_request_4";
     const expectedResponse = createTableExpectedResponses.request4;
-    const queryDataRequest = createTableV2Requests.request4;
+    const DataqueryRequest = createTableV2Requests.request4;
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTableV2(
-      ulid() as PFrameInternal.PTableId,
-      queryDataRequest
-    );
+    using table = pframe.createTableV2(ulid() as PFrameInternal.PTableId, DataqueryRequest);
 
-    const columnIndices = Array.from(
-      { length: table.getSpec().length },
-      (_, i) => i
-    );
+    const columnIndices = Array.from({ length: table.getSpec().length }, (_, i) => i);
     const actualResponse = await table.getData(columnIndices);
     expect(actualResponse).toEqual(expectedResponse);
   });
 
-  test.concurrent('create_table_by_data_query_fail', async ({ expect }) => {
-    const testCase = 'create_table_request_fail';
+  test.concurrent("create_table_by_data_query_fail", async ({ expect }) => {
+    const testCase = "create_table_request_fail";
 
-    const columnId = 'column' as PObjectId;
-    const columnSpec = readJsonTestFile(testCase, 'column.spec');
-    const dataInfo = readJsonTestFile(testCase, 'column.datainfo');
+    const columnId = "column" as PObjectId;
+    const columnSpec = readJsonTestFile(testCase, "column.spec");
+    const dataInfo = readJsonTestFile(testCase, "column.datainfo");
     const dataSource = createFailingDataSource();
 
     using pframe = PFrameFactory.createPFrame({
       frameId: ulid() as PFrameInternal.PFrameId,
-      spillPath: tmpdir()
+      spillPath: tmpdir(),
     });
     pframe.setDataSource(dataSource);
 
     pframe.addColumnSpec(columnId, columnSpec);
     await pframe.setColumnData(columnId, dataInfo);
 
-    // Construct QueryData request for the failing column
-    const queryDataRequest = {
+    // Construct DataQuery request for the failing column
+    const DataqueryRequest = {
       tableSpec: [
         {
-          type: 'axis',
-          id: { name: 'axis', type: 'Long' },
-          spec: { name: 'axis', type: 'Long' }
+          type: "axis",
+          id: { name: "axis", type: "Long" },
+          spec: { name: "axis", type: "Long" },
         },
         {
-          type: 'column',
-          id: 'column',
+          type: "column",
+          id: "column",
           spec: {
-            kind: 'PColumn',
-            axesSpec: [{ name: 'axis', type: 'Long' }],
-            name: 'column',
-            valueType: 'Long'
-          }
-        }
+            kind: "PColumn",
+            axesSpec: [{ name: "axis", type: "Long" }],
+            name: "column",
+            valueType: "Long",
+          },
+        },
       ] as PTableColumnSpec[],
       dataQuery: {
-        type: 'column',
-        columnId: 'column'
-      } as QueryData
+        type: "column",
+        column: "column",
+      } as DataQuery,
     };
 
     using table = (pframe as unknown as PFrame).createTableV2(
       ulid() as PFrameInternal.PTableId,
-      queryDataRequest
+      DataqueryRequest,
     );
 
     await expect(table.getShape()).rejects.toThrow();
   });
 });
 
-describe('PFrame Table Operations', () => {
-  test.concurrent('sort_table_request', async ({ expect }) => {
-    const testCase = 'sort_table_request';
+describe("PFrame Table Operations", () => {
+  test.concurrent("sort_table_request", async ({ expect }) => {
+    const testCase = "sort_table_request";
 
-    const request = readJsonTestFile(testCase, 'request.json');
-    const sorting: PTableSorting[] = readJsonTestFile(testCase, 'sorting.json');
+    const request = readJsonTestFile(testCase, "request.json");
+    const sorting: PTableSorting[] = readJsonTestFile(testCase, "sorting.json");
 
     // Expected response for full sorted data
     let expectedFullResponse: PTableVector[] = [
       {
-        type: 'Long', // Axis A1 - all values present
+        type: "Long", // Axis A1 - all values present
         data: new BigInt64Array([BigInt(0), BigInt(0), BigInt(1), BigInt(2)]),
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'String', // Axis A2 - positions 2,3 absent (no record in column2 for A1=1,2)
-        data: ['FloatOne', 'FloatTwo', null, null],
+        type: "String", // Axis A2 - positions 2,3 absent (no record in column2 for A1=1,2)
+        data: ["FloatOne", "FloatTwo", null, null],
         isNA: new Uint8Array([48]),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'String', // Column column1 - positions 0,1 are NA (no data for A1=0)
-        data: [null, null, 'IntOne', 'IntTwo'],
+        type: "String", // Column column1 - positions 0,1 are NA (no data for A1=0)
+        data: [null, null, "IntOne", "IntTwo"],
         isNA: new Uint8Array([192]),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'Float', // Column column2 - positions 2,3 are NA (no data for A1=1,2)
+        type: "Float", // Column column2 - positions 2,3 are NA (no data for A1=1,2)
         data: new Float32Array([1.0, 2.0, NaN, NaN]),
         isNA: new Uint8Array([48]),
-        absent: new Uint8Array()
-      }
+        absent: new Uint8Array(),
+      },
     ];
 
     // Expected response for range query (rows 1-2, reordered columns)
     const expectedRangeResponse: PTableVector[] = [
       {
-        type: 'Float', // Column column2 - position 1 is NA
+        type: "Float", // Column column2 - position 1 is NA
         data: new Float32Array([2.0, NaN]),
         isNA: new Uint8Array([64]),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'String', // Column column1 - position 0 is NA
-        data: [null, 'IntOne'],
+        type: "String", // Column column1 - position 0 is NA
+        data: [null, "IntOne"],
         isNA: new Uint8Array([128]),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'String', // Axis A2 - position 1 is absent
-        data: ['FloatTwo', null],
+        type: "String", // Axis A2 - position 1 is absent
+        data: ["FloatTwo", null],
         isNA: new Uint8Array([64]),
-        absent: new Uint8Array()
+        absent: new Uint8Array(),
       },
       {
-        type: 'Long', // Axis A1 - all present
+        type: "Long", // Axis A1 - all present
         data: new BigInt64Array([BigInt(0), BigInt(1)]),
         isNA: new Uint8Array(),
-        absent: new Uint8Array()
-      }
+        absent: new Uint8Array(),
+      },
     ];
 
     using pframe = await readPFrame(testCase);
-    using table = pframe.createTable(
-      ulid() as PFrameInternal.PTableId,
-      request
-    );
+    using table = pframe.createTable(ulid() as PFrameInternal.PTableId, request);
 
     using sortedTable = table.sort(ulid() as PFrameInternal.PTableId, sorting);
     const footprint = await sortedTable.getFootprint();
@@ -695,7 +630,7 @@ describe('PFrame Table Operations', () => {
 
     // Test full sorted data
     const columnIndices = sortedTable.getColumnIndices(
-      Array.from(sorting, (entry) => entry.column)
+      Array.from(sorting, (entry) => entry.column),
     );
     let actualResponse = await sortedTable.getData(columnIndices);
     expect(actualResponse).toEqual(expectedFullResponse);
@@ -703,31 +638,28 @@ describe('PFrame Table Operations', () => {
     // Test range query with reordered columns
     actualResponse = await sortedTable.getData(
       [columnIndices[3], columnIndices[2], columnIndices[1], columnIndices[0]],
-      { range: { offset: 1, length: 2 } }
+      { range: { offset: 1, length: 2 } },
     );
     expect(actualResponse).toEqual(expectedRangeResponse);
   });
 });
 
-describe('PFrame Complex Operations', () => {
-  test.concurrent('complex_join', async ({ expect }) => {
-    const testCase = 'complex_join';
+describe("PFrame Complex Operations", () => {
+  test.concurrent("complex_join", async ({ expect }) => {
+    const testCase = "complex_join";
     using pframe = await readPFrame(testCase);
 
-    const request = readJsonTestFile(testCase, 'request.json');
-    using table = pframe.createTable(
-      ulid() as PFrameInternal.PTableId,
-      request
-    );
+    const request = readJsonTestFile(testCase, "request.json");
+    using table = pframe.createTable(ulid() as PFrameInternal.PTableId, request);
 
     const shape = await table.getShape();
     expect(shape).toEqual({
       columns: 6,
-      rows: 7124
+      rows: 7124,
     });
 
     // Test profiling functionality (platform-dependent)
-    if (process.platform === 'win32') {
+    if (process.platform === "win32") {
       expect(PFrameFactory.pprofDump()).rejects.toThrow();
     } else {
       const profile = await PFrameFactory.pprofDump();
@@ -738,12 +670,12 @@ describe('PFrame Complex Operations', () => {
 
     // Test out of bounds range
     const result = await table.getData([0], {
-      range: { offset: 10000, length: 20000 }
+      range: { offset: 10000, length: 20000 },
     });
     expect(result).toMatchObject([{ data: [] }]);
 
     const result2 = await table.getData([0], {
-      range: { offset: 7123, length: 2 }
+      range: { offset: 7123, length: 2 },
     });
     expect(result2[0].data.length).toBe(1);
   });