@intentius/chant-lexicon-aws 0.0.8 → 0.0.9

package/src/serializer.test.ts

@@ -11,6 +11,7 @@ import { createResource } from "@intentius/chant/runtime";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import type { BuildResult } from "@intentius/chant/build";
 import { Parameter } from "./parameter";
+import { defaultTags } from "./default-tags";
 
 // Mock S3 Bucket for testing
 class MockBucket implements Declarable {
@@ -18,9 +19,9 @@ class MockBucket implements Declarable {
   readonly lexicon = "aws";
   readonly entityType = "AWS::S3::Bucket";
   readonly arn: AttrRef;
-  readonly props: { BucketName?: string; VersioningConfiguration?: { Status: string } };
+  readonly props: Record<string, unknown>;
 
-  constructor(props: { BucketName?: string; VersioningConfiguration?: { Status: string } } = {}) {
+  constructor(props: { BucketName?: string; VersioningConfiguration?: { Status: string }; Tags?: unknown[] } = {}) {
     this.props = props;
     this.arn = new AttrRef(this, "Arn");
   }
@@ -489,3 +490,330 @@ describe("nested stack serialization", () => {
     });
   });
 });
+
+// ── Resource-Level CF Attributes ──────────────────────────
+
+// Mock resource that supports the second constructor `attributes` argument
+class MockResourceWithAttrs implements Declarable {
+  readonly [DECLARABLE_MARKER] = true as const;
+  readonly lexicon = "aws";
+  readonly entityType: string;
+  readonly props: Record<string, unknown>;
+  readonly attributes: Record<string, unknown>;
+
+  constructor(
+    type: string,
+    props: Record<string, unknown>,
+    attributes: Record<string, unknown> = {},
+  ) {
+    this.entityType = type;
+    this.props = props;
+    Object.defineProperty(this, "attributes", { value: attributes, enumerable: false, configurable: true });
+  }
+}
+
+describe("resource-level CF attributes", () => {
+  function serialize(...entries: [string, Declarable][]) {
+    const entities = new Map<string, Declarable>(entries);
+    const output = awsSerializer.serialize(entities);
+    return JSON.parse(output as string);
+  }
+
+  test("DependsOn with string logical name", () => {
+    const res = new MockResourceWithAttrs(
+      "AWS::EC2::Instance", { InstanceType: "t3.micro" }, { DependsOn: "Database" },
+    );
+    const template = serialize(["Server", res]);
+    expect(template.Resources.Server.DependsOn).toBe("Database");
+  });
+
+  test("DependsOn with Declarable reference resolves to logical name", () => {
+    const bucket = new MockBucket({ BucketName: "data" });
+    const fn = new MockResourceWithAttrs(
+      "AWS::Lambda::Function", { Runtime: "nodejs20.x" }, { DependsOn: bucket },
+    );
+    const template = serialize(["DataBucket", bucket], ["Handler", fn]);
+    expect(template.Resources.Handler.DependsOn).toBe("DataBucket");
+  });
+
+  test("DependsOn with array of mixed strings and Declarables", () => {
+    const bucket = new MockBucket({ BucketName: "data" });
+    const fn = new MockResourceWithAttrs(
+      "AWS::Lambda::Function", { Runtime: "nodejs20.x" },
+      { DependsOn: [bucket, "ExternalResource"] },
+    );
+    const template = serialize(["DataBucket", bucket], ["Handler", fn]);
+    expect(template.Resources.Handler.DependsOn).toEqual(["DataBucket", "ExternalResource"]);
+  });
+
+  test("single DependsOn array item serializes as string, not array", () => {
+    const fn = new MockResourceWithAttrs(
+      "AWS::Lambda::Function", { Runtime: "nodejs20.x" }, { DependsOn: ["OnlyOne"] },
+    );
+    const template = serialize(["Handler", fn]);
+    expect(template.Resources.Handler.DependsOn).toBe("OnlyOne");
+  });
+
+  test("Condition attribute", () => {
+    const res = new MockResourceWithAttrs(
+      "AWS::S3::Bucket", { BucketName: "cond-bucket" }, { Condition: "CreateProdResources" },
+    );
+    const template = serialize(["MyBucket", res]);
+    expect(template.Resources.MyBucket.Condition).toBe("CreateProdResources");
+  });
+
+  test("DeletionPolicy attribute", () => {
+    const res = new MockResourceWithAttrs(
+      "AWS::RDS::DBInstance", { DBInstanceClass: "db.t3.micro" }, { DeletionPolicy: "Retain" },
+    );
+    const template = serialize(["Database", res]);
+    expect(template.Resources.Database.DeletionPolicy).toBe("Retain");
+  });
+
+  test("UpdateReplacePolicy attribute", () => {
+    const res = new MockResourceWithAttrs(
+      "AWS::RDS::DBInstance", { DBInstanceClass: "db.t3.micro" }, { UpdateReplacePolicy: "Snapshot" },
+    );
+    const template = serialize(["Database", res]);
+    expect(template.Resources.Database.UpdateReplacePolicy).toBe("Snapshot");
+  });
+
+  test("UpdatePolicy attribute", () => {
+    const policy = {
+      AutoScalingRollingUpdate: {
+        MaxBatchSize: 2,
+        MinInstancesInService: 1,
+        PauseTime: "PT5M",
+        WaitOnResourceSignals: true,
+      },
+    };
+    const res = new MockResourceWithAttrs(
+      "AWS::AutoScaling::AutoScalingGroup", { MinSize: "1", MaxSize: "4" },
+      { UpdatePolicy: policy },
+    );
+    const template = serialize(["ASG", res]);
+    expect(template.Resources.ASG.UpdatePolicy).toEqual(policy);
+  });
+
+  test("CreationPolicy attribute", () => {
+    const policy = { ResourceSignal: { Count: 3, Timeout: "PT15M" } };
+    const res = new MockResourceWithAttrs(
+      "AWS::AutoScaling::AutoScalingGroup", { MinSize: "3", MaxSize: "3" },
+      { CreationPolicy: policy },
+    );
+    const template = serialize(["ASG", res]);
+    expect(template.Resources.ASG.CreationPolicy).toEqual(policy);
+  });
+
+  test("Metadata attribute with plain object", () => {
+    const res = new MockResourceWithAttrs(
+      "AWS::EC2::Instance", { InstanceType: "t3.micro" },
+      { Metadata: { "AWS::CloudFormation::Init": { config: { packages: { yum: { httpd: [] } } } } } },
+    );
+    const template = serialize(["Server", res]);
+    expect(template.Resources.Server.Metadata).toEqual({
+      "AWS::CloudFormation::Init": { config: { packages: { yum: { httpd: [] } } } },
+    });
+  });
+
+  test("Metadata with intrinsic values resolves them", () => {
+    const res = new MockResourceWithAttrs(
+      "AWS::EC2::Instance", { InstanceType: "t3.micro" },
+      { Metadata: { StackInfo: Sub`${AWS.StackName}-metadata` } },
+    );
+    const template = serialize(["Server", res]);
+    expect(template.Resources.Server.Metadata.StackInfo).toEqual({
+      "Fn::Sub": "${AWS::StackName}-metadata",
+    });
+  });
+
+  test("all 7 attributes on a single resource", () => {
+    const dependency = new MockBucket({ BucketName: "dep" });
+    const res = new MockResourceWithAttrs(
+      "AWS::RDS::DBInstance", { DBInstanceClass: "db.t3.micro", Engine: "postgres" },
+      {
+        DependsOn: dependency,
+        Condition: "CreateDatabase",
+        DeletionPolicy: "Snapshot",
+        UpdateReplacePolicy: "Retain",
+        UpdatePolicy: { AutoScalingReplacingUpdate: { WillReplace: true } },
+        CreationPolicy: { ResourceSignal: { Count: 1, Timeout: "PT10M" } },
+        Metadata: { Version: "1.0" },
+      },
+    );
+    const template = serialize(["DepBucket", dependency], ["Database", res]);
+
+    const db = template.Resources.Database;
+    expect(db.DependsOn).toBe("DepBucket");
+    expect(db.Condition).toBe("CreateDatabase");
+    expect(db.DeletionPolicy).toBe("Snapshot");
+    expect(db.UpdateReplacePolicy).toBe("Retain");
+    expect(db.UpdatePolicy).toEqual({ AutoScalingReplacingUpdate: { WillReplace: true } });
+    expect(db.CreationPolicy).toEqual({ ResourceSignal: { Count: 1, Timeout: "PT10M" } });
+    expect(db.Metadata).toEqual({ Version: "1.0" });
+  });
+
+  test("undefined attributes are omitted from CF template", () => {
+    const res = new MockResourceWithAttrs(
+      "AWS::S3::Bucket", { BucketName: "bucket" },
+      { DependsOn: undefined, Condition: undefined },
+    );
+    const template = serialize(["MyBucket", res]);
+    expect(template.Resources.MyBucket.DependsOn).toBeUndefined();
+    expect(template.Resources.MyBucket.Condition).toBeUndefined();
+  });
+
+  test("empty attributes object produces no resource-level attributes", () => {
+    const res = new MockResourceWithAttrs("AWS::S3::Bucket", { BucketName: "bucket" }, {});
+    const template = serialize(["MyBucket", res]);
+    const r = template.Resources.MyBucket;
+    expect(r.DependsOn).toBeUndefined();
+    expect(r.Condition).toBeUndefined();
+    expect(r.DeletionPolicy).toBeUndefined();
+    expect(r.Metadata).toBeUndefined();
+  });
+
+  test("resource without attributes property works unchanged", () => {
+    // MockBucket has no `attributes` property — should still serialize fine
+    const bucket = new MockBucket({ BucketName: "legacy" });
+    const template = serialize(["MyBucket", bucket]);
+    expect(template.Resources.MyBucket.Type).toBe("AWS::S3::Bucket");
+    expect(template.Resources.MyBucket.Properties.BucketName).toBe("legacy");
+    expect(template.Resources.MyBucket.DependsOn).toBeUndefined();
+  });
+});
+
+// ── Default Tags Serialization ──────────────────────────
+
+// Mock Lambda Permission (non-taggable) for testing
+class MockPermission implements Declarable {
+  readonly [DECLARABLE_MARKER] = true as const;
+  readonly lexicon = "aws";
+  readonly entityType = "AWS::Lambda::Permission";
+  readonly props: { Action: string; FunctionName: string; Principal: string };
+
+  constructor(props: { Action: string; FunctionName: string; Principal: string }) {
+    this.props = props;
+  }
+}
+
+// Mock Lambda Function (taggable) for testing
+class MockFunction implements Declarable {
+  readonly [DECLARABLE_MARKER] = true as const;
+  readonly lexicon = "aws";
+  readonly entityType = "AWS::Lambda::Function";
+  readonly props: Record<string, unknown>;
+
+  constructor(props: Record<string, unknown> = {}) {
+    this.props = props;
+  }
+}
+
+describe("default tags serialization", () => {
+  test("DefaultTags entity is not emitted as a CF Resource", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("MyBucket", new MockBucket({ BucketName: "bucket" }));
+    entities.set("tags", defaultTags([{ Key: "Env", Value: "prod" }]) as unknown as Declarable);
+
+    const output = awsSerializer.serialize(entities);
+    const template = JSON.parse(output as string);
+
+    expect(template.Resources.tags).toBeUndefined();
+    expect(template.Resources.MyBucket).toBeDefined();
+  });
+
+  test("taggable resource gets default tags injected", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("MyBucket", new MockBucket({ BucketName: "bucket" }));
+    entities.set("tags", defaultTags([{ Key: "Env", Value: "prod" }]) as unknown as Declarable);
+
+    const output = awsSerializer.serialize(entities);
+    const template = JSON.parse(output as string);
+
+    expect(template.Resources.MyBucket.Properties.Tags).toEqual([
+      { Key: "Env", Value: "prod" },
+    ]);
+  });
+
+  test("non-taggable resource does NOT get tags", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("Perm", new MockPermission({
+      Action: "lambda:InvokeFunction",
+      FunctionName: "fn",
+      Principal: "apigateway.amazonaws.com",
+    }));
+    entities.set("tags", defaultTags([{ Key: "Env", Value: "prod" }]) as unknown as Declarable);
+
+    const output = awsSerializer.serialize(entities);
+    const template = JSON.parse(output as string);
+
+    expect(template.Resources.Perm.Properties.Tags).toBeUndefined();
+  });
+
+  test("explicit tags win over defaults on same key", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("MyBucket", new MockBucket({
+      BucketName: "bucket",
+      Tags: [{ Key: "Env", Value: "staging" }],
+    }));
+    entities.set("tags", defaultTags([
+      { Key: "Env", Value: "prod" },
+      { Key: "Team", Value: "platform" },
+    ]) as unknown as Declarable);
+
+    const output = awsSerializer.serialize(entities);
+    const template = JSON.parse(output as string);
+
+    const tags = template.Resources.MyBucket.Properties.Tags;
+    expect(tags).toHaveLength(2);
+    // Explicit "Env" wins, default "Team" is added
+    const envTag = tags.find((t: { Key: string }) => t.Key === "Env");
+    const teamTag = tags.find((t: { Key: string }) => t.Key === "Team");
+    expect(envTag.Value).toBe("staging");
+    expect(teamTag.Value).toBe("platform");
+  });
+
+  test("intrinsic tag values resolve correctly", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("MyBucket", new MockBucket({ BucketName: "bucket" }));
+    entities.set("tags", defaultTags([
+      { Key: "Stack", Value: Sub`${AWS.StackName}` },
+    ]) as unknown as Declarable);
+
+    const output = awsSerializer.serialize(entities);
+    const template = JSON.parse(output as string);
+
+    const tags = template.Resources.MyBucket.Properties.Tags;
+    expect(tags).toHaveLength(1);
+    expect(tags[0].Key).toBe("Stack");
+    expect(tags[0].Value).toEqual({ "Fn::Sub": "${AWS::StackName}" });
+  });
+
+  test("parameter tag values resolve to Ref", () => {
+    const env = new Parameter("String", { defaultValue: "dev" });
+    const entities = new Map<string, Declarable>();
+    entities.set("Env", env as unknown as Declarable);
+    entities.set("MyBucket", new MockBucket({ BucketName: "bucket" }));
+    entities.set("tags", defaultTags([
+      { Key: "Environment", Value: env },
+    ]) as unknown as Declarable);
+
+    const output = awsSerializer.serialize(entities);
+    const template = JSON.parse(output as string);
+
+    const tags = template.Resources.MyBucket.Properties.Tags;
+    expect(tags).toHaveLength(1);
+    expect(tags[0].Key).toBe("Environment");
+    expect(tags[0].Value).toEqual({ Ref: "Env" });
+  });
+
+  test("no defaultTags = no injection (existing behavior)", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("MyBucket", new MockBucket({ BucketName: "bucket" }));
+
+    const output = awsSerializer.serialize(entities);
+    const template = JSON.parse(output as string);
+
+    expect(template.Resources.MyBucket.Properties.Tags).toBeUndefined();
+  });
+});

package/src/serializer.ts

@@ -5,6 +5,9 @@ import type { LexiconOutput } from "@intentius/chant/lexicon-output";
 import { walkValue, type SerializerVisitor } from "@intentius/chant/serializer-walker";
 import { isChildProject, type ChildProjectInstance } from "@intentius/chant/child-project";
 import { isStackOutput, type StackOutput } from "@intentius/chant/stack-output";
+import { resolveDependsOn } from "@intentius/chant/resource-attributes";
+import { isDefaultTags, type TagEntry } from "./default-tags";
+import { loadTaggableResources } from "./taggable";
 
 /**
  * Check if a declarable is a CoreParameter
@@ -49,6 +52,10 @@ interface CFResource {
   Properties?: Record<string, unknown>;
   DependsOn?: string | string[];
   Condition?: string;
+  DeletionPolicy?: string;
+  UpdateReplacePolicy?: string;
+  UpdatePolicy?: unknown;
+  CreationPolicy?: unknown;
   Metadata?: Record<string, unknown>;
 }
 
@@ -141,6 +148,14 @@ function serializeToTemplate(
     entityNames.set(entity, name);
   }
 
+  // Collect default tags
+  const defaultTagEntries: TagEntry[] = [];
+  for (const [, entity] of entities) {
+    if (isDefaultTags(entity)) {
+      defaultTagEntries.push(...entity.tags);
+    }
+  }
+
   // Process entities
   for (const [name, entity] of entities) {
     // Skip StackOutput entities — they go in the Outputs section
@@ -148,6 +163,11 @@ function serializeToTemplate(
       continue;
     }
 
+    // Skip DefaultTags entities — handled via tag injection below
+    if (isDefaultTags(entity)) {
+      continue;
+    }
+
     if (isCoreParameter(entity)) {
       if (!template.Parameters) {
         template.Parameters = {};
@@ -202,15 +222,56 @@ function serializeToTemplate(
         Type: entity.entityType,
       };
 
+      // Read resource-level attributes from the second constructor arg
+      const attrs = ("attributes" in entity && typeof entity.attributes === "object" && entity.attributes !== null)
+        ? entity.attributes as Record<string, unknown>
+        : undefined;
+
+      if (attrs) {
+        // DependsOn — resolve Declarable refs to logical names
+        if (attrs.DependsOn !== undefined) {
+          const resolved = resolveDependsOn(attrs.DependsOn, entityNames, name);
+          if (resolved.length > 0) {
+            resource.DependsOn = resolved.length === 1 ? resolved[0] : resolved;
+          }
+        }
+        // Pass-through attributes
+        if (attrs.Condition) resource.Condition = attrs.Condition as string;
+        if (attrs.DeletionPolicy) resource.DeletionPolicy = attrs.DeletionPolicy as string;
+        if (attrs.UpdateReplacePolicy) resource.UpdateReplacePolicy = attrs.UpdateReplacePolicy as string;
+        if (attrs.UpdatePolicy) resource.UpdatePolicy = attrs.UpdatePolicy;
+        if (attrs.CreationPolicy) resource.CreationPolicy = attrs.CreationPolicy;
+        if (attrs.Metadata) resource.Metadata = toCFValue(attrs.Metadata, entityNames) as Record<string, unknown>;
+      }
+
       const properties = toProperties(entity, entityNames);
       if (properties) {
-        resource.Properties = properties;
+        if (Object.keys(properties).length > 0) {
+          resource.Properties = properties;
+        }
       }
 
       template.Resources[name] = resource;
     }
   }
 
+  // Inject default tags into taggable resources
+  if (defaultTagEntries.length > 0) {
+    const taggable = loadTaggableResources();
+    for (const [, resource] of Object.entries(template.Resources)) {
+      if (!taggable.has(resource.Type)) continue;
+      const resolved = defaultTagEntries.map(t => ({
+        Key: t.Key,
+        Value: toCFValue(t.Value, entityNames),
+      }));
+      const explicit = (resource.Properties?.Tags ?? []) as Array<{ Key: string }>;
+      const explicitKeys = new Set(explicit.map(t => t.Key));
+      const merged = [...resolved.filter(t => !explicitKeys.has(t.Key)), ...explicit];
+      if (!resource.Properties) resource.Properties = {};
+      resource.Properties.Tags = merged;
+    }
+  }
+
   // Emit StackOutput entities as CF Outputs
   for (const [name, entity] of entities) {
     if (isStackOutput(entity)) {

package/src/spec/fetch.ts

@@ -15,6 +15,16 @@ export interface CFNSchema {
   createOnlyProperties?: string[];
   writeOnlyProperties?: string[];
   primaryIdentifier?: string[];
+  deprecatedProperties?: string[];
+  conditionalCreateOnlyProperties?: string[];
+  replacementStrategy?: string;
+  tagging?: {
+    taggable?: boolean;
+    tagOnCreate?: boolean;
+    tagUpdatable?: boolean;
+    cloudFormationSystemTags?: boolean;
+    tagProperty?: string;
+  };
   additionalProperties?: boolean;
 }
 

package/src/spec/parse.test.ts

@@ -20,6 +20,7 @@ const sampleBucketSchema = JSON.stringify({
     },
     AccessControl: {
       type: "string",
+      description: "This is a legacy property, and it is not recommended for most use cases.",
       enum: ["Private", "PublicRead", "PublicReadWrite"],
     },
   },
@@ -42,6 +43,7 @@ const sampleBucketSchema = JSON.stringify({
       additionalProperties: false,
     },
   },
+  deprecatedProperties: ["/properties/AccessControl"],
   readOnlyProperties: [
     "/properties/Arn",
     "/properties/DomainName",
@@ -134,6 +136,145 @@ describe("parseCFNSchema", () => {
     expect(result.resource.properties).toEqual([]);
     expect(result.resource.attributes).toEqual([]);
   });
+
+  // --- Deprecated properties ---
+
+  test("parses explicit deprecatedProperties", () => {
+    const result = parseCFNSchema(sampleBucketSchema);
+    expect(result.resource.deprecatedProperties).toContain("AccessControl");
+  });
+
+  test("mines deprecation from property description", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::DescMined",
+      properties: {
+        OldProp: { type: "string", description: "This property is deprecated. Use NewProp instead." },
+        NewProp: { type: "string", description: "The replacement property" },
+      },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.deprecatedProperties).toContain("OldProp");
+    expect(result.resource.deprecatedProperties).not.toContain("NewProp");
+  });
+
+  test("mines 'legacy' keyword from description", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::Legacy",
+      properties: {
+        LegacyProp: { type: "string", description: "This is a legacy property, not recommended." },
+      },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.deprecatedProperties).toContain("LegacyProp");
+  });
+
+  test("deduplicates when both explicit and description flag same property", () => {
+    // sampleBucketSchema has AccessControl in both deprecatedProperties array and description
+    const result = parseCFNSchema(sampleBucketSchema);
+    const count = result.resource.deprecatedProperties.filter((p) => p === "AccessControl").length;
+    expect(count).toBe(1);
+  });
+
+  test("empty deprecatedProperties when none found", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::Clean",
+      properties: {
+        Name: { type: "string", description: "A normal property" },
+      },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.deprecatedProperties).toEqual([]);
+  });
+
+  // --- Tagging metadata ---
+
+  test("parses tagging metadata when taggable", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::Taggable",
+      properties: { Tags: { type: "array" } },
+      tagging: { taggable: true, tagOnCreate: true, tagUpdatable: true },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.tagging).toEqual({
+      taggable: true,
+      tagOnCreate: true,
+      tagUpdatable: true,
+    });
+  });
+
+  test("omits tagging when not taggable", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::NotTaggable",
+      properties: { Name: { type: "string" } },
+      tagging: { taggable: false },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.tagging).toBeUndefined();
+  });
+
+  test("omits tagging when absent", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::NoTagging",
+      properties: { Name: { type: "string" } },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.tagging).toBeUndefined();
+  });
+
+  // --- Replacement strategy ---
+
+  test("parses replacementStrategy", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::DeleteFirst",
+      properties: { Name: { type: "string" } },
+      replacementStrategy: "delete_then_create",
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.replacementStrategy).toBe("delete_then_create");
+  });
+
+  test("omits replacementStrategy when absent", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::NoStrategy",
+      properties: { Name: { type: "string" } },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.replacementStrategy).toBeUndefined();
+  });
+
+  // --- Conditional create-only ---
+
+  test("parses conditionalCreateOnlyProperties", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::ConditionalCreate",
+      properties: {
+        Name: { type: "string" },
+        Engine: { type: "string" },
+      },
+      conditionalCreateOnlyProperties: ["/properties/Engine"],
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.conditionalCreateOnly).toContain("Engine");
+  });
+
+  test("empty conditionalCreateOnly when absent", () => {
+    const schema = JSON.stringify({
+      typeName: "AWS::Test::NoConditional",
+      properties: { Name: { type: "string" } },
+      additionalProperties: false,
+    });
+    const result = parseCFNSchema(schema);
+    expect(result.resource.conditionalCreateOnly).toEqual([]);
+  });
 });
 
 describe("cfnShortName", () => {

package/src/spec/parse.ts

@@ -52,6 +52,10 @@ export interface ParsedResource {
   createOnly: string[];
   writeOnly: string[];
   primaryIdentifier: string[];
+  deprecatedProperties: string[];
+  conditionalCreateOnly: string[];
+  replacementStrategy?: "delete_then_create" | "create_then_delete";
+  tagging?: { taggable: boolean; tagOnCreate: boolean; tagUpdatable: boolean };
 }
 
 export interface SchemaParseResult {
@@ -137,6 +141,38 @@ export function parseCFNSchema(data: string | Buffer): SchemaParseResult {
     }
   }
 
+  // --- Deprecated properties: explicit + description-mined ---
+  const deprecatedSet = new Set<string>(
+    stripPointerPaths(schema.deprecatedProperties ?? []),
+  );
+
+  const DEPRECATION_RE = /\bdeprecated\b|\blegacy\b|no longer (available|recommended|used|supported)|is not recommended|has been discontinued/i;
+
+  // Mine top-level property descriptions
+  if (schema.properties) {
+    for (const [name, prop] of Object.entries(schema.properties)) {
+      if (prop.description && DEPRECATION_RE.test(prop.description)) {
+        deprecatedSet.add(name);
+      }
+    }
+  }
+
+  // --- Tagging ---
+  let tagging: ParsedResource["tagging"];
+  if (schema.tagging && schema.tagging.taggable) {
+    tagging = {
+      taggable: true,
+      tagOnCreate: schema.tagging.tagOnCreate ?? false,
+      tagUpdatable: schema.tagging.tagUpdatable ?? false,
+    };
+  }
+
+  // --- Replacement strategy ---
+  let replacementStrategy: ParsedResource["replacementStrategy"];
+  if (schema.replacementStrategy === "delete_then_create" || schema.replacementStrategy === "create_then_delete") {
+    replacementStrategy = schema.replacementStrategy;
+  }
+
   return {
     resource: {
       typeName: schema.typeName,
@@ -145,6 +181,10 @@ export function parseCFNSchema(data: string | Buffer): SchemaParseResult {
       createOnly: stripPointerPaths(schema.createOnlyProperties ?? []),
       writeOnly: stripPointerPaths(schema.writeOnlyProperties ?? []),
       primaryIdentifier: stripPointerPaths(schema.primaryIdentifier ?? []),
+      deprecatedProperties: [...deprecatedSet],
+      conditionalCreateOnly: stripPointerPaths(schema.conditionalCreateOnlyProperties ?? []),
+      ...(replacementStrategy && { replacementStrategy }),
+      ...(tagging && { tagging }),
     },
     propertyTypes,
     enums,