@highstate/backend 0.19.1 → 0.21.1

package/src/orchestrator/operation.update.skip.test.ts

@@ -17,6 +17,8 @@ describe("RuntimeOperation - Update Short-Circuit", () => {
       instanceStateService,
       projectModelService,
       unitExtraService,
+      entitySnapshotService,
+      unitOutputService,
       createUnit,
       createDeployedUnitState,
       createContext,
@@ -62,6 +64,8 @@ describe("RuntimeOperation - Update Short-Circuit", () => {
         instanceStateService,
         projectModelService,
         unitExtraService,
+        entitySnapshotService,
+        unitOutputService,
         logger,
       )
 
@@ -83,6 +87,7 @@ describe("RuntimeOperation - Update Short-Circuit", () => {
       const skipOptions = skipCall?.[3]
       expect(skipOptions?.instanceState).toEqual({
         inputHash: expected.inputHash,
+        parentId: null,
       })
 
       expect(operationService.markOperationFinished).toHaveBeenCalledWith(
@@ -92,4 +97,195 @@ describe("RuntimeOperation - Update Short-Circuit", () => {
       )
     },
   )
+
+  operationTest(
+    "updates parentId during short-circuit when unit moved between composites",
+    async ({
+      project,
+      logger,
+      runnerBackend,
+      libraryBackend,
+      artifactService,
+      instanceLockService,
+      operationService,
+      secretService,
+      instanceStateService,
+      projectModelService,
+      unitExtraService,
+      entitySnapshotService,
+      unitOutputService,
+      createComposite,
+      createUnit,
+      createDeployedUnitState,
+      createContext,
+      createOperation,
+      setupImmediateLocking,
+      setupPersistenceMocks,
+      expect,
+    }) => {
+      // arrange
+      const oldParent = createComposite("OldParent")
+      const newParent = createComposite("NewParent")
+      const unit = {
+        ...createUnit("A"),
+        parentId: newParent.id,
+      }
+
+      const oldParentState = createDeployedUnitState(oldParent)
+      const newParentState = createDeployedUnitState(newParent)
+      const state = createDeployedUnitState(unit)
+      state.parentInstanceId = oldParent.id
+
+      const context = await createContext({
+        instances: [oldParent, newParent, unit],
+        states: [oldParentState, newParentState, state],
+      })
+
+      const expected = await context.getUpToDateInputHashOutput(unit)
+      state.selfHash = expected.selfHash
+      state.dependencyOutputHash = expected.dependencyOutputHash
+      instanceStateService.getInstanceStates.mockResolvedValue([
+        oldParentState,
+        newParentState,
+        state,
+      ])
+
+      setupImmediateLocking()
+      setupPersistenceMocks({ instances: [oldParent, newParent, unit] })
+
+      const operation = createOperation({
+        type: "update",
+        requestedInstanceIds: [],
+        phases: [
+          {
+            type: "update",
+            instances: [
+              { id: newParent.id, message: "parent", parentId: undefined },
+              { id: unit.id, message: "explicitly requested", parentId: newParent.id },
+            ],
+          },
+        ],
+      })
+
+      const runtimeOperation = new RuntimeOperation(
+        project,
+        operation,
+        runnerBackend,
+        libraryBackend,
+        artifactService,
+        instanceLockService,
+        operationService,
+        secretService,
+        instanceStateService,
+        projectModelService,
+        unitExtraService,
+        entitySnapshotService,
+        unitOutputService,
+        logger,
+      )
+
+      // act
+      await runtimeOperation.operateSafe()
+
+      // assert
+      expect(runnerBackend.update).not.toHaveBeenCalled()
+
+      const skipCall = instanceStateService.updateOperationState.mock.calls.find(
+        ([, stateId, , options]) =>
+          stateId === unit.id && options.operationState?.status === "skipped",
+      )
+
+      expect(skipCall).toBeDefined()
+      expect(skipCall?.[3].instanceState).toEqual({
+        inputHash: expected.inputHash,
+        parentId: newParent.id,
+      })
+    },
+  )
+
+  operationTest(
+    "does not short-circuit update for instances destroyed earlier in recreate",
+    async ({
+      project,
+      logger,
+      runnerBackend,
+      libraryBackend,
+      artifactService,
+      instanceLockService,
+      operationService,
+      secretService,
+      instanceStateService,
+      projectModelService,
+      unitExtraService,
+      entitySnapshotService,
+      unitOutputService,
+      createUnit,
+      createDeployedUnitState,
+      createContext,
+      createOperation,
+      setupImmediateLocking,
+      setupPersistenceMocks,
+      expect,
+    }) => {
+      // arrange
+      const unit = createUnit("A")
+      const state = createDeployedUnitState(unit)
+
+      const context = await createContext({ instances: [unit], states: [state] })
+
+      const expected = await context.getUpToDateInputHashOutput(unit)
+      state.selfHash = expected.selfHash
+      state.dependencyOutputHash = expected.dependencyOutputHash
+      instanceStateService.getInstanceStates.mockResolvedValue([state])
+
+      setupImmediateLocking()
+      setupPersistenceMocks({ instances: [unit] })
+
+      const operation = createOperation({
+        type: "recreate",
+        requestedInstanceIds: [unit.id],
+        phases: [
+          {
+            type: "destroy",
+            instances: [{ id: unit.id, message: "explicitly requested", parentId: undefined }],
+          },
+          {
+            type: "update",
+            instances: [{ id: unit.id, message: "explicitly requested", parentId: undefined }],
+          },
+        ],
+      })
+
+      const runtimeOperation = new RuntimeOperation(
+        project,
+        operation,
+        runnerBackend,
+        libraryBackend,
+        artifactService,
+        instanceLockService,
+        operationService,
+        secretService,
+        instanceStateService,
+        projectModelService,
+        unitExtraService,
+        entitySnapshotService,
+        unitOutputService,
+        logger,
+      )
+
+      // act
+      await runtimeOperation.operateSafe()
+
+      // assert
+      expect(runnerBackend.destroy).toHaveBeenCalledTimes(1)
+      expect(runnerBackend.update).toHaveBeenCalledTimes(1)
+
+      const skipCall = instanceStateService.updateOperationState.mock.calls.find(
+        ([, stateId, , options]) =>
+          stateId === unit.id && options.operationState?.status === "skipped",
+      )
+
+      expect(skipCall).toBeUndefined()
+    },
+  )
 })

package/src/orchestrator/operation.update.test.ts

@@ -19,6 +19,8 @@ describe("Operation - Update", () => {
       instanceStateService,
       projectModelService,
       unitExtraService,
+      entitySnapshotService,
+      unitOutputService,
       createUnit,
       createDeployedUnitState,
       createOperation,
@@ -90,6 +92,8 @@ describe("Operation - Update", () => {
         instanceStateService,
         projectModelService,
         unitExtraService,
+        entitySnapshotService,
+        unitOutputService,
         logger,
       )
 

package/src/orchestrator/plan-test-builder.ts

@@ -101,6 +101,7 @@ export class PlanTestBuilder {
       status: "undeployed",
       source: stateType === "ghost" ? "virtual" : "resident",
       kind: instance.kind,
+      hasResourceHooks: false,
       parentId: null,
       parentInstanceId: instance.parentId ?? null,
       selfHash: null,

package/src/orchestrator/unit-input-values.test.ts

@@ -0,0 +1,450 @@
+import type { VersionedName } from "@highstate/contract"
+import type { ResolvedInstanceInput } from "../shared"
+import { describe, expect, test } from "vitest"
+import { resolveUnitInputValues } from "./unit-input-values"
+
+describe("resolveUnitInputValues", () => {
+  test("returns captured values when input type matches output type", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "parent.v1" },
+          },
+        },
+      },
+      entities: {
+        "parent.v1": {
+          type: "parent.v1",
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+      } as never,
+      type: "parent.v1",
+    }
+
+    const values = resolveUnitInputValues({
+      library: library as never,
+      inputName: "dep",
+      resolvedInput: resolved,
+      dependencyInstanceType,
+      captured: [{ ok: true, value: { a: 1 } }],
+    })
+
+    expect(values).toEqual([
+      {
+        value: { a: 1 },
+        source: { instanceId: dependencyInstanceId, output: "out" },
+      },
+    ])
+  })
+
+  test("extracts inclusion field when input type differs", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "parent.v1" },
+          },
+        },
+      },
+      entities: {
+        "parent.v1": {
+          type: "parent.v1",
+          inclusions: [{ type: "child.v1", field: "child" }],
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+      } as never,
+      type: "child.v1",
+    }
+
+    const values = resolveUnitInputValues({
+      library: library as never,
+      inputName: "dep",
+      resolvedInput: resolved,
+      dependencyInstanceType,
+      captured: [{ ok: true, value: { child: { v: 42 }, other: "x" } }],
+    })
+
+    expect(values).toEqual([
+      {
+        value: { v: 42 },
+        source: { instanceId: dependencyInstanceId, output: "out" },
+      },
+    ])
+  })
+
+  test("uses included entity from reconstructed parent value", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "parent.v1" },
+          },
+        },
+      },
+      entities: {
+        "parent.v1": {
+          type: "parent.v1",
+          inclusions: [{ type: "child.v1", field: "child" }],
+        },
+        "child.v1": {
+          type: "child.v1",
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+      } as never,
+      type: "child.v1",
+    }
+
+    const captured = [
+      {
+        ok: true as const,
+        value: {
+          $meta: { type: "parent.v1", identity: "p1" },
+          child: { $meta: { type: "child.v1", identity: "c1" }, v: 41 },
+        },
+      },
+      {
+        ok: true as const,
+        value: {
+          $meta: { type: "child.v1", identity: "c1", title: "Child" },
+          v: 42,
+        },
+      },
+    ]
+
+    const values = resolveUnitInputValues({
+      library: library as never,
+      inputName: "dep",
+      resolvedInput: resolved,
+      dependencyInstanceType,
+      captured,
+    })
+
+    expect(values).toEqual([
+      {
+        value: { $meta: { type: "child.v1", identity: "c1" }, v: 41 },
+        source: { instanceId: dependencyInstanceId, output: "out" },
+      },
+    ])
+  })
+
+  test("throws when no matching inclusion exists", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "parent.v1" },
+          },
+        },
+      },
+      entities: {
+        "parent.v1": {
+          type: "parent.v1",
+          inclusions: [{ type: "other.v1", field: "x" }],
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+      } as never,
+      type: "child.v1",
+    }
+
+    expect(() =>
+      resolveUnitInputValues({
+        library: library as never,
+        inputName: "dep",
+        resolvedInput: resolved,
+        dependencyInstanceType,
+        captured: [{ ok: true, value: { child: { v: 1 } } }],
+      }),
+    ).toThrow(/no matching inclusion found/i)
+  })
+
+  test("returns captured values when effective output type is forwarded subtype", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "parent.v1" },
+          },
+        },
+      },
+      entities: {
+        "parent.v1": {
+          type: "parent.v1",
+        },
+        "child.v1": {
+          type: "child.v1",
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+      } as never,
+      type: "child.v1",
+    }
+
+    const values = resolveUnitInputValues({
+      library: library as never,
+      inputName: "dep",
+      resolvedInput: resolved,
+      dependencyInstanceType,
+      captured: [{ ok: true, value: { v: 42 } }],
+      effectiveOutputType: "child.v1",
+      effectiveRootOutputType: "child.v1",
+    })
+
+    expect(values).toEqual([
+      {
+        value: { v: 42 },
+        source: { instanceId: dependencyInstanceId, output: "out" },
+      },
+    ])
+  })
+
+  test("throws when captured value is an error", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "parent.v1" },
+          },
+        },
+      },
+      entities: {
+        "parent.v1": {
+          type: "parent.v1",
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+      } as never,
+      type: "parent.v1",
+    }
+
+    expect(() =>
+      resolveUnitInputValues({
+        library: library as never,
+        inputName: "dep",
+        resolvedInput: resolved,
+        dependencyInstanceType,
+        captured: [
+          {
+            ok: false,
+            error: {
+              message: 'Missing required inclusion "child"',
+              snapshotId: "snap_1",
+            },
+          },
+        ],
+      }),
+    ).toThrow(/failed to reconstruct/i)
+  })
+
+  test("extracts values using explicit nested inclusion path", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "network.v1" },
+          },
+        },
+      },
+      entities: {
+        "network.v1": {
+          type: "network.v1",
+          inclusions: [{ type: "peer.v1", field: "peer", multiple: false }],
+        },
+        "peer.v1": {
+          type: "peer.v1",
+          inclusions: [{ type: "endpoint.v1", field: "endpoints", multiple: true }],
+        },
+        "endpoint.v1": {
+          type: "endpoint.v1",
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+        path: "peer.endpoints",
+      } as never,
+      type: "endpoint.v1",
+    }
+
+    const values = resolveUnitInputValues({
+      library: library as never,
+      inputName: "dep",
+      resolvedInput: resolved,
+      dependencyInstanceType,
+      captured: [
+        {
+          ok: true,
+          value: {
+            peer: {
+              endpoints: [{ host: "a.example" }, { host: "b.example" }],
+            },
+          },
+        },
+      ],
+    })
+
+    expect(values).toEqual([
+      {
+        value: { host: "a.example" },
+        source: {
+          instanceId: dependencyInstanceId,
+          output: "out",
+          path: "peer.endpoints",
+        },
+      },
+      {
+        value: { host: "b.example" },
+        source: {
+          instanceId: dependencyInstanceId,
+          output: "out",
+          path: "peer.endpoints",
+        },
+      },
+    ])
+  })
+
+  test("throws when explicit path contains bracket syntax", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "peer.v1" },
+          },
+        },
+      },
+      entities: {
+        "peer.v1": {
+          type: "peer.v1",
+          inclusions: [{ type: "endpoint.v1", field: "endpoints", multiple: true }],
+        },
+        "endpoint.v1": {
+          type: "endpoint.v1",
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+        path: "endpoints[*]",
+      } as never,
+      type: "endpoint.v1",
+    }
+
+    expect(() =>
+      resolveUnitInputValues({
+        library: library as never,
+        inputName: "dep",
+        resolvedInput: resolved,
+        dependencyInstanceType,
+        captured: [{ ok: true, value: { endpoints: [{ host: "a.example" }] } }],
+      }),
+    ).toThrow(/invalid input path segment/i)
+  })
+
+  test("applies explicit path even when output type matches input type", () => {
+    const dependencyInstanceId = "component.v1:dep"
+    const dependencyInstanceType = "component.v1" satisfies VersionedName
+
+    const library = {
+      components: {
+        "component.v1": {
+          outputs: {
+            out: { type: "network.v1" },
+          },
+        },
+      },
+      entities: {
+        "network.v1": {
+          type: "network.v1",
+          inclusions: [{ type: "peer.v1", field: "peer", multiple: false }],
+        },
+        "peer.v1": {
+          type: "peer.v1",
+        },
+      },
+    }
+
+    const resolved: ResolvedInstanceInput = {
+      input: {
+        instanceId: dependencyInstanceId,
+        output: "out",
+        path: "peer",
+      } as never,
+      // same as output type on purpose: explicit path should still be applied first
+      type: "network.v1",
+    }
+
+    expect(() =>
+      resolveUnitInputValues({
+        library: library as never,
+        inputName: "dep",
+        resolvedInput: resolved,
+        dependencyInstanceType,
+        captured: [{ ok: true, value: { peer: { id: "p1" } } }],
+      }),
+    ).toThrow(/resolved path type is "peer\.v1"/i)
+  })
+})