@milaboratories/pl-middle-layer 1.45.5 → 1.46.1

package/src/mutator/project-v3.test.ts

@@ -0,0 +1,280 @@
+import { field, poll, TestHelpers, toGlobalResourceId } from '@milaboratories/pl-client';
+import { getQuickJS } from 'quickjs-emscripten';
+import { expect, test } from 'vitest';
+import { outputRef } from '../model/args';
+import { ProjectHelper } from '../model/project_helper';
+import {
+  BlockRenderingStateKey,
+  projectFieldName,
+  ProjectRenderingState
+} from '../model/project_model';
+import {
+  TestBPPreparer
+} from '../test/block_packs';
+import { createProject, ProjectMutator } from './project';
+import type { BlockPackSpec } from '@milaboratories/pl-model-middle-layer';
+import path from 'node:path';
+
+// V3 block specs - using dev-v2 type with local folders
+// These blocks use the new unified state format (state instead of args+uiState)
+const BPSpecEnterV3: BlockPackSpec = {
+  type: 'dev-v2',
+  // Navigate from lib/node/pl-middle-layer/src/mutator to etc/blocks/enter-numbers-v3/block
+  folder: path.resolve(__dirname, '../../../../../etc/blocks/enter-numbers-v3/block'),
+};
+
+const BPSpecSumV3: BlockPackSpec = {
+  type: 'dev-v2',
+  folder: path.resolve(__dirname, '../../../../../etc/blocks/sum-numbers-v3/block'),
+};
+
+test('v3 blocks: basic test with unified state', async () => {
+  const quickJs = await getQuickJS();
+
+  await TestHelpers.withTempRoot(async (pl) => {
+    const prj = await pl.withWriteTx('CreatingProject', async (tx) => {
+      const prjRef = await createProject(tx);
+      tx.createField(field(tx.clientRoot, 'prj'), 'Dynamic', prjRef);
+      await tx.commit();
+      return await toGlobalResourceId(prjRef);
+    });
+
+    // Add enter-numbers-v3 block with storageMode: 'fromModel'
+    // Initial storage comes from VM, then we set desired state via setStates
+    await pl.withWriteTx('AddEnterNumbersV3Block', async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.addBlock(
+        { id: 'enter1', label: 'Enter Numbers V3', renderingMode: 'Heavy' },
+        {
+          storageMode: 'fromModel',
+          blockPack: await TestBPPreparer.prepare(BPSpecEnterV3)
+        }
+      );
+      // Set initial test data
+      mut.setStates([{ 
+        modelAPIVersion: 2, 
+        blockId: 'enter1', 
+        payload: { 
+          operation: 'update-data', 
+          value: { numbers: [1, 2, 3] } 
+        } 
+      }]);
+      mut.save();
+      await tx.commit();
+    });
+
+    // Verify blockStorage was saved
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const blockStorage = await prjR.get(projectFieldName('enter1', 'blockStorage'));
+      const stateData = Buffer.from(blockStorage.data.data!).toString();
+      expect(JSON.parse(stateData).__data).toStrictEqual({ numbers: [1, 2, 3] });
+    });
+
+    // Add second enter-numbers-v3 block
+    await pl.withWriteTx('AddEnterNumbersV3Block2', async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.addBlock(
+        { id: 'enter2', label: 'Enter Numbers V3 #2', renderingMode: 'Heavy' },
+        {
+          storageMode: 'fromModel',
+          blockPack: await TestBPPreparer.prepare(BPSpecEnterV3)
+        }
+      );
+      mut.setStates([{ 
+        modelAPIVersion: 2, 
+        blockId: 'enter2', 
+        payload: { 
+          operation: 'update-data', 
+          value: { numbers: [4, 5, 6] } 
+        } 
+      }]);
+      mut.doRefresh();
+      mut.save();
+      await tx.commit();
+    });
+
+    // Add sum-numbers-v3 block that references both enter blocks
+    await pl.withWriteTx('AddSumNumbersV3Block', async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.addBlock(
+        { id: 'sum1', label: 'Sum Numbers V3', renderingMode: 'Heavy' },
+        {
+          storageMode: 'fromModel',
+          blockPack: await TestBPPreparer.prepare(BPSpecSumV3)
+        }
+      );
+      // Set sources to reference upstream blocks
+      mut.setStates([{
+        modelAPIVersion: 2,
+        blockId: 'sum1',
+        payload: { 
+          operation: 'update-data', 
+          value: { sources: [outputRef('enter1', 'numbers'), outputRef('enter2', 'numbers')] } 
+        } 
+      }]);
+      mut.doRefresh();
+      mut.save();
+      await tx.commit();
+    });
+
+    // Wait for staging outputs
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const stagingOutput = await prjR
+        .get(projectFieldName('enter1', 'stagingOutput'))
+        .then((r) => r.final());
+      const all = await stagingOutput.getAllFinal();
+      // V3 enter-numbers-v3 block has prerun with numbersCount output
+      expect(Object.keys(all)).toContain('numbersCount');
+    });
+
+    // Render production for all blocks
+    await pl.withWriteTx('RenderProduction', async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.renderProduction(['enter1', 'enter2', 'sum1']);
+      mut.doRefresh();
+      mut.save();
+      await tx.commit();
+    });
+
+    // Verify production outputs
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const prodOutput = await prjR
+        .get(projectFieldName('sum1', 'prodOutput'))
+        .then((r) => r.final());
+      const all = await prodOutput.getAllFinal();
+      expect(Object.keys(all)).toContain('sum');
+
+      const sumValue = await prodOutput.get('sum');
+      const sum = JSON.parse(Buffer.from(sumValue.data.data!).toString());
+      // [1,2,3] + [4,5,6] = 21
+      expect(sum).toBe(21);
+    });
+  });
+});
+
+test('v3 blocks: prerunArgs skip test', async () => {
+  const quickJs = await getQuickJS();
+
+  await TestHelpers.withTempRoot(async (pl) => {
+    const prj = await pl.withWriteTx('CreatingProject', async (tx) => {
+      const prjRef = await createProject(tx);
+      tx.createField(field(tx.clientRoot, 'prj'), 'Dynamic', prjRef);
+      await tx.commit();
+      return await toGlobalResourceId(prjRef);
+    });
+
+    // Add enter-numbers-v3 block
+    await pl.withWriteTx('AddEnterNumbersV3Block', async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.addBlock(
+        { id: 'enter1', label: 'Enter Numbers V3', renderingMode: 'Heavy' },
+        {
+          storageMode: 'fromModel',
+          blockPack: await TestBPPreparer.prepare(BPSpecEnterV3)
+        }
+      );
+      // Set initial state: [3, 1, 2] - has one even number (2)
+      mut.setStates([{ 
+        modelAPIVersion: 2, 
+        blockId: 'enter1', 
+        payload: { 
+          operation: 'update-data', 
+          value: { numbers: [3, 1, 2] } 
+        } 
+      }]);
+      mut.doRefresh();
+      mut.save();
+      await tx.commit();
+    });
+
+    // Wait for initial staging
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const stagingOutput = await prjR
+        .get(projectFieldName('enter1', 'stagingOutput'))
+        .then((r) => r.final());
+      const all = await stagingOutput.getAllFinal();
+      expect(Object.keys(all)).toContain('numbersCount');
+      // Should count even numbers: [2] -> count = 1
+      const countValue = await stagingOutput.get('numbersCount');
+      const count = JSON.parse(Buffer.from(countValue.data.data!).toString());
+      expect(count).toBe(1);
+    });
+
+    // Change state: [3, 1, 2] -> [5, 1, 2]
+    // prerunArgs (evenNumbers) stays [2], so staging should be SKIPPED
+    await pl.withWriteTx('ChangeState_SamePrerunArgs', async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.setStates([{
+        modelAPIVersion: 2,
+        blockId: 'enter1',
+        payload: { 
+          operation: 'update-data', 
+          value: { numbers: [5, 1, 2] } // Changed odd numbers only
+        }
+      }]);
+      mut.doRefresh();
+      mut.save();
+      await tx.commit();
+    });
+
+    // Staging should still have numbersCount = 1
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const stagingOutput = await prjR
+        .get(projectFieldName('enter1', 'stagingOutput'))
+        .then((r) => r.final());
+      const countValue = await stagingOutput.get('numbersCount');
+      const count = JSON.parse(Buffer.from(countValue.data.data!).toString());
+      expect(count).toBe(1);  // Still 1 (only [2] is even)
+    });
+
+    // Change state: [5, 1, 2] -> [5, 1, 4]
+    // prerunArgs (evenNumbers) changes from [2] to [4], so staging should RUN
+    await pl.withWriteTx('ChangeState_DifferentPrerunArgs', async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.setStates([{
+        modelAPIVersion: 2,
+        blockId: 'enter1',
+        payload: { 
+          operation: 'update-data', 
+          value: { numbers: [5, 1, 4] }  // Changed even number from 2 to 4
+        }
+      }]);
+      mut.doRefresh();
+      mut.save();
+      await tx.commit();
+    });
+
+    // Wait for new staging
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const stagingOutput = await prjR
+        .get(projectFieldName('enter1', 'stagingOutput'))
+        .then((r) => r.final());
+      const countValue = await stagingOutput.get('numbersCount');
+      const count = JSON.parse(Buffer.from(countValue.data.data!).toString());
+      expect(count).toBe(1);  // Still 1 (only [4] is even)
+    });
+
+    // Verify prerunArgsJson output contains evenNumbers, not numbers
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const stagingOutput = await prjR
+        .get(projectFieldName('enter1', 'stagingOutput'))
+        .then((r) => r.final());
+
+      const prerunArgsValue = await stagingOutput.get('prerunArgsJson');
+      const prerunArgs = JSON.parse(Buffer.from(prerunArgsValue.data.data!).toString());
+
+      // Should have evenNumbers, NOT numbers
+      expect(prerunArgs).toHaveProperty('evenNumbers');
+      expect(prerunArgs.evenNumbers).toStrictEqual([4]);
+      expect(prerunArgs).not.toHaveProperty('numbers');
+    });
+  });
+});
+

package/src/mutator/project.test.ts

@@ -31,8 +31,8 @@ test('simple test #1', async () => {
       mut.addBlock(
         { id: 'block1', label: 'Block1', renderingMode: 'Heavy' },
         {
-          args: JSON.stringify({ numbers: [1, 2, 3] }),
-          uiState: "{}",
+          storageMode: 'legacy',
+          legacyState: JSON.stringify({ args: { numbers: [1, 2, 3] } }),
           blockPack: await TestBPPreparer.prepare(BPSpecEnterV041NotPrepared)
         }
       );
@@ -45,8 +45,8 @@ test('simple test #1', async () => {
       mut.addBlock(
         { id: 'block2', label: 'Block2', renderingMode: 'Heavy' },
         {
-          args: JSON.stringify({ numbers: [3, 4, 5] }),
-          uiState: "{}",
+          storageMode: 'legacy',
+          legacyState: JSON.stringify({ args: { numbers: [3, 4, 5] } }),
           blockPack: await TestBPPreparer.prepare(BPSpecEnterV041NotPrepared)
         }
       );
@@ -60,18 +60,20 @@ test('simple test #1', async () => {
       mut.addBlock(
         { id: 'block3', label: 'Block3', renderingMode: 'Heavy' },
         {
-          args: JSON.stringify({
-            sources: [outputRef('block1', 'column'), outputRef('block2', 'column')]
+          storageMode: 'legacy',
+          legacyState: JSON.stringify({ 
+            args: { sources: [outputRef('block1', 'column'), outputRef('block2', 'column')] }, 
+            uiState: {"some":2} 
           }),
-          uiState: "{}",
           blockPack: await TestBPPreparer.prepare(BPSpecSumV042NotPrepared)
         }
       );
       const rendered = mut.renderProduction(['block3'], true);
       expect([...rendered]).toEqual(['block3']);
+      // setStates requires complete unified state (not partial updates)
       mut.setStates([
-        { blockId: 'block2', uiState: {"some":1} },
-        { blockId: 'block3', uiState: {"some":2} }
+        { modelAPIVersion: 1, blockId: 'block2', state: { args: { numbers: [3, 4, 5] }, uiState: {"some":1} } },
+        { modelAPIVersion: 1, blockId: 'block3', state: { args: { sources: [outputRef('block1', 'column'), outputRef('block2', 'column')] }, uiState: {"some":2} } }
       ]);
       mut.doRefresh();
       mut.save();
@@ -86,7 +88,6 @@ test('simple test #1', async () => {
       const all = await outputs.getAllFinal();
       expect(new Set(Object.keys(all))).toEqual(new Set(['sum', 'dependsOnBlocks']));
       const v = await outputs.get('sum');
-      console.log(Buffer.from(v.data.data!).toString());
     });
 
     await poll(pl, async (tx) => {
@@ -100,13 +101,15 @@ test('simple test #1', async () => {
 
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
-      const uiStateB2 = await prjR
-        .get(projectFieldName('block2', 'uiState'));
-      expect(Buffer.from(uiStateB2.data.data!).toString()).toEqual('{"some":1}');
+      const blockStorageB2 = await prjR
+        .get(projectFieldName('block2', 'blockStorage'));
+      expect(Buffer.from(blockStorageB2.data.data!).toString()).toEqual('{"args":{"numbers":[3,4,5]},"uiState":{"some":1}}');
 
-      const uiStateB3 = await prjR
-        .get(projectFieldName('block3', 'uiState'));
-      expect(Buffer.from(uiStateB3.data.data!).toString()).toEqual('{"some":2}');
+      const blockStorageB3 = await prjR
+        .get(projectFieldName('block3', 'blockStorage'));
+      expect(JSON.parse(Buffer.from(blockStorageB3.data.data!).toString()).uiState).toStrictEqual({
+        some: 2
+      });
     });
 
     await pl.withWriteTx('DeleteBlock2', async (tx) => {
@@ -118,8 +121,8 @@ test('simple test #1', async () => {
 
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
-      const uiState = prjR.data.fields.find((f) => f.name === projectFieldName('block2', 'uiState'));
-      expect(uiState).toBeUndefined();
+      const blockStorage = prjR.data.fields.find((f) => f.name === projectFieldName('block2', 'blockStorage'));
+      expect(blockStorage).toBeUndefined();
     });
 
     await poll(pl, async (tx) => {
@@ -164,7 +167,6 @@ test('simple test #1', async () => {
         .then((r) => r.final());
       const v = await outputs.get('sum');
       // there should be an error here telling that one of the upstream blocks not found
-      // console.log(Buffer.from(v.data.data!).toString());
       const renderingState = await prjR.getKValueObj<ProjectRenderingState>(BlockRenderingStateKey);
       expect(renderingState.blocksInLimbo).not.toContain('block3');
     });
@@ -187,26 +189,24 @@ test('simple test #2 with bp migration', async () => {
       mut.addBlock(
         { id: 'block1', label: 'Block1', renderingMode: 'Heavy' },
         {
-          args: JSON.stringify({ numbers: [1, 2, 3] }),
-          uiState: "{}",
+          storageMode: 'legacy',
+          legacyState: JSON.stringify({ args: { numbers: [1, 2, 3] } }),
           blockPack: await TestBPPreparer.prepare(BPSpecEnterV041NotPrepared)
         }
       );
       mut.addBlock(
         { id: 'block2', label: 'Block2', renderingMode: 'Heavy' },
         {
-          args: JSON.stringify({ numbers: [3, 4, 5] }),
-          uiState: "{}",
+          storageMode: 'legacy',
+          legacyState: JSON.stringify({ args: { numbers: [3, 4, 5] } }),
           blockPack: await TestBPPreparer.prepare(BPSpecEnterV041NotPrepared)
         }
       );
       mut.addBlock(
         { id: 'block3', label: 'Block3', renderingMode: 'Heavy' },
         {
-          args: JSON.stringify({
-            sources: [outputRef('block1', 'column'), outputRef('block2', 'column')]
-          }),
-          uiState: "{}",
+          storageMode: 'legacy',
+          legacyState: JSON.stringify({ args: { sources: [outputRef('block1', 'column'), outputRef('block2', 'column')] }, uiState: {"some":2} }),
           blockPack: await TestBPPreparer.prepare(BPSpecSumV042NotPrepared)
         }
       );