@go-to-k/cdkd 0.1.0 → 0.2.0

package/README.md

@@ -78,7 +78,7 @@ Reproduce with `./tests/benchmark/run-benchmark.sh all`. See [tests/benchmark/RE
 │ cdkd Engine     │
 │ - DAG Analysis  │  Dependency graph construction
 │ - Diff Calc     │  Compare with existing resources
-│ - Parallel Exec │  Deploy by levels
+│ - Parallel Exec │  Event-driven dispatch
 └────────┬────────┘
          │
     ┌────┴────┐
@@ -134,10 +134,11 @@ Reproduce with `./tests/benchmark/run-benchmark.sh all`. See [tests/benchmark/RE
    │   ├── Build DAG from template (Ref/Fn::GetAtt/DependsOn)
    │   ├── Calculate diff (CREATE/UPDATE/DELETE)
    │   ├── Resolve intrinsic functions (Ref, Fn::Sub, Fn::Join, etc.)
-   │   ├── Execute by levels (parallel within each level):
+   │   ├── Execute via event-driven DAG dispatch (a resource starts as
+   │   │   soon as ALL of its own deps complete; no level barrier):
    │   │   ├── SDK Providers (direct API calls, preferred)
    │   │   └── Cloud Control API (fallback, async polling)
-   │   ├── Save state after each level (partial state save)
+   │   ├── Save state after each successful resource (partial state save)
    │   └── Release lock
    └── synth does NOT publish assets or deploy (deploy only)
 ```
@@ -459,7 +460,7 @@ LambdaStack
 ✓ Deployed LambdaStack (4 resources, 7.2s)
 ```
 
-Resources without dependencies (ServiceRole and Table) are created in parallel.
+Resources are dispatched as soon as their own dependencies complete (event-driven DAG). ServiceRole and Table run in parallel; DefaultPolicy starts the moment ServiceRole is done — without waiting for Table — and Handler starts the moment DefaultPolicy is done.
 
 ## Architecture
 

package/dist/cli.js

@@ -25053,8 +25053,96 @@ function registerAllProviders(registry) {
   registry.register("AWS::S3Tables::Table", s3TablesProvider);
 }
 
+// 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)");
@@ -25187,6 +25275,7 @@ var DeployEngine = class _DeployEngine {
         template,
         currentState,
         changes,
+        dag,
         executionLevels,
         stackName,
         parameterValues,
@@ -25219,13 +25308,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 = [];
@@ -25256,32 +25348,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(
@@ -25308,30 +25404,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,
@@ -25343,23 +25445,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) {
@@ -25453,12 +25557,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) {
@@ -25491,7 +25595,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();
@@ -25913,17 +26017,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];
@@ -25932,38 +26049,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.
@@ -27029,7 +27119,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command8();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.1.0");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.2.0");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createDeployCommand());