@go-to-k/cdkd 0.84.0 → 0.86.0

package/README.md

@@ -4,7 +4,7 @@
 
 - **Drop-in CDK compatible** — your existing CDK app code runs as-is.
 - **Up to 15x faster deploys than the AWS CDK CLI (CloudFormation)**
-- **Run AWS resources locally without deploying** — invoke Lambdas, serve API Gateway routes, and run ECS task definitions against Docker. SAM-compatible mental model, no `template.yaml` round-trip.
+- **Run AWS resources locally without deploying** — invoke Lambdas, run ECS tasks, and serve API Gateway routes from Docker.
 
 ![cdkd demo](https://github.com/user-attachments/assets/0128730d-186d-4bd3-abea-aabc80ba4dd5)
 

package/dist/cli.js

@@ -76798,6 +76798,13 @@ function inspectImageForSubstitutions(image, resources) {
       return { pseudo: false, state: true };
     }
   }
+  const join11 = obj["Fn::Join"];
+  if (Array.isArray(join11) && join11.length === 2 && Array.isArray(join11[1])) {
+    const scan = { pseudo: false, state: false };
+    inspectIntrinsicNeeds(join11[1], resources, scan);
+    if (scan.pseudo || scan.state)
+      return scan;
+  }
   let sub;
   const subRaw = obj["Fn::Sub"];
   if (typeof subRaw === "string")
@@ -76823,6 +76830,42 @@ function inspectImageForSubstitutions(image, resources) {
   }
   return { pseudo, state };
 }
+function inspectIntrinsicNeeds(node, resources, scan) {
+  if (node === null || node === void 0)
+    return;
+  if (typeof node === "string" || typeof node === "number" || typeof node === "boolean")
+    return;
+  if (Array.isArray(node)) {
+    for (const item of node)
+      inspectIntrinsicNeeds(item, resources, scan);
+    return;
+  }
+  if (typeof node !== "object")
+    return;
+  const obj = node;
+  if (typeof obj["Ref"] === "string") {
+    const target = obj["Ref"];
+    if (target.startsWith("AWS::"))
+      scan.pseudo = true;
+    else if (resources[target]?.Type === "AWS::ECR::Repository")
+      scan.state = true;
+    return;
+  }
+  const getAtt = obj["Fn::GetAtt"];
+  if (getAtt !== void 0) {
+    let lid;
+    if (Array.isArray(getAtt) && typeof getAtt[0] === "string")
+      lid = getAtt[0];
+    else if (typeof getAtt === "string")
+      lid = getAtt.split(".")[0];
+    if (lid && resources[lid]?.Type === "AWS::ECR::Repository")
+      scan.state = true;
+    return;
+  }
+  for (const value of Object.values(obj)) {
+    inspectIntrinsicNeeds(value, resources, scan);
+  }
+}
 function parseEcsTarget(target) {
   if (typeof target !== "string" || target.length === 0) {
     throw new EcsTaskResolutionError(
@@ -77147,6 +77190,20 @@ function parseContainerImage(raw, containerName, taskLogicalId, resources, _stac
   if (getAttImage) {
     return classifyResolvedImage(getAttImage);
   }
+  const joinResolved = tryResolveImageFnJoin(raw, resources, context);
+  if (joinResolved.kind === "resolved") {
+    return classifyResolvedImage(joinResolved.uri);
+  }
+  if (joinResolved.kind === "needs-state") {
+    throw new EcsTaskResolutionError(
+      `Container '${containerName}' in task '${taskLogicalId}' references same-stack ECR repository '${joinResolved.repoLogicalId}' via Fn::Join. cdkd local run-task cannot resolve the repository URI without state \u2014 pass --from-state (the stack must have been deployed via cdkd deploy), build via ContainerImage.fromAsset, or pin a public image.`
+    );
+  }
+  if (joinResolved.kind === "unsupported-join") {
+    throw new EcsTaskResolutionError(
+      `Container '${containerName}' in task '${taskLogicalId}' has an unsupported Fn::Join Image shape: ${joinResolved.reason}. cdkd local run-task recognizes the canonical CDK 2.x ContainerImage.fromEcrRepository Fn::Join shape (delimiter "" with nested Fn::Select/Fn::Split over an ECR Repository Arn GetAtt + Ref to the repo).`
+    );
+  }
   const flat = extractImageString(raw);
   if (!flat) {
     throw new EcsTaskResolutionError(
@@ -77298,6 +77355,228 @@ function extractImageString(value) {
   }
   return void 0;
 }
+function tryResolveImageFnJoin(raw, resources, context) {
+  if (!raw || typeof raw !== "object")
+    return { kind: "not-applicable" };
+  const obj = raw;
+  const arg = obj["Fn::Join"];
+  if (arg === void 0)
+    return { kind: "not-applicable" };
+  if (!Array.isArray(arg) || arg.length !== 2 || !Array.isArray(arg[1])) {
+    return { kind: "unsupported-join", reason: "Fn::Join must be [delimiter, [elements]]" };
+  }
+  const [delimiter, elements] = arg;
+  if (typeof delimiter !== "string") {
+    return {
+      kind: "unsupported-join",
+      reason: `Fn::Join delimiter must be a string, got ${typeof delimiter}`
+    };
+  }
+  const repoLogicalId = findEcrRepositoryRefInTree(elements, resources);
+  const stateResources = context?.stateResources;
+  if (repoLogicalId && !stateResources) {
+    return { kind: "needs-state", repoLogicalId };
+  }
+  const parts = [];
+  for (const element of elements) {
+    const r = resolveImageIntrinsic(element, resources, context);
+    if (r === void 0) {
+      if (!repoLogicalId)
+        return { kind: "not-applicable" };
+      return {
+        kind: "unsupported-join",
+        reason: "one or more Fn::Join elements could not be resolved"
+      };
+    }
+    parts.push(r);
+  }
+  return { kind: "resolved", uri: parts.join(delimiter) };
+}
+function findEcrRepositoryRefInTree(node, resources) {
+  if (node === null || node === void 0)
+    return void 0;
+  if (typeof node === "string" || typeof node === "number" || typeof node === "boolean") {
+    return void 0;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      const hit = findEcrRepositoryRefInTree(item, resources);
+      if (hit)
+        return hit;
+    }
+    return void 0;
+  }
+  if (typeof node !== "object")
+    return void 0;
+  const obj = node;
+  if (typeof obj["Ref"] === "string") {
+    const target = obj["Ref"];
+    if (resources[target]?.Type === "AWS::ECR::Repository")
+      return target;
+    return void 0;
+  }
+  const getAtt = obj["Fn::GetAtt"];
+  if (getAtt !== void 0) {
+    let lid;
+    if (Array.isArray(getAtt) && typeof getAtt[0] === "string")
+      lid = getAtt[0];
+    else if (typeof getAtt === "string")
+      lid = getAtt.split(".")[0];
+    if (lid && resources[lid]?.Type === "AWS::ECR::Repository")
+      return lid;
+    return void 0;
+  }
+  for (const value of Object.values(obj)) {
+    const hit = findEcrRepositoryRefInTree(value, resources);
+    if (hit)
+      return hit;
+  }
+  return void 0;
+}
+function resolveImageIntrinsic(node, resources, context) {
+  const v = resolveImageIntrinsicAny(node, resources, context);
+  if (typeof v === "string")
+    return v;
+  if (typeof v === "number" || typeof v === "boolean")
+    return String(v);
+  return void 0;
+}
+function resolveImageIntrinsicAny(node, resources, context) {
+  if (node === null || node === void 0)
+    return void 0;
+  if (typeof node === "string" || typeof node === "number" || typeof node === "boolean") {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return void 0;
+  }
+  if (typeof node !== "object")
+    return void 0;
+  const obj = node;
+  const keys = Object.keys(obj);
+  if (keys.length !== 1)
+    return void 0;
+  const intrinsic = keys[0];
+  const arg = obj[intrinsic];
+  if (intrinsic === "Ref") {
+    if (typeof arg !== "string")
+      return void 0;
+    if (arg.startsWith("AWS::")) {
+      const p = context?.pseudoParameters;
+      if (!p)
+        return void 0;
+      if (arg === "AWS::URLSuffix")
+        return p.urlSuffix;
+      if (arg === "AWS::Partition")
+        return p.partition;
+      if (arg === "AWS::Region")
+        return p.region;
+      if (arg === "AWS::AccountId")
+        return p.accountId;
+      return void 0;
+    }
+    const refResource = resources[arg];
+    if (refResource?.Type !== "AWS::ECR::Repository")
+      return void 0;
+    const stateEntry = context?.stateResources?.[arg];
+    if (!stateEntry)
+      return void 0;
+    return stateEntry.physicalId;
+  }
+  if (intrinsic === "Fn::GetAtt") {
+    let logicalId;
+    let attr;
+    if (Array.isArray(arg) && arg.length === 2 && typeof arg[0] === "string" && typeof arg[1] === "string") {
+      logicalId = arg[0];
+      attr = arg[1];
+    } else if (typeof arg === "string") {
+      const dot = arg.indexOf(".");
+      if (dot > 0 && dot < arg.length - 1) {
+        logicalId = arg.slice(0, dot);
+        attr = arg.slice(dot + 1);
+      }
+    }
+    if (!logicalId || !attr)
+      return void 0;
+    if (resources[logicalId]?.Type !== "AWS::ECR::Repository")
+      return void 0;
+    const cached = context?.stateResources?.[logicalId]?.attributes?.[attr];
+    if (typeof cached === "string" && cached.length > 0)
+      return cached;
+    return void 0;
+  }
+  if (intrinsic === "Fn::Split") {
+    if (!Array.isArray(arg) || arg.length !== 2)
+      return void 0;
+    const argArr = arg;
+    const delim = argArr[0];
+    if (typeof delim !== "string")
+      return void 0;
+    const src = resolveImageIntrinsicAny(argArr[1], resources, context);
+    if (typeof src !== "string")
+      return void 0;
+    return src.split(delim);
+  }
+  if (intrinsic === "Fn::Select") {
+    if (!Array.isArray(arg) || arg.length !== 2)
+      return void 0;
+    const argArr = arg;
+    const rawIndex = argArr[0];
+    let index;
+    if (typeof rawIndex === "number") {
+      index = rawIndex;
+    } else if (typeof rawIndex === "string" && /^-?\d+$/.test(rawIndex)) {
+      index = Number.parseInt(rawIndex, 10);
+    }
+    if (index === void 0 || !Number.isFinite(index))
+      return void 0;
+    const list = resolveImageIntrinsicAny(argArr[1], resources, context);
+    if (Array.isArray(list)) {
+      if (index < 0 || index >= list.length)
+        return void 0;
+      const picked = list[index];
+      if (typeof picked === "string")
+        return picked;
+      return void 0;
+    }
+    if (Array.isArray(argArr[1])) {
+      const listLiteral = argArr[1];
+      if (index < 0 || index >= listLiteral.length)
+        return void 0;
+      return resolveImageIntrinsic(listLiteral[index], resources, context);
+    }
+    return void 0;
+  }
+  if (intrinsic === "Fn::Join") {
+    if (!Array.isArray(arg) || arg.length !== 2)
+      return void 0;
+    const [delim, parts] = arg;
+    if (typeof delim !== "string" || !Array.isArray(parts))
+      return void 0;
+    const resolved = [];
+    for (const part of parts) {
+      const r = resolveImageIntrinsic(part, resources, context);
+      if (r === void 0)
+        return void 0;
+      resolved.push(r);
+    }
+    return resolved.join(delim);
+  }
+  if (intrinsic === "Fn::Sub") {
+    let template;
+    if (typeof arg === "string")
+      template = arg;
+    else if (Array.isArray(arg) && typeof arg[0] === "string")
+      template = arg[0];
+    if (template === void 0)
+      return void 0;
+    const out = substituteImagePlaceholders(template, resources, context);
+    if (out.includes("${"))
+      return void 0;
+    return out;
+  }
+  return void 0;
+}
 function parseVolume(raw, idx, taskLogicalId) {
   if (!raw || typeof raw !== "object") {
     throw new EcsTaskResolutionError(`Task '${taskLogicalId}' Volumes[${idx}] is not an object.`);
@@ -79038,6 +79317,38 @@ var PRIMARY_IDENTIFIER_FALLBACK = {
   "AWS::Cognito::UserPool": "UserPoolId",
   "AWS::ECR::Repository": "RepositoryName"
 };
+var COMPOSITE_ID_SPLITTERS = {
+  // cdkd stores `restApiId|resourceId|httpMethod` (apigateway-provider.ts);
+  // CFn primary identifier is [RestApiId, ResourceId, HttpMethod] — same order.
+  "AWS::ApiGateway::Method": (id) => {
+    const parts = id.split("|");
+    if (parts.length !== 3) {
+      throw new Error(
+        `expected 3 parts (restApiId|resourceId|httpMethod), got ${parts.length}: '${id}'`
+      );
+    }
+    return { RestApiId: parts[0], ResourceId: parts[1], HttpMethod: parts[2] };
+  },
+  // cdkd stores `restApiId|resourceId` (apigateway-provider.ts);
+  // CFn primary identifier is [RestApiId, ResourceId].
+  "AWS::ApiGateway::Resource": (id) => {
+    const parts = id.split("|");
+    if (parts.length !== 2) {
+      throw new Error(`expected 2 parts (restApiId|resourceId), got ${parts.length}: '${id}'`);
+    }
+    return { RestApiId: parts[0], ResourceId: parts[1] };
+  },
+  // cdkd stores `IGW|VpcId` (ec2-provider.ts);
+  // CFn primary identifier is [VpcId, InternetGatewayId] — DIFFERENT order
+  // from cdkd. Splitter reorders explicitly.
+  "AWS::EC2::VPCGatewayAttachment": (id) => {
+    const parts = id.split("|");
+    if (parts.length !== 2) {
+      throw new Error(`expected 2 parts (IGW|VpcId), got ${parts.length}: '${id}'`);
+    }
+    return { VpcId: parts[1], InternetGatewayId: parts[0] };
+  }
+};
 async function exportCommand(stackArg, options) {
   const logger = getLogger();
   if (options.verbose) {
@@ -79308,14 +79619,19 @@ async function buildImportPlan(state, template, cfnClient) {
       });
       continue;
     }
-    let identifierKey;
+    let resourceIdentifier;
     try {
-      identifierKey = await resolvePrimaryIdentifier(resourceType, cfnClient, identifierCache);
+      resourceIdentifier = await resolveResourceIdentifier(
+        resourceType,
+        stateEntry.physicalId,
+        cfnClient,
+        identifierCache
+      );
     } catch (err) {
       skipped.push({
         logicalId,
         resourceType,
-        reason: "could not resolve primary identifier: " + (err instanceof Error ? err.message : String(err))
+        reason: "could not resolve resource identifier: " + (err instanceof Error ? err.message : String(err))
       });
       continue;
     }
@@ -79323,15 +79639,44 @@ async function buildImportPlan(state, template, cfnClient) {
       logicalId,
       resourceType,
       physicalId: stateEntry.physicalId,
-      identifierKey
+      resourceIdentifier
     });
   }
   return { plan, skipped };
 }
-async function resolvePrimaryIdentifier(resourceType, cfnClient, cache2) {
-  const cached = cache2.get(resourceType);
-  if (cached !== void 0)
-    return cached;
+async function resolveResourceIdentifier(resourceType, physicalId, cfnClient, cache2) {
+  let entry = cache2.get(resourceType);
+  if (entry === void 0) {
+    entry = await fetchPrimaryIdentifier(resourceType, cfnClient);
+    cache2.set(resourceType, entry);
+  }
+  if (entry.fields.length === 1) {
+    return { [entry.fields[0]]: physicalId };
+  }
+  const splitter = COMPOSITE_ID_SPLITTERS[resourceType];
+  if (!splitter) {
+    throw new Error(
+      `resource type uses a composite primary identifier (${entry.fields.length} fields: ${entry.fields.join(", ")}); add an entry to COMPOSITE_ID_SPLITTERS in src/cli/commands/export.ts that parses cdkd's physicalId for this type, or destroy the resource first and let CFn create it fresh`
+    );
+  }
+  let split;
+  try {
+    split = splitter(physicalId);
+  } catch (err) {
+    throw new Error(
+      `composite-id splitter for ${resourceType} failed: ` + (err instanceof Error ? err.message : String(err))
+    );
+  }
+  for (const f of entry.fields) {
+    if (!(f in split)) {
+      throw new Error(
+        `composite-id splitter for ${resourceType} did not produce field '${f}' (produced: ${Object.keys(split).join(", ")})`
+      );
+    }
+  }
+  return split;
+}
+async function fetchPrimaryIdentifier(resourceType, cfnClient) {
   try {
     const resp = await cfnClient.send(
       new DescribeTypeCommand({ Type: "RESOURCE", TypeName: resourceType })
@@ -79339,15 +79684,9 @@ async function resolvePrimaryIdentifier(resourceType, cfnClient, cache2) {
     if (resp.Schema) {
       const parsed = JSON.parse(resp.Schema);
       const primary = parsed.primaryIdentifier;
-      if (Array.isArray(primary) && primary.length === 1 && typeof primary[0] === "string") {
-        const propName = primary[0].replace(/^\/properties\//, "");
-        cache2.set(resourceType, propName);
-        return propName;
-      }
-      if (Array.isArray(primary) && primary.length > 1) {
-        throw new Error(
-          `resource type uses a composite primary identifier (${primary.length} fields); cdkd does not yet support composite identifiers for cdkd export`
-        );
+      if (Array.isArray(primary) && primary.length > 0 && primary.every((p) => typeof p === "string")) {
+        const fields = primary.map((p) => p.replace(/^\/properties\//, ""));
+        return { fields };
       }
     }
   } catch (err) {
@@ -79356,8 +79695,7 @@ async function resolvePrimaryIdentifier(resourceType, cfnClient, cache2) {
   }
   const fallback = PRIMARY_IDENTIFIER_FALLBACK[resourceType];
   if (fallback) {
-    cache2.set(resourceType, fallback);
-    return fallback;
+    return { fields: [fallback] };
   }
   throw new Error(
     `primary identifier unknown (DescribeType returned no usable schema and no fallback is registered). Add ${resourceType} to PRIMARY_IDENTIFIER_FALLBACK in export.ts, or open an issue.`
@@ -79417,9 +79755,8 @@ function printPlan(plan, cfnStackName) {
   logger.info("");
   logger.info(`Import plan for CloudFormation stack '${cfnStackName}':`);
   for (const entry of plan) {
-    logger.info(
-      `  ${entry.logicalId} (${entry.resourceType}) \u2190 ${entry.identifierKey}=${entry.physicalId}`
-    );
+    const idStr = Object.entries(entry.resourceIdentifier).map(([k, v]) => `${k}=${v}`).join(", ");
+    logger.info(`  ${entry.logicalId} (${entry.resourceType}) \u2190 ${idStr}`);
   }
   logger.info("");
 }
@@ -79430,7 +79767,7 @@ async function executeImportChangeSet(cfnClient, stackName, template, plan) {
   const resourcesToImport = plan.map((entry) => ({
     ResourceType: entry.resourceType,
     LogicalResourceId: entry.logicalId,
-    ResourceIdentifier: { [entry.identifierKey]: entry.physicalId }
+    ResourceIdentifier: entry.resourceIdentifier
   }));
   logger.info(
     `Creating IMPORT changeset '${changeSetName}' for stack '${stackName}' (${plan.length} resource(s), ${templateBody.length} bytes)...`
@@ -79601,7 +79938,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command18();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.84.0");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.86.0");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createListCommand());