@intentius/chant-lexicon-aws 0.18.14 → 0.18.16

package/src/generated/index.ts

@@ -697,6 +697,7 @@ export const IntegrationResourceProperty = createResource("AWS::Glue::Integratio
 export const IntegrationResponse = createResource("AWS::ApiGatewayV2::IntegrationResponse", "aws", {"IntegrationResponseId":"IntegrationResponseId"});
 export const IntelligentPromptRouter = createResource("AWS::Bedrock::IntelligentPromptRouter", "aws", {"CreatedAt":"CreatedAt","PromptRouterArn":"PromptRouterArn","Status":"Status","Type":"Type","UpdatedAt":"UpdatedAt"});
 export const InterconnectConnection = createResource("AWS::Interconnect::Connection", "aws", {"ConnectionId":"ConnectionId","Arn":"Arn","Provider":"Provider","Type":"Type","State":"State","SharedId":"SharedId","OwnerAccount":"OwnerAccount","BillingTier":"BillingTier"});
+export const IntermediateTable = createResource("AWS::CleanRooms::IntermediateTable", "aws", {"IntermediateTableIdentifier":"IntermediateTableIdentifier","Arn":"Arn","MembershipArn":"MembershipArn","CollaborationIdentifier":"CollaborationIdentifier","CollaborationArn":"CollaborationArn","Status":"Status"});
 export const InternetGateway = createResource("AWS::EC2::InternetGateway", "aws", {"InternetGatewayId":"InternetGatewayId"});
 export const InternetMonitorMonitor = createResource("AWS::InternetMonitor::Monitor", "aws", {"CreatedAt":"CreatedAt","ModifiedAt":"ModifiedAt","MonitorArn":"MonitorArn","ProcessingStatus":"ProcessingStatus","ProcessingStatusInfo":"ProcessingStatusInfo"});
 export const InvestigationGroup = createResource("AWS::AIOps::InvestigationGroup", "aws", {"CreatedBy":"CreatedBy","CreatedAt":"CreatedAt","LastModifiedBy":"LastModifiedBy","LastModifiedAt":"LastModifiedAt","Arn":"Arn"});
@@ -5873,6 +5874,13 @@ export const InterconnectConnection_Tag = createProperty("AWS::Interconnect::Con
 export const Interface = createProperty("AWS::MediaConnect::FlowOutput.Interface", "aws");
 export const InterfaceMapping = createProperty("AWS::MediaLive::Cluster.InterfaceMapping", "aws");
 export const IntermediateStorage = createProperty("AWS::Bedrock::DataSource.IntermediateStorage", "aws");
+export const IntermediateTable_IntermediateTableAnalysisRule = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule", "aws");
+export const IntermediateTable_IntermediateTableAnalysisRulePolicy = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy", "aws");
+export const IntermediateTable_PopulationAnalysisConfiguration = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration", "aws");
+export const IntermediateTable_PopulationAnalysisSqlParameters = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters", "aws");
+export const IntermediateTable_Tag = createProperty("AWS::CleanRooms::IntermediateTable.Tag", "aws");
+export const IntermediateTableAnalysisRule = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule", "aws");
+export const IntermediateTableAnalysisRulePolicy = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy", "aws");
 export const InternetGateway_Tag = createProperty("AWS::EC2::InternetGateway.Tag", "aws");
 export const InternetMeasurementsLogDelivery = createProperty("AWS::InternetMonitor::Monitor.InternetMeasurementsLogDelivery", "aws");
 export const InternetMonitorMonitor_HealthEventsConfig = createProperty("AWS::InternetMonitor::Monitor.HealthEventsConfig", "aws");
@@ -6427,6 +6435,7 @@ export const Listener_JwtValidationConfig = createProperty("AWS::ElasticLoadBala
 export const Listener_ListenerAttribute = createProperty("AWS::ElasticLoadBalancingV2::Listener.ListenerAttribute", "aws");
 export const Listener_MutualAuthentication = createProperty("AWS::ElasticLoadBalancingV2::Listener.MutualAuthentication", "aws");
 export const Listener_RedirectConfig = createProperty("AWS::ElasticLoadBalancingV2::Listener.RedirectConfig", "aws");
+export const Listener_Tag = createProperty("AWS::ElasticLoadBalancingV2::Listener.Tag", "aws");
 export const Listener_TargetGroupStickinessConfig = createProperty("AWS::ElasticLoadBalancingV2::Listener.TargetGroupStickinessConfig", "aws");
 export const Listener_TargetGroupTuple = createProperty("AWS::ElasticLoadBalancingV2::Listener.TargetGroupTuple", "aws");
 export const ListenerAttribute = createProperty("AWS::ElasticLoadBalancingV2::Listener.ListenerAttribute", "aws");
@@ -7919,6 +7928,8 @@ export const PolicyStore_ValidationSettings = createProperty("AWS::VerifiedPermi
 export const PolicyTag = createProperty("AWS::FMS::Policy.PolicyTag", "aws");
 export const Pool_OptionalKeyword = createProperty("AWS::SMSVOICE::Pool.OptionalKeyword", "aws");
 export const Pool_Tag = createProperty("AWS::SMSVOICE::Pool.Tag", "aws");
+export const PopulationAnalysisConfiguration = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration", "aws");
+export const PopulationAnalysisSqlParameters = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters", "aws");
 export const Port = createProperty("AWS::Lightsail::Instance.Port", "aws");
 export const Portal = createProperty("AWS::IoTSiteWise::AccessPolicy.Portal", "aws");
 export const PortalOptionsConfiguration = createProperty("AWS::SSO::Application.PortalOptionsConfiguration", "aws");

package/src/generated/lexicon-aws.json

@@ -8347,8 +8347,7 @@
       "KmsKeyArn": "KmsKeyArn"
     },
     "createOnly": [
-      "KmsKeyId",
-      "ForceDelete"
+      "KmsKeyId"
     ],
     "writeOnly": [
       "KmsKeyId",
@@ -49451,6 +49450,92 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "IntermediateTable": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable",
+    "kind": "resource",
+    "lexicon": "aws",
+    "attrs": {
+      "IntermediateTableIdentifier": "IntermediateTableIdentifier",
+      "Arn": "Arn",
+      "MembershipArn": "MembershipArn",
+      "CollaborationIdentifier": "CollaborationIdentifier",
+      "CollaborationArn": "CollaborationArn",
+      "Status": "Status"
+    },
+    "propertyConstraints": {
+      "Arn": {
+        "maxLength": 256
+      },
+      "MembershipArn": {
+        "maxLength": 100
+      },
+      "CollaborationArn": {
+        "maxLength": 100
+      },
+      "Name": {
+        "pattern": "^(?!\\s*$)[\\u0020-\\uD7FF\\uE000-\\uFFFD\\uD800\\uDBFF-\\uDC00\\uDFFF\\t]*$",
+        "minLength": 1,
+        "maxLength": 100
+      },
+      "Description": {
+        "pattern": "^[\\u0020-\\uD7FF\\uE000-\\uFFFD\\uD800\\uDBFF-\\uDC00\\uDFFF\\t\\r\\n]*$",
+        "maxLength": 255
+      },
+      "KmsKeyArn": {
+        "minLength": 4,
+        "maxLength": 2048
+      }
+    },
+    "createOnly": [
+      "MembershipIdentifier",
+      "Name",
+      "PopulationAnalysisConfiguration"
+    ],
+    "primaryIdentifier": [
+      "IntermediateTableIdentifier",
+      "MembershipIdentifier"
+    ],
+    "tagging": {
+      "taggable": true,
+      "tagOnCreate": true,
+      "tagUpdatable": true
+    }
+  },
+  "IntermediateTableAnalysisRule": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTableAnalysisRulePolicy": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_IntermediateTableAnalysisRule": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_IntermediateTableAnalysisRulePolicy": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_PopulationAnalysisConfiguration": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_PopulationAnalysisSqlParameters": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_Tag": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.Tag",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "InternetGateway": {
     "resourceType": "AWS::EC2::InternetGateway",
     "kind": "resource",
@@ -54791,7 +54876,12 @@
     ],
     "primaryIdentifier": [
       "ListenerArn"
-    ]
+    ],
+    "tagging": {
+      "taggable": true,
+      "tagOnCreate": true,
+      "tagUpdatable": true
+    }
   },
   "ListenerAttribute": {
     "resourceType": "AWS::ElasticLoadBalancingV2::Listener.ListenerAttribute",
@@ -55022,6 +55112,11 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "Listener_Tag": {
+    "resourceType": "AWS::ElasticLoadBalancingV2::Listener.Tag",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "Listener_TargetGroupStickinessConfig": {
     "resourceType": "AWS::ElasticLoadBalancingV2::Listener.TargetGroupStickinessConfig",
     "kind": "property",
@@ -71684,6 +71779,16 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "PopulationAnalysisConfiguration": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "PopulationAnalysisSqlParameters": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "Port": {
     "resourceType": "AWS::Lightsail::Instance.Port",
     "kind": "property",

package/src/import/live-export-io.test.ts

@@ -41,14 +41,24 @@ describe("aws exportResources I/O glue (#160)", () => {
     expect(ir.resources.map((r) => r.logicalId)).toEqual(["MyBucket"]);
   });
 
-  test("a non-zero exit throws with the stderr surfaced", async () => {
+  test("a not-yet-deployed stack returns empty live state (pre-first-apply), not an error", async () => {
     spawnMock.mockResolvedValue({
       stdout: "",
-      stderr: "Stack with id ghost does not exist",
+      stderr: "An error occurred (ValidationError) …: Stack with id ghost does not exist",
       exitCode: 254,
     });
-    await expect(awsPlugin.exportResources!({ environment: "ghost" })).rejects.toThrow(
-      /Failed to get template for stack "ghost".*does not exist/,
+    const ir = await awsPlugin.exportResources!({ environment: "ghost" });
+    expect(ir.resources).toEqual([]);
+  });
+
+  test("a genuine failure (not 'does not exist') still throws with the stderr surfaced", async () => {
+    spawnMock.mockResolvedValue({
+      stdout: "",
+      stderr: "An error occurred (AccessDenied) …: not authorized",
+      exitCode: 254,
+    });
+    await expect(awsPlugin.exportResources!({ environment: "prod" })).rejects.toThrow(
+      /Failed to get template for stack "prod".*AccessDenied/,
     );
   });
 

package/src/plugin.test.ts

@@ -1,7 +1,19 @@
 import { describe, test, expect } from "vitest";
-import { awsPlugin } from "./plugin";
+import { awsPlugin, stackDoesNotExist } from "./plugin";
 import { isLexiconPlugin } from "@intentius/chant/lexicon";
 
+describe("stackDoesNotExist (pre-first-apply live state)", () => {
+  test("true for the CloudFormation 'does not exist' error", () => {
+    expect(stackDoesNotExist(
+      "An error occurred (ValidationError) when calling the DescribeStackResources operation: Stack with id prod does not exist",
+    )).toBe(true);
+  });
+  test("false for other failures (auth, network) — those still throw", () => {
+    expect(stackDoesNotExist("An error occurred (InvalidClientTokenId) ...")).toBe(false);
+    expect(stackDoesNotExist("Could not connect to the endpoint URL")).toBe(false);
+  });
+});
+
 describe("awsPlugin", () => {
   // -----------------------------------------------------------------------
   // Basic interface

package/src/plugin.ts

@@ -15,6 +15,7 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { awsSerializer } from "./serializer";
 import { FLOCI_EMULATOR } from "./op/activities/floci";
+import { applyAwsEndpointArgv } from "./components/cloud-executor";
 import { awsReferenceCatalog } from "./reference-catalog";
 import { resolveTemplateAttrs } from "./live-attrs";
 import { CFParser } from "./import/parser";
@@ -23,6 +24,13 @@ import { parseStackTemplate } from "./import/live-export";
 import { awsCompletions } from "./lsp/completions";
 import { awsHover } from "./lsp/hover";
 
+/** True when a CloudFormation CLI error means the stack simply isn't there yet
+ * (`ValidationError … does not exist`) — the pre-first-apply state, which live
+ * queries should treat as "nothing deployed", not a failure. Exported for testing. */
+export function stackDoesNotExist(stderr: string): boolean {
+  return /does not exist/i.test(stderr);
+}
+
 /**
  * AWS CloudFormation lexicon plugin.
  *
@@ -486,14 +494,23 @@ aws cloudformation wait stack-update-complete --stack-name my-app-prod`,
     // Try to parse the build output to detect stack name from Metadata or use convention
     const stackName = `${options.environment}`;
 
-    // Describe stack resources
-    const listResult = await rt.spawn([
+    // Describe stack resources. Inject --endpoint-url from AWS_ENDPOINT_URL so a
+    // local emulator (Floci) is observed instead of real AWS (#926) — behold
+    // serve --local relies on this for the overlay.
+    const listResult = await rt.spawn(applyAwsEndpointArgv([
       "aws", "cloudformation", "describe-stack-resources",
       "--stack-name", stackName,
       "--output", "json",
-    ]);
+    ], process.env.AWS_ENDPOINT_URL));
 
     if (listResult.exitCode !== 0) {
+      // A stack that doesn't exist yet is the pre-first-apply state: nothing is
+      // deployed for this env, so there are no live resources (every declared
+      // resource is "pending") — not an error. Returning empty lets `lifecycle
+      // diff --live` / the overlay show pending nodes instead of failing hard.
+      if (stackDoesNotExist(listResult.stderr)) {
+        return resources;
+      }
       throw new Error(`Failed to describe stack "${stackName}": ${listResult.stderr}`);
     }
 
@@ -514,11 +531,11 @@ aws cloudformation wait stack-update-complete --stack-name my-app-prod`,
     }
 
     // Get stack outputs
-    const describeResult = await rt.spawn([
+    const describeResult = await rt.spawn(applyAwsEndpointArgv([
       "aws", "cloudformation", "describe-stacks",
       "--stack-name", stackName,
       "--output", "json",
-    ]);
+    ], process.env.AWS_ENDPOINT_URL));
 
     let stackOutputs: Record<string, string> = {};
     if (describeResult.exitCode === 0) {
@@ -569,13 +586,19 @@ aws cloudformation wait stack-update-complete --stack-name my-app-prod`,
     // Same stack-name convention as describeResources.
     const stackName = `${options.environment}`;
 
-    const result = await rt.spawn([
+    const result = await rt.spawn(applyAwsEndpointArgv([
       "aws", "cloudformation", "get-template",
       "--stack-name", stackName,
       "--template-stage", "Original",
       "--output", "json",
-    ]);
+    ], process.env.AWS_ENDPOINT_URL));
     if (result.exitCode !== 0) {
+      // Not deployed yet → no template to export (nothing live), not an error.
+      // Keeps `chant graph --live` edge enrichment and `import --from` quiet
+      // before the first apply.
+      if (stackDoesNotExist(result.stderr)) {
+        return parseStackTemplate({ Resources: {} }, options.selector, options.owned);
+      }
       throw new Error(`Failed to get template for stack "${stackName}": ${result.stderr}`);
     }