@intentius/chant-lexicon-aws 0.0.22 → 0.1.0

package/src/composites/rds-instance.ts

@@ -1,4 +1,4 @@
-import { Composite } from "@intentius/chant";
+import { Composite, mergeDefaults } from "@intentius/chant";
 import {
   DbInstance,
   RDSDBSubnetGroup,
@@ -66,6 +66,12 @@ export interface RdsInstanceProps {
 
   // ── Protection ────────────────────────────────────────────────
   deletionProtection?: boolean;
+  defaults?: {
+    subnetGroup?: Partial<ConstructorParameters<typeof RDSDBSubnetGroup>[0]>;
+    sg?: Partial<ConstructorParameters<typeof SecurityGroup>[0]>;
+    db?: Partial<ConstructorParameters<typeof DbInstance>[0]>;
+    parameterGroup?: Partial<ConstructorParameters<typeof RDSDBParameterGroup>[0]>;
+  };
 }
 
 export const RdsInstance = Composite<RdsInstanceProps>((props) => {
@@ -84,12 +90,13 @@ export const RdsInstance = Composite<RdsInstanceProps>((props) => {
   const autoMinorVersionUpgrade = props.autoMinorVersionUpgrade ?? true;
   const publiclyAccessible = props.publiclyAccessible ?? false;
   const deletionProtection = props.deletionProtection ?? false;
+  const { defaults: defs } = props;
 
   // DB Subnet Group
-  const subnetGroup = new RDSDBSubnetGroup({
+  const subnetGroup = new RDSDBSubnetGroup(mergeDefaults({
     DBSubnetGroupDescription: "Subnet group for RDS instance",
     SubnetIds: props.subnetIds,
-  });
+  }, defs?.subnetGroup));
 
   // Security Group
   const ingressRules: InstanceType<typeof SecurityGroup_Ingress>[] = [];
@@ -113,20 +120,20 @@ export const RdsInstance = Composite<RdsInstanceProps>((props) => {
     );
   }
 
-  const sg = new SecurityGroup({
+  const sg = new SecurityGroup(mergeDefaults({
     GroupDescription: "Security group for RDS instance",
     VpcId: props.vpcId,
     SecurityGroupIngress: ingressRules.length > 0 ? ingressRules : undefined,
-  });
+  }, defs?.sg));
 
   // Optional Parameter Group
   let parameterGroup: InstanceType<typeof RDSDBParameterGroup> | undefined;
   if (props.parameterGroupFamily) {
-    parameterGroup = new RDSDBParameterGroup({
+    parameterGroup = new RDSDBParameterGroup(mergeDefaults({
       Family: props.parameterGroupFamily,
       Description: "Custom parameter group",
       Parameters: props.parameters,
-    });
+    }, defs?.parameterGroup));
   }
 
   // DB Instance
@@ -164,7 +171,7 @@ export const RdsInstance = Composite<RdsInstanceProps>((props) => {
   }
   if (parameterGroup) dbProps.DBParameterGroupName = parameterGroup.Ref;
 
-  const db = new DbInstance(dbProps);
+  const db = new DbInstance(mergeDefaults(dbProps, defs?.db));
 
   const result: Record<string, any> = { subnetGroup, sg, db };
   if (parameterGroup) result.parameterGroup = parameterGroup;

package/src/composites/scheduled-lambda.ts

@@ -1,4 +1,4 @@
-import { Composite } from "@intentius/chant";
+import { Composite, mergeDefaults } from "@intentius/chant";
 import { EventRule, EventRule_Target, Permission } from "../generated";
 import { LambdaFunction, type LambdaFunctionProps } from "./lambda-function";
 
@@ -6,12 +6,17 @@ export interface ScheduledLambdaProps extends LambdaFunctionProps {
   ruleName?: string;
   schedule: string;
   enabled?: boolean;
+  defaults?: LambdaFunctionProps["defaults"] & {
+    rule?: Partial<ConstructorParameters<typeof EventRule>[0]>;
+    permission?: Partial<ConstructorParameters<typeof Permission>[0]>;
+  };
 }
 
 export const LambdaScheduled = Composite<ScheduledLambdaProps>((props) => {
+  const { defaults } = props;
   const { role, func } = LambdaFunction(props);
 
-  const rule = new EventRule({
+  const rule = new EventRule(mergeDefaults({
     Name: props.ruleName,
     ScheduleExpression: props.schedule,
     State: (props.enabled ?? true) ? "ENABLED" : "DISABLED",
@@ -21,14 +26,14 @@ export const LambdaScheduled = Composite<ScheduledLambdaProps>((props) => {
         Id: "Target0",
       }),
     ],
-  });
+  }, defaults?.rule));
 
-  const permission = new Permission({
+  const permission = new Permission(mergeDefaults({
     FunctionName: func.Arn,
     Action: "lambda:InvokeFunction",
     Principal: "events.amazonaws.com",
     SourceArn: rule.Arn,
-  });
+  }, defaults?.permission));
 
   return { role, func, rule, permission };
 }, "LambdaScheduled");

package/src/composites/vpc-default.ts

@@ -1,4 +1,4 @@
-import { Composite } from "@intentius/chant";
+import { Composite, mergeDefaults } from "@intentius/chant";
 import {
   Vpc,
   Subnet,
@@ -14,14 +14,32 @@ import { Select, GetAZs } from "../intrinsics";
 
 export interface VpcDefaultProps {
   cidr?: string;
+  /** Number of availability zones (2 or 3, default: 2). */
+  azCount?: 2 | 3;
   publicSubnet1Cidr?: string;
   publicSubnet2Cidr?: string;
   privateSubnet1Cidr?: string;
   privateSubnet2Cidr?: string;
+  /** Public subnet 3 CIDR (default: "10.0.32.0/20"). Used when azCount is 3. */
+  publicSubnet3Cidr?: string;
+  /** Private subnet 3 CIDR (default: "10.0.160.0/20"). Used when azCount is 3. */
+  privateSubnet3Cidr?: string;
+  defaults?: {
+    vpc?: Partial<ConstructorParameters<typeof Vpc>[0]>;
+    publicSubnet1?: Partial<ConstructorParameters<typeof Subnet>[0]>;
+    publicSubnet2?: Partial<ConstructorParameters<typeof Subnet>[0]>;
+    privateSubnet1?: Partial<ConstructorParameters<typeof Subnet>[0]>;
+    privateSubnet2?: Partial<ConstructorParameters<typeof Subnet>[0]>;
+    publicSubnet3?: Partial<ConstructorParameters<typeof Subnet>[0]>;
+    privateSubnet3?: Partial<ConstructorParameters<typeof Subnet>[0]>;
+    natGateway?: Partial<ConstructorParameters<typeof NatGateway>[0]>;
+  };
 }
 
 export const VpcDefault = Composite<VpcDefaultProps>((props) => {
+  const { defaults: defs } = props;
   const cidr = props.cidr ?? "10.0.0.0/16";
+  const azCount = props.azCount ?? 2;
   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";
@@ -30,11 +48,11 @@ export const VpcDefault = Composite<VpcDefaultProps>((props) => {
   const az1 = Select(0, GetAZs(""));
   const az2 = Select(1, GetAZs(""));
 
-  const vpc = new Vpc({
+  const vpc = new Vpc(mergeDefaults({
     CidrBlock: cidr,
     EnableDnsSupport: true,
     EnableDnsHostnames: true,
-  });
+  }, defs?.vpc));
 
   const igw = new InternetGateway({});
 
@@ -44,32 +62,32 @@ export const VpcDefault = Composite<VpcDefaultProps>((props) => {
   });
 
   // Public subnets
-  const publicSubnet1 = new Subnet({
+  const publicSubnet1 = new Subnet(mergeDefaults({
     VpcId: vpc.VpcId,
     CidrBlock: publicSubnet1Cidr,
     AvailabilityZone: az1,
     MapPublicIpOnLaunch: true,
-  });
+  }, defs?.publicSubnet1));
 
-  const publicSubnet2 = new Subnet({
+  const publicSubnet2 = new Subnet(mergeDefaults({
     VpcId: vpc.VpcId,
     CidrBlock: publicSubnet2Cidr,
     AvailabilityZone: az2,
     MapPublicIpOnLaunch: true,
-  });
+  }, defs?.publicSubnet2));
 
   // Private subnets
-  const privateSubnet1 = new Subnet({
+  const privateSubnet1 = new Subnet(mergeDefaults({
     VpcId: vpc.VpcId,
     CidrBlock: privateSubnet1Cidr,
     AvailabilityZone: az1,
-  });
+  }, defs?.privateSubnet1));
 
-  const privateSubnet2 = new Subnet({
+  const privateSubnet2 = new Subnet(mergeDefaults({
     VpcId: vpc.VpcId,
     CidrBlock: privateSubnet2Cidr,
     AvailabilityZone: az2,
-  });
+  }, defs?.privateSubnet2));
 
   // Public route table
   const publicRouteTable = new RouteTable({
@@ -100,10 +118,10 @@ export const VpcDefault = Composite<VpcDefaultProps>((props) => {
     Domain: "vpc",
   });
 
-  const natGateway = new NatGateway({
+  const natGateway = new NatGateway(mergeDefaults({
     AllocationId: natEip.AllocationId,
     SubnetId: publicSubnet1.SubnetId,
-  });
+  }, defs?.natGateway));
 
   // Private route table
   const privateRouteTable = new RouteTable({
@@ -126,23 +144,56 @@ export const VpcDefault = Composite<VpcDefaultProps>((props) => {
     RouteTableId: privateRouteTable.RouteTableId,
   });
 
+  // ── AZ3 (optional) ──────────────────────────────────────────────
+
+  if (azCount >= 3) {
+    const az3 = Select(2, GetAZs(""));
+    const publicSubnet3Cidr = props.publicSubnet3Cidr ?? "10.0.32.0/20";
+    const privateSubnet3Cidr = props.privateSubnet3Cidr ?? "10.0.160.0/20";
+
+    const publicSubnet3 = new Subnet(mergeDefaults({
+      VpcId: vpc.VpcId,
+      CidrBlock: publicSubnet3Cidr,
+      AvailabilityZone: az3,
+      MapPublicIpOnLaunch: true,
+    }, defs?.publicSubnet3));
+
+    const privateSubnet3 = new Subnet(mergeDefaults({
+      VpcId: vpc.VpcId,
+      CidrBlock: privateSubnet3Cidr,
+      AvailabilityZone: az3,
+    }, defs?.privateSubnet3));
+
+    const publicRta3 = new SubnetRouteTableAssociation({
+      SubnetId: publicSubnet3.SubnetId,
+      RouteTableId: publicRouteTable.RouteTableId,
+    });
+
+    const privateRta3 = new SubnetRouteTableAssociation({
+      SubnetId: privateSubnet3.SubnetId,
+      RouteTableId: privateRouteTable.RouteTableId,
+    });
+
+    return {
+      vpc, igw, igwAttachment,
+      publicSubnet1, publicSubnet2, publicSubnet3,
+      privateSubnet1, privateSubnet2, privateSubnet3,
+      publicRouteTable, publicRoute,
+      publicRta1, publicRta2, publicRta3,
+      privateRouteTable, privateRoute,
+      privateRta1, privateRta2, privateRta3,
+      natEip, natGateway,
+    };
+  }
+
   return {
-    vpc,
-    igw,
-    igwAttachment,
-    publicSubnet1,
-    publicSubnet2,
-    privateSubnet1,
-    privateSubnet2,
-    publicRouteTable,
-    publicRoute,
-    publicRta1,
-    publicRta2,
-    privateRouteTable,
-    privateRta1,
-    privateRta2,
-    natEip,
-    natGateway,
-    privateRoute,
+    vpc, igw, igwAttachment,
+    publicSubnet1, publicSubnet2,
+    privateSubnet1, privateSubnet2,
+    publicRouteTable, publicRoute,
+    publicRta1, publicRta2,
+    privateRouteTable, privateRoute,
+    privateRta1, privateRta2,
+    natEip, natGateway,
   };
 }, "VpcDefault");