@go-to-k/cdkd 0.1.0 → 0.2.0

package/dist/index.js

@@ -6993,8 +6993,96 @@ var IAMRoleProvider = class {
   }
 };
 
+// src/deployment/dag-executor.ts
+var DagExecutor = class {
+  nodes = /* @__PURE__ */ new Map();
+  logger = getLogger().child("DagExecutor");
+  add(node) {
+    this.nodes.set(node.id, node);
+  }
+  has(id) {
+    return this.nodes.has(id);
+  }
+  size() {
+    return this.nodes.size;
+  }
+  values() {
+    return this.nodes.values();
+  }
+  async execute(concurrency, fn, cancelled = () => false) {
+    let active = 0;
+    const errors = [];
+    return new Promise((resolve4, reject) => {
+      const dispatch = () => {
+        let changed = true;
+        while (changed) {
+          changed = false;
+          for (const node of this.nodes.values()) {
+            if (node.state !== "pending")
+              continue;
+            const hasFailedDep = [...node.dependencies].some((depId) => {
+              const dep = this.nodes.get(depId);
+              return dep && (dep.state === "failed" || dep.state === "skipped");
+            });
+            if (hasFailedDep) {
+              node.state = "skipped";
+              changed = true;
+              this.logger.debug(`Skipped ${node.id}: dependency failed or was skipped`);
+            }
+          }
+        }
+        const ready = [];
+        for (const node of this.nodes.values()) {
+          if (node.state !== "pending")
+            continue;
+          const depsReady = [...node.dependencies].every((depId) => {
+            const dep = this.nodes.get(depId);
+            return !dep || dep.state === "completed";
+          });
+          if (depsReady)
+            ready.push(node);
+        }
+        if (!cancelled()) {
+          for (const node of ready) {
+            if (active >= concurrency)
+              break;
+            node.state = "running";
+            active++;
+            fn(node).then(() => {
+              node.state = "completed";
+            }).catch((error) => {
+              node.state = "failed";
+              errors.push({ id: node.id, error });
+            }).finally(() => {
+              active--;
+              dispatch();
+            });
+          }
+        }
+        if (active === 0) {
+          if (errors.length > 0) {
+            reject(errors[0].error);
+            return;
+          }
+          const stillPending = [...this.nodes.values()].some((n) => n.state === "pending");
+          if (stillPending && !cancelled()) {
+            const pending = [...this.nodes.values()].filter((n) => n.state === "pending").map((n) => n.id);
+            reject(
+              new Error(
+                `Deadlock detected: ${pending.length} node(s) stuck with unresolvable dependencies (${pending.join(", ")})`
+              )
+            );
+            return;
+          }
+          resolve4();
+        }
+      };
+      dispatch();
+    });
+  }
+};
+
 // src/deployment/deploy-engine.ts
-import pLimit from "p-limit";
 var InterruptedError = class extends Error {
   constructor() {
     super("Deployment interrupted by user (Ctrl+C)");
@@ -7127,6 +7215,7 @@ var DeployEngine = class _DeployEngine {
         template,
         currentState,
         changes,
+        dag,
         executionLevels,
         stackName,
         parameterValues,
@@ -7159,13 +7248,16 @@ var DeployEngine = class _DeployEngine {
     }
   }
   /**
-   * Execute deployment by processing resources in DAG order
+   * Execute deployment by processing resources via event-driven DAG dispatch.
    *
-   * Important: DELETE operations are executed in reverse dependency order,
-   * while CREATE/UPDATE follow normal dependency order.
-   */
-  async executeDeployment(template, currentState, changes, executionLevels, stackName, parameterValues, conditions, currentEtag, progress) {
-    const limit = pLimit(this.options.concurrency);
+   * - CREATE/UPDATE follow forward dependency order (a node starts as soon as
+   *   ALL of its dependencies are completed — does not wait for unrelated
+   *   siblings in the same "level")
+   * - DELETE follows reverse dependency order (a node starts as soon as all
+   *   resources that depend ON it have finished deleting)
+   */
+  async executeDeployment(template, currentState, changes, dag, executionLevels, stackName, parameterValues, conditions, currentEtag, progress) {
+    const concurrency = this.options.concurrency;
     const newResources = { ...currentState.resources };
     const actualCounts = { created: 0, updated: 0, deleted: 0, skipped: 0 };
     const completedOperations = [];
@@ -7196,32 +7288,36 @@ var DeployEngine = class _DeployEngine {
       Array.from(changes.entries()).filter(([_, change]) => change.changeType === "DELETE").map(([logicalId]) => logicalId)
     );
     try {
-      for (let levelIndex = 0; levelIndex < executionLevels.length; levelIndex++) {
-        if (this.interrupted) {
-          throw new InterruptedError();
-        }
-        const levelNodes = executionLevels[levelIndex];
-        if (!levelNodes)
+      const createUpdateIds = [];
+      for (const [id, change] of changes.entries()) {
+        if (deleteChanges.has(id))
           continue;
-        const level = levelNodes.filter((id) => {
-          if (deleteChanges.has(id))
-            return false;
-          const change = changes.get(id);
-          return !!change && change.changeType !== "NO_CHANGE";
-        });
-        if (level.length === 0)
+        if (change.changeType === "NO_CHANGE")
           continue;
+        createUpdateIds.push(id);
+      }
+      if (createUpdateIds.length > 0) {
         this.logger.info(
-          `Level ${levelIndex + 1}/${executionLevels.length} (${level.length} resources)`
+          `Deploying ${createUpdateIds.length} resource(s) (DAG: ${executionLevels.length} levels, max parallel: ${concurrency})`
         );
-        const results = await Promise.allSettled(
-          level.map(
-            (logicalId) => limit(async () => {
-              const change = changes.get(logicalId);
-              if (!change || change.changeType === "NO_CHANGE") {
-                this.logger.debug(`Skipping ${logicalId} (no change)`);
-                return;
-              }
+        const createUpdateExecutor = new DagExecutor();
+        const provisionable = new Set(createUpdateIds);
+        for (const id of createUpdateIds) {
+          const allDeps = this.dagBuilder.getDirectDependencies(dag, id);
+          const deps = new Set(allDeps.filter((d) => provisionable.has(d)));
+          createUpdateExecutor.add({
+            id,
+            dependencies: deps,
+            state: "pending",
+            data: changes.get(id)
+          });
+        }
+        try {
+          await createUpdateExecutor.execute(
+            concurrency,
+            async (node) => {
+              const logicalId = node.id;
+              const change = node.data;
               const previousState = currentState.resources[logicalId] ? { ...currentState.resources[logicalId] } : void 0;
               try {
                 await this.provisionResource(
@@ -7248,30 +7344,36 @@ var DeployEngine = class _DeployEngine {
                 properties: newResources[logicalId]?.properties
               });
               saveStateAfterResource(logicalId);
-            })
-          )
-        );
-        await saveChain;
-        const failures = results.filter((r) => r.status === "rejected");
-        if (failures.length > 0) {
-          throw failures[0].reason;
+            },
+            () => this.interrupted
+          );
+        } finally {
+          await saveChain;
+        }
+        if (this.interrupted && this.hasPending(createUpdateExecutor)) {
+          throw new InterruptedError();
         }
       }
       if (deleteChanges.size > 0) {
         this.logger.info(`Deleting ${deleteChanges.size} resource(s)`);
-        const deletionLevels = this.buildDeletionLevels(deleteChanges, currentState);
-        for (let levelIndex = 0; levelIndex < deletionLevels.length; levelIndex++) {
-          if (this.interrupted) {
-            throw new InterruptedError();
-          }
-          const level = deletionLevels[levelIndex];
-          if (level.length === 0)
-            continue;
-          const deleteResults = await Promise.allSettled(
-            level.map(
-              (logicalId) => limit(async () => {
-                const change = changes.get(logicalId);
-                const previousState = currentState.resources[logicalId] ? { ...currentState.resources[logicalId] } : void 0;
+        const deleteDeps = this.buildDeletionDependencies(deleteChanges, currentState);
+        const deleteExecutor = new DagExecutor();
+        for (const id of deleteChanges) {
+          deleteExecutor.add({
+            id,
+            dependencies: deleteDeps.get(id) ?? /* @__PURE__ */ new Set(),
+            state: "pending",
+            data: changes.get(id)
+          });
+        }
+        try {
+          await deleteExecutor.execute(
+            concurrency,
+            async (node) => {
+              const logicalId = node.id;
+              const change = node.data;
+              const previousState = currentState.resources[logicalId] ? { ...currentState.resources[logicalId] } : void 0;
+              try {
                 await this.provisionResource(
                   logicalId,
                   change,
@@ -7283,23 +7385,25 @@ var DeployEngine = class _DeployEngine {
                   actualCounts,
                   progress
                 );
-                completedOperations.push({
-                  logicalId,
-                  changeType: "DELETE",
-                  resourceType: change.resourceType,
-                  previousState
-                });
-                saveStateAfterResource(logicalId);
-              })
-            )
+              } catch (provisionError) {
+                this.interrupted = true;
+                throw provisionError;
+              }
+              completedOperations.push({
+                logicalId,
+                changeType: "DELETE",
+                resourceType: change.resourceType,
+                previousState
+              });
+              saveStateAfterResource(logicalId);
+            },
+            () => this.interrupted
           );
+        } finally {
           await saveChain;
-          const deleteFailures = deleteResults.filter(
-            (r) => r.status === "rejected"
-          );
-          if (deleteFailures.length > 0) {
-            throw deleteFailures[0].reason;
-          }
+        }
+        if (this.interrupted && this.hasPending(deleteExecutor)) {
+          throw new InterruptedError();
         }
       }
     } catch (error) {
@@ -7393,12 +7497,12 @@ var DeployEngine = class _DeployEngine {
    * - UPDATE → update back to previous properties
    * - DELETE → cannot rollback (resource already deleted), log warning
    *
-   * Resources created in the same DAG level may have dependencies between them
-   * (e.g., IAM Policy depends on IAM Role). When rolling back CREATEs (deleting),
-   * dependent resources must be deleted before their dependencies. This method
-   * sorts CREATE rollback operations using dependency information from state,
-   * then processes UPDATE/DELETE rollbacks, and finally processes sorted CREATE
-   * rollback deletions.
+   * Resources completed concurrently in the dispatcher may have dependencies
+   * between them (e.g., IAM Policy depends on IAM Role). When rolling back
+   * CREATEs (deleting), dependent resources must be deleted before their
+   * dependencies. This method sorts CREATE rollback operations using dependency
+   * information from state, then processes UPDATE/DELETE rollbacks, and finally
+   * processes sorted CREATE rollback deletions.
    */
   async performRollback(completedOperations, stateResources, _stackName) {
     if (completedOperations.length === 0) {
@@ -7431,7 +7535,7 @@ var DeployEngine = class _DeployEngine {
    * Sort CREATE rollback operations so that resources depending on others
    * are deleted first (reverse dependency order).
    *
-   * Uses state dependencies to build deletion levels, similar to buildDeletionLevels.
+   * Uses state dependencies to determine reverse-dependency order, similar to buildDeletionDependencies.
    */
   sortRollbackCreates(createOps, stateResources) {
     const opMap = /* @__PURE__ */ new Map();
@@ -7853,17 +7957,30 @@ var DeployEngine = class _DeployEngine {
     "AWS::EC2::SecurityGroup": ["AWS::EC2::SecurityGroupIngress", "AWS::EC2::SecurityGroupEgress"]
   };
   /**
-   * Build deletion levels from state dependencies (reverse topological order).
-   * Resources that are depended upon by others are deleted LAST.
+   * Build a per-resource map of "must be deleted before me" dependencies for
+   * the DELETE phase, derived from state-recorded dependencies plus implicit
+   * type-based ordering rules.
+   *
+   * For a resource X, the returned set contains every resource Y such that Y
+   * must finish deleting before X starts — i.e., Y depends on X (or is otherwise
+   * required to vanish first per implicit type rules).
+   */
+  /**
+   * Returns true if the executor still has un-started pending nodes —
+   * used to distinguish "SIGINT cancelled real work" from "SIGINT landed
+   * after all nodes already completed" (the latter should not error).
    */
-  buildDeletionLevels(deleteIds, state) {
+  hasPending(executor) {
+    for (const node of executor.values()) {
+      if (node.state === "pending")
+        return true;
+    }
+    return false;
+  }
+  buildDeletionDependencies(deleteIds, state) {
     const dependedBy = /* @__PURE__ */ new Map();
-    const inDegree = /* @__PURE__ */ new Map();
     for (const id of deleteIds) {
-      if (!dependedBy.has(id))
-        dependedBy.set(id, /* @__PURE__ */ new Set());
-      if (!inDegree.has(id))
-        inDegree.set(id, 0);
+      dependedBy.set(id, /* @__PURE__ */ new Set());
     }
     for (const id of deleteIds) {
       const resource = state.resources[id];
@@ -7872,38 +7989,11 @@ var DeployEngine = class _DeployEngine {
       for (const dep of resource.dependencies) {
         if (!deleteIds.has(dep))
           continue;
-        if (!dependedBy.has(dep))
-          dependedBy.set(dep, /* @__PURE__ */ new Set());
         dependedBy.get(dep).add(id);
-        inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
       }
     }
     this.addImplicitDeleteDependencies(deleteIds, state, dependedBy);
-    const levels = [];
-    let remaining = new Set(deleteIds);
-    while (remaining.size > 0) {
-      const level = [];
-      for (const id of remaining) {
-        const dependents = dependedBy.get(id);
-        const hasPendingDependents = dependents ? [...dependents].some((d) => remaining.has(d)) : false;
-        if (!hasPendingDependents) {
-          level.push(id);
-        }
-      }
-      if (level.length === 0) {
-        this.logger.warn(
-          `Circular dependency detected in delete order, deleting remaining ${remaining.size} resources`
-        );
-        levels.push([...remaining]);
-        break;
-      }
-      levels.push(level);
-      remaining = new Set([...remaining].filter((id) => !level.includes(id)));
-    }
-    this.logger.debug(
-      `Delete order: ${levels.length} levels - ${levels.map((l, i) => `L${i + 1}(${l.length})`).join(", ")}`
-    );
-    return levels;
+    return dependedBy;
   }
   /**
    * Add implicit delete dependency edges based on resource type relationships.