@go-to-k/cdkd 0.50.13 → 0.51.0

package/dist/index.js

@@ -8807,6 +8807,65 @@ var DeployEngine = class {
       }
     }
   }
+  /**
+   * Kick off `provider.readCurrentState` for every resource in the
+   * loaded state that lacks `observedProperties` (e.g. state written
+   * by a pre-v3 binary, or a v3 record where a NO_CHANGE-skipped
+   * resource's baseline never landed). Calls go through
+   * `kickOffObservedCapture`, so they share the same fire-and-forget
+   * pipeline, error swallowing, and final-drain wiring that the
+   * post-CREATE / post-UPDATE captures use.
+   *
+   * The deploy critical path does NOT wait on these; the cost is
+   * bounded by `max(per-resource readCurrentState latency)` (typically
+   * ~200-300ms in practice) once at the end-of-deploy drain. Any
+   * resource that subsequently goes through CREATE / UPDATE in the
+   * same deploy will overwrite this entry via the `Map.set` keyed by
+   * `logicalId` (latest-wins) — so there's no double-write to state,
+   * just a wasted SDK call for the (rare) UPDATE / DELETE intersection.
+   *
+   * Resources whose provider lookup throws (e.g. unsupported type) or
+   * lacks `readCurrentState` are silently skipped — same policy as the
+   * manual `cdkd state refresh-observed` command.
+   */
+  kickOffAutoRefreshObservedProperties(stateResources) {
+    if (this.options.captureObservedState !== true)
+      return;
+    if (this.options.dryRun === true)
+      return;
+    let toRefresh = 0;
+    const candidates = [];
+    for (const [logicalId, resource] of Object.entries(stateResources)) {
+      if (resource.observedProperties !== void 0)
+        continue;
+      candidates.push({ logicalId, resource });
+    }
+    if (candidates.length === 0)
+      return;
+    for (const { logicalId, resource } of candidates) {
+      let provider;
+      try {
+        provider = this.providerRegistry.getProvider(resource.resourceType);
+      } catch {
+        continue;
+      }
+      if (!provider.readCurrentState)
+        continue;
+      this.kickOffObservedCapture(
+        provider,
+        logicalId,
+        resource.physicalId,
+        resource.resourceType,
+        resource.properties ?? {}
+      );
+      toRefresh++;
+    }
+    if (toRefresh > 0) {
+      this.logger.warn(
+        `cdkd state schema upgrade detected \u2014 refreshing observed-properties baseline for ${toRefresh} resource(s) (one-time, runs in parallel with deploy)`
+      );
+    }
+  }
   async doDeploy(stackName, template) {
     const startTime = Date.now();
     this.logger.debug(`Starting deployment for stack: ${stackName}`);
@@ -8838,6 +8897,7 @@ var DeployEngine = class {
       this.logger.debug(
         `Loaded current state: ${Object.keys(currentState.resources).length} resources`
       );
+      this.kickOffAutoRefreshObservedProperties(currentState.resources);
       this.logger.debug(`Template has ${Object.keys(template.Resources || {}).length} resources`);
       const parameterValues = await this.resolver.resolveParameters(
         template,
@@ -8882,6 +8942,35 @@ var DeployEngine = class {
       const hasChanges = this.diffCalculator.hasChanges(changes);
       if (!hasChanges) {
         this.logger.info("No changes detected. Stack is up to date.");
+        if (!this.options.dryRun && this.observedCaptureTasks.size > 0) {
+          await this.drainObservedCaptures(currentState.resources);
+          try {
+            const refreshedState = {
+              version: STATE_SCHEMA_VERSION_CURRENT,
+              region: this.stackRegion,
+              stackName: currentState.stackName,
+              resources: currentState.resources,
+              outputs: currentState.outputs,
+              lastModified: Date.now()
+            };
+            const saveOptions = {};
+            if (currentEtag !== void 0)
+              saveOptions.expectedEtag = currentEtag;
+            if (migrationPending)
+              saveOptions.migrateLegacy = true;
+            await this.stateBackend.saveState(
+              stackName,
+              this.stackRegion,
+              refreshedState,
+              saveOptions
+            );
+            this.logger.debug("Persisted refreshed observedProperties (no-change path)");
+          } catch (saveError) {
+            this.logger.warn(
+              `Failed to persist refreshed observedProperties: ${saveError instanceof Error ? saveError.message : String(saveError)} \u2014 drift baseline will be re-fetched on next deploy.`
+            );
+          }
+        }
         return {
           stackName,
           created: 0,