@highstate/backend 0.6.2 → 0.7.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { pickBy, mapKeys, mapValues, funnel, omit, pick } from 'remeda';
+import { pickBy, mapKeys, mapValues, omit, pick } from 'remeda';
 import { BetterLock } from 'better-lock';
 import { basename, relative, dirname, resolve as resolve$1 } from 'node:path';
 import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
@@ -10,7 +10,7 @@ import Watcher from 'watcher';
 import { resolve } from 'import-meta-resolve';
 import { readdir, readFile, writeFile, mkdir } from 'node:fs/promises';
 import { getInstanceId, isUnitModel, parseInstanceId } from '@highstate/contract';
-import { h as hubModelSchema, i as instanceModelSchema, c as createInputResolver, a as createInputHashResolver, b as createInstanceState, d as instanceTerminalSchema, e as instancePageSchema, f as instanceFileSchema, g as instanceStatusFieldSchema, j as instanceTriggerSchema, k as compositeInstanceSchema, p as projectOperationSchema, l as instanceStateSchema, m as isFinalOperationStatus, t as terminalSessionSchema, n as applyPartialInstanceState, o as createInstanceStateFrontendPatch } from './terminal-C4MfopTF.mjs';
+import { h as hubModelSchema, i as instanceModelSchema, c as createInputResolver, a as createInputHashResolver, b as createInstanceState, d as instanceTerminalSchema, e as instancePageSchema, f as instanceFileSchema, g as instanceStatusFieldSchema, j as instanceTriggerSchema, k as compositeInstanceSchema, p as projectOperationSchema, l as instanceStateSchema, m as isFinalOperationStatus, t as terminalSessionSchema, n as createInstanceStateFrontendPatch, o as applyPartialInstanceState } from './terminal-CqIsctlZ.mjs';
 import { sha256 } from 'crypto-hash';
 import 'ajv';
 import { Readable, PassThrough } from 'node:stream';
@@ -57,11 +57,60 @@ function errorToString(error) {
   }
   return JSON.stringify(error);
 }
-function arrayAccumulator(values, value) {
-  if (!values) {
-    return [value];
+function createAsyncBatcher(fn, { waitMs = 100, maxWaitTimeMs = 1e3 } = {}) {
+  let batch = [];
+  let activeTimeout = null;
+  let maxWaitTimeout = null;
+  let firstCallTimestamp = null;
+  async function processBatch() {
+    if (batch.length === 0) return;
+    const currentBatch = batch;
+    batch = [];
+    await fn(currentBatch);
+    if (maxWaitTimeout) {
+      clearTimeout(maxWaitTimeout);
+      maxWaitTimeout = null;
+    }
+    firstCallTimestamp = null;
+  }
+  function schedule() {
+    if (activeTimeout) clearTimeout(activeTimeout);
+    activeTimeout = setTimeout(() => {
+      activeTimeout = null;
+      void processBatch();
+    }, waitMs);
+    if (!firstCallTimestamp) {
+      firstCallTimestamp = Date.now();
+      maxWaitTimeout = setTimeout(() => {
+        if (activeTimeout) clearTimeout(activeTimeout);
+        activeTimeout = null;
+        void processBatch();
+      }, maxWaitTimeMs);
+    }
   }
-  return [...values, value];
+  return {
+    /**
+     * Add an item to the batch.
+     */
+    call(item) {
+      batch.push(item);
+      schedule();
+    },
+    /**
+     * Immediately flush the pending batch (if any).
+     */
+    async flush() {
+      if (activeTimeout) {
+        clearTimeout(activeTimeout);
+        activeTimeout = null;
+      }
+      if (maxWaitTimeout) {
+        clearTimeout(maxWaitTimeout);
+        maxWaitTimeout = null;
+      }
+      await processBatch();
+    }
+  };
 }
 
 class LocalPulumiHost {
@@ -79,14 +128,15 @@ class LocalPulumiHost {
       return null;
     }
   }
-  async runInline(projectId, pulumiProjectName, pulumiStackName, program, fn) {
+  async runEmpty(options, fn) {
+    const { projectId, pulumiProjectName, pulumiStackName, envVars } = options;
     return await this.lock.acquire(`${pulumiProjectName}.${pulumiStackName}`, async () => {
       const { LocalWorkspace } = await import('@pulumi/pulumi/automation/index.js');
       const stack = await LocalWorkspace.createOrSelectStack(
         {
           projectName: pulumiProjectName,
           stackName: pulumiStackName,
-          program
+          program: () => Promise.resolve()
         },
         {
           projectSettings: {
@@ -95,7 +145,8 @@ class LocalPulumiHost {
           },
           envVars: {
             PULUMI_CONFIG_PASSPHRASE: this.getPassword(projectId),
-            PULUMI_K8S_AWAIT_ALL: "true"
+            PULUMI_K8S_AWAIT_ALL: "true",
+            ...envVars
           }
         }
       );
@@ -112,18 +163,14 @@ class LocalPulumiHost {
       }
     });
   }
-  async runEmpty(projectId, pulumiProjectName, pulumiStackName, fn) {
-    return await this.runInline(projectId, pulumiProjectName, pulumiStackName, async () => {
-    }, fn);
-  }
-  // TODO: extract args to options object
-  async runLocal(projectId, pulumiProjectName, pulumiStackName, programPathResolver, fn, stackConfig) {
+  async runLocal(options, fn) {
+    const { projectId, pulumiProjectName, pulumiStackName, projectPath, stackConfig, envVars } = options;
     return await this.lock.acquire(`${pulumiProjectName}.${pulumiStackName}`, async () => {
       const { LocalWorkspace } = await import('@pulumi/pulumi/automation/index.js');
       const stack = await LocalWorkspace.createOrSelectStack(
         {
           stackName: pulumiStackName,
-          workDir: await programPathResolver()
+          workDir: projectPath
         },
         {
           projectSettings: {
@@ -137,7 +184,8 @@ class LocalPulumiHost {
           } : void 0,
           envVars: {
             PULUMI_CONFIG_PASSPHRASE: this.getPassword(projectId),
-            PULUMI_K8S_AWAIT_ALL: "true"
+            PULUMI_K8S_AWAIT_ALL: "true",
+            ...envVars
           }
         }
       );
@@ -251,10 +299,12 @@ class LocalSecretBackend {
     this.pulumiProjectHost.setPassword(projectId, password);
     try {
       await this.pulumiProjectHost.runLocal(
-        projectId,
-        this.projectName,
-        projectId,
-        () => this.projectPath,
+        {
+          projectId,
+          pulumiProjectName: this.projectName,
+          pulumiStackName: projectId,
+          projectPath: this.projectPath
+        },
         async (stack) => {
           this.logger.debug({ projectId }, "checking password");
           await stack.info(true);
@@ -274,10 +324,12 @@ class LocalSecretBackend {
   }
   get(projectId, instanceId) {
     return this.pulumiProjectHost.runLocal(
-      projectId,
-      this.projectName,
-      projectId,
-      () => this.projectPath,
+      {
+        projectId,
+        pulumiProjectName: this.projectName,
+        pulumiStackName: projectId,
+        projectPath: this.projectPath
+      },
       async (stack) => {
         this.logger.debug({ projectId, instanceId }, "getting secrets");
         const config = await stack.getAllConfig();
@@ -290,10 +342,12 @@ class LocalSecretBackend {
   }
   set(projectId, instanceId, values) {
     return this.pulumiProjectHost.runLocal(
-      projectId,
-      this.projectName,
-      projectId,
-      () => this.projectPath,
+      {
+        projectId,
+        pulumiProjectName: this.projectName,
+        pulumiStackName: projectId,
+        projectPath: this.projectPath
+      },
       async (stack) => {
         this.logger.debug({ projectId, instanceId }, "setting secrets");
         const componentSecrets = mapValues(
@@ -768,6 +822,9 @@ class ProjectLock {
     this.lock = lock;
     this.projectId = projectId;
   }
+  canImmediatelyAcquireLock(instanceId) {
+    return this.lock.canAcquire(`${this.projectId}/${instanceId}`);
+  }
   lockInstance(instanceId, fn) {
     return this.lock.acquire(`${this.projectId}/${instanceId}`, fn);
   }
@@ -1180,17 +1237,10 @@ class TerminalManager {
       logger.child({ service: "TerminalManager" })
     );
   }
-  persistHistory = funnel(
-    (entries) => {
-      this.logger.trace({ msg: "persisting history lines", count: entries.length });
-      void this.stateBackend.appendTerminalSessionHistory(entries);
-    },
-    {
-      minQuietPeriodMs: 100,
-      maxBurstDurationMs: 200,
-      reducer: arrayAccumulator
-    }
-  );
+  persistHistory = createAsyncBatcher(async (entries) => {
+    this.logger.trace({ msg: "persisting history lines", count: entries.length });
+    await this.stateBackend.appendTerminalSessionHistory(entries);
+  });
 }
 
 class InvalidInstanceStatusError extends Error {
@@ -1206,14 +1256,16 @@ const localRunnerBackendConfig = z.object({
   HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_SOURCE_CHECK: z.boolean({ coerce: true }).default(false),
   HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK: z.boolean({ coerce: true }).default(false),
   HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT: z.boolean({ coerce: true }).default(true),
-  HIGHSTATE_BACKEND_RUNNER_LOCAL_SOURCE_BASE_PATH: z.string().optional()
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_SOURCE_BASE_PATH: z.string().optional(),
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR: z.string().optional()
 });
 class LocalRunnerBackend {
-  constructor(skipSourceCheck, skipStateCheck, printOutput, sourceBasePath, pulumiProjectHost) {
+  constructor(skipSourceCheck, skipStateCheck, printOutput, sourceBasePath, cacheDir, pulumiProjectHost) {
     this.skipSourceCheck = skipSourceCheck;
     this.skipStateCheck = skipStateCheck;
     this.printOutput = printOutput;
     this.sourceBasePath = sourceBasePath;
+    this.cacheDir = cacheDir;
     this.pulumiProjectHost = pulumiProjectHost;
   }
   events = new EventEmitter();
@@ -1233,9 +1285,11 @@ class LocalRunnerBackend {
   }
   getState(options) {
     return this.pulumiProjectHost.runEmpty(
-      options.projectId,
-      options.instanceType,
-      LocalRunnerBackend.getStackName(options),
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options)
+      },
       async (stack) => {
         const info = await stack.info();
         const instanceId = getInstanceId(options.instanceType, options.instanceName);
@@ -1262,9 +1316,11 @@ class LocalRunnerBackend {
   }
   getTerminalFactory(options, terminalName) {
     return this.pulumiProjectHost.runEmpty(
-      options.projectId,
-      options.instanceType,
-      LocalRunnerBackend.getStackName(options),
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options)
+      },
       async (stack) => {
         const outputs = await stack.outputs();
         if (!outputs["$terminals"]) {
@@ -1281,9 +1337,11 @@ class LocalRunnerBackend {
   }
   getPageContent(options, pageName) {
     return this.pulumiProjectHost.runEmpty(
-      options.projectId,
-      options.instanceType,
-      LocalRunnerBackend.getStackName(options),
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options)
+      },
       async (stack) => {
         const outputs = await stack.outputs();
         if (!outputs["$pages"]) {
@@ -1300,9 +1358,11 @@ class LocalRunnerBackend {
   }
   getFileContent(options, fileName) {
     return this.pulumiProjectHost.runEmpty(
-      options.projectId,
-      options.instanceType,
-      LocalRunnerBackend.getStackName(options),
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options)
+      },
       async (stack) => {
         const outputs = await stack.outputs();
         if (!outputs["$files"]) {
@@ -1331,21 +1391,47 @@ class LocalRunnerBackend {
       ...mapValues(options.config, (value) => ({ value })),
       ...mapValues(options.secrets, (value) => ({ value, secret: true }))
     };
-    void this.updateWorker(options, configMap);
+    void this.updateWorker(options, configMap, false);
   }
-  async updateWorker(options, configMap) {
+  async preview(options) {
+    const currentStatus = await this.validateStatus(options, [
+      "not_created",
+      "previewing",
+      "created",
+      "error"
+    ]);
+    if (currentStatus === "previewing") {
+      return;
+    }
+    const configMap = {
+      ...mapValues(options.config, (value) => ({ value })),
+      ...mapValues(options.secrets, (value) => ({ value, secret: true }))
+    };
+    void this.updateWorker(options, configMap, true);
+  }
+  async updateWorker(options, configMap, preview) {
     const instanceId = LocalRunnerBackend.getInstanceId(options);
     try {
+      const [projectPath, allowedDependencies] = await this.resolveProjectPath(
+        options.instanceName,
+        options.source
+      );
       await this.pulumiProjectHost.runLocal(
-        options.projectId,
-        options.instanceType,
-        LocalRunnerBackend.getStackName(options),
-        () => this.resolveProjectPath(options.source),
+        {
+          projectId: options.projectId,
+          pulumiProjectName: options.instanceType,
+          pulumiStackName: LocalRunnerBackend.getStackName(options),
+          projectPath,
+          stackConfig: configMap,
+          envVars: {
+            HIGHSTATE_CACHE_DIR: this.cacheDir
+          }
+        },
         async (stack) => {
-          await stack.setAllConfig(configMap);
+          await this.setStackConfig(stack, configMap);
           this.updateState({
             id: instanceId,
-            status: "updating",
+            status: preview ? "previewing" : "updating",
             currentResourceCount: 0,
             totalResourceCount: 0
           });
@@ -1353,8 +1439,11 @@ class LocalRunnerBackend {
           let totalResourceCount = 0;
           await runWithRetryOnError(
             async () => {
-              await stack.up({
+              await stack[preview ? "preview" : "up"]({
                 color: "always",
+                refresh: options.refresh,
+                signal: options.signal,
+                diff: preview,
                 onEvent: (event) => {
                   if (event.resourcePreEvent) {
                     totalResourceCount = updateResourceCount(
@@ -1378,8 +1467,7 @@ class LocalRunnerBackend {
                   if (this.printOutput) {
                     console.log(message);
                   }
-                },
-                signal: options.signal
+                }
               });
               const extraOutputs = await this.getExtraOutputsStatePatch(stack);
               this.updateState({
@@ -1392,13 +1480,15 @@ class LocalRunnerBackend {
             async (error) => {
               const isUnlocked = await this.pulumiProjectHost.tryUnlockStack(stack, error);
               if (isUnlocked) return true;
-              const isResolved = await this.tryInstallMissingDependencies(error);
+              const isResolved = await this.tryInstallMissingDependencies(
+                error,
+                allowedDependencies
+              );
               if (isResolved) return true;
               return false;
             }
           );
-        },
-        configMap
+        }
       );
     } catch (error) {
       this.updateState({
@@ -1408,6 +1498,12 @@ class LocalRunnerBackend {
       });
     }
   }
+  async setStackConfig(stack, configMap) {
+    const currentConfig = await stack.getAllConfig();
+    const currentConfigKeys = Object.keys(currentConfig);
+    await stack.removeAllConfig(currentConfigKeys);
+    await stack.setAllConfig(configMap);
+  }
   async destroy(options) {
     const currentStatus = await this.validateStatus(options, [
       "not_created",
@@ -1423,10 +1519,18 @@ class LocalRunnerBackend {
   async destroyWorker(options) {
     const instanceId = LocalRunnerBackend.getInstanceId(options);
     try {
-      await this.pulumiProjectHost.runEmpty(
-        options.projectId,
-        options.instanceType,
-        LocalRunnerBackend.getStackName(options),
+      const [projectPath] = await this.resolveProjectPath(options.instanceName, options.source);
+      await this.pulumiProjectHost.runLocal(
+        {
+          projectId: options.projectId,
+          pulumiProjectName: options.instanceType,
+          pulumiStackName: LocalRunnerBackend.getStackName(options),
+          projectPath,
+          envVars: {
+            HIGHSTATE_CACHE_DIR: this.cacheDir,
+            PULUMI_K8S_DELETE_UNREACHABLE: options.deleteUnreachable ? "true" : ""
+          }
+        },
         async (stack) => {
           const summary = await stack.workspace.stack();
           let currentResourceCount = summary?.resourceCount ?? 0;
@@ -1440,6 +1544,9 @@ class LocalRunnerBackend {
             async () => {
               await stack.destroy({
                 color: "always",
+                refresh: options.refresh,
+                remove: true,
+                signal: options.signal,
                 onEvent: (event) => {
                   if (event.resOutputsEvent) {
                     currentResourceCount = updateResourceCount(
@@ -1455,8 +1562,7 @@ class LocalRunnerBackend {
                   if (this.printOutput) {
                     console.log(message);
                   }
-                },
-                signal: options.signal
+                }
               });
               const extraOutputs = await this.getExtraOutputsStatePatch(stack);
               this.updateState({
@@ -1471,6 +1577,16 @@ class LocalRunnerBackend {
         }
       );
     } catch (error) {
+      const { StackNotFoundError } = await import('@pulumi/pulumi/automation');
+      if (error instanceof StackNotFoundError) {
+        this.updateState({
+          id: instanceId,
+          status: "not_created",
+          totalResourceCount: 0,
+          currentResourceCount: 0
+        });
+        return;
+      }
       this.updateState({
         id: instanceId,
         status: "error",
@@ -1494,9 +1610,11 @@ class LocalRunnerBackend {
     const instanceId = LocalRunnerBackend.getInstanceId(options);
     try {
       await this.pulumiProjectHost.runEmpty(
-        options.projectId,
-        options.instanceType,
-        LocalRunnerBackend.getStackName(options),
+        {
+          projectId: options.projectId,
+          pulumiProjectName: options.instanceType,
+          pulumiStackName: LocalRunnerBackend.getStackName(options)
+        },
         async (stack) => {
           const summary = await stack.workspace.stack();
           let currentResourceCount = 0;
@@ -1618,24 +1736,33 @@ class LocalRunnerBackend {
   static getInstanceId(options) {
     return getInstanceId(options.instanceType, options.instanceName);
   }
-  async resolveProjectPath(source) {
+  async resolveProjectPath(instanceType, source) {
     if (source.type === "local") {
-      if (!source.path) {
-        throw new Error("Source path is required for local units");
-      }
-      return resolve$1(this.sourceBasePath, source.path);
+      const path = source.path ?? instanceType.replace(/\./g, "/");
+      const projectPath = resolve$1(this.sourceBasePath, path);
+      return [projectPath, []];
     }
     if (!this.skipSourceCheck) {
       const packageName = source.version ? `${source.package}@${source.version}` : source.package;
       await ensureDependencyInstalled(packageName);
     }
-    const fullPath = source.path ? `${source.package}/${source.path}` : source.package;
-    const url = resolve(fullPath, import.meta.url);
-    const path = fileURLToPath(url);
-    const projectPath = dirname(path);
-    return projectPath;
+    const workerPathUrl = resolve(
+      `@highstate/backend/source-resolution-worker`,
+      import.meta.url
+    );
+    const workerPath = fileURLToPath(workerPathUrl);
+    const worker = new Worker(workerPath, {
+      workerData: { source, skipSourceCheck: this.skipSourceCheck }
+    });
+    for await (const [event] of on(worker, "message")) {
+      const eventData = event;
+      if (eventData.type === "result") {
+        return [eventData.projectPath, eventData.allowedDependencies];
+      }
+    }
+    throw new Error("Worker ended without sending the result");
   }
-  async tryInstallMissingDependencies(error) {
+  async tryInstallMissingDependencies(error, allowedDependencies) {
     if (!(error instanceof Error)) {
       return false;
     }
@@ -1645,6 +1772,11 @@ class LocalRunnerBackend {
       return false;
     }
     const packageName = match[1];
+    if (!allowedDependencies.includes(packageName)) {
+      throw new Error(
+        `Dependency '${packageName}' was requested to be auto-installed, but it is not allowed. Please add it to the 'peerDependencies' in the package.json of the unit.`
+      );
+    }
     await ensureDependencyInstalled(packageName);
     return true;
   }
@@ -1657,11 +1789,22 @@ class LocalRunnerBackend {
       const [projectPath] = await resolveMainLocalProject();
       sourceBasePath = resolve$1(projectPath, "units");
     }
+    let cacheDir = config.HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR;
+    if (!cacheDir) {
+      const homeDir = process.env.HOME ?? process.env.USERPROFILE;
+      if (!homeDir) {
+        throw new Error(
+          "Failed to determine the home directory, please set HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR"
+        );
+      }
+      cacheDir = resolve$1(homeDir, ".cache", "highstate");
+    }
     return new LocalRunnerBackend(
       config.HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_SOURCE_CHECK,
       config.HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK,
       config.HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT,
       sourceBasePath,
+      cacheDir,
       pulumiProjectHost
     );
   }
@@ -1973,7 +2116,7 @@ class LocalStateBackend {
       const currentUser = await localPulumiHost.getCurrentUser();
       if (!currentUser) {
         throw new Error(
-          "The pulumi is not authenticated, please login first or specify the state location manually"
+          "The pulumi state is not specified, please run `pulumi login` or specify the state location manually before restarting the service"
         );
       }
       if (!currentUser.url) {
@@ -2126,6 +2269,14 @@ class RuntimeOperation {
         this.persistSecrets.flush()
       ]);
       this.logger.debug("operation finished, all entries persisted");
+      if (this.operation.type === "preview") {
+        const states = await this.stateBackend.getInstanceStates(this.operation.projectId);
+        for (const state of states) {
+          if (this.operation.instanceIds.includes(state.id)) {
+            this.stateEE.emit(this.operation.projectId, createInstanceStateFrontendPatch(state));
+          }
+        }
+      }
     }
   }
   resetPendingStateStatuses() {
@@ -2203,9 +2354,9 @@ class RuntimeOperation {
       { promiseCache: this.inputHashPromiseCache }
     );
     if (this.operation.type === "update") {
-      await this.extendWithNotCreatedDependencies();
+      await this.extendWithDependencies();
       await this.updateOperation();
-    } else if (this.operation.type === "destroy") {
+    } else if (this.operation.type === "destroy" && this.operation.options.destroyDependentInstances !== false) {
       this.extendWithCreatedDependents();
       await this.updateOperation();
     }
@@ -2252,7 +2403,8 @@ class RuntimeOperation {
   }
   async getUnitPromise(instance, component) {
     switch (this.operation.type) {
-      case "update": {
+      case "update":
+      case "preview": {
         return this.updateUnit(instance, component);
       }
       case "recreate": {
@@ -2340,11 +2492,12 @@ class RuntimeOperation {
       const secrets = await this.secretBackend.get(this.operation.projectId, instance.id);
       this.abortController.signal.throwIfAborted();
       logger.debug("secrets loaded", { count: Object.keys(secrets).length });
-      await this.runnerBackend.update({
+      await this.runnerBackend[this.operation.type === "preview" ? "preview" : "update"]({
         projectId: this.operation.projectId,
         instanceType: instance.type,
         instanceName: instance.name,
         config: await this.prepareUnitConfig(instance),
+        refresh: this.operation.options.refresh,
         secrets: mapValues(secrets, (value) => valueToString(value)),
         source: this.resolveUnitSource(component),
         signal: this.abortController.signal
@@ -2357,23 +2510,34 @@ class RuntimeOperation {
         finalStatuses: ["created", "error"]
       });
       await this.watchStateStream(stream);
-      const inputHash = await this.inputHashLock.acquire(async () => {
-        this.inputHashNodes.set(instance.id, {
-          instance,
-          resolvedInputs: this.resolvedInstanceInputs.get(instance.id),
-          state: this.stateMap.get(instance.id),
-          sourceHash: void 0
-          // TODO: implement source hash
-        });
-        this.inputHashPromiseCache.clear();
-        return await this.resolveInputHash(instance.id);
+      const inputHash = await this.getUpToDateInputHash(instance);
+      this.updateInstanceState({
+        id: instance.id,
+        inputHash,
+        dependencyIds: dependencies.map((dependency) => dependency.id)
       });
-      this.updateInstanceState({ id: instance.id, inputHash });
       logger.debug("input hash after update", { inputHash });
       logger.info("unit updated");
     });
   }
+  async getUpToDateInputHash(instance) {
+    return await this.inputHashLock.acquire(async () => {
+      this.inputHashNodes.set(instance.id, {
+        instance,
+        resolvedInputs: this.resolvedInstanceInputs.get(instance.id),
+        state: this.stateMap.get(instance.id),
+        sourceHash: void 0
+        // TODO: implement source hash
+      });
+      this.inputHashPromiseCache.clear();
+      return await this.resolveInputHash(instance.id);
+    });
+  }
   async processBeforeDestroyTriggers(state, component, logger) {
+    if (!this.operation.options.invokeDestroyTriggers) {
+      logger.debug("destroy triggers are disabled for the operation");
+      return;
+    }
     const instance = this.instanceMap.get(state.id);
     if (!instance) {
       throw new Error(`Instance not found: ${state.id}`);
@@ -2386,12 +2550,13 @@ class RuntimeOperation {
     logger.info("updating unit to process before-destroy triggers...");
     const secrets = await this.secretBackend.get(this.operation.projectId, instance.id);
     this.abortController.signal.throwIfAborted();
-    logger.debug("secrets loaded", { count: Object.keys(secrets).length });
+    logger.debug({ count: Object.keys(secrets).length }, "secrets loaded");
     await this.runnerBackend.update({
       projectId: this.operation.projectId,
       instanceType: instance.type,
       instanceName: instance.name,
       config: await this.prepareUnitConfig(instance, invokedTriggers),
+      refresh: this.operation.options.refresh,
       secrets: mapValues(secrets, (value) => valueToString(value)),
       source: this.resolveUnitSource(component),
       signal: this.abortController.signal
@@ -2435,7 +2600,10 @@ class RuntimeOperation {
         projectId: this.operation.projectId,
         instanceType: type,
         instanceName: name,
-        signal: this.abortController.signal
+        refresh: this.operation.options.refresh,
+        signal: this.abortController.signal,
+        source: this.resolveUnitSource(component),
+        deleteUnreachable: this.operation.options.deleteUnreachableResources
       });
       this.logger.debug("destroy request sent");
       const stream = this.runnerBackend.watch({
@@ -2469,7 +2637,10 @@ class RuntimeOperation {
         projectId: this.operation.projectId,
         instanceType: instance.type,
         instanceName: instance.name,
-        signal: this.abortController.signal
+        refresh: this.operation.options.refresh,
+        signal: this.abortController.signal,
+        source: this.resolveUnitSource(component),
+        deleteUnreachable: this.operation.options.deleteUnreachableResources
       });
       logger.debug("destroy request sent");
       const destroyStream = this.runnerBackend.watch({
@@ -2490,6 +2661,7 @@ class RuntimeOperation {
         instanceType: instance.type,
         instanceName: instance.name,
         config: await this.prepareUnitConfig(instance),
+        refresh: this.operation.options.refresh,
         secrets: mapValues(secrets, (value) => valueToString(value)),
         source: this.resolveUnitSource(component),
         signal: this.abortController.signal
@@ -2501,7 +2673,13 @@ class RuntimeOperation {
         instanceName: instance.name,
         finalStatuses: ["created", "error"]
       });
-      this.updateInstanceState({ id: instance.id, inputHash: null });
+      const inputHash = await this.getUpToDateInputHash(instance);
+      const dependencies = this.getInstanceDependencies(instance);
+      this.updateInstanceState({
+        id: instance.id,
+        inputHash,
+        dependencyIds: dependencies.map((dependency) => dependency.id)
+      });
       await this.watchStateStream(updateStream);
       logger.info("unit recreated");
     });
@@ -2639,9 +2817,11 @@ class RuntimeOperation {
       return;
     }
     const state = applyPartialInstanceState(this.stateMap, patch);
-    this.persistStates.call(state);
-    if (patch.secrets) {
-      this.persistSecrets.call([patch.id, patch.secrets]);
+    if (this.operation.type !== "preview") {
+      this.persistStates.call(state);
+      if (patch.secrets) {
+        this.persistSecrets.call([patch.id, patch.secrets]);
+      }
     }
     this.stateEE.emit(this.operation.projectId, createInstanceStateFrontendPatch(patch));
   }
@@ -2653,7 +2833,29 @@ class RuntimeOperation {
     children.push(state);
     this.childrenStateMap.set(state.parentId, children);
   }
+  removeStateFromParent(state) {
+    if (!state.parentId) {
+      return;
+    }
+    const children = this.childrenStateMap.get(state.parentId) ?? [];
+    const index = children.findIndex((child) => child.id === state.id);
+    if (index !== -1) {
+      children.splice(index, 1);
+      this.childrenStateMap.set(state.parentId, children);
+    }
+  }
   addDependentState(state) {
+    const instance = this.instanceMap.get(state.id);
+    if (!instance) {
+      return;
+    }
+    for (const dependency of state.dependencyIds) {
+      const dependents = this.dependentStateMap.get(dependency) ?? [];
+      dependents.push(state);
+      this.dependentStateMap.set(dependency, dependents);
+    }
+  }
+  removeDependentState(state) {
     const instance = this.instanceMap.get(state.id);
     if (!instance) {
       return;
@@ -2662,12 +2864,15 @@ class RuntimeOperation {
     for (const inputs of Object.values(instanceInputs)) {
       for (const input of inputs) {
         const dependents = this.dependentStateMap.get(input.input.instanceId) ?? [];
-        dependents.push(state);
-        this.dependentStateMap.set(input.input.instanceId, dependents);
+        const index = dependents.findIndex((dependent) => dependent.id === state.id);
+        if (index !== -1) {
+          dependents.splice(index, 1);
+          this.dependentStateMap.set(input.input.instanceId, dependents);
+        }
       }
     }
   }
-  async extendWithNotCreatedDependencies() {
+  async extendWithDependencies() {
     const instanceIdsSet = /* @__PURE__ */ new Set();
     const traverse = async (instanceId) => {
       if (instanceIdsSet.has(instanceId)) {
@@ -2685,6 +2890,10 @@ class RuntimeOperation {
       }
       const state = this.stateMap.get(instance.id);
       const expectedInputHash = await this.resolveInputHash(instance.id);
+      if (this.operation.options.forceUpdateDependencies) {
+        instanceIdsSet.add(instanceId);
+        return;
+      }
       if (state?.status !== "created" || state.inputHash !== expectedInputHash) {
         instanceIdsSet.add(instanceId);
       }
@@ -2726,7 +2935,15 @@ class RuntimeOperation {
     if (instancePromise) {
       return instancePromise;
     }
-    instancePromise = this.projectLock.lockInstance(instanceId, fn);
+    instancePromise = (async () => {
+      const wasImmediatelyAcquired = this.projectLock.canImmediatelyAcquireLock(instanceId);
+      await this.projectLock.lockInstance(instanceId, async () => {
+        if (!wasImmediatelyAcquired) {
+          await this.refetchState(instanceId);
+        }
+        return await fn();
+      });
+    })();
     instancePromise = instancePromise.finally(() => this.instancePromiseMap.delete(instanceId));
     this.instancePromiseMap.set(instanceId, instancePromise);
     return instancePromise;
@@ -2735,6 +2952,8 @@ class RuntimeOperation {
     switch (this.operation.type) {
       case "update":
         return "updating";
+      case "preview":
+        return "previewing";
       case "recreate":
         return "updating";
       case "destroy":
@@ -2768,47 +2987,44 @@ class RuntimeOperation {
     }
     return component.source;
   }
-  persistStates = funnel(
-    (states) => {
-      this.logger.debug({ msg: "persisting states", count: states.length });
-      void this.stateBackend.putAffectedInstanceStates(
-        this.operation.projectId,
-        this.operation.id,
-        states
-      );
-    },
-    {
-      minQuietPeriodMs: 100,
-      maxBurstDurationMs: 1e3,
-      triggerAt: "end",
-      reducer: arrayAccumulator
-    }
-  );
-  persistLogs = funnel(
-    (entries) => {
-      this.logger.trace({ msg: "persisting logs", count: entries.length });
-      void this.stateBackend.appendInstanceLogs(this.operation.id, entries);
-    },
-    {
-      minQuietPeriodMs: 100,
-      maxBurstDurationMs: 200,
-      reducer: arrayAccumulator
+  async refetchState(instanceId) {
+    this.logger.info({ instanceId }, "refetching state since the lock was not immediately acquired");
+    const state = await this.stateBackend.getInstanceState(this.operation.projectId, instanceId);
+    const oldState = this.stateMap.get(instanceId);
+    if (oldState) {
+      this.removeStateFromParent(oldState);
+      this.removeDependentState(oldState);
+    }
+    if (state) {
+      this.stateMap.set(instanceId, state);
+      this.initialStatusMap.set(instanceId, state.status);
+      this.tryAddStateToParent(state);
+      this.addDependentState(state);
+    } else {
+      this.stateMap.delete(instanceId);
+      this.initialStatusMap.delete(instanceId);
     }
-  );
-  persistSecrets = funnel(
-    (entries) => {
+  }
+  persistStates = createAsyncBatcher(async (states) => {
+    this.logger.debug({ msg: "persisting states", count: states.length });
+    await this.stateBackend.putAffectedInstanceStates(
+      this.operation.projectId,
+      this.operation.id,
+      states
+    );
+  });
+  persistLogs = createAsyncBatcher(async (entries) => {
+    this.logger.trace({ msg: "persisting logs", count: entries.length });
+    await this.stateBackend.appendInstanceLogs(this.operation.id, entries);
+  });
+  persistSecrets = createAsyncBatcher(
+    async (entries) => {
       this.logger.debug({ msg: "persisting secrets", count: entries.length });
       for (const [instanceId, secrets] of entries) {
-        void this.secretBackend.get(this.operation.projectId, instanceId).then((existingSecrets) => {
-          Object.assign(existingSecrets, secrets);
-          return this.secretBackend.set(this.operation.projectId, instanceId, existingSecrets);
-        });
+        const existingSecrets = await this.secretBackend.get(this.operation.projectId, instanceId);
+        Object.assign(existingSecrets, secrets);
+        await this.secretBackend.set(this.operation.projectId, instanceId, existingSecrets);
       }
-    },
-    {
-      minQuietPeriodMs: 100,
-      maxBurstDurationMs: 200,
-      reducer: arrayAccumulator
     }
   );
   static abortMessagePatterns = [
@@ -2901,12 +3117,21 @@ class OperationManager {
       type: request.type,
       instanceIds: request.instanceIds,
       status: "pending",
+      options: {
+        forceUpdateDependencies: request.options?.forceUpdateDependencies ?? false,
+        destroyDependentInstances: request.options?.destroyDependentInstances ?? true,
+        invokeDestroyTriggers: request.options?.invokeDestroyTriggers ?? false,
+        deleteUnreachableResources: request.options?.deleteUnreachableResources ?? false,
+        refresh: request.options?.refresh ?? false
+      },
       error: null,
       startedAt: Date.now(),
       completedAt: null
     };
+    this.logger.info({ operation }, "launching operation");
     await this.stateBackend.putOperation(operation);
     this.startOperation(operation);
+    return operation;
   }
   /**
    * Cancels the current operation.