@platforma-sdk/model 1.22.59 → 1.22.97

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PlatformaSDKVersion = "1.22.59";
+export declare const PlatformaSDKVersion = "1.22.97";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/model",
-  "version": "1.22.59",
+  "version": "1.22.97",
   "description": "Platforma.bio SDK / Block Model",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -28,7 +28,7 @@
     "@types/jest": "^29.5.14",
     "jest": "^29.7.0",
     "@jest/globals": "^29.7.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.6",
     "@milaboratories/platforma-build-configs": "1.0.2"
   },
   "scripts": {

package/src/components/PFrameForGraphs.test.ts

@@ -1,12 +1,11 @@
 import {test, expect, describe} from '@jest/globals';
-import {getAdditionalColumns} from './PFrameForGraphs';
+import {enrichColumnsWithCompatible, getAdditionalColumns, IS_VIRTUAL_COLUMN} from './PFrameForGraphs';
 import {PColumn, PColumnSpec, PColumnValues, PObjectId} from "@milaboratories/pl-model-common";
 import {TreeNodeAccessor} from "../render";
 
-
 describe('PFrameForGraph', () => {
     test('columns are compatible, no additional columns', () => {
-        const columnSpec1:PColumnSpec = {
+        const columnSpec1: PColumnSpec = {
             kind: 'PColumn',
             name: 'column1',
             valueType: 'Int',
@@ -15,13 +14,13 @@ describe('PFrameForGraph', () => {
                 {type: 'Int', name: 'axis2', domain: {}}
             ]
         }
-        const columnSpec2:PColumnSpec = {
+        const columnSpec2: PColumnSpec = {
             kind: 'PColumn',
             name: 'column2',
             valueType: 'Int',
             axesSpec: [{type: 'String', name: 'axis1', domain: {}}]
         }
-        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [{
+        const columns: PColumn<TreeNodeAccessor | PColumnValues>[] = [{
             id: 'id1' as PObjectId,
             spec: columnSpec1,
             data: []
@@ -36,19 +35,19 @@ describe('PFrameForGraph', () => {
     });
 
     test('columns are not compatible, 1 additional column', () => {
-        const columnSpec1:PColumnSpec = {
+        const columnSpec1: PColumnSpec = {
             kind: 'PColumn',
             name: 'column1',
             valueType: 'Int',
             axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
         }
-        const columnSpec2:PColumnSpec = {
+        const columnSpec2: PColumnSpec = {
             kind: 'PColumn',
             name: 'column2',
             valueType: 'Int',
             axesSpec: [{type: 'String', name: 'axis1', domain: {}}]
         }
-        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+        const columns: PColumn<TreeNodeAccessor | PColumnValues>[] = [
             {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
             {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
         ] as PColumn<PColumnValues>[]
@@ -61,23 +60,24 @@ describe('PFrameForGraph', () => {
             kind: 'PColumn',
             name: 'column2',
             valueType: 'Int',
-            axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
+            axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}],
+            annotations: {[IS_VIRTUAL_COLUMN]: 'true'}
         });
     });
     test('columns are not compatible, additional columns are impossible', () => {
-        const columnSpec1:PColumnSpec = {
+        const columnSpec1: PColumnSpec = {
             kind: 'PColumn',
             name: 'column1',
             valueType: 'Int',
             axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
         }
-        const columnSpec2:PColumnSpec = {
+        const columnSpec2: PColumnSpec = {
             kind: 'PColumn',
             name: 'column2',
             valueType: 'Int',
             axesSpec: [{type: 'String', name: 'axis1', domain: {key2: 'b'}}]
         }
-        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+        const columns: PColumn<TreeNodeAccessor | PColumnValues>[] = [
             {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
             {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
         ] as PColumn<PColumnValues>[]
@@ -86,7 +86,7 @@ describe('PFrameForGraph', () => {
         expect(additionalColumns.length).toEqual(0);
     });
     test('columns are not compatible, 2 additional columns', () => {
-        const columnSpec1:PColumnSpec = {
+        const columnSpec1: PColumnSpec = {
             kind: 'PColumn',
             name: 'column1',
             valueType: 'Int',
@@ -95,13 +95,13 @@ describe('PFrameForGraph', () => {
                 {type: 'String', name: 'axis1', domain: {key1: 'b'}},
             ]
         }
-        const columnSpec2:PColumnSpec = {
+        const columnSpec2: PColumnSpec = {
             kind: 'PColumn',
             name: 'column2',
             valueType: 'Int',
             axesSpec: [{type: 'String', name: 'axis1', domain: {}}]
         }
-        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+        const columns: PColumn<TreeNodeAccessor | PColumnValues>[] = [
             {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
             {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
         ] as PColumn<PColumnValues>[]
@@ -110,7 +110,7 @@ describe('PFrameForGraph', () => {
         expect(additionalColumns.length).toEqual(2);
     });
     test('columns are not compatible, 4 additional columns - by 2 axes', () => {
-        const columnSpec1:PColumnSpec = {
+        const columnSpec1: PColumnSpec = {
             kind: 'PColumn',
             name: 'column1',
             valueType: 'Int',
@@ -121,7 +121,7 @@ describe('PFrameForGraph', () => {
                 {type: 'String', name: 'axis2', domain: {key1: 'b'}},
             ]
         }
-        const columnSpec2:PColumnSpec = {
+        const columnSpec2: PColumnSpec = {
             kind: 'PColumn',
             name: 'column2',
             valueType: 'Int',
@@ -130,7 +130,7 @@ describe('PFrameForGraph', () => {
                 {type: 'String', name: 'axis2', domain: {}}
             ]
         }
-        const columns:PColumn<TreeNodeAccessor | PColumnValues>[] = [
+        const columns: PColumn<TreeNodeAccessor | PColumnValues>[] = [
             {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
             {id: 'id2' as PObjectId, spec: columnSpec2, data: []}
         ] as PColumn<PColumnValues>[]
@@ -138,4 +138,47 @@ describe('PFrameForGraph', () => {
         const additionalColumns = getAdditionalColumns(columns);
         expect(additionalColumns.length).toEqual(4);
     });
+
+    test('enrichColumnsWithCompatibleMetadata', () => {
+        const columnSpec1: PColumnSpec = {
+            kind: 'PColumn',
+            name: 'column1',
+            valueType: 'Int',
+            axesSpec: [
+                {type: 'String', name: 'axis1', domain: {key1: 'a'}},
+                {type: 'String', name: 'axis2', domain: {key1: 'b'}},
+            ]
+        };
+        const metaColumnSpec1: PColumnSpec = {
+            kind: 'PColumn',
+            name: 'metadata1',
+            valueType: 'Int',
+            axesSpec: [{type: 'String', name: 'axis1'}]
+        };
+        const metaColumnSpec2: PColumnSpec = {
+            kind: 'PColumn',
+            name: 'metadata2',
+            valueType: 'String',
+            axesSpec: [{type: 'String', name: 'axis1', domain: {key1: 'a'}}]
+        };
+        const metaColumnSpec3: PColumnSpec = {
+            kind: 'PColumn',
+            name: 'metadata2',
+            valueType: 'String',
+            axesSpec: [{type: 'String', name: 'axis3'}]
+        };
+
+        const columns: PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
+        ] as PColumn<PColumnValues>[];
+        const upstream: PColumn<TreeNodeAccessor | PColumnValues>[] = [
+            {id: 'id1' as PObjectId, spec: columnSpec1, data: []},
+            {id: 'id2' as PObjectId, spec: metaColumnSpec1, data: []},
+            {id: 'id3' as PObjectId, spec: metaColumnSpec2, data: []},
+            {id: 'id4' as PObjectId, spec: metaColumnSpec3, data: []},
+        ] as PColumn<PColumnValues>[];
+
+        const enrichedColumns = enrichColumnsWithCompatible(columns, upstream);
+        expect(enrichedColumns.map((c) => c.id)).toEqual(['id1', 'id2', 'id3'])
+    })
 })

package/src/components/PFrameForGraphs.ts

@@ -1,12 +1,15 @@
 import {
     AxisId,
     getAxisId,
+    isPColumn,
     matchAxisId,
     PColumn,
-    PColumnValues, PFrameHandle,
+    PColumnValues,
+    PFrameHandle,
     PObjectId,
+    ValueType,
 } from '@milaboratories/pl-model-common';
-import { RenderCtx, TreeNodeAccessor } from '../render';
+import {RenderCtx, TreeNodeAccessor} from '../render';
 
 /** Create id for column copy with added keys in axes domains */
 const colId = (id: PObjectId, domains: (Record<string, string> | undefined)[]) => {
@@ -38,8 +41,30 @@ function getKeysCombinations(idsLists: AxisId[][]) {
     return result;
 }
 
+/** Check if axes of secondary column are exactly in axes of main column */
+function checkFullCompatibility(
+    mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
+    secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>
+): boolean {
+    const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
+    const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
+    return secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id) && matchAxisId(id, mainId)));
+}
+
+/** Check if axes of secondary column are in axes of main column, but they can have compatible difference in domains */
+function checkCompatibility(
+    mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
+    secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>
+): boolean {
+    const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
+    const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
+    return secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id)));
+}
+
+export const IS_VIRTUAL_COLUMN = 'pl7.app/graph/isVirtual'; // annotation for column duplicates with extended domains
+
 /** Main column can have additional domains, if secondary column (meta-column) has all axes match main column axes
-we can add its copy with missed domain fields for compatibility */
+ we can add its copy with missed domain fields for compatibility */
 function getAdditionalColumnsForPair(
     mainColumn: PColumn<TreeNodeAccessor | PColumnValues>,
     secondaryColumn: PColumn<TreeNodeAccessor | PColumnValues>
@@ -47,11 +72,11 @@ function getAdditionalColumnsForPair(
     const mainAxesIds = mainColumn.spec.axesSpec.map(getAxisId);
     const secondaryAxesIds = secondaryColumn.spec.axesSpec.map(getAxisId);
 
-    const isFullCompatible = secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id) && matchAxisId(id, mainId)));
+    const isFullCompatible = checkFullCompatibility(mainColumn, secondaryColumn);
     if (isFullCompatible) { // in this case it isn't necessary to add more columns
         return [];
     }
-    const isCompatible = secondaryAxesIds.every(id => mainAxesIds.some(mainId => matchAxisId(mainId, id)));
+    const isCompatible = checkCompatibility(mainColumn, secondaryColumn);
     if (!isCompatible) { // in this case it is impossible to add some compatible column
         return [];
     }
@@ -71,14 +96,18 @@ function getAdditionalColumnsForPair(
                 axesSpec: idsList.map((axisId, idx) => ({
                     ...axisId,
                     annotations: secondaryColumn.spec.axesSpec[idx].annotations
-                }))
+                })),
+                annotations: {
+                    ...secondaryColumn.spec.annotations,
+                    [IS_VIRTUAL_COLUMN]: 'true'
+                }
             },
             data: secondaryColumn.data
         };
     });
 }
 
-export function getAdditionalColumns(columns: PColumn<TreeNodeAccessor | PColumnValues>[]):PColumn<TreeNodeAccessor | PColumnValues>[] {
+export function getAdditionalColumns(columns: PColumn<TreeNodeAccessor | PColumnValues>[]): PColumn<TreeNodeAccessor | PColumnValues>[] {
     const additionalColumns: PColumn<TreeNodeAccessor | PColumnValues>[] = [];
     for (let i = 0; i < columns.length; i++) {
         for (let j = i + 1; j < columns.length; j++) {
@@ -95,11 +124,51 @@ export function getAdditionalColumns(columns: PColumn<TreeNodeAccessor | PColumn
     return additionalColumns;
 }
 
+export function enrichColumnsWithCompatible(
+    mainColumns: PColumn<TreeNodeAccessor | PColumnValues>[],
+    secondaryColumns: PColumn<TreeNodeAccessor | PColumnValues>[]
+): PColumn<TreeNodeAccessor | PColumnValues>[] {
+    const result = [...mainColumns];
+    for (const secondaryColumn of secondaryColumns) {
+        for (const mainColumn of mainColumns) {
+            if (mainColumn.id === secondaryColumn.id) {
+                break;
+            }
+            if (checkCompatibility(mainColumn, secondaryColumn)) {
+                result.push(secondaryColumn);
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+const VALUE_TYPES: ValueType[] = [
+    'Int',
+    'Long',
+    'Float',
+    'Double',
+    'String',
+    'Bytes'
+];
+
 export function createPFrameForGraphs<A, U>(
     ctx: RenderCtx<A, U>,
-    columns: PColumn<TreeNodeAccessor | PColumnValues>[]
+    blockColumns?: PColumn<TreeNodeAccessor | PColumnValues>[]
 ): PFrameHandle | undefined {
-    const extendedColumns = [...columns, ...getAdditionalColumns(columns)];
+    if (blockColumns === undefined) return undefined;
+
+    const upstreamColumns = ctx.resultPool
+        .getData()
+        .entries.map((v) => v.obj)
+        .filter(isPColumn)
+        .filter((column) => VALUE_TYPES.includes(column.spec.valueType));
+
+    const columnsWithCompatibleFromUpstream = enrichColumnsWithCompatible(blockColumns, upstreamColumns);
+
+    // additional columns are duplicates with extra fields in domains for compatibility in all possible pairs of columns set
+    const extendedColumns = [...columnsWithCompatibleFromUpstream, ...getAdditionalColumns(columnsWithCompatibleFromUpstream)];
+
     // if at least one column is not yet ready, we can't show the table
     if (
         extendedColumns.some(
@@ -109,4 +178,4 @@ export function createPFrameForGraphs<A, U>(
         return undefined;
 
     return ctx.createPFrame(extendedColumns);
-}
+}