@fjall/components-infrastructure 0.76.0 → 0.77.2

package/dist/lib/patterns/aws/freeTierApp.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicApp = void 0;
+const awsStack_1 = require("../../resources/aws/base/awsStack");
+const vpc_1 = require("../../resources/aws/networking/vpc");
+const ecs_1 = require("../../resources/aws/compute/ecs");
+const ecsFreeTier_1 = require("../../resources/aws/compute/ecsFreeTier");
+const secrets_1 = require("../../resources/aws/secrets");
+const storage_1 = require("../../resources/aws/storage");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const databaseFreeTier_1 = require("../../resources/aws/database/databaseFreeTier");
+class BasicApp {
+    constructor(id, rawProps) {
+        const props = this.getProps(id, rawProps);
+        const stackProps = this.getStackProps(props);
+        this.vpcStack = new awsStack_1.default(`${id}Network`, [], stackProps)
+            .addNetwork(vpc_1.Vpc.build(`${id}Vpc`, {
+            region: props.region
+        }))
+            .addContainerRegistry(storage_1.Ecr.build(`${id}Ecr`));
+        this.databaseStack = new awsStack_1.default(`${id}Database`, this.vpcStack, stackProps)
+            .addNetwork(this.vpcStack.getNetwork())
+            .addResource(databaseFreeTier_1.default.build(`${id}Database`, {}));
+        // Fetches the dbResource from the databaseStack
+        const dbResource = this.databaseStack.getResource(`${id}Database`);
+        const secretObjectValue = {};
+        if (props.containerSecrets) {
+            for (const secretObject of props.containerSecrets) {
+                secretObjectValue[secretObject] = aws_cdk_lib_1.SecretValue.unsafePlainText("");
+            }
+        }
+        this.secretStack = new awsStack_1.default(`${id}Secret`, [], stackProps).addResource(secrets_1.Secret.build(`${id}Secret`, {
+            secretName: `/${props.clusterName}/${props.serviceName}`,
+            secretObjectValue: secretObjectValue
+        }));
+        this.computeStack = new awsStack_1.default(`${id}Compute`, [this.vpcStack, this.databaseStack, this.secretStack], stackProps)
+            .addNetwork(this.vpcStack.getNetwork())
+            .addResource(ecsFreeTier_1.default.build(`${id}Fargate`, {
+            clusterName: props.clusterName,
+            //TODO: This should work via line 124, but doesn't work (at least on update)
+            databaseConnection: dbResource.databaseSecurityGroup.connections,
+            containerEntryPoint: props.containerEntryPoint,
+            containerCommand: props.containerCommand,
+            containerEnvironment: props.containerEnvironment,
+            containerPort: props.containerPort,
+            containerSecrets: secretObjectValue,
+            ecrRepository: this.vpcStack.getContainerRegistry(),
+            parentDomain: props.parentDomain?.toLowerCase(),
+            listenerPort: props.listenerPort,
+            serviceName: props.serviceName,
+            taskRoleInlinePolicies: props.taskRoleInlinePolicies,
+            taskRoleManagedPolicies: props.taskRoleManagedPolicies
+        }))
+            .connect(`${id}Fargate`, `${id}Database`, 5432);
+    }
+    getStackProps(props) {
+        if (!props)
+            return;
+        return {
+            accountId: props.account,
+            region: props.region
+        };
+    }
+    getProps(id, rawProps) {
+        const defaultProps = {
+            scalingType: ecs_1.ScalingType.CPU,
+            containerPort: rawProps.containerPort || 3000,
+            serviceName: `${id}Service`,
+            clusterName: `${id}Cluster`,
+            containerEntryPoint: ["node", "main.js"],
+            containerCommand: rawProps.containerPort
+                ? [`${rawProps.containerPort}`]
+                : [`3000`]
+        };
+        return {
+            ...defaultProps,
+            ...rawProps
+        };
+    }
+}
+exports.BasicApp = BasicApp;
+exports.default = BasicApp;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"freeTierApp.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/freeTierApp.ts"],"names":[],"mappings":"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","sourcesContent":["import AwsStack, { AwsStackProps } from \"../../resources/aws/base/awsStack\";\nimport { Vpc } from \"../../resources/aws/networking/vpc\";\nimport { ContainerSecret, ScalingType } from \"../../resources/aws/compute/ecs\";\nimport Ec2Cluster from \"../../resources/aws/compute/ecsFreeTier\";\nimport { Secret } from \"../../resources/aws/secrets\";\nimport { Ecr } from \"../../resources/aws/storage\";\nimport { SecretValue } from \"aws-cdk-lib\";\nimport { IManagedPolicy, PolicyDocument } from \"aws-cdk-lib/aws-iam\";\nimport { KeyValue } from \"../../types\";\nimport Database from \"../../resources/aws/database/databaseFreeTier\";\n\n/**\n * Intersected with BasicAppProps in the getProps method. This allows the BasicApp construct\n * to treat these as required properties and avoid constant null checking.\n */\nexport interface BasicAppPropDefaults {\n  serviceName: string;\n  clusterName: string;\n  scalingType: ScalingType;\n  containerPort: number;\n}\n\nexport interface BasicAppProps {\n  account?: string;\n  clusterName?: string;\n  containerEntryPoint?: string[];\n  containerCommand?: string[];\n  containerEnvironment?: KeyValue;\n  containerPort?: number;\n  containerSecrets?: string[];\n  environment?: string;\n  // The team/domain/business-unit that is responsible for this service\n  owner?: string;\n  parentDomain?: string; // Fix to make a dependency of protocol\n  listenerPort?: number;\n  region?: string;\n  scalingType?: ScalingType;\n  serviceName?: string;\n  taskRoleInlinePolicies?: {\n    [name: string]: PolicyDocument;\n  };\n  taskRoleManagedPolicies?: IManagedPolicy[];\n}\n\nexport class BasicApp {\n  private vpcStack: AwsStack;\n  private databaseStack: AwsStack;\n  private secretStack: AwsStack;\n  private computeStack: AwsStack;\n\n  constructor(id: string, rawProps: BasicAppProps) {\n    const props = this.getProps(id, rawProps);\n    const stackProps = this.getStackProps(props);\n\n    this.vpcStack = new AwsStack(`${id}Network`, [], stackProps)\n      .addNetwork(\n        Vpc.build(`${id}Vpc`, {\n          region: props.region\n        })\n      )\n      .addContainerRegistry(Ecr.build(`${id}Ecr`));\n\n    this.databaseStack = new AwsStack(\n      `${id}Database`,\n      this.vpcStack,\n      stackProps\n    )\n      .addNetwork(this.vpcStack.getNetwork())\n      .addResource(Database.build(`${id}Database`, {}));\n\n    // Fetches the dbResource from the databaseStack\n    const dbResource = this.databaseStack.getResource(\n      `${id}Database`\n    ) as Database;\n\n    const secretObjectValue: ContainerSecret = {};\n    if (props.containerSecrets) {\n      for (const secretObject of props.containerSecrets) {\n        secretObjectValue[secretObject] = SecretValue.unsafePlainText(\"\");\n      }\n    }\n\n    this.secretStack = new AwsStack(`${id}Secret`, [], stackProps).addResource(\n      Secret.build(`${id}Secret`, {\n        secretName: `/${props.clusterName}/${props.serviceName}`,\n        secretObjectValue: secretObjectValue\n      })\n    );\n\n    this.computeStack = new AwsStack(\n      `${id}Compute`,\n      [this.vpcStack, this.databaseStack, this.secretStack],\n      stackProps\n    )\n      .addNetwork(this.vpcStack.getNetwork())\n      .addResource(\n        Ec2Cluster.build(`${id}Fargate`, {\n          clusterName: props.clusterName,\n          //TODO: This should work via line 124, but doesn't work (at least on update)\n          databaseConnection: dbResource.databaseSecurityGroup.connections,\n          containerEntryPoint: props.containerEntryPoint,\n          containerCommand: props.containerCommand,\n          containerEnvironment: props.containerEnvironment,\n          containerPort: props.containerPort,\n          containerSecrets: secretObjectValue,\n          ecrRepository: this.vpcStack.getContainerRegistry(),\n          parentDomain: props.parentDomain?.toLowerCase(),\n          listenerPort: props.listenerPort,\n          serviceName: props.serviceName,\n          taskRoleInlinePolicies: props.taskRoleInlinePolicies,\n          taskRoleManagedPolicies: props.taskRoleManagedPolicies\n        })\n      )\n      .connect(`${id}Fargate`, `${id}Database`, 5432);\n  }\n\n  getStackProps(props: BasicAppProps): AwsStackProps | undefined {\n    if (!props) return;\n\n    return {\n      accountId: props.account,\n      region: props.region\n    };\n  }\n\n  getProps(\n    id: string,\n    rawProps: BasicAppProps\n  ): BasicAppProps & BasicAppPropDefaults {\n    const defaultProps = {\n      scalingType: ScalingType.CPU,\n      containerPort: rawProps.containerPort || 3000,\n      serviceName: `${id}Service`,\n      clusterName: `${id}Cluster`,\n      containerEntryPoint: [\"node\", \"main.js\"],\n      containerCommand: rawProps.containerPort\n        ? [`${rawProps.containerPort}`]\n        : [`3000`]\n    };\n\n    return {\n      ...defaultProps,\n      ...rawProps\n    };\n  }\n}\nexport default BasicApp;\n"]}

package/dist/lib/patterns/aws/index.d.ts

@@ -8,3 +8,4 @@ export * from "./database";
 export * from "./hostedZone";
 export * from "./compute";
 export * from "./storage";
+export * from "./network";

package/dist/lib/patterns/aws/index.js

@@ -25,4 +25,5 @@ __exportStar(require("./hostedZone"), exports);
 // Patterns
 __exportStar(require("./compute"), exports);
 __exportStar(require("./storage"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvcGF0dGVybnMvYXdzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3REFBc0M7QUFDdEMsb0RBQWtDO0FBQ2xDLG1EQUFpQztBQUNqQyw4Q0FBNEI7QUFDNUIsa0VBQWdEO0FBQ2hELGtEQUFnQztBQUNoQyw2Q0FBMkI7QUFDM0IsK0NBQTZCO0FBRTdCLFdBQVc7QUFDWCw0Q0FBMEI7QUFDMUIsNENBQTBCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vbWFuYWdlZE9yZ2FuaXNhdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbWFuYWdlZFBsYXRmb3JtXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tYW5hZ2VkQWNjb3VudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vYnVpbGRraXRlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi4vLi4vcmVzb3VyY2VzL2F3cy9jb21wdXRlL2VjMlwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZml2ZXRyYW5Qcm94eVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGF0YWJhc2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2hvc3RlZFpvbmVcIjtcblxuLy8gUGF0dGVybnNcbmV4cG9ydCAqIGZyb20gXCIuL2NvbXB1dGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N0b3JhZ2VcIjtcbiJdfQ==
+__exportStar(require("./network"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvcGF0dGVybnMvYXdzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3REFBc0M7QUFDdEMsb0RBQWtDO0FBQ2xDLG1EQUFpQztBQUNqQyw4Q0FBNEI7QUFDNUIsa0VBQWdEO0FBQ2hELGtEQUFnQztBQUNoQyw2Q0FBMkI7QUFDM0IsK0NBQTZCO0FBRTdCLFdBQVc7QUFDWCw0Q0FBMEI7QUFDMUIsNENBQTBCO0FBQzFCLDRDQUEwQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL21hbmFnZWRPcmdhbmlzYXRpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL21hbmFnZWRQbGF0Zm9ybVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbWFuYWdlZEFjY291bnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2J1aWxka2l0ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4uLy4uL3Jlc291cmNlcy9hd3MvY29tcHV0ZS9lYzJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZpdmV0cmFuUHJveHlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RhdGFiYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ob3N0ZWRab25lXCI7XG5cbi8vIFBhdHRlcm5zXG5leHBvcnQgKiBmcm9tIFwiLi9jb21wdXRlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdG9yYWdlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9uZXR3b3JrXCI7XG4iXX0=

package/dist/lib/patterns/aws/network.d.ts

@@ -0,0 +1,75 @@
+import { Construct } from "constructs";
+import { type IVpc } from "aws-cdk-lib/aws-ec2";
+import type App from "../../app";
+import { Vpc } from "../../resources/aws/networking/vpc";
+export interface NatConfig {
+    count?: number;
+}
+export interface FlowLogConfig {
+    destination?: "cloudwatch" | "s3";
+    retentionDays?: number;
+    trafficType?: "ALL" | "ACCEPT" | "REJECT";
+}
+export interface GatewayEndpointsConfig {
+    s3?: boolean;
+    dynamodb?: boolean;
+}
+export interface InterfaceEndpointsConfig {
+    ecr?: boolean;
+    secretsManager?: boolean;
+    kms?: boolean;
+    cloudwatchLogs?: boolean;
+    ssm?: boolean;
+    sts?: boolean;
+}
+export interface VpcEndpointsConfig {
+    gateway?: GatewayEndpointsConfig | false;
+    interface?: InterfaceEndpointsConfig | false;
+}
+export interface SubnetConfig {
+    cidrMask?: number;
+}
+export interface SubnetsConfig {
+    public?: SubnetConfig;
+    private?: SubnetConfig;
+    isolated?: SubnetConfig | false;
+}
+export interface TransitGatewayConfig {
+    id: string;
+}
+/**
+ * Network (VPC) configuration.
+ *
+ * @example
+ * // Minimal cost VPC (no NAT, gateway endpoints only)
+ * { natGateways: false }
+ *
+ * @example
+ * // Production VPC with 1 NAT gateway
+ * { natGateways: { count: 1 }, flowLogs: {} }
+ *
+ * @example
+ * // High-availability VPC with interface endpoints
+ * { maxAzs: 3, natGateways: { count: 3 }, vpcEndpoints: { interface: { ecr: true } } }
+ */
+export interface INetworkProps {
+    maxAzs?: number;
+    cidrMask?: number;
+    natGateways?: NatConfig | false;
+    flowLogs?: FlowLogConfig | false;
+    vpcEndpoints?: VpcEndpointsConfig | false;
+    subnets?: SubnetsConfig;
+    transitGateway?: TransitGatewayConfig;
+}
+export declare class NetworkFactory {
+    static build(id: string, props: INetworkProps): (app: App, scope: Construct) => Network;
+}
+export declare class Network extends Construct {
+    readonly vpc: Vpc;
+    constructor(scope: Construct, id: string, props: INetworkProps, app: App);
+    private createVpc;
+    private resolveNatConfig;
+    private resolveFlowLogConfig;
+    private resolveEndpointsConfig;
+    getVpc(): IVpc;
+}

package/dist/lib/patterns/aws/network.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Network = exports.NetworkFactory = void 0;
+const constructs_1 = require("constructs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const vpc_1 = require("../../resources/aws/networking/vpc");
+function validateNetworkProps(props) {
+    if (props.maxAzs !== undefined && (props.maxAzs < 1 || props.maxAzs > 3)) {
+        console.warn(`[Fjall] Warning: 'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`);
+    }
+    if (typeof props.natGateways === "object" &&
+        props.natGateways !== null &&
+        props.natGateways.count !== undefined) {
+        const maxAzs = props.maxAzs ?? 3;
+        if (props.natGateways.count > maxAzs) {
+            console.warn(`[Fjall] Warning: 'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`);
+        }
+    }
+    if (props.transitGateway && !props.transitGateway.id) {
+        throw new Error("Transit Gateway configuration requires 'id'.");
+    }
+}
+class NetworkFactory {
+    static build(id, props) {
+        return (app, scope) => {
+            validateNetworkProps(props);
+            return new Network(scope, id, props, app);
+        };
+    }
+}
+exports.NetworkFactory = NetworkFactory;
+class Network extends constructs_1.Construct {
+    constructor(scope, id, props, app) {
+        super(scope, id);
+        this.vpc = this.createVpc(id, props, app);
+    }
+    createVpc(id, props, app) {
+        const accountId = app.node.tryGetContext("accountId") || process.env.CDK_DEFAULT_ACCOUNT;
+        const region = process.env.CDK_DEFAULT_REGION;
+        const isManagedAccount = app.node.tryGetContext("managedAccount") === "true";
+        let ipv4IpamPoolId;
+        if (isManagedAccount && accountId && region) {
+            const regionSuffix = region.replace(/-/g, "");
+            ipv4IpamPoolId = aws_cdk_lib_1.Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);
+        }
+        const vpcProps = {
+            accountId,
+            region,
+            ipv4IpamPoolId,
+            maxAzs: props.maxAzs,
+            vpcCidrMask: props.cidrMask,
+            subnetCidrMask: props.subnets?.private?.cidrMask,
+            natGatewayConfig: this.resolveNatConfig(props.natGateways),
+            flowLogConfig: this.resolveFlowLogConfig(props.flowLogs),
+            endpointsConfig: this.resolveEndpointsConfig(props.vpcEndpoints)
+        };
+        return new vpc_1.Vpc(this, id, vpcProps);
+    }
+    resolveNatConfig(config) {
+        if (config === undefined)
+            return undefined;
+        if (config === false)
+            return false;
+        return { count: config.count };
+    }
+    resolveFlowLogConfig(config) {
+        if (config === undefined)
+            return undefined;
+        if (config === false)
+            return false;
+        return {
+            destination: config.destination,
+            retentionDays: config.retentionDays,
+            trafficType: config.trafficType
+        };
+    }
+    resolveEndpointsConfig(config) {
+        if (config === false)
+            return false;
+        // Default: gateway endpoints enabled
+        if (config === undefined) {
+            return { gateway: { s3: true, dynamodb: true } };
+        }
+        return {
+            gateway: config.gateway === false
+                ? false
+                : {
+                    s3: config.gateway?.s3 ?? true,
+                    dynamodb: config.gateway?.dynamodb ?? true
+                },
+            interface: config.interface === false ? false : config.interface
+        };
+    }
+    getVpc() {
+        return this.vpc;
+    }
+}
+exports.Network = Network;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/network.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { Fn } from \"aws-cdk-lib\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\n\nimport type App from \"../../app\";\nimport { Vpc, type VpcProps } from \"../../resources/aws/networking/vpc\";\n\nexport interface NatConfig {\n  count?: number;\n}\n\nexport interface FlowLogConfig {\n  destination?: \"cloudwatch\" | \"s3\";\n  retentionDays?: number;\n  trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n}\n\nexport interface GatewayEndpointsConfig {\n  s3?: boolean;\n  dynamodb?: boolean;\n}\n\nexport interface InterfaceEndpointsConfig {\n  ecr?: boolean;\n  secretsManager?: boolean;\n  kms?: boolean;\n  cloudwatchLogs?: boolean;\n  ssm?: boolean;\n  sts?: boolean;\n}\n\nexport interface VpcEndpointsConfig {\n  gateway?: GatewayEndpointsConfig | false;\n  interface?: InterfaceEndpointsConfig | false;\n}\n\nexport interface SubnetConfig {\n  cidrMask?: number;\n}\n\nexport interface SubnetsConfig {\n  public?: SubnetConfig;\n  private?: SubnetConfig;\n  isolated?: SubnetConfig | false;\n}\n\nexport interface TransitGatewayConfig {\n  id: string;\n}\n\n/**\n * Network (VPC) configuration.\n *\n * @example\n * // Minimal cost VPC (no NAT, gateway endpoints only)\n * { natGateways: false }\n *\n * @example\n * // Production VPC with 1 NAT gateway\n * { natGateways: { count: 1 }, flowLogs: {} }\n *\n * @example\n * // High-availability VPC with interface endpoints\n * { maxAzs: 3, natGateways: { count: 3 }, vpcEndpoints: { interface: { ecr: true } } }\n */\nexport interface INetworkProps {\n  maxAzs?: number;\n  cidrMask?: number;\n  natGateways?: NatConfig | false;\n  flowLogs?: FlowLogConfig | false;\n  vpcEndpoints?: VpcEndpointsConfig | false;\n  subnets?: SubnetsConfig;\n  transitGateway?: TransitGatewayConfig;\n}\n\nfunction validateNetworkProps(props: INetworkProps): void {\n  if (props.maxAzs !== undefined && (props.maxAzs < 1 || props.maxAzs > 3)) {\n    console.warn(\n      `[Fjall] Warning: 'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`\n    );\n  }\n\n  if (\n    typeof props.natGateways === \"object\" &&\n    props.natGateways !== null &&\n    props.natGateways.count !== undefined\n  ) {\n    const maxAzs = props.maxAzs ?? 3;\n    if (props.natGateways.count > maxAzs) {\n      console.warn(\n        `[Fjall] Warning: 'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`\n      );\n    }\n  }\n\n  if (props.transitGateway && !props.transitGateway.id) {\n    throw new Error(\"Transit Gateway configuration requires 'id'.\");\n  }\n}\n\nexport class NetworkFactory {\n  static build(id: string, props: INetworkProps) {\n    return (app: App, scope: Construct) => {\n      validateNetworkProps(props);\n      return new Network(scope, id, props, app);\n    };\n  }\n}\n\nexport class Network extends Construct {\n  public readonly vpc: Vpc;\n\n  constructor(scope: Construct, id: string, props: INetworkProps, app: App) {\n    super(scope, id);\n    this.vpc = this.createVpc(id, props, app);\n  }\n\n  private createVpc(id: string, props: INetworkProps, app: App): Vpc {\n    const accountId =\n      app.node.tryGetContext(\"accountId\") || process.env.CDK_DEFAULT_ACCOUNT;\n    const region = process.env.CDK_DEFAULT_REGION;\n    const isManagedAccount =\n      app.node.tryGetContext(\"managedAccount\") === \"true\";\n\n    let ipv4IpamPoolId: string | undefined;\n    if (isManagedAccount && accountId && region) {\n      const regionSuffix = region.replace(/-/g, \"\");\n      ipv4IpamPoolId = Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);\n    }\n\n    const vpcProps: VpcProps = {\n      accountId,\n      region,\n      ipv4IpamPoolId,\n      maxAzs: props.maxAzs,\n      vpcCidrMask: props.cidrMask,\n      subnetCidrMask: props.subnets?.private?.cidrMask,\n      natGatewayConfig: this.resolveNatConfig(props.natGateways),\n      flowLogConfig: this.resolveFlowLogConfig(props.flowLogs),\n      endpointsConfig: this.resolveEndpointsConfig(props.vpcEndpoints)\n    };\n\n    return new Vpc(this, id, vpcProps);\n  }\n\n  private resolveNatConfig(\n    config: NatConfig | false | undefined\n  ): { count?: number } | false | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return { count: config.count };\n  }\n\n  private resolveFlowLogConfig(config: FlowLogConfig | false | undefined):\n    | {\n        destination?: \"cloudwatch\" | \"s3\";\n        retentionDays?: number;\n        trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n      }\n    | false\n    | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return {\n      destination: config.destination,\n      retentionDays: config.retentionDays,\n      trafficType: config.trafficType\n    };\n  }\n\n  private resolveEndpointsConfig(\n    config: VpcEndpointsConfig | false | undefined\n  ):\n    | {\n        gateway?: { s3?: boolean; dynamodb?: boolean } | false;\n        interface?:\n          | {\n              ecr?: boolean;\n              secretsManager?: boolean;\n              kms?: boolean;\n              cloudwatchLogs?: boolean;\n              ssm?: boolean;\n              sts?: boolean;\n            }\n          | false;\n      }\n    | false\n    | undefined {\n    if (config === false) return false;\n\n    // Default: gateway endpoints enabled\n    if (config === undefined) {\n      return { gateway: { s3: true, dynamodb: true } };\n    }\n\n    return {\n      gateway:\n        config.gateway === false\n          ? false\n          : {\n              s3: config.gateway?.s3 ?? true,\n              dynamodb: config.gateway?.dynamodb ?? true\n            },\n      interface: config.interface === false ? false : config.interface\n    };\n  }\n\n  getVpc(): IVpc {\n    return this.vpc;\n  }\n}\n"]}

package/dist/lib/patterns/aws/spotInstanceApp.d.ts

@@ -0,0 +1,45 @@
+import { AwsStackProps } from "../../resources/aws/base/awsStack";
+import { ScalingType } from "../../resources/aws/compute/ecs";
+import { IManagedPolicy, PolicyDocument } from "aws-cdk-lib/aws-iam";
+import { KeyValue } from "../../types";
+/**
+ * Intersected with BasicAppProps in the getProps method. This allows the BasicApp construct
+ * to treat these as required properties and avoid constant null checking.
+ */
+export interface BasicAppPropDefaults {
+    serviceName: string;
+    clusterName: string;
+    scalingType: ScalingType;
+    containerPort: number;
+}
+export interface BasicAppProps {
+    account?: string;
+    clusterName?: string;
+    containerEntryPoint?: string[];
+    containerCommand?: string[];
+    containerEnvironment?: KeyValue;
+    containerPort?: number;
+    containerSecrets?: string[];
+    accountName: string;
+    owner?: string;
+    parentDomain?: string;
+    environment: string;
+    listenerPort?: number;
+    region?: string;
+    scalingType?: ScalingType;
+    serviceName?: string;
+    taskRoleInlinePolicies?: {
+        [name: string]: PolicyDocument;
+    };
+    taskRoleManagedPolicies?: IManagedPolicy[];
+}
+export declare class BasicApp {
+    private vpcStack;
+    private databaseStack;
+    private secretStack;
+    private computeStack;
+    constructor(id: string, rawProps: BasicAppProps);
+    getStackProps(props: BasicAppProps): AwsStackProps | undefined;
+    getProps(id: string, rawProps: BasicAppProps): BasicAppProps & BasicAppPropDefaults;
+}
+export default BasicApp;

package/dist/lib/patterns/aws/spotInstanceApp.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicApp = void 0;
+const awsStack_1 = require("../../resources/aws/base/awsStack");
+const vpc_1 = require("../../resources/aws/networking/vpc");
+const ecs_1 = require("../../resources/aws/compute/ecs");
+const ecsSpot_1 = require("../../resources/aws/compute/ecsSpot");
+const secrets_1 = require("../../resources/aws/secrets");
+const storage_1 = require("../../resources/aws/storage");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const databaseInstance_1 = require("../../resources/aws/database/databaseInstance");
+class BasicApp {
+    constructor(id, rawProps) {
+        const props = this.getProps(id, rawProps);
+        const stackProps = this.getStackProps(props);
+        this.vpcStack = new awsStack_1.default(`${id}Network`, [], stackProps)
+            .addNetwork(vpc_1.Vpc.build(`${id}Vpc`, {
+            // environment: props.environment,
+            region: props.region
+        }))
+            .addContainerRegistry(storage_1.Ecr.build(`${id}Ecr`));
+        this.databaseStack = new awsStack_1.default(`${id}Database`, this.vpcStack, stackProps)
+            .addNetwork(this.vpcStack.getNetwork())
+            .addResource(databaseInstance_1.default.build(`${id}Database`, {}));
+        // Fetches the dbResource from the databaseStack
+        const dbResource = this.databaseStack.getResource(`${id}Database`);
+        const secretObjectValue = {};
+        if (props.containerSecrets) {
+            for (const secretObject of props.containerSecrets) {
+                secretObjectValue[secretObject] = aws_cdk_lib_1.SecretValue.unsafePlainText("");
+            }
+        }
+        this.secretStack = new awsStack_1.default(`${id}Secret`, [], stackProps).addResource(secrets_1.Secret.build(`${id}Secret`, {
+            secretName: `/${props.clusterName}/${props.serviceName}`,
+            secretObjectValue: secretObjectValue
+        }));
+        this.computeStack = new awsStack_1.default(`${id}Compute`, [this.vpcStack, this.databaseStack, this.secretStack], stackProps)
+            .addNetwork(this.vpcStack.getNetwork())
+            .addResource(ecsSpot_1.default.build(`${id}Fargate`, {
+            clusterName: props.clusterName,
+            //TODO: This should work via line 124, but doesn't work (at least on update)
+            databaseConnection: dbResource.databaseSecurityGroup.connections,
+            containerEntryPoint: props.containerEntryPoint,
+            containerCommand: props.containerCommand,
+            containerEnvironment: props.containerEnvironment,
+            containerPort: props.containerPort,
+            containerSecrets: secretObjectValue,
+            ecrRepository: this.vpcStack.getContainerRegistry(),
+            parentDomain: props.parentDomain?.toLowerCase(),
+            listenerPort: props.listenerPort,
+            serviceName: props.serviceName,
+            taskRoleInlinePolicies: props.taskRoleInlinePolicies,
+            taskRoleManagedPolicies: props.taskRoleManagedPolicies
+        }))
+            .connect(`${id}Fargate`, `${id}Database`, 5432);
+    }
+    getStackProps(props) {
+        if (!props)
+            return;
+        return {
+            accountId: props.account,
+            region: props.region,
+            accountName: props.accountName
+        };
+    }
+    getProps(id, rawProps) {
+        const defaultProps = {
+            scalingType: ecs_1.ScalingType.CPU,
+            containerPort: rawProps.containerPort || 3000,
+            serviceName: `${id}Service`,
+            clusterName: `${id}Cluster`,
+            containerEntryPoint: ["node", "main.js"],
+            containerCommand: rawProps.containerPort
+                ? [`${rawProps.containerPort}`]
+                : [`3000`]
+        };
+        return {
+            ...defaultProps,
+            ...rawProps
+        };
+    }
+}
+exports.BasicApp = BasicApp;
+exports.default = BasicApp;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spotInstanceApp.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/spotInstanceApp.ts"],"names":[],"mappings":"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","sourcesContent":["import AwsStack, { AwsStackProps } from \"../../resources/aws/base/awsStack\";\nimport { Vpc } from \"../../resources/aws/networking/vpc\";\nimport { ContainerSecret, ScalingType } from \"../../resources/aws/compute/ecs\";\nimport Ec2Cluster from \"../../resources/aws/compute/ecsSpot\";\nimport { Secret } from \"../../resources/aws/secrets\";\nimport { Ecr } from \"../../resources/aws/storage\";\nimport { SecretValue } from \"aws-cdk-lib\";\nimport { IManagedPolicy, PolicyDocument } from \"aws-cdk-lib/aws-iam\";\nimport { KeyValue } from \"../../types\";\nimport Database from \"../../resources/aws/database/databaseInstance\";\n\n/**\n * Intersected with BasicAppProps in the getProps method. This allows the BasicApp construct\n * to treat these as required properties and avoid constant null checking.\n */\nexport interface BasicAppPropDefaults {\n  serviceName: string;\n  clusterName: string;\n  scalingType: ScalingType;\n  containerPort: number;\n}\n\nexport interface BasicAppProps {\n  account?: string;\n  clusterName?: string;\n  containerEntryPoint?: string[];\n  containerCommand?: string[];\n  containerEnvironment?: KeyValue;\n  containerPort?: number;\n  containerSecrets?: string[];\n  accountName: string;\n  // The team/domain/business-unit that is responsible for this service\n  owner?: string;\n  parentDomain?: string; // Fix to make a dependency of protocol\n  environment: string;\n  listenerPort?: number;\n  region?: string;\n  scalingType?: ScalingType;\n  serviceName?: string;\n  taskRoleInlinePolicies?: {\n    [name: string]: PolicyDocument;\n  };\n  taskRoleManagedPolicies?: IManagedPolicy[];\n}\n\nexport class BasicApp {\n  private vpcStack: AwsStack;\n  private databaseStack: AwsStack;\n  private secretStack: AwsStack;\n  private computeStack: AwsStack;\n\n  constructor(id: string, rawProps: BasicAppProps) {\n    const props = this.getProps(id, rawProps);\n    const stackProps = this.getStackProps(props);\n\n    this.vpcStack = new AwsStack(`${id}Network`, [], stackProps)\n      .addNetwork(\n        Vpc.build(`${id}Vpc`, {\n          // environment: props.environment,\n          region: props.region\n        })\n      )\n      .addContainerRegistry(Ecr.build(`${id}Ecr`));\n\n    this.databaseStack = new AwsStack(\n      `${id}Database`,\n      this.vpcStack,\n      stackProps\n    )\n      .addNetwork(this.vpcStack.getNetwork())\n      .addResource(Database.build(`${id}Database`, {}));\n\n    // Fetches the dbResource from the databaseStack\n    const dbResource = this.databaseStack.getResource(\n      `${id}Database`\n    ) as Database;\n\n    const secretObjectValue: ContainerSecret = {};\n    if (props.containerSecrets) {\n      for (const secretObject of props.containerSecrets) {\n        secretObjectValue[secretObject] = SecretValue.unsafePlainText(\"\");\n      }\n    }\n\n    this.secretStack = new AwsStack(`${id}Secret`, [], stackProps).addResource(\n      Secret.build(`${id}Secret`, {\n        secretName: `/${props.clusterName}/${props.serviceName}`,\n        secretObjectValue: secretObjectValue\n      })\n    );\n\n    this.computeStack = new AwsStack(\n      `${id}Compute`,\n      [this.vpcStack, this.databaseStack, this.secretStack],\n      stackProps\n    )\n      .addNetwork(this.vpcStack.getNetwork())\n      .addResource(\n        Ec2Cluster.build(`${id}Fargate`, {\n          clusterName: props.clusterName,\n          //TODO: This should work via line 124, but doesn't work (at least on update)\n          databaseConnection: dbResource.databaseSecurityGroup.connections,\n          containerEntryPoint: props.containerEntryPoint,\n          containerCommand: props.containerCommand,\n          containerEnvironment: props.containerEnvironment,\n          containerPort: props.containerPort,\n          containerSecrets: secretObjectValue,\n          ecrRepository: this.vpcStack.getContainerRegistry(),\n          parentDomain: props.parentDomain?.toLowerCase(),\n          listenerPort: props.listenerPort,\n          serviceName: props.serviceName,\n          taskRoleInlinePolicies: props.taskRoleInlinePolicies,\n          taskRoleManagedPolicies: props.taskRoleManagedPolicies\n        })\n      )\n      .connect(`${id}Fargate`, `${id}Database`, 5432);\n  }\n\n  getStackProps(props: BasicAppProps): AwsStackProps | undefined {\n    if (!props) return;\n\n    return {\n      accountId: props.account,\n      region: props.region,\n      accountName: props.accountName\n    };\n  }\n\n  getProps(\n    id: string,\n    rawProps: BasicAppProps\n  ): BasicAppProps & BasicAppPropDefaults {\n    const defaultProps = {\n      scalingType: ScalingType.CPU,\n      containerPort: rawProps.containerPort || 3000,\n      serviceName: `${id}Service`,\n      clusterName: `${id}Cluster`,\n      containerEntryPoint: [\"node\", \"main.js\"],\n      containerCommand: rawProps.containerPort\n        ? [`${rawProps.containerPort}`]\n        : [`3000`]\n    };\n\n    return {\n      ...defaultProps,\n      ...rawProps\n    };\n  }\n}\nexport default BasicApp;\n"]}

package/dist/lib/resources/aws/audit/auditRole.d.ts

@@ -0,0 +1,32 @@
+import { Role } from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
+export interface AuditRoleConfig {
+    /**
+     * The AWS account ID of the Fjall webapp that will assume this role
+     */
+    webappAccountId: string;
+    /**
+     * The application name to scope the role's permissions to
+     */
+    appName: string;
+    /**
+     * External ID for additional security when assuming the role
+     */
+    externalId: string;
+    /**
+     * Optional role name prefix. Defaults to "FjallAudit"
+     */
+    roleNamePrefix?: string;
+    /**
+     * Optional IAM path for the role. Defaults to "/"
+     */
+    rolePath?: string;
+}
+/**
+ * Factory to build a cross-account audit IAM role that allows the Fjall webapp
+ * to use CloudQuery for comprehensive read-only auditing of AWS resources.
+ */
+export declare class AuditRoleFactory {
+    static build(id: string, config: AuditRoleConfig): (app: Construct, scope: Construct) => Role;
+}
+export default AuditRoleFactory;

package/dist/lib/resources/aws/audit/auditRole.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditRoleFactory = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_cdk_lib_2 = require("aws-cdk-lib");
+/**
+ * Factory to build a cross-account audit IAM role that allows the Fjall webapp
+ * to use CloudQuery for comprehensive read-only auditing of AWS resources.
+ */
+class AuditRoleFactory {
+    static build(id, config) {
+        return (app, scope) => {
+            const stack = aws_cdk_lib_1.Stack.of(scope);
+            const role = new aws_iam_1.Role(scope, id, {
+                roleName: `${config.roleNamePrefix || "FjallAudit"}-${config.appName}`,
+                path: config.rolePath || "/",
+                assumedBy: new aws_iam_1.AccountPrincipal(config.webappAccountId),
+                description: `Cross-account audit role for CloudQuery access to application: ${config.appName}`,
+                externalIds: [config.externalId],
+                managedPolicies: [
+                    // AWS managed policy for comprehensive read-only access
+                    aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName("ReadOnlyAccess"),
+                    // AWS managed policy for security auditing
+                    aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName("SecurityAudit")
+                ]
+            });
+            // Export the role ARN so it can be retrieved after deployment
+            new aws_cdk_lib_2.CfnOutput(scope, `${id}Arn`, {
+                value: role.roleArn,
+                description: `ARN of the audit role for ${config.appName}`,
+                exportName: `${config.appName}-AuditRoleArn`
+            });
+            // Export the external ID so it can be retrieved after deployment
+            new aws_cdk_lib_2.CfnOutput(scope, `${id}ExternalId`, {
+                value: config.externalId,
+                description: `External ID for the audit role for ${config.appName}`,
+                exportName: `${config.appName}-AuditRoleExternalId`
+            });
+            return role;
+        };
+    }
+}
+exports.AuditRoleFactory = AuditRoleFactory;
+exports.default = AuditRoleFactory;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/resources/aws/base/awsStack.js

@@ -27,9 +27,6 @@ class AwsStack {
         }
     }
     getCdkStack(id, props) {
-        if (process.env.JEST_WORKER_ID !== undefined) {
-            return new aws_cdk_lib_1.Stack(undefined, id, this.getStackProps(props)); // Create a mock stack for testing
-        }
         return new aws_cdk_lib_1.Stack(app_1.default.getInstance(), id, this.getStackProps(props));
     }
     getStackProps(props) {
@@ -109,4 +106,4 @@ class AwsStack {
 }
 exports.AwsStack = AwsStack;
 exports.default = AwsStack;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"awsStack.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/base/awsStack.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, type StackProps } from \"aws-cdk-lib\";\nimport { type IConnectable, Port } from \"aws-cdk-lib/aws-ec2\";\nimport { Construct } from \"constructs\";\n\nimport App from \"../../../app\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\n\nexport interface StackBuilder {\n  addConstruct(resource: Construct): StackBuilder;\n  addResource(fn: (stackBuilder: StackBuilder) => Construct): StackBuilder;\n\n  addNetwork(resource: Construct): StackBuilder;\n  addNetwork(fn: (stackBuilder: StackBuilder) => Construct): StackBuilder;\n  addNetwork(resource: Construct | string): StackBuilder;\n\n  getStack(): Stack;\n  getNetwork(): Construct;\n}\n\nexport interface AwsStackProps {\n  readonly accountId?: string;\n  readonly region?: string;\n  accountName?: string;\n}\n\nexport class AwsStack implements StackBuilder {\n  public readonly resources: {\n    [key: string]: Construct;\n  } = {};\n\n  private stack: Stack;\n  private network: Construct;\n  private containerRegistry: Repository;\n\n  constructor(\n    id: string,\n    dependencies?: AwsStack | AwsStack[],\n    props?: AwsStackProps\n  ) {\n    // Create inner CDK Stack\n    this.stack = this.getCdkStack(id, props);\n\n    // Register all stack dependencies\n    this.addDependencies(dependencies);\n  }\n\n  private addDependencies(dependencies?: AwsStack | AwsStack[]) {\n    if (!dependencies) return;\n\n    if (Array.isArray(dependencies)) {\n      for (const dependency of dependencies) {\n        this.stack.addDependency(dependency.getStack());\n      }\n    } else {\n      this.stack.addDependency(dependencies.getStack());\n    }\n  }\n\n  private getCdkStack(id: string, props?: AwsStackProps) {\n    if (process.env.JEST_WORKER_ID !== undefined) {\n      return new Stack(undefined, id, this.getStackProps(props)); // Create a mock stack for testing\n    }\n\n    return new Stack(App.getInstance(), id, this.getStackProps(props));\n  }\n\n  private getStackProps(\n    props: AwsStackProps | undefined\n  ): StackProps | undefined {\n    // If no explicit props are provided, fall back to the account/region that\n    // CDK resolved for this run. This allows context look-ups (e.g.\n    // Vpc.fromLookup) to work without every stack having to be created with\n    // explicit env settings.\n\n    if (!props) {\n      const account = process.env.CDK_DEFAULT_ACCOUNT;\n      const region = process.env.CDK_DEFAULT_REGION;\n\n      if (account && region) {\n        return { env: { account, region } } as StackProps;\n      }\n\n      return;\n    }\n\n    const stackProps: StackProps = {\n      env:\n        props.accountId && props.region\n          ? { account: props.accountId, region: props.region }\n          : undefined\n    };\n\n    return stackProps;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private isConnectable(arg: any): arg is IConnectable {\n    return arg.connections;\n  }\n\n  public addConstruct(construct: Construct): AwsStack {\n    this.resources[construct.node.id] = construct;\n    return this;\n  }\n\n  // @deprecated - use addConstruct instead\n  public addResource(fn: (stackBuilder: StackBuilder) => Construct): AwsStack {\n    const resource = fn(this);\n    this.resources[resource.node.id] = resource;\n    return this;\n  }\n\n  public addNetwork(resource: Construct): AwsStack;\n  public addNetwork(\n    resource: (stackBuilder: StackBuilder) => Construct\n  ): AwsStack;\n  public addNetwork(\n    resource: Construct | ((stackBuilder: StackBuilder) => Construct)\n  ): AwsStack {\n    const resourceActual =\n      resource instanceof Construct ? resource : resource(this);\n    this.resources[resourceActual.node.id] = resourceActual;\n    this.network = resourceActual;\n    return this;\n  }\n\n  public addContainerRegistry(resource: Repository): AwsStack;\n  public addContainerRegistry(\n    resource: (stackBuilder: StackBuilder) => Repository\n  ): AwsStack;\n  public addContainerRegistry(\n    resource: Repository | ((stackBuilder: StackBuilder) => Repository)\n  ): AwsStack {\n    const resourceActual =\n      resource instanceof Repository ? resource : resource(this);\n    this.resources[resourceActual.node.id] = resourceActual;\n    this.containerRegistry = resourceActual;\n    return this;\n  }\n\n  public getStack() {\n    return this.stack;\n  }\n\n  public getStackName() {\n    return this.stack.stackName;\n  }\n\n  public getNetwork() {\n    return this.network;\n  }\n\n  public getContainerRegistry() {\n    return this.containerRegistry;\n  }\n\n  public getResource(identifier: string) {\n    return this.resources[identifier];\n  }\n\n  public connect(\n    from: Construct | string,\n    to: Construct | string,\n    port?: number\n  ) {\n    if (!from || !to) return this;\n\n    const fromResource =\n      from instanceof Construct ? from : this.getResource(from);\n    const toResource = to instanceof Construct ? to : this.getResource(to);\n\n    if (!fromResource || !toResource) return this;\n\n    if (!this.isConnectable(fromResource) || !this.isConnectable(toResource))\n      return this;\n\n    const portActual = port ? Port.tcp(port) : Port.allTcp();\n    fromResource.connections.allowTo(toResource, portActual);\n\n    return this;\n  }\n}\nexport default AwsStack;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"awsStack.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/base/awsStack.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, type StackProps } from \"aws-cdk-lib\";\nimport { type IConnectable, Port } from \"aws-cdk-lib/aws-ec2\";\nimport { Construct } from \"constructs\";\n\nimport App from \"../../../app\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\n\nexport interface StackBuilder {\n  addConstruct(resource: Construct): StackBuilder;\n  addResource(fn: (stackBuilder: StackBuilder) => Construct): StackBuilder;\n\n  addNetwork(resource: Construct): StackBuilder;\n  addNetwork(fn: (stackBuilder: StackBuilder) => Construct): StackBuilder;\n  addNetwork(resource: Construct | string): StackBuilder;\n\n  getStack(): Stack;\n  getNetwork(): Construct;\n}\n\nexport interface AwsStackProps {\n  readonly accountId?: string;\n  readonly region?: string;\n  accountName?: string;\n}\n\nexport class AwsStack implements StackBuilder {\n  public readonly resources: {\n    [key: string]: Construct;\n  } = {};\n\n  private stack: Stack;\n  private network: Construct;\n  private containerRegistry: Repository;\n\n  constructor(\n    id: string,\n    dependencies?: AwsStack | AwsStack[],\n    props?: AwsStackProps\n  ) {\n    // Create inner CDK Stack\n    this.stack = this.getCdkStack(id, props);\n\n    // Register all stack dependencies\n    this.addDependencies(dependencies);\n  }\n\n  private addDependencies(dependencies?: AwsStack | AwsStack[]) {\n    if (!dependencies) return;\n\n    if (Array.isArray(dependencies)) {\n      for (const dependency of dependencies) {\n        this.stack.addDependency(dependency.getStack());\n      }\n    } else {\n      this.stack.addDependency(dependencies.getStack());\n    }\n  }\n\n  private getCdkStack(id: string, props?: AwsStackProps) {\n    return new Stack(App.getInstance(), id, this.getStackProps(props));\n  }\n\n  private getStackProps(\n    props: AwsStackProps | undefined\n  ): StackProps | undefined {\n    // If no explicit props are provided, fall back to the account/region that\n    // CDK resolved for this run. This allows context look-ups (e.g.\n    // Vpc.fromLookup) to work without every stack having to be created with\n    // explicit env settings.\n\n    if (!props) {\n      const account = process.env.CDK_DEFAULT_ACCOUNT;\n      const region = process.env.CDK_DEFAULT_REGION;\n\n      if (account && region) {\n        return { env: { account, region } } as StackProps;\n      }\n\n      return;\n    }\n\n    const stackProps: StackProps = {\n      env:\n        props.accountId && props.region\n          ? { account: props.accountId, region: props.region }\n          : undefined\n    };\n\n    return stackProps;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private isConnectable(arg: any): arg is IConnectable {\n    return arg.connections;\n  }\n\n  public addConstruct(construct: Construct): AwsStack {\n    this.resources[construct.node.id] = construct;\n    return this;\n  }\n\n  // @deprecated - use addConstruct instead\n  public addResource(fn: (stackBuilder: StackBuilder) => Construct): AwsStack {\n    const resource = fn(this);\n    this.resources[resource.node.id] = resource;\n    return this;\n  }\n\n  public addNetwork(resource: Construct): AwsStack;\n  public addNetwork(\n    resource: (stackBuilder: StackBuilder) => Construct\n  ): AwsStack;\n  public addNetwork(\n    resource: Construct | ((stackBuilder: StackBuilder) => Construct)\n  ): AwsStack {\n    const resourceActual =\n      resource instanceof Construct ? resource : resource(this);\n    this.resources[resourceActual.node.id] = resourceActual;\n    this.network = resourceActual;\n    return this;\n  }\n\n  public addContainerRegistry(resource: Repository): AwsStack;\n  public addContainerRegistry(\n    resource: (stackBuilder: StackBuilder) => Repository\n  ): AwsStack;\n  public addContainerRegistry(\n    resource: Repository | ((stackBuilder: StackBuilder) => Repository)\n  ): AwsStack {\n    const resourceActual =\n      resource instanceof Repository ? resource : resource(this);\n    this.resources[resourceActual.node.id] = resourceActual;\n    this.containerRegistry = resourceActual;\n    return this;\n  }\n\n  public getStack() {\n    return this.stack;\n  }\n\n  public getStackName() {\n    return this.stack.stackName;\n  }\n\n  public getNetwork() {\n    return this.network;\n  }\n\n  public getContainerRegistry() {\n    return this.containerRegistry;\n  }\n\n  public getResource(identifier: string) {\n    return this.resources[identifier];\n  }\n\n  public connect(\n    from: Construct | string,\n    to: Construct | string,\n    port?: number\n  ) {\n    if (!from || !to) return this;\n\n    const fromResource =\n      from instanceof Construct ? from : this.getResource(from);\n    const toResource = to instanceof Construct ? to : this.getResource(to);\n\n    if (!fromResource || !toResource) return this;\n\n    if (!this.isConnectable(fromResource) || !this.isConnectable(toResource))\n      return this;\n\n    const portActual = port ? Port.tcp(port) : Port.allTcp();\n    fromResource.connections.allowTo(toResource, portActual);\n\n    return this;\n  }\n}\nexport default AwsStack;\n"]}

package/dist/lib/resources/aws/compute/ec2.d.ts

@@ -16,6 +16,7 @@ interface Ec2InstanceProps extends StackProps {
     userData?: UserData;
     role?: Role;
     enableSSH?: boolean;
+    defaultPort?: number;
 }
 export declare class Ec2Instance extends Construct implements IConnectable {
     private launchTemplate;