@milaboratories/pl-middle-layer 1.46.20 → 1.46.22

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

@@ -1,64 +1,60 @@
-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';
+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 { projectFieldName } 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',
+  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'),
+  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'),
+  type: "dev-v2",
+  folder: path.resolve(__dirname, "../../../../../etc/blocks/sum-numbers-v3/block"),
 };
 
-test('v3 blocks: basic test with unified state', async () => {
+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 prj = await pl.withWriteTx("CreatingProject", async (tx) => {
       const prjRef = await createProject(tx);
-      tx.createField(field(tx.clientRoot, 'prj'), 'Dynamic', prjRef);
+      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) => {
+    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' },
+        { id: "enter1", label: "Enter Numbers V3", renderingMode: "Heavy" },
         {
-          storageMode: 'fromModel',
-          blockPack: await TestBPPreparer.prepare(BPSpecEnterV3)
-        }
+          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.setStates([
+        {
+          modelAPIVersion: 2,
+          blockId: "enter1",
+          payload: {
+            operation: "update-data",
+            value: { numbers: [1, 2, 3] },
+          },
+        },
+      ]);
       mut.save();
       await tx.commit();
     });
@@ -66,53 +62,57 @@ test('v3 blocks: basic test with unified state', async () => {
     // Verify blockStorage was saved
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
-      const blockStorage = await prjR.get(projectFieldName('enter1', 'blockStorage'));
+      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) => {
+    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' },
+        { id: "enter2", label: "Enter Numbers V3 #2", renderingMode: "Heavy" },
         {
-          storageMode: 'fromModel',
-          blockPack: await TestBPPreparer.prepare(BPSpecEnterV3)
-        }
+          storageMode: "fromModel",
+          blockPack: await TestBPPreparer.prepare(BPSpecEnterV3),
+        },
       );
-      mut.setStates([{ 
-        modelAPIVersion: 2, 
-        blockId: 'enter2', 
-        payload: { 
-          operation: 'update-data', 
-          value: { numbers: [4, 5, 6] } 
-        } 
-      }]);
+      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) => {
+    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' },
+        { id: "sum1", label: "Sum Numbers V3", renderingMode: "Heavy" },
         {
-          storageMode: 'fromModel',
-          blockPack: await TestBPPreparer.prepare(BPSpecSumV3)
-        }
+          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.setStates([
+        {
+          modelAPIVersion: 2,
+          blockId: "sum1",
+          payload: {
+            operation: "update-data",
+            value: { sources: [outputRef("enter1", "numbers"), outputRef("enter2", "numbers")] },
+          },
+        },
+      ]);
       mut.doRefresh();
       mut.save();
       await tx.commit();
@@ -122,17 +122,17 @@ test('v3 blocks: basic test with unified state', async () => {
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
       const stagingOutput = await prjR
-        .get(projectFieldName('enter1', 'stagingOutput'))
+        .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');
+      expect(Object.keys(all)).toContain("numbersCount");
     });
 
     // Render production for all blocks
-    await pl.withWriteTx('RenderProduction', async (tx) => {
+    await pl.withWriteTx("RenderProduction", async (tx) => {
       const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
-      mut.renderProduction(['enter1', 'enter2', 'sum1']);
+      mut.renderProduction(["enter1", "enter2", "sum1"]);
       mut.doRefresh();
       mut.save();
       await tx.commit();
@@ -142,12 +142,12 @@ test('v3 blocks: basic test with unified state', async () => {
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
       const prodOutput = await prjR
-        .get(projectFieldName('sum1', 'prodOutput'))
+        .get(projectFieldName("sum1", "prodOutput"))
         .then((r) => r.final());
       const all = await prodOutput.getAllFinal();
-      expect(Object.keys(all)).toContain('sum');
+      expect(Object.keys(all)).toContain("sum");
 
-      const sumValue = await prodOutput.get('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);
@@ -155,36 +155,38 @@ test('v3 blocks: basic test with unified state', async () => {
   });
 });
 
-test('v3 blocks: prerunArgs skip test', async () => {
+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 prj = await pl.withWriteTx("CreatingProject", async (tx) => {
       const prjRef = await createProject(tx);
-      tx.createField(field(tx.clientRoot, 'prj'), 'Dynamic', prjRef);
+      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) => {
+    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' },
+        { id: "enter1", label: "Enter Numbers V3", renderingMode: "Heavy" },
         {
-          storageMode: 'fromModel',
-          blockPack: await TestBPPreparer.prepare(BPSpecEnterV3)
-        }
+          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.setStates([
+        {
+          modelAPIVersion: 2,
+          blockId: "enter1",
+          payload: {
+            operation: "update-data",
+            value: { numbers: [3, 1, 2] },
+          },
+        },
+      ]);
       mut.doRefresh();
       mut.save();
       await tx.commit();
@@ -194,28 +196,30 @@ test('v3 blocks: prerunArgs skip test', async () => {
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
       const stagingOutput = await prjR
-        .get(projectFieldName('enter1', 'stagingOutput'))
+        .get(projectFieldName("enter1", "stagingOutput"))
         .then((r) => r.final());
       const all = await stagingOutput.getAllFinal();
-      expect(Object.keys(all)).toContain('numbersCount');
+      expect(Object.keys(all)).toContain("numbersCount");
       // Should count even numbers: [2] -> count = 1
-      const countValue = await stagingOutput.get('numbersCount');
+      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) => {
+    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.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();
@@ -225,25 +229,27 @@ test('v3 blocks: prerunArgs skip test', async () => {
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
       const stagingOutput = await prjR
-        .get(projectFieldName('enter1', 'stagingOutput'))
+        .get(projectFieldName("enter1", "stagingOutput"))
         .then((r) => r.final());
-      const countValue = await stagingOutput.get('numbersCount');
+      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)
+      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) => {
+    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.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();
@@ -253,28 +259,27 @@ test('v3 blocks: prerunArgs skip test', async () => {
     await poll(pl, async (tx) => {
       const prjR = await tx.get(prj);
       const stagingOutput = await prjR
-        .get(projectFieldName('enter1', 'stagingOutput'))
+        .get(projectFieldName("enter1", "stagingOutput"))
         .then((r) => r.final());
-      const countValue = await stagingOutput.get('numbersCount');
+      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)
+      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'))
+        .get(projectFieldName("enter1", "stagingOutput"))
         .then((r) => r.final());
 
-      const prerunArgsValue = await stagingOutput.get('prerunArgsJson');
+      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).toHaveProperty("evenNumbers");
       expect(prerunArgs.evenNumbers).toStrictEqual([4]);
-      expect(prerunArgs).not.toHaveProperty('numbers');
+      expect(prerunArgs).not.toHaveProperty("numbers");
     });
   });
 });
-