@intentius/chant-lexicon-aws 0.0.6 → 0.0.9

package/src/composites/vpc-default.ts

@@ -0,0 +1,148 @@
+import { Composite } from "@intentius/chant";
+import {
+  Vpc,
+  Subnet,
+  InternetGateway,
+  VPCGatewayAttachment,
+  RouteTable,
+  EC2Route,
+  SubnetRouteTableAssociation,
+  EIP,
+  NatGateway,
+} from "../generated";
+import { Select, GetAZs } from "../intrinsics";
+
+export interface VpcDefaultProps {
+  cidr?: string;
+  publicSubnet1Cidr?: string;
+  publicSubnet2Cidr?: string;
+  privateSubnet1Cidr?: string;
+  privateSubnet2Cidr?: string;
+}
+
+export const VpcDefault = Composite<VpcDefaultProps>((props) => {
+  const cidr = props.cidr ?? "10.0.0.0/16";
+  const publicSubnet1Cidr = props.publicSubnet1Cidr ?? "10.0.0.0/20";
+  const publicSubnet2Cidr = props.publicSubnet2Cidr ?? "10.0.16.0/20";
+  const privateSubnet1Cidr = props.privateSubnet1Cidr ?? "10.0.128.0/20";
+  const privateSubnet2Cidr = props.privateSubnet2Cidr ?? "10.0.144.0/20";
+
+  const az1 = Select(0, GetAZs(""));
+  const az2 = Select(1, GetAZs(""));
+
+  const vpc = new Vpc({
+    CidrBlock: cidr,
+    EnableDnsSupport: true,
+    EnableDnsHostnames: true,
+  });
+
+  const igw = new InternetGateway({});
+
+  const igwAttachment = new VPCGatewayAttachment({
+    VpcId: vpc.VpcId,
+    InternetGatewayId: igw.InternetGatewayId,
+  });
+
+  // Public subnets
+  const publicSubnet1 = new Subnet({
+    VpcId: vpc.VpcId,
+    CidrBlock: publicSubnet1Cidr,
+    AvailabilityZone: az1,
+    MapPublicIpOnLaunch: true,
+  });
+
+  const publicSubnet2 = new Subnet({
+    VpcId: vpc.VpcId,
+    CidrBlock: publicSubnet2Cidr,
+    AvailabilityZone: az2,
+    MapPublicIpOnLaunch: true,
+  });
+
+  // Private subnets
+  const privateSubnet1 = new Subnet({
+    VpcId: vpc.VpcId,
+    CidrBlock: privateSubnet1Cidr,
+    AvailabilityZone: az1,
+  });
+
+  const privateSubnet2 = new Subnet({
+    VpcId: vpc.VpcId,
+    CidrBlock: privateSubnet2Cidr,
+    AvailabilityZone: az2,
+  });
+
+  // Public route table
+  const publicRouteTable = new RouteTable({
+    VpcId: vpc.VpcId,
+  });
+
+  const publicRoute = new EC2Route(
+    {
+      RouteTableId: publicRouteTable.RouteTableId,
+      DestinationCidrBlock: "0.0.0.0/0",
+      GatewayId: igw.InternetGatewayId,
+    },
+    { DependsOn: [igwAttachment] },
+  );
+
+  const publicRta1 = new SubnetRouteTableAssociation({
+    SubnetId: publicSubnet1.SubnetId,
+    RouteTableId: publicRouteTable.RouteTableId,
+  });
+
+  const publicRta2 = new SubnetRouteTableAssociation({
+    SubnetId: publicSubnet2.SubnetId,
+    RouteTableId: publicRouteTable.RouteTableId,
+  });
+
+  // NAT gateway
+  const natEip = new EIP({
+    Domain: "vpc",
+  });
+
+  const natGateway = new NatGateway({
+    AllocationId: natEip.AllocationId,
+    SubnetId: publicSubnet1.SubnetId,
+  });
+
+  // Private route table
+  const privateRouteTable = new RouteTable({
+    VpcId: vpc.VpcId,
+  });
+
+  const privateRoute = new EC2Route({
+    RouteTableId: privateRouteTable.RouteTableId,
+    DestinationCidrBlock: "0.0.0.0/0",
+    NatGatewayId: natGateway.NatGatewayId,
+  });
+
+  const privateRta1 = new SubnetRouteTableAssociation({
+    SubnetId: privateSubnet1.SubnetId,
+    RouteTableId: privateRouteTable.RouteTableId,
+  });
+
+  const privateRta2 = new SubnetRouteTableAssociation({
+    SubnetId: privateSubnet2.SubnetId,
+    RouteTableId: privateRouteTable.RouteTableId,
+  });
+
+  return {
+    vpc,
+    igw,
+    igwAttachment,
+    publicSubnet1,
+    publicSubnet2,
+    privateSubnet1,
+    privateSubnet2,
+    publicRouteTable,
+    publicRoute,
+    publicRta1,
+    publicRta2,
+    privateRouteTable,
+    privateRta1,
+    privateRta2,
+    natEip,
+    natGateway,
+    privateRoute,
+  };
+}, "VpcDefault");

package/src/default-tags.test.ts

@@ -0,0 +1,38 @@
+import { describe, test, expect } from "bun:test";
+import { DECLARABLE_MARKER } from "@intentius/chant/declarable";
+import { defaultTags, isDefaultTags, DEFAULT_TAGS_MARKER } from "./default-tags";
+
+describe("defaultTags", () => {
+  test("factory returns correct markers and tags", () => {
+    const tags = defaultTags([
+      { Key: "Env", Value: "prod" },
+      { Key: "Team", Value: "platform" },
+    ]);
+
+    expect(tags[DEFAULT_TAGS_MARKER]).toBe(true);
+    expect(tags[DECLARABLE_MARKER]).toBe(true);
+    expect(tags.lexicon).toBe("aws");
+    expect(tags.entityType).toBe("chant:aws:defaultTags");
+    expect(tags.tags).toHaveLength(2);
+    expect(tags.tags[0]).toEqual({ Key: "Env", Value: "prod" });
+    expect(tags.tags[1]).toEqual({ Key: "Team", Value: "platform" });
+  });
+
+  test("factory accepts empty tags array", () => {
+    const tags = defaultTags([]);
+    expect(tags.tags).toHaveLength(0);
+  });
+
+  test("isDefaultTags returns true for DefaultTags", () => {
+    const tags = defaultTags([{ Key: "k", Value: "v" }]);
+    expect(isDefaultTags(tags)).toBe(true);
+  });
+
+  test("isDefaultTags returns false for non-DefaultTags", () => {
+    expect(isDefaultTags(null)).toBe(false);
+    expect(isDefaultTags(undefined)).toBe(false);
+    expect(isDefaultTags({})).toBe(false);
+    expect(isDefaultTags("string")).toBe(false);
+    expect(isDefaultTags({ lexicon: "aws" })).toBe(false);
+  });
+});

package/src/default-tags.ts

@@ -0,0 +1,77 @@
+/**
+ * Default Tags — declares project-wide tags for all taggable resources.
+ *
+ * When a project exports a `defaultTags(...)` declaration, the serializer
+ * automatically injects those tags into every taggable resource at synthesis
+ * time. Explicit tags on individual resources take precedence.
+ */
+
+import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
+
+/**
+ * Marker symbol for default tags identification.
+ */
+export const DEFAULT_TAGS_MARKER = Symbol.for("chant.aws.defaultTags");
+
+/**
+ * A single tag entry — Key is always a string, Value supports strings,
+ * Parameters, intrinsics, or any value the serializer can resolve.
+ */
+export interface TagEntry {
+  readonly Key: string;
+  readonly Value: unknown;
+}
+
+/**
+ * A default tags declaration — wraps a tag array into a Declarable
+ * that the serializer uses to inject tags into all taggable resources.
+ */
+export interface DefaultTags extends Declarable {
+  readonly [DEFAULT_TAGS_MARKER]: true;
+  readonly [DECLARABLE_MARKER]: true;
+  readonly lexicon: "aws";
+  readonly entityType: "chant:aws:defaultTags";
+  readonly tags: readonly TagEntry[];
+}
+
+/**
+ * Type guard for DefaultTags.
+ */
+export function isDefaultTags(value: unknown): value is DefaultTags {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    DEFAULT_TAGS_MARKER in value &&
+    (value as Record<symbol, unknown>)[DEFAULT_TAGS_MARKER] === true
+  );
+}
+
+/**
+ * Declare project-wide default tags for all taggable resources.
+ *
+ * Tags are injected at synthesis time into every resource that supports
+ * tagging (per the CloudFormation Registry metadata). If a resource has
+ * an explicit Tag with the same Key, the explicit value wins.
+ *
+ * @param tags - Array of { Key, Value } tag entries
+ * @returns A DefaultTags Declarable
+ *
+ * @example
+ * ```ts
+ * import { defaultTags, Sub, AWS } from "@intentius/chant-lexicon-aws";
+ *
+ * export const tags = defaultTags([
+ *   { Key: "Project", Value: "my-app" },
+ *   { Key: "Environment", Value: Sub`${AWS.StackName}` },
+ * ]);
+ * ```
+ */
+export function defaultTags(tags: TagEntry[]): DefaultTags {
+  return {
+    [DEFAULT_TAGS_MARKER]: true,
+    [DECLARABLE_MARKER]: true,
+    lexicon: "aws",
+    entityType: "chant:aws:defaultTags",
+    tags,
+  };
+}