@highstate/backend 0.16.0 → 0.18.0

package/src/orchestrator/operation.ts

@@ -18,6 +18,7 @@ import {
   parseInstanceId,
   type TriggerInvocation,
   type UnitConfig,
+  type UnitInputReference,
   type VersionedName,
 } from "@highstate/contract"
 import { createId } from "@paralleldrive/cuid2"
@@ -28,6 +29,7 @@ import {
   isTransientInstanceOperationStatus,
   type OperationPhase,
   PromiseTracker,
+  type ResolvedInstanceInput,
   waitAll,
 } from "../shared"
 import { OperationContext } from "./operation-context"
@@ -186,7 +188,7 @@ export class RuntimeOperation {
             this.workset.markInstanceLocked(stateId)
           }
         },
-        true, // allow partial locks to allow independent free branches to run
+        true, // allow partial locks to allow independent branches to run
         this.workset.abortController.signal,
         60_000, // wait up to 60 seconds for unlock events before retrying
         this.unlockToken,
@@ -390,6 +392,47 @@ export class RuntimeOperation {
         throw new AbortError("The operation is failing, aborting current branch (still not failed)")
       }
 
+      // Runtime short-circuit:
+      // If this instance's own config has not changed and none of its dependencies outputs changed,
+      // we can skip execution even if the full inputHash changed due to upstream config-only changes.
+      //
+      // Do not short-circuit when the caller requested side effects that require a real engine run or the instance was explicitly requested.
+      if (
+        state.status === "deployed" &&
+        state.selfHash != null &&
+        state.dependencyOutputHash != null &&
+        // ignore explicitly requested updates
+        !this.operation.requestedInstanceIds.includes(instance.id) &&
+        // ignore when side effects are requested
+        !this.operation.options.refresh &&
+        !this.operation.options.deleteUnreachableResources &&
+        !this.operation.options.forceUpdateDependencies
+      ) {
+        const expected = await this.context.getUpToDateInputHashOutput(instance)
+
+        if (
+          expected.selfHash === state.selfHash &&
+          expected.dependencyOutputHash === state.dependencyOutputHash
+        ) {
+          logger.info("skipping unit update (short-circuit: no effective changes)")
+
+          const now = new Date()
+
+          await this.workset.updateState(instance.id, {
+            operationState: {
+              status: "skipped",
+              startedAt: now,
+              finishedAt: now,
+            },
+            instanceState: {
+              inputHash: expected.inputHash,
+            },
+          })
+
+          return
+        }
+      }
+
       logger.info("updating unit")
 
       await this.workset.updateState(instance.id, {
@@ -421,6 +464,7 @@ export class RuntimeOperation {
         instanceName: instance.name,
         config,
         refresh: this.operation.options.refresh,
+        deleteUnreachable: this.operation.options.deleteUnreachableResources,
         secrets,
         artifacts,
         signal,
@@ -503,6 +547,7 @@ export class RuntimeOperation {
       instanceName: instance.name,
       config: this.prepareUnitConfig(instance, secrets, invokedTriggers),
       refresh: this.operation.options.refresh,
+      deleteUnreachable: this.operation.options.deleteUnreachableResources,
       secrets,
       signal,
       forceSignal,
@@ -661,7 +706,9 @@ export class RuntimeOperation {
     return {
       instanceId: instance.id,
       args: instance.args ?? {},
-      inputs: mapValues(resolvedInputs ?? {}, input => input.map(value => value.input)),
+      inputs: mapValues(resolvedInputs ?? {}, (input, inputName) =>
+        input.map(value => this.getUnitInputRef(inputName, value)),
+      ),
       invokedTriggers,
       secretNames: Object.keys(secrets),
       stateIdMap: this.context.getInstanceIdToStateIdMap(instance.id),
@@ -669,6 +716,45 @@ export class RuntimeOperation {
     }
   }
 
+  private getUnitInputRef(inputName: string, input: ResolvedInstanceInput): UnitInputReference {
+    const instance = this.context.getInstance(input.input.instanceId)
+    const component = this.context.library.components[instance.type]
+
+    const outputSpec = component.outputs[input.input.output]
+    if (!outputSpec) {
+      throw new Error(
+        `Output "${input.input.output}" is not defined on component "${instance.type}"`,
+      )
+    }
+
+    const entity = this.context.library.entities[outputSpec.type]
+    if (!entity) {
+      throw new Error(`Entity type "${outputSpec.type}" is not defined in the library`)
+    }
+
+    // if output type matches input type or extends it, return simple reference, no transformation needed
+    if (input.type === outputSpec.type || entity.extensions?.includes(input.type)) {
+      return {
+        instanceId: input.input.instanceId,
+        output: input.input.output,
+      }
+    }
+
+    // otherwise, find matching inclusion to perform transformation
+    const inclusion = entity.inclusions?.find(inc => inc.type === input.type)
+    if (!inclusion) {
+      throw new Error(
+        `Cannot use output "${input.input.output}" of type "${outputSpec.type}" from instance "${input.input.instanceId}" for input "${inputName}" of type "${input.type}": no matching inclusion found in entity "${entity.type}"`,
+      )
+    }
+
+    return {
+      instanceId: input.input.instanceId,
+      output: input.input.output,
+      inclusion,
+    }
+  }
+
   private async handleUnitStateUpdate(
     update: UnitStateUpdate,
     state: InstanceState,
@@ -753,9 +839,10 @@ export class RuntimeOperation {
       state.outputHash = update.outputHash ?? null
 
       // recalculate the input and output hashes for the instance
-      const { inputHash, dependencyOutputHash } =
+      const { selfHash, inputHash, dependencyOutputHash } =
         await this.context.getUpToDateInputHashOutput(instance)
 
+      data.selfHash = selfHash
       data.inputHash = inputHash
       data.dependencyOutputHash = dependencyOutputHash
       data.outputHash = update.outputHash
@@ -770,6 +857,7 @@ export class RuntimeOperation {
         data.parentId = null
       }
     } else {
+      data.selfHash = null
       data.inputHash = null
       data.dependencyOutputHash = null
       data.outputHash = null

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

@@ -0,0 +1,88 @@
+import { describe } from "vitest"
+import { RuntimeOperation } from "./operation"
+import { operationTest } from "./operation.test-utils"
+
+describe("Operation - Update Failure", () => {
+  operationTest(
+    "marks operation failed when runner emits error update",
+    async ({
+      project,
+      logger,
+      runnerBackend,
+      runner,
+      libraryBackend,
+      artifactService,
+      instanceLockService,
+      operationService,
+      secretService,
+      instanceStateService,
+      projectModelService,
+      unitExtraService,
+      createUnit,
+      createDeployedUnitState,
+      createOperation,
+      createContext,
+      setupPersistenceMocks,
+      setupImmediateLocking,
+      expect,
+    }) => {
+      // arrange
+      const unit = createUnit("A")
+      const state = createDeployedUnitState(unit)
+
+      await createContext({ instances: [unit], states: [state] })
+      setupImmediateLocking()
+      setupPersistenceMocks({ instances: [unit] })
+
+      runner.setAutoCompletion(false)
+      runner.emitError(unit.id, "boom")
+
+      const operation = createOperation({
+        type: "update",
+        requestedInstanceIds: [unit.id],
+        phases: [
+          {
+            type: "update",
+            instances: [{ id: unit.id, message: "requested", parentId: undefined }],
+          },
+        ],
+      })
+
+      const runtimeOperation = new RuntimeOperation(
+        project,
+        operation,
+        runnerBackend,
+        libraryBackend,
+        artifactService,
+        instanceLockService,
+        operationService,
+        secretService,
+        instanceStateService,
+        projectModelService,
+        unitExtraService,
+        logger,
+      )
+
+      // act
+      await runtimeOperation.operateSafe()
+
+      // assert
+      expect(runnerBackend.update).toHaveBeenCalledTimes(1)
+
+      const updateOperationCalls = operationService.updateOperation.mock.calls
+      const wasMarkedFailed = updateOperationCalls.some(call => {
+        const patch = call[2] as unknown
+        if (!patch || typeof patch !== "object") {
+          return false
+        }
+
+        const maybePatch = patch as { status?: unknown }
+        return maybePatch.status === "failed"
+      })
+
+      expect(wasMarkedFailed).toBe(true)
+      expect(operationService.markOperationFinished).not.toHaveBeenCalled()
+      expect(operationService.appendLog).toHaveBeenCalled()
+    },
+  )
+})

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

@@ -0,0 +1,95 @@
+import { describe } from "vitest"
+import { RuntimeOperation } from "./operation"
+import { operationTest } from "./operation.test-utils"
+
+describe("RuntimeOperation - Update Short-Circuit", () => {
+  operationTest(
+    "skips unit update when selfHash and dependencyOutputHash match",
+    async ({
+      project,
+      logger,
+      runnerBackend,
+      libraryBackend,
+      artifactService,
+      instanceLockService,
+      operationService,
+      secretService,
+      instanceStateService,
+      projectModelService,
+      unitExtraService,
+      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: "update",
+        requestedInstanceIds: [],
+        phases: [
+          {
+            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,
+        logger,
+      )
+
+      // act
+      await runtimeOperation.operateSafe()
+
+      // assert
+      expect(runnerBackend.update).not.toHaveBeenCalled()
+
+      const skipCall = instanceStateService.updateOperationState.mock.calls.find(
+        (_call): boolean => {
+          const options = _call[3]
+          return options.operationState?.status === "skipped"
+        },
+      )
+
+      expect(skipCall).toBeDefined()
+
+      const skipOptions = skipCall?.[3]
+      expect(skipOptions?.instanceState).toEqual({
+        inputHash: expected.inputHash,
+      })
+
+      expect(operationService.markOperationFinished).toHaveBeenCalledWith(
+        project.id,
+        operation.id,
+        "completed",
+      )
+    },
+  )
+})

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

@@ -0,0 +1,117 @@
+import type { InstanceModel } from "@highstate/contract"
+import { describe } from "vitest"
+import { RuntimeOperation } from "./operation"
+import { createDeferred, operationTest } from "./operation.test-utils"
+
+describe("Operation - Update", () => {
+  operationTest(
+    "waits for dependency update to complete before running dependent",
+    async ({
+      project,
+      logger,
+      runnerBackend,
+      runner,
+      libraryBackend,
+      artifactService,
+      instanceLockService,
+      operationService,
+      secretService,
+      instanceStateService,
+      projectModelService,
+      unitExtraService,
+      createUnit,
+      createDeployedUnitState,
+      createOperation,
+      createContext,
+      setupPersistenceMocks,
+      setupImmediateLocking,
+      expect,
+    }) => {
+      // arrange
+      const unitA = createUnit("A")
+      const unitB: InstanceModel = {
+        ...createUnit("B"),
+        inputs: {
+          dependency: [{ instanceId: unitA.id, output: "value" }],
+        },
+      }
+
+      const stateA = createDeployedUnitState(unitA)
+      const stateB = createDeployedUnitState(unitB)
+
+      await createContext({ instances: [unitA, unitB], states: [stateA, stateB] })
+
+      setupImmediateLocking()
+      setupPersistenceMocks({ instances: [unitA, unitB] })
+
+      const aStarted = createDeferred<void>()
+      const aDone = createDeferred<void>()
+      let canRunB = false
+
+      runner.setUpdateImpl(async input => {
+        if (input.instanceName === "A") {
+          aStarted.resolve(undefined)
+          await aDone.promise
+          canRunB = true
+          return
+        }
+
+        if (input.instanceName === "B") {
+          expect(canRunB).toBe(true)
+          return
+        }
+
+        throw new Error(`unexpected unit: ${input.instanceName}`)
+      })
+
+      const operation = createOperation({
+        type: "update",
+        requestedInstanceIds: [unitB.id],
+        phases: [
+          {
+            type: "update",
+            instances: [
+              { id: unitA.id, message: "dependency", parentId: undefined },
+              { id: unitB.id, message: "requested", parentId: undefined },
+            ],
+          },
+        ],
+      })
+
+      const runtimeOperation = new RuntimeOperation(
+        project,
+        operation,
+        runnerBackend,
+        libraryBackend,
+        artifactService,
+        instanceLockService,
+        operationService,
+        secretService,
+        instanceStateService,
+        projectModelService,
+        unitExtraService,
+        logger,
+      )
+
+      // act
+      const operationPromise = runtimeOperation.operateSafe()
+
+      // assert
+      await aStarted.promise
+      expect(runnerBackend.update).toHaveBeenCalledTimes(1)
+      expect(runnerBackend.update.mock.calls[0]?.[0].instanceName).toBe("A")
+
+      // act
+      aDone.resolve(undefined)
+      await operationPromise
+
+      // assert
+      expect(runnerBackend.update).toHaveBeenCalledTimes(2)
+      expect(operationService.markOperationFinished).toHaveBeenCalledWith(
+        project.id,
+        operation.id,
+        "completed",
+      )
+    },
+  )
+})

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

@@ -103,6 +103,7 @@ export class PlanTestBuilder {
       kind: instance.kind,
       parentId: null,
       parentInstanceId: instance.parentId ?? null,
+      selfHash: null,
       inputHash: null,
       outputHash: null,
       dependencyOutputHash: null,

package/src/runner/abstractions.ts

@@ -171,6 +171,11 @@ export type UnitUpdateOptions = UnitOptions & {
    * Whether to refresh the state before updating.
    */
   refresh?: boolean
+
+  /**
+   * Whether to delete the unreachable resources (e.g. k8s resources in unreachable clusters).
+   */
+  deleteUnreachable?: boolean
 }
 
 export type UnitDestroyOptions = UnitOptions & {

package/src/runner/local.ts

@@ -129,6 +129,7 @@ export class LocalRunnerBackend implements RunnerBackend {
       const envVars: Record<string, string> = {
         HIGHSTATE_CACHE_DIR: this.cacheDir,
         HIGHSTATE_TEMP_PATH: unitTempPath,
+        PULUMI_K8S_DELETE_UNREACHABLE: options.deleteUnreachable ? "true" : "",
         ...options.envVars,
       }
 

package/src/shared/resolvers/input-hash.ts

@@ -16,6 +16,7 @@ export type InputHashNode = {
 }
 
 export type InputHashOutput = {
+  selfHash: number
   inputHash: number
   dependencyOutputHash: number
   outputHash: number
@@ -44,27 +45,27 @@ export class InputHashResolver extends GraphResolver<InputHashNode, InputHashOut
     sourceHash,
     state,
   }: InputHashNode): InputHashOutput {
-    const inputHashSink: Uint8Array[] = []
+    const selfHashSink: Uint8Array[] = []
 
     // 0. include the instance id to reflect renames
-    inputHashSink.push(Buffer.from(instance.id))
+    selfHashSink.push(Buffer.from(instance.id))
 
     // 1. include the component definition hash
-    inputHashSink.push(int32ToBytes(component.definitionHash))
+    selfHashSink.push(int32ToBytes(component.definitionHash))
 
     // 2. include the input hash nonce if available
     if (state?.inputHashNonce) {
-      inputHashSink.push(int32ToBytes(state.inputHashNonce))
+      selfHashSink.push(int32ToBytes(state.inputHashNonce))
     }
 
     // 3. include instance args encoded as msgpack
     if (instance.args) {
-      inputHashSink.push(encode(instance.args))
+      selfHashSink.push(encode(instance.args))
     }
 
     // 4. include the source hash if available
     if (sourceHash) {
-      inputHashSink.push(int32ToBytes(sourceHash))
+      selfHashSink.push(int32ToBytes(sourceHash))
     } else if (isUnitModel(component)) {
       this.logger.warn(
         { instanceId: instance.id },
@@ -72,6 +73,8 @@ export class InputHashResolver extends GraphResolver<InputHashNode, InputHashOut
       )
     }
 
+    const inputHashSink = [...selfHashSink]
+
     const sortedInputs = Object.entries(resolvedInputs)
       //
       .sort(([a], [b]) => a.localeCompare(b))
@@ -126,6 +129,7 @@ export class InputHashResolver extends GraphResolver<InputHashNode, InputHashOut
     }
 
     return {
+      selfHash: crc32(Buffer.concat(selfHashSink)),
       inputHash: crc32(Buffer.concat(inputHashSink)),
       dependencyOutputHash: crc32(Buffer.concat(dependencyOutputHashSink)),
       outputHash: state?.outputHash ?? 0,

package/src/terminal/manager.ts

@@ -106,12 +106,9 @@ export class TerminalManager {
       throw new Error(`Terminal "${terminalId}" not found`)
     }
 
-    const sessionId = uuidv7()
-
     // create the terminal session in database
     const session = await database.terminalSession.create({
       data: {
-        id: sessionId,
         terminalId,
       },
     })

package/src/test-utils/database.ts

@@ -4,12 +4,17 @@ import { constants } from "node:fs"
 import { access, mkdtemp, rm } from "node:fs/promises"
 import { hostname, tmpdir } from "node:os"
 import { join } from "node:path"
-import { PrismaLibSQL } from "@prisma/adapter-libsql"
+import { PrismaLibSql } from "@prisma/adapter-libsql"
 import { generateIdentity, identityToRecipient } from "age-encryption"
-import { type DatabaseManager, ensureWellKnownEntitiesCreated } from "../database"
+import { createProjectLogger } from "../common"
+import {
+  type DatabaseManager,
+  ensureWellKnownEntitiesCreated,
+  migrateDatabase,
+  migrationPacks,
+} from "../database"
 import { PrismaClient as BackendPrismaClient } from "../database/_generated/backend/sqlite/client"
 import { getInitialBackendUnlockMethodMeta } from "../database/local/backend"
-import { migrateDatabase } from "../database/migrate"
 import {
   type BackendDatabase as BackendDatabaseClient,
   ProjectDatabase as ProjectDatabaseClient,
@@ -58,12 +63,15 @@ export class TestDatabaseManager implements DatabaseManager {
   async _forProject(projectId: string): Promise<ProjectDatabase> {
     const tempPath = await this.createTempPath()
     const projectUrl = `file:${join(tempPath, `${projectId}.db`)}`
+    const logger = createProjectLogger(this.logger, projectId)
 
-    await migrateDatabase(projectUrl, "project", undefined, this.logger)
-
-    return new ProjectDatabaseClient({
-      adapter: new PrismaLibSQL({ url: projectUrl }),
+    const client = new ProjectDatabaseClient({
+      adapter: new PrismaLibSql({ url: projectUrl }),
     })
+
+    await migrateDatabase(client, migrationPacks.project, 0, () => Promise.resolve(), logger)
+
+    return client
   }
 
   static async create(
@@ -75,20 +83,26 @@ export class TestDatabaseManager implements DatabaseManager {
     const tempPath = await mkdtemp(join(tempRoot, "highstate"))
     const backendUrl = `file:${join(tempPath, "backend.db")}`
 
-    await migrateDatabase(backendUrl, "backend/sqlite", undefined, logger)
-
-    const backend = new BackendPrismaClient({
-      adapter: new PrismaLibSQL({ url: backendUrl }),
+    const backendClient = new BackendPrismaClient({
+      adapter: new PrismaLibSql({ url: backendUrl }),
     }) as BackendDatabaseClient
 
-    await ensureWellKnownEntitiesCreated(backend)
+    await migrateDatabase(
+      backendClient,
+      migrationPacks["backend/sqlite"],
+      0,
+      () => Promise.resolve(),
+      logger,
+    )
+
+    await ensureWellKnownEntitiesCreated(backendClient)
 
     if (isEncryptionEnabled) {
       const identity = await generateIdentity()
       const recipient = await identityToRecipient(identity)
       const meta = getInitialBackendUnlockMethodMeta(hostname())
 
-      await backend.backendUnlockMethod.create({
+      await backendClient.backendUnlockMethod.create({
         data: {
           recipient,
           meta,
@@ -96,7 +110,7 @@ export class TestDatabaseManager implements DatabaseManager {
       })
     }
 
-    return new TestDatabaseManager(backend, logger, isEncryptionEnabled)
+    return new TestDatabaseManager(backendClient, logger, isEncryptionEnabled)
   }
 
   private async createTempPath(): Promise<string> {