@go-to-k/cdkd 0.50.12 → 0.51.0

package/dist/cli.js

@@ -12008,11 +12008,11 @@ var S3BucketProvider = class {
       this.logger.debug(`Applied EventBridge notification to bucket ${bucketName}`);
     }
     const corsConfig = properties["CorsConfiguration"];
-    if (corsConfig?.CorsRules) {
+    if (corsConfig?.CorsRules && Array.isArray(corsConfig.CorsRules) && corsConfig.CorsRules.length > 0) {
       await this.applyCorsConfiguration(bucketName, corsConfig);
     }
     const lifecycleConfig = properties["LifecycleConfiguration"];
-    if (lifecycleConfig?.Rules) {
+    if (lifecycleConfig?.Rules && Array.isArray(lifecycleConfig.Rules) && lifecycleConfig.Rules.length > 0) {
       await this.applyLifecycleConfiguration(bucketName, lifecycleConfig);
     }
     const publicAccessBlock = properties["PublicAccessBlockConfiguration"];
@@ -12020,7 +12020,7 @@ var S3BucketProvider = class {
       await this.applyPublicAccessBlockConfiguration(bucketName, publicAccessBlock);
     }
     const bucketEncryption = properties["BucketEncryption"];
-    if (bucketEncryption?.ServerSideEncryptionConfiguration) {
+    if (bucketEncryption?.ServerSideEncryptionConfiguration && Array.isArray(bucketEncryption.ServerSideEncryptionConfiguration) && bucketEncryption.ServerSideEncryptionConfiguration.length > 0) {
       await this.applyBucketEncryption(bucketName, bucketEncryption);
     }
     const loggingConfig = properties["LoggingConfiguration"];
@@ -12281,11 +12281,12 @@ var S3BucketProvider = class {
     }
     try {
       const resp = await this.s3Client.send(new GetBucketTaggingCommand({ Bucket: physicalId }));
-      const tags = normalizeAwsTagsToCfn(resp.TagSet);
-      result["Tags"] = tags;
+      result["Tags"] = normalizeAwsTagsToCfn(resp.TagSet);
     } catch (err) {
       const e = err;
-      if (e.name !== "NoSuchTagSet") {
+      if (e.name === "NoSuchTagSet") {
+        result["Tags"] = [];
+      } else {
         throw err;
       }
     }
@@ -38026,6 +38027,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}`);
@@ -38057,6 +38117,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,
@@ -38101,6 +38162,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,
@@ -43889,7 +43979,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command14();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.50.12");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.51.0");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createListCommand());