@fjall/components-infrastructure 0.86.1 → 0.87.3

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

@@ -147,4 +147,4 @@ class HostedZone extends constructs_1.Construct {
     }
 }
 exports.HostedZone = HostedZone;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hostedZone.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/hostedZone.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { CfnOutput, Fn, Stack, Tags } from \"aws-cdk-lib\";\nimport { Role } from \"../../resources/aws/iam\";\nimport {\n  OrganizationPrincipal,\n  PolicyDocument,\n  PolicyStatement\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  ARecord,\n  type ARecordProps,\n  CnameRecord,\n  type CnameRecordProps,\n  HostedZone as AWSHostedZone,\n  type IHostedZone,\n  MxRecord,\n  type MxRecordProps,\n  NsRecord,\n  type NsRecordProps,\n  TxtRecord,\n  type TxtRecordProps\n} from \"aws-cdk-lib/aws-route53\";\n\nimport { type AwsStack } from \"../../resources\";\n\nfunction getSafeZoneName(zoneName: string) {\n  return zoneName.split(\".\").join(\"\");\n}\n\nexport interface HostedZoneProps {\n  zoneName: string;\n  hostedZoneId?: string;\n}\n\nexport class HostedZoneFactory {\n  static import(stack: AwsStack, hostedZoneId: string, zoneName: string) {\n    const safeZoneName = getSafeZoneName(zoneName);\n\n    return new HostedZone(stack.getStack(), `${safeZoneName}HostedZone`, {\n      hostedZoneId: hostedZoneId,\n      zoneName: zoneName\n    });\n  }\n}\n\nexport class HostedZone extends Construct {\n  private hostedZone: AWSHostedZone;\n  private hostedZoneId: string;\n  private importedHostedZone: IHostedZone;\n  private zoneName: string;\n\n  private scope: Construct;\n\n  constructor(scope: Construct, id: string, props: HostedZoneProps) {\n    super(scope, id);\n\n    this.scope = scope;\n    this.zoneName = props.zoneName;\n\n    // If a hostedZoneId is provided import it, unless create a new hosted zone\n    if (!props.hostedZoneId) {\n      this.addHostedZone(props.zoneName);\n      this.hostedZoneId = this.hostedZone.hostedZoneId;\n      this.delegateHostedZone();\n    } else {\n      this.hostedZoneId = props.hostedZoneId;\n      this.importHostedZone(props.zoneName);\n    }\n  }\n\n  getInternalHostedZone() {\n    return this.hostedZone || this.importedHostedZone;\n  }\n\n  safeZoneName() {\n    return getSafeZoneName(this.zoneName);\n  }\n\n  addHostedZone(zoneName: string) {\n    this.hostedZone = new AWSHostedZone(\n      this,\n      `${this.safeZoneName}HostedZone`,\n      {\n        zoneName: zoneName,\n        comment: `Hosted Zone for ${zoneName}`\n      }\n    );\n  }\n\n  importHostedZone(zoneName: string) {\n    this.importedHostedZone = AWSHostedZone.fromHostedZoneAttributes(\n      // HostedZone.fromHostedZoneAttributes explicitly must be passed a stack as parent scope\n      this.scope,\n\n      // Use safeZoneName in the id so we can theoretically\n      //  import multiple hosted zones in a single app\n      `${this.safeZoneName()}ImportedHostedZone`,\n      {\n        hostedZoneId: this.hostedZoneId,\n        zoneName: zoneName\n      }\n    );\n\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:environment\",\n      \"management\"\n    );\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:service\",\n      \"hostedZone\"\n    );\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:domain\",\n      zoneName\n    );\n\n    // Make export name unique by including the stack name to avoid conflicts\n    // when multiple stacks import the same hosted zone\n    const stack = Stack.of(this);\n    const stackName = stack.stackName;\n    const exportName = `${stackName}${this.safeZoneName()}HostedZoneId`;\n\n    new CfnOutput(this, `${this.safeZoneName()}HostedZoneId`, {\n      key: `${this.safeZoneName()}HostedZoneId`,\n      value: this.hostedZoneId,\n      exportName: exportName\n    });\n  }\n\n  delegateHostedZone() {\n    const domainName = this.hostedZone.zoneName.split(\".\", 1);\n    const role = new Role(this, `${domainName}DelegateHostedZoneRole`, {\n      assumedBy: new OrganizationPrincipal(Fn.importValue(\"OrganisationId\")),\n      roleName: `${domainName}DelegateHostedZoneRole`,\n      inlinePolicies: {\n        [\"listHostedZones\"]: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              actions: [\"route53:ListHostedZonesByName\"],\n              resources: [\"*\"]\n            })\n          ]\n        }),\n        [\"changeResourceRecordSets\"]: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              actions: [\"route53:ChangeResourceRecordSets\"],\n              resources: [\n                `arn:aws:route53:::hostedzone/${this.hostedZone.hostedZoneId}`\n              ]\n            })\n          ]\n        })\n      }\n    });\n\n    this.hostedZone.grantDelegation(role);\n\n    new CfnOutput(this, \"DelegateHostedZoneRoleArn\", {\n      key: `${domainName}DelegateHostedZoneRoleArn`,\n      value: role.roleArn,\n      exportName: `${domainName}DelegateHostedZoneRoleArn`\n    });\n  }\n\n  public addARecord(props: Omit<ARecordProps, \"zone\">) {\n    new ARecord(this, \"ARecord\", {\n      zone: this.importedHostedZone,\n      recordName: props.recordName,\n      comment:\n        props.comment || `A Record for ${this.importedHostedZone.zoneName}`,\n      target: props.target,\n      ttl: props.ttl\n    });\n  }\n\n  public addCname(props: Omit<CnameRecordProps, \"zone\">) {\n    new CnameRecord(this, ``, {\n      domainName: props.domainName,\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `CNAME Record for ${this.importedHostedZone.zoneName}`,\n      ttl: props.ttl\n    });\n  }\n\n  public addMx(props: Omit<MxRecordProps, \"zone\">) {\n    new MxRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `MX Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n\n  public addNS(props: Omit<NsRecordProps, \"zone\">) {\n    new NsRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `NS Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n\n  public addTxt(props: Omit<TxtRecordProps, \"zone\">) {\n    new TxtRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `TXT Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hostedZone.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/hostedZone.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { CfnOutput, Fn, Stack, Tags } from \"aws-cdk-lib\";\nimport { Role } from \"../../resources/aws/iam\";\nimport {\n  OrganizationPrincipal,\n  PolicyDocument,\n  PolicyStatement\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  ARecord,\n  type ARecordProps,\n  CnameRecord,\n  type CnameRecordProps,\n  HostedZone as AWSHostedZone,\n  type IHostedZone,\n  MxRecord,\n  type MxRecordProps,\n  NsRecord,\n  type NsRecordProps,\n  TxtRecord,\n  type TxtRecordProps\n} from \"aws-cdk-lib/aws-route53\";\n\nimport { type AwsStack } from \"../../resources\";\n\nfunction getSafeZoneName(zoneName: string) {\n  return zoneName.split(\".\").join(\"\");\n}\n\nexport interface HostedZoneProps {\n  zoneName: string;\n  hostedZoneId?: string;\n}\n\nexport class HostedZoneFactory {\n  static import(stack: AwsStack, hostedZoneId: string, zoneName: string) {\n    const safeZoneName = getSafeZoneName(zoneName);\n\n    return new HostedZone(stack.getStack(), `${safeZoneName}HostedZone`, {\n      hostedZoneId: hostedZoneId,\n      zoneName: zoneName\n    });\n  }\n}\n\nexport class HostedZone extends Construct {\n  private hostedZone!: AWSHostedZone;\n  private hostedZoneId!: string;\n  private importedHostedZone!: IHostedZone;\n  private zoneName: string;\n\n  private scope: Construct;\n\n  constructor(scope: Construct, id: string, props: HostedZoneProps) {\n    super(scope, id);\n\n    this.scope = scope;\n    this.zoneName = props.zoneName;\n\n    // If a hostedZoneId is provided import it, unless create a new hosted zone\n    if (!props.hostedZoneId) {\n      this.addHostedZone(props.zoneName);\n      this.hostedZoneId = this.hostedZone.hostedZoneId;\n      this.delegateHostedZone();\n    } else {\n      this.hostedZoneId = props.hostedZoneId;\n      this.importHostedZone(props.zoneName);\n    }\n  }\n\n  getInternalHostedZone() {\n    return this.hostedZone || this.importedHostedZone;\n  }\n\n  safeZoneName() {\n    return getSafeZoneName(this.zoneName);\n  }\n\n  addHostedZone(zoneName: string) {\n    this.hostedZone = new AWSHostedZone(\n      this,\n      `${this.safeZoneName}HostedZone`,\n      {\n        zoneName: zoneName,\n        comment: `Hosted Zone for ${zoneName}`\n      }\n    );\n  }\n\n  importHostedZone(zoneName: string) {\n    this.importedHostedZone = AWSHostedZone.fromHostedZoneAttributes(\n      // HostedZone.fromHostedZoneAttributes explicitly must be passed a stack as parent scope\n      this.scope,\n\n      // Use safeZoneName in the id so we can theoretically\n      //  import multiple hosted zones in a single app\n      `${this.safeZoneName()}ImportedHostedZone`,\n      {\n        hostedZoneId: this.hostedZoneId,\n        zoneName: zoneName\n      }\n    );\n\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:environment\",\n      \"management\"\n    );\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:service\",\n      \"hostedZone\"\n    );\n    Tags.of(this.importedHostedZone).add(\n      \"fjall:costAllocation:domain\",\n      zoneName\n    );\n\n    // Make export name unique by including the stack name to avoid conflicts\n    // when multiple stacks import the same hosted zone\n    const stack = Stack.of(this);\n    const stackName = stack.stackName;\n    const exportName = `${stackName}${this.safeZoneName()}HostedZoneId`;\n\n    new CfnOutput(this, `${this.safeZoneName()}HostedZoneId`, {\n      key: `${this.safeZoneName()}HostedZoneId`,\n      value: this.hostedZoneId,\n      exportName: exportName\n    });\n  }\n\n  delegateHostedZone() {\n    const domainName = this.hostedZone.zoneName.split(\".\", 1);\n    const role = new Role(this, `${domainName}DelegateHostedZoneRole`, {\n      assumedBy: new OrganizationPrincipal(Fn.importValue(\"OrganisationId\")),\n      roleName: `${domainName}DelegateHostedZoneRole`,\n      inlinePolicies: {\n        [\"listHostedZones\"]: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              actions: [\"route53:ListHostedZonesByName\"],\n              resources: [\"*\"]\n            })\n          ]\n        }),\n        [\"changeResourceRecordSets\"]: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              actions: [\"route53:ChangeResourceRecordSets\"],\n              resources: [\n                `arn:aws:route53:::hostedzone/${this.hostedZone.hostedZoneId}`\n              ]\n            })\n          ]\n        })\n      }\n    });\n\n    this.hostedZone.grantDelegation(role);\n\n    new CfnOutput(this, \"DelegateHostedZoneRoleArn\", {\n      key: `${domainName}DelegateHostedZoneRoleArn`,\n      value: role.roleArn,\n      exportName: `${domainName}DelegateHostedZoneRoleArn`\n    });\n  }\n\n  public addARecord(props: Omit<ARecordProps, \"zone\">) {\n    new ARecord(this, \"ARecord\", {\n      zone: this.importedHostedZone,\n      recordName: props.recordName,\n      comment:\n        props.comment || `A Record for ${this.importedHostedZone.zoneName}`,\n      target: props.target,\n      ttl: props.ttl\n    });\n  }\n\n  public addCname(props: Omit<CnameRecordProps, \"zone\">) {\n    new CnameRecord(this, ``, {\n      domainName: props.domainName,\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `CNAME Record for ${this.importedHostedZone.zoneName}`,\n      ttl: props.ttl\n    });\n  }\n\n  public addMx(props: Omit<MxRecordProps, \"zone\">) {\n    new MxRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `MX Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n\n  public addNS(props: Omit<NsRecordProps, \"zone\">) {\n    new NsRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `NS Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n\n  public addTxt(props: Omit<TxtRecordProps, \"zone\">) {\n    new TxtRecord(this, ``, {\n      zone: this.importedHostedZone,\n      comment:\n        props.comment || `TXT Record for ${this.importedHostedZone.zoneName}`,\n      values: props.values,\n      ttl: props.ttl\n    });\n  }\n}\n"]}

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

@@ -10,3 +10,6 @@ export * from "./compute";
 export * from "./storage";
 export * from "./auditRole";
 export * from "./network";
+export * from "./cdn";
+export * from "./messaging";
+export * from "./pattern";

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

@@ -27,4 +27,7 @@ __exportStar(require("./compute"), exports);
 __exportStar(require("./storage"), exports);
 __exportStar(require("./auditRole"), exports);
 __exportStar(require("./network"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvcGF0dGVybnMvYXdzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3REFBc0M7QUFDdEMsb0RBQWtDO0FBQ2xDLG1EQUFpQztBQUNqQyw4Q0FBNEI7QUFDNUIsa0VBQWdEO0FBQ2hELGtEQUFnQztBQUNoQyw2Q0FBMkI7QUFDM0IsK0NBQTZCO0FBRTdCLFdBQVc7QUFDWCw0Q0FBMEI7QUFDMUIsNENBQTBCO0FBQzFCLDhDQUE0QjtBQUM1Qiw0Q0FBMEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9tYW5hZ2VkT3JnYW5pc2F0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tYW5hZ2VkUGxhdGZvcm1cIjtcbmV4cG9ydCAqIGZyb20gXCIuL21hbmFnZWRBY2NvdW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9idWlsZGtpdGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuLi8uLi9yZXNvdXJjZXMvYXdzL2NvbXB1dGUvZWMyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9maXZldHJhblByb3h5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kYXRhYmFzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vaG9zdGVkWm9uZVwiO1xuXG4vLyBQYXR0ZXJuc1xuZXhwb3J0ICogZnJvbSBcIi4vY29tcHV0ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3RvcmFnZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXVkaXRSb2xlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9uZXR3b3JrXCI7XG4iXX0=
+__exportStar(require("./cdn"), exports);
+__exportStar(require("./messaging"), exports);
+__exportStar(require("./pattern"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvcGF0dGVybnMvYXdzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3REFBc0M7QUFDdEMsb0RBQWtDO0FBQ2xDLG1EQUFpQztBQUNqQyw4Q0FBNEI7QUFDNUIsa0VBQWdEO0FBQ2hELGtEQUFnQztBQUNoQyw2Q0FBMkI7QUFDM0IsK0NBQTZCO0FBRTdCLFdBQVc7QUFDWCw0Q0FBMEI7QUFDMUIsNENBQTBCO0FBQzFCLDhDQUE0QjtBQUM1Qiw0Q0FBMEI7QUFDMUIsd0NBQXNCO0FBQ3RCLDhDQUE0QjtBQUM1Qiw0Q0FBMEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9tYW5hZ2VkT3JnYW5pc2F0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tYW5hZ2VkUGxhdGZvcm1cIjtcbmV4cG9ydCAqIGZyb20gXCIuL21hbmFnZWRBY2NvdW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9idWlsZGtpdGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuLi8uLi9yZXNvdXJjZXMvYXdzL2NvbXB1dGUvZWMyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9maXZldHJhblByb3h5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kYXRhYmFzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vaG9zdGVkWm9uZVwiO1xuXG4vLyBQYXR0ZXJuc1xuZXhwb3J0ICogZnJvbSBcIi4vY29tcHV0ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3RvcmFnZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXVkaXRSb2xlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9uZXR3b3JrXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jZG5cIjtcbmV4cG9ydCAqIGZyb20gXCIuL21lc3NhZ2luZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcGF0dGVyblwiO1xuIl19

package/dist/lib/patterns/aws/interfaces/compute.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Type-safe compute interfaces.
+ *
+ * These interfaces provide compile-time type safety for compute resources.
+ * Each compute type has a specific interface with only the methods that apply to it.
+ *
+ * @example
+ * const ecs = app.addCompute(ComputeFactory.build("Api", { type: "ecs", ... }));
+ * ecs.getLoadBalancer(); // ✓ Available on IEcsCompute
+ *
+ * const lambda = app.addCompute(ComputeFactory.build("Fn", { type: "lambda", ... }));
+ * lambda.getFunctionUrl(); // ✓ Available on ILambdaCompute
+ * lambda.getLoadBalancer(); // ✗ Compile error - not on ILambdaCompute
+ */
+import { type ICluster, type IBaseService } from "aws-cdk-lib/aws-ecs";
+import { type IApplicationLoadBalancer } from "aws-cdk-lib/aws-elasticloadbalancingv2";
+import { type IFunction } from "aws-cdk-lib/aws-lambda";
+import { type IAutoScalingGroup } from "aws-cdk-lib/aws-autoscaling";
+import { type ISecurityGroup, type IConnectable } from "aws-cdk-lib/aws-ec2";
+import { type IGrantable, type Grant } from "aws-cdk-lib/aws-iam";
+import { type Construct } from "constructs";
+/**
+ * Compute type discriminator.
+ * Used to determine which specific interface applies.
+ */
+export type ComputeType = "ecs" | "lambda" | "ec2";
+/**
+ * Base compute interface.
+ * All compute types implement this interface.
+ */
+export interface ICompute {
+    /** The type of compute resource. Used for runtime type narrowing. */
+    readonly computeType: ComputeType;
+    /** The underlying CDK construct node. */
+    readonly node: Construct["node"];
+}
+/**
+ * ECS compute interface.
+ * Provides access to ECS-specific resources like clusters, load balancers, and services.
+ */
+export interface IEcsCompute extends ICompute, IConnectable {
+    readonly computeType: "ecs";
+    /** Get the ECS cluster. */
+    getCluster(): ICluster;
+    /** Get the Application Load Balancer if one was created. */
+    getLoadBalancer(): IApplicationLoadBalancer | undefined;
+    /**
+     * Get a specific service by name.
+     * Returns IBaseService which is the common interface for both Fargate and EC2 services.
+     * @param name The service name
+     */
+    getService(name: string): IBaseService | undefined;
+    /** Get all services in the cluster. */
+    getAllServices(): IBaseService[];
+    /** Get the security group for the cluster. */
+    getSecurityGroup(): ISecurityGroup;
+}
+/**
+ * Lambda compute interface.
+ * Provides access to Lambda-specific resources like functions and function URLs.
+ * Extends IConnectable for VPC-based Lambdas that need security group connections.
+ */
+export interface ILambdaCompute extends ICompute, IConnectable {
+    readonly computeType: "lambda";
+    /**
+     * Get a Lambda function by name.
+     * If no name is provided and there's a single function, returns that function.
+     * @param name Optional function name
+     */
+    getFunction(name?: string): IFunction | undefined;
+    /** Get all Lambda functions. */
+    getAllFunctions(): IFunction[];
+    /**
+     * Get the function URL for a Lambda function.
+     * @param name Optional function name
+     */
+    getFunctionUrl(name?: string): string | undefined;
+    /**
+     * Get the security group for VPC-enabled Lambda functions.
+     * Returns undefined if the Lambda is not VPC-enabled.
+     */
+    getSecurityGroup(): ISecurityGroup | undefined;
+    /**
+     * Grant invoke permissions to a grantee.
+     * @param grantee The principal to grant invoke permissions to
+     * @param functionName Optional specific function name
+     */
+    grantInvoke(grantee: IGrantable, functionName?: string): Grant;
+}
+/**
+ * EC2 compute interface.
+ * Provides access to EC2-specific resources like Auto Scaling Groups and security groups.
+ */
+export interface IEc2Compute extends ICompute, IConnectable {
+    readonly computeType: "ec2";
+    /** Get the Auto Scaling Group. */
+    getAutoScalingGroup(): IAutoScalingGroup;
+    /** Get the security group. */
+    getSecurityGroup(): ISecurityGroup;
+}
+/**
+ * Union type representing any compute interface.
+ * Use with type guards for generic handling.
+ */
+export type AnyCompute = IEcsCompute | ILambdaCompute | IEc2Compute;
+/**
+ * Type guard to check if a compute is ECS.
+ */
+export declare function isEcsCompute(compute: ICompute): compute is IEcsCompute;
+/**
+ * Type guard to check if a compute is Lambda.
+ */
+export declare function isLambdaCompute(compute: ICompute): compute is ILambdaCompute;
+/**
+ * Type guard to check if a compute is EC2.
+ */
+export declare function isEc2Compute(compute: ICompute): compute is IEc2Compute;
+/**
+ * Type guard to check if a resource is any compute type.
+ */
+export declare function isCompute(resource: unknown): resource is ICompute;

package/dist/lib/patterns/aws/interfaces/compute.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Type-safe compute interfaces.
+ *
+ * These interfaces provide compile-time type safety for compute resources.
+ * Each compute type has a specific interface with only the methods that apply to it.
+ *
+ * @example
+ * const ecs = app.addCompute(ComputeFactory.build("Api", { type: "ecs", ... }));
+ * ecs.getLoadBalancer(); // ✓ Available on IEcsCompute
+ *
+ * const lambda = app.addCompute(ComputeFactory.build("Fn", { type: "lambda", ... }));
+ * lambda.getFunctionUrl(); // ✓ Available on ILambdaCompute
+ * lambda.getLoadBalancer(); // ✗ Compile error - not on ILambdaCompute
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEcsCompute = isEcsCompute;
+exports.isLambdaCompute = isLambdaCompute;
+exports.isEc2Compute = isEc2Compute;
+exports.isCompute = isCompute;
+/**
+ * Type guard to check if a compute is ECS.
+ */
+function isEcsCompute(compute) {
+    return compute.computeType === "ecs";
+}
+/**
+ * Type guard to check if a compute is Lambda.
+ */
+function isLambdaCompute(compute) {
+    return compute.computeType === "lambda";
+}
+/**
+ * Type guard to check if a compute is EC2.
+ */
+function isEc2Compute(compute) {
+    return compute.computeType === "ec2";
+}
+/**
+ * Type guard to check if a resource is any compute type.
+ */
+function isCompute(resource) {
+    return (resource !== null &&
+        typeof resource === "object" &&
+        "computeType" in resource &&
+        typeof resource.computeType === "string");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/patterns/aws/interfaces/connector.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Unified connector interface for bidirectional connections.
+ *
+ * This module provides a unified `IConnector` interface that enables
+ * bidirectional connections between compute resources (ECS, Lambda, EC2)
+ * and data resources (S3, DynamoDB, SQS, RDS).
+ *
+ * The connector pattern unifies:
+ * - Security group rules (IConnectable) for RDS, ECS, etc.
+ * - IAM grants for S3, DynamoDB, SQS
+ *
+ * @example
+ * // Simple connections (default permissions)
+ * const api = app.addCompute(ComputeFactory.build("Api", {
+ *   type: "ecs",
+ *   services: [{
+ *     name: "api",
+ *     capacityProvider: "FARGATE",
+ *     connections: [database, bucket, cache, queue]
+ *   }]
+ * }));
+ *
+ * @example
+ * // Explicit access levels
+ * const worker = app.addCompute(ComputeFactory.build("Worker", {
+ *   type: "ecs",
+ *   services: [{
+ *     name: "worker",
+ *     capacityProvider: "FARGATE",
+ *     connections: [
+ *       database,                              // Security group (RDS)
+ *       { resource: cache, access: "read" },   // Read-only DynamoDB
+ *       { resource: bucket, access: "write" }, // Write-only S3
+ *       { resource: queue, access: "consume" } // Consume-only SQS
+ *     ]
+ *   }]
+ * }));
+ */
+import { type IConnectable } from "aws-cdk-lib/aws-ec2";
+import { type IGrantable, type Grant } from "aws-cdk-lib/aws-iam";
+/**
+ * Connector type discriminator.
+ * - "storage": S3 buckets
+ * - "dynamodb": DynamoDB tables
+ * - "queue": SQS queues
+ * - "securityGroup": Resources with security groups (ECS, Lambda with VPC)
+ * - "relational": RDS databases (uses security groups)
+ */
+export type ConnectorType = "storage" | "dynamodb" | "queue" | "securityGroup" | "relational";
+/**
+ * Access level for storage and DynamoDB connectors.
+ */
+export type ConnectionAccess = "read" | "write" | "readWrite";
+/**
+ * Access level for messaging connectors (SQS).
+ */
+export type MessagingAccess = "send" | "consume" | "full";
+/**
+ * Base connector interface.
+ * All connector types implement this interface.
+ */
+export interface IConnector {
+    /** The type of connector resource. Used for runtime type narrowing. */
+    readonly connectorType: ConnectorType;
+}
+/**
+ * Storage connector interface (S3).
+ * Provides IAM grant methods for S3 bucket access.
+ */
+export interface IStorageConnector extends IConnector {
+    readonly connectorType: "storage";
+    /** Grant read permissions to the grantee. */
+    grantRead(grantee: IGrantable): Grant;
+    /** Grant write permissions to the grantee. */
+    grantWrite(grantee: IGrantable): Grant;
+    /** Grant read and write permissions to the grantee. */
+    grantReadWrite(grantee: IGrantable): Grant;
+}
+/**
+ * DynamoDB connector interface.
+ * Provides IAM grant methods for DynamoDB table access.
+ */
+export interface IDynamoDBConnector extends IConnector {
+    readonly connectorType: "dynamodb";
+    /** Grant read data permissions to the grantee. */
+    grantReadData(grantee: IGrantable): Grant;
+    /** Grant write data permissions to the grantee. */
+    grantWriteData(grantee: IGrantable): Grant;
+    /** Grant read and write data permissions to the grantee. */
+    grantReadWriteData(grantee: IGrantable): Grant;
+}
+/**
+ * Queue connector interface (SQS).
+ * Provides IAM grant methods for SQS queue access.
+ */
+export interface IQueueConnector extends IConnector {
+    readonly connectorType: "queue";
+    /** Grant send message permissions to the grantee. */
+    grantSendMessages(grantee: IGrantable): Grant;
+    /** Grant consume (receive and delete) message permissions to the grantee. */
+    grantConsumeMessages(grantee: IGrantable): Grant;
+    /** Grant full access (send and consume) to the grantee. */
+    grantFull(grantee: IGrantable): Grant;
+}
+/**
+ * Security group connector interface (RDS, ECS with VPC).
+ * Provides access to the security group connections for network-level access.
+ *
+ * Both "securityGroup" and "relational" types use this interface:
+ * - "relational": RDS databases (Aurora, Instance, GlobalAurora)
+ * - "securityGroup": Other resources requiring security group rules (ECS, EC2)
+ */
+export interface ISecurityGroupConnector extends IConnector {
+    readonly connectorType: "securityGroup" | "relational";
+    /** The security group connections for this resource. */
+    readonly connections: IConnectable["connections"];
+}
+/**
+ * Union type representing any connector interface.
+ */
+export type AnyConnector = IStorageConnector | IDynamoDBConnector | IQueueConnector | ISecurityGroupConnector;
+/**
+ * Connection configuration with explicit access level.
+ * Use this to specify non-default access levels.
+ */
+export interface ConnectionConfig {
+    /** The resource to connect to. */
+    resource: AnyConnector | IConnectable;
+    /** The access level to grant. Defaults vary by resource type. */
+    access?: ConnectionAccess | MessagingAccess;
+}
+/**
+ * Connection specification.
+ * Can be:
+ * - IConnectable: Legacy security group resource
+ * - AnyConnector: Unified connector resource
+ * - ConnectionConfig: Explicit access configuration
+ */
+export type ConnectionSpec = IConnectable | AnyConnector | ConnectionConfig;
+/** Connection result types. */
+export declare const CONNECTION_TYPE: {
+    readonly SECURITY_GROUP: "securityGroup";
+    readonly IAM: "iam";
+};
+export type ConnectionType = (typeof CONNECTION_TYPE)[keyof typeof CONNECTION_TYPE];
+/**
+ * Result of processing a connection.
+ * Contains the grant result for IAM-based connections.
+ */
+export interface ConnectionResult {
+    /** The resource that was connected. */
+    resource: AnyConnector | IConnectable;
+    /** The grant result if IAM permissions were granted. */
+    grant?: Grant;
+    /** The type of connection that was made. */
+    connectionType: ConnectionType;
+}
+/** Check if a value is a valid ConnectionAccess. */
+export declare function isConnectionAccess(value: unknown): value is ConnectionAccess;
+/** Check if a value is a valid MessagingAccess. */
+export declare function isMessagingAccess(value: unknown): value is MessagingAccess;
+/**
+ * Type guard to check if a resource is a connector.
+ * Returns AnyConnector for discriminated union narrowing in switch statements.
+ */
+export declare function isConnector(resource: unknown): resource is AnyConnector;
+/**
+ * Type guard to check if a resource is a CDK IConnectable.
+ * Checks for the `connections` property that IConnectable resources have.
+ */
+export declare function isConnectable(resource: unknown): resource is IConnectable;
+/**
+ * Type guard to check if a connection spec is a ConnectionConfig.
+ */
+export declare function isConnectionConfig(spec: ConnectionSpec): spec is ConnectionConfig;
+/** Type guard for storage connectors (S3 buckets). */
+export declare function isStorageConnector(connector: IConnector): connector is IStorageConnector;
+/** Type guard for DynamoDB connectors. */
+export declare function isDynamoDBConnector(connector: IConnector): connector is IDynamoDBConnector;
+/** Type guard for queue connectors (SQS queues). */
+export declare function isQueueConnector(connector: IConnector): connector is IQueueConnector;
+/** Type guard for security group connectors (RDS, ECS). */
+export declare function isSecurityGroupConnector(connector: IConnector): connector is ISecurityGroupConnector;

package/dist/lib/patterns/aws/interfaces/connector.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Unified connector interface for bidirectional connections.
+ *
+ * This module provides a unified `IConnector` interface that enables
+ * bidirectional connections between compute resources (ECS, Lambda, EC2)
+ * and data resources (S3, DynamoDB, SQS, RDS).
+ *
+ * The connector pattern unifies:
+ * - Security group rules (IConnectable) for RDS, ECS, etc.
+ * - IAM grants for S3, DynamoDB, SQS
+ *
+ * @example
+ * // Simple connections (default permissions)
+ * const api = app.addCompute(ComputeFactory.build("Api", {
+ *   type: "ecs",
+ *   services: [{
+ *     name: "api",
+ *     capacityProvider: "FARGATE",
+ *     connections: [database, bucket, cache, queue]
+ *   }]
+ * }));
+ *
+ * @example
+ * // Explicit access levels
+ * const worker = app.addCompute(ComputeFactory.build("Worker", {
+ *   type: "ecs",
+ *   services: [{
+ *     name: "worker",
+ *     capacityProvider: "FARGATE",
+ *     connections: [
+ *       database,                              // Security group (RDS)
+ *       { resource: cache, access: "read" },   // Read-only DynamoDB
+ *       { resource: bucket, access: "write" }, // Write-only S3
+ *       { resource: queue, access: "consume" } // Consume-only SQS
+ *     ]
+ *   }]
+ * }));
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONNECTION_TYPE = void 0;
+exports.isConnectionAccess = isConnectionAccess;
+exports.isMessagingAccess = isMessagingAccess;
+exports.isConnector = isConnector;
+exports.isConnectable = isConnectable;
+exports.isConnectionConfig = isConnectionConfig;
+exports.isStorageConnector = isStorageConnector;
+exports.isDynamoDBConnector = isDynamoDBConnector;
+exports.isQueueConnector = isQueueConnector;
+exports.isSecurityGroupConnector = isSecurityGroupConnector;
+/** Connection result types. */
+exports.CONNECTION_TYPE = {
+    SECURITY_GROUP: "securityGroup",
+    IAM: "iam"
+};
+const VALID_CONNECTION_ACCESS = [
+    "read",
+    "write",
+    "readWrite"
+];
+const VALID_MESSAGING_ACCESS = [
+    "send",
+    "consume",
+    "full"
+];
+/** Check if a value is a valid ConnectionAccess. */
+function isConnectionAccess(value) {
+    return (typeof value === "string" &&
+        VALID_CONNECTION_ACCESS.includes(value));
+}
+/** Check if a value is a valid MessagingAccess. */
+function isMessagingAccess(value) {
+    return (typeof value === "string" &&
+        VALID_MESSAGING_ACCESS.includes(value));
+}
+/**
+ * Type guard to check if a resource is a connector.
+ * Returns AnyConnector for discriminated union narrowing in switch statements.
+ */
+function isConnector(resource) {
+    return (resource !== null &&
+        typeof resource === "object" &&
+        "connectorType" in resource);
+}
+/**
+ * Type guard to check if a resource is a CDK IConnectable.
+ * Checks for the `connections` property that IConnectable resources have.
+ */
+function isConnectable(resource) {
+    return (resource !== null &&
+        typeof resource === "object" &&
+        "connections" in resource);
+}
+/**
+ * Type guard to check if a connection spec is a ConnectionConfig.
+ */
+function isConnectionConfig(spec) {
+    return spec !== null && typeof spec === "object" && "resource" in spec;
+}
+/** Type guard for storage connectors (S3 buckets). */
+function isStorageConnector(connector) {
+    return connector.connectorType === "storage";
+}
+/** Type guard for DynamoDB connectors. */
+function isDynamoDBConnector(connector) {
+    return connector.connectorType === "dynamodb";
+}
+/** Type guard for queue connectors (SQS queues). */
+function isQueueConnector(connector) {
+    return connector.connectorType === "queue";
+}
+/** Type guard for security group connectors (RDS, ECS). */
+function isSecurityGroupConnector(connector) {
+    return (connector.connectorType === "securityGroup" ||
+        connector.connectorType === "relational");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connector.js","sourceRoot":"","sources":["../../../../../lib/patterns/aws/interfaces/connector.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;;;AA2KH,gDAKC;AAGD,8CAKC;AAMD,kCAMC;AAMD,sCAMC;AAKD,gDAIC;AAGD,gDAIC;AAGD,kDAIC;AAGD,4CAIC;AAGD,4DAOC;AAjHD,+BAA+B;AAClB,QAAA,eAAe,GAAG;IAC7B,cAAc,EAAE,eAAe;IAC/B,GAAG,EAAE,KAAK;CACF,CAAC;AAoBX,MAAM,uBAAuB,GAAgC;IAC3D,MAAM;IACN,OAAO;IACP,WAAW;CACZ,CAAC;AACF,MAAM,sBAAsB,GAA+B;IACzD,MAAM;IACN,SAAS;IACT,MAAM;CACP,CAAC;AAEF,oDAAoD;AACpD,SAAgB,kBAAkB,CAAC,KAAc;IAC/C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,uBAAuB,CAAC,QAAQ,CAAC,KAAyB,CAAC,CAC5D,CAAC;AACJ,CAAC;AAED,mDAAmD;AACnD,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,sBAAsB,CAAC,QAAQ,CAAC,KAAwB,CAAC,CAC1D,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,WAAW,CAAC,QAAiB;IAC3C,OAAO,CACL,QAAQ,KAAK,IAAI;QACjB,OAAO,QAAQ,KAAK,QAAQ;QAC5B,eAAe,IAAI,QAAQ,CAC5B,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAAC,QAAiB;IAC7C,OAAO,CACL,QAAQ,KAAK,IAAI;QACjB,OAAO,QAAQ,KAAK,QAAQ;QAC5B,aAAa,IAAI,QAAQ,CAC1B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAChC,IAAoB;IAEpB,OAAO,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,UAAU,IAAI,IAAI,CAAC;AACzE,CAAC;AAED,sDAAsD;AACtD,SAAgB,kBAAkB,CAChC,SAAqB;IAErB,OAAO,SAAS,CAAC,aAAa,KAAK,SAAS,CAAC;AAC/C,CAAC;AAED,0CAA0C;AAC1C,SAAgB,mBAAmB,CACjC,SAAqB;IAErB,OAAO,SAAS,CAAC,aAAa,KAAK,UAAU,CAAC;AAChD,CAAC;AAED,oDAAoD;AACpD,SAAgB,gBAAgB,CAC9B,SAAqB;IAErB,OAAO,SAAS,CAAC,aAAa,KAAK,OAAO,CAAC;AAC7C,CAAC;AAED,2DAA2D;AAC3D,SAAgB,wBAAwB,CACtC,SAAqB;IAErB,OAAO,CACL,SAAS,CAAC,aAAa,KAAK,eAAe;QAC3C,SAAS,CAAC,aAAa,KAAK,YAAY,CACzC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Unified connector interface for bidirectional connections.\n *\n * This module provides a unified `IConnector` interface that enables\n * bidirectional connections between compute resources (ECS, Lambda, EC2)\n * and data resources (S3, DynamoDB, SQS, RDS).\n *\n * The connector pattern unifies:\n * - Security group rules (IConnectable) for RDS, ECS, etc.\n * - IAM grants for S3, DynamoDB, SQS\n *\n * @example\n * // Simple connections (default permissions)\n * const api = app.addCompute(ComputeFactory.build(\"Api\", {\n *   type: \"ecs\",\n *   services: [{\n *     name: \"api\",\n *     capacityProvider: \"FARGATE\",\n *     connections: [database, bucket, cache, queue]\n *   }]\n * }));\n *\n * @example\n * // Explicit access levels\n * const worker = app.addCompute(ComputeFactory.build(\"Worker\", {\n *   type: \"ecs\",\n *   services: [{\n *     name: \"worker\",\n *     capacityProvider: \"FARGATE\",\n *     connections: [\n *       database,                              // Security group (RDS)\n *       { resource: cache, access: \"read\" },   // Read-only DynamoDB\n *       { resource: bucket, access: \"write\" }, // Write-only S3\n *       { resource: queue, access: \"consume\" } // Consume-only SQS\n *     ]\n *   }]\n * }));\n */\n\nimport { type IConnectable } from \"aws-cdk-lib/aws-ec2\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\n\n/**\n * Connector type discriminator.\n * - \"storage\": S3 buckets\n * - \"dynamodb\": DynamoDB tables\n * - \"queue\": SQS queues\n * - \"securityGroup\": Resources with security groups (ECS, Lambda with VPC)\n * - \"relational\": RDS databases (uses security groups)\n */\nexport type ConnectorType =\n  | \"storage\"\n  | \"dynamodb\"\n  | \"queue\"\n  | \"securityGroup\"\n  | \"relational\";\n\n/**\n * Access level for storage and DynamoDB connectors.\n */\nexport type ConnectionAccess = \"read\" | \"write\" | \"readWrite\";\n\n/**\n * Access level for messaging connectors (SQS).\n */\nexport type MessagingAccess = \"send\" | \"consume\" | \"full\";\n\n/**\n * Base connector interface.\n * All connector types implement this interface.\n */\nexport interface IConnector {\n  /** The type of connector resource. Used for runtime type narrowing. */\n  readonly connectorType: ConnectorType;\n}\n\n/**\n * Storage connector interface (S3).\n * Provides IAM grant methods for S3 bucket access.\n */\nexport interface IStorageConnector extends IConnector {\n  readonly connectorType: \"storage\";\n\n  /** Grant read permissions to the grantee. */\n  grantRead(grantee: IGrantable): Grant;\n\n  /** Grant write permissions to the grantee. */\n  grantWrite(grantee: IGrantable): Grant;\n\n  /** Grant read and write permissions to the grantee. */\n  grantReadWrite(grantee: IGrantable): Grant;\n}\n\n/**\n * DynamoDB connector interface.\n * Provides IAM grant methods for DynamoDB table access.\n */\nexport interface IDynamoDBConnector extends IConnector {\n  readonly connectorType: \"dynamodb\";\n\n  /** Grant read data permissions to the grantee. */\n  grantReadData(grantee: IGrantable): Grant;\n\n  /** Grant write data permissions to the grantee. */\n  grantWriteData(grantee: IGrantable): Grant;\n\n  /** Grant read and write data permissions to the grantee. */\n  grantReadWriteData(grantee: IGrantable): Grant;\n}\n\n/**\n * Queue connector interface (SQS).\n * Provides IAM grant methods for SQS queue access.\n */\nexport interface IQueueConnector extends IConnector {\n  readonly connectorType: \"queue\";\n\n  /** Grant send message permissions to the grantee. */\n  grantSendMessages(grantee: IGrantable): Grant;\n\n  /** Grant consume (receive and delete) message permissions to the grantee. */\n  grantConsumeMessages(grantee: IGrantable): Grant;\n\n  /** Grant full access (send and consume) to the grantee. */\n  grantFull(grantee: IGrantable): Grant;\n}\n\n/**\n * Security group connector interface (RDS, ECS with VPC).\n * Provides access to the security group connections for network-level access.\n *\n * Both \"securityGroup\" and \"relational\" types use this interface:\n * - \"relational\": RDS databases (Aurora, Instance, GlobalAurora)\n * - \"securityGroup\": Other resources requiring security group rules (ECS, EC2)\n */\nexport interface ISecurityGroupConnector extends IConnector {\n  readonly connectorType: \"securityGroup\" | \"relational\";\n\n  /** The security group connections for this resource. */\n  readonly connections: IConnectable[\"connections\"];\n}\n\n/**\n * Union type representing any connector interface.\n */\nexport type AnyConnector =\n  | IStorageConnector\n  | IDynamoDBConnector\n  | IQueueConnector\n  | ISecurityGroupConnector;\n\n/**\n * Connection configuration with explicit access level.\n * Use this to specify non-default access levels.\n */\nexport interface ConnectionConfig {\n  /** The resource to connect to. */\n  resource: AnyConnector | IConnectable;\n\n  /** The access level to grant. Defaults vary by resource type. */\n  access?: ConnectionAccess | MessagingAccess;\n}\n\n/**\n * Connection specification.\n * Can be:\n * - IConnectable: Legacy security group resource\n * - AnyConnector: Unified connector resource\n * - ConnectionConfig: Explicit access configuration\n */\nexport type ConnectionSpec = IConnectable | AnyConnector | ConnectionConfig;\n\n/** Connection result types. */\nexport const CONNECTION_TYPE = {\n  SECURITY_GROUP: \"securityGroup\",\n  IAM: \"iam\"\n} as const;\n\nexport type ConnectionType =\n  (typeof CONNECTION_TYPE)[keyof typeof CONNECTION_TYPE];\n\n/**\n * Result of processing a connection.\n * Contains the grant result for IAM-based connections.\n */\nexport interface ConnectionResult {\n  /** The resource that was connected. */\n  resource: AnyConnector | IConnectable;\n\n  /** The grant result if IAM permissions were granted. */\n  grant?: Grant;\n\n  /** The type of connection that was made. */\n  connectionType: ConnectionType;\n}\n\nconst VALID_CONNECTION_ACCESS: readonly ConnectionAccess[] = [\n  \"read\",\n  \"write\",\n  \"readWrite\"\n];\nconst VALID_MESSAGING_ACCESS: readonly MessagingAccess[] = [\n  \"send\",\n  \"consume\",\n  \"full\"\n];\n\n/** Check if a value is a valid ConnectionAccess. */\nexport function isConnectionAccess(value: unknown): value is ConnectionAccess {\n  return (\n    typeof value === \"string\" &&\n    VALID_CONNECTION_ACCESS.includes(value as ConnectionAccess)\n  );\n}\n\n/** Check if a value is a valid MessagingAccess. */\nexport function isMessagingAccess(value: unknown): value is MessagingAccess {\n  return (\n    typeof value === \"string\" &&\n    VALID_MESSAGING_ACCESS.includes(value as MessagingAccess)\n  );\n}\n\n/**\n * Type guard to check if a resource is a connector.\n * Returns AnyConnector for discriminated union narrowing in switch statements.\n */\nexport function isConnector(resource: unknown): resource is AnyConnector {\n  return (\n    resource !== null &&\n    typeof resource === \"object\" &&\n    \"connectorType\" in resource\n  );\n}\n\n/**\n * Type guard to check if a resource is a CDK IConnectable.\n * Checks for the `connections` property that IConnectable resources have.\n */\nexport function isConnectable(resource: unknown): resource is IConnectable {\n  return (\n    resource !== null &&\n    typeof resource === \"object\" &&\n    \"connections\" in resource\n  );\n}\n\n/**\n * Type guard to check if a connection spec is a ConnectionConfig.\n */\nexport function isConnectionConfig(\n  spec: ConnectionSpec\n): spec is ConnectionConfig {\n  return spec !== null && typeof spec === \"object\" && \"resource\" in spec;\n}\n\n/** Type guard for storage connectors (S3 buckets). */\nexport function isStorageConnector(\n  connector: IConnector\n): connector is IStorageConnector {\n  return connector.connectorType === \"storage\";\n}\n\n/** Type guard for DynamoDB connectors. */\nexport function isDynamoDBConnector(\n  connector: IConnector\n): connector is IDynamoDBConnector {\n  return connector.connectorType === \"dynamodb\";\n}\n\n/** Type guard for queue connectors (SQS queues). */\nexport function isQueueConnector(\n  connector: IConnector\n): connector is IQueueConnector {\n  return connector.connectorType === \"queue\";\n}\n\n/** Type guard for security group connectors (RDS, ECS). */\nexport function isSecurityGroupConnector(\n  connector: IConnector\n): connector is ISecurityGroupConnector {\n  return (\n    connector.connectorType === \"securityGroup\" ||\n    connector.connectorType === \"relational\"\n  );\n}\n"]}