@fjall/components-infrastructure 0.88.3 → 0.89.2

package/dist/lib/utils/connections.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Shared connection processor for unified connector interface.
+ *
+ * This module provides the `processConnections` function that handles
+ * both security group rules (IConnectable) and IAM grants (IGrantable)
+ * in a unified way.
+ *
+ * @example
+ * // In ECS service setup
+ * processConnections(
+ *   serviceProps.connections,
+ *   serviceData.taskRole,  // IGrantable for IAM
+ *   service               // IConnectable for security groups
+ * );
+ *
+ * @example
+ * // In Lambda setup
+ * processConnections(
+ *   props.connections,
+ *   this.lambdaFunction,  // IGrantable (execution role)
+ *   this.lambdaFunction   // IConnectable (security group)
+ * );
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processConnections = processConnections;
+const connector_js_1 = require("./connector.js");
+/** Default access levels for each connector type. */
+const DEFAULT_ACCESS = {
+    storage: "readWrite",
+    dynamodb: "readWrite",
+    queue: "full"
+};
+/** Grant storage access based on access level. */
+function processStorageConnection(connector, grantee, access) {
+    switch (access) {
+        case "read":
+            return connector.grantRead(grantee);
+        case "write":
+            return connector.grantWrite(grantee);
+        case "readWrite":
+            return connector.grantReadWrite(grantee);
+    }
+}
+/** Grant DynamoDB access based on access level. */
+function processDynamoDBConnection(connector, grantee, access) {
+    switch (access) {
+        case "read":
+            return connector.grantReadData(grantee);
+        case "write":
+            return connector.grantWriteData(grantee);
+        case "readWrite":
+            return connector.grantReadWriteData(grantee);
+    }
+}
+/** Grant queue access based on access level. */
+function processQueueConnection(connector, grantee, access) {
+    switch (access) {
+        case "send":
+            return connector.grantSendMessages(grantee);
+        case "consume":
+            return connector.grantConsumeMessages(grantee);
+        case "full":
+            return connector.grantFull(grantee);
+    }
+}
+/** Build an IAM connection result. */
+function buildIamResult(connector, grant) {
+    return { resource: connector, grant, connectionType: connector_js_1.CONNECTION_TYPE.IAM };
+}
+/** Build a security group connection result. */
+function buildSecurityGroupResult(resource) {
+    return { resource, connectionType: connector_js_1.CONNECTION_TYPE.SECURITY_GROUP };
+}
+/** Validate and narrow access type for storage/dynamodb connectors. */
+function validateConnectionAccess(access, connectorType, defaultAccess) {
+    if (access === undefined)
+        return defaultAccess;
+    if ((0, connector_js_1.isConnectionAccess)(access))
+        return access;
+    throw new Error(`Invalid access "${access}" for ${connectorType} connector. ` +
+        `Valid values: read, write, readWrite`);
+}
+/** Validate and narrow access type for queue connectors. */
+function validateMessagingAccess(access, defaultAccess) {
+    if (access === undefined)
+        return defaultAccess;
+    if ((0, connector_js_1.isMessagingAccess)(access))
+        return access;
+    throw new Error(`Invalid access "${access}" for queue connector. ` +
+        `Valid values: send, consume, full`);
+}
+/**
+ * Require IConnectable for security group operations.
+ * Throws a descriptive error if not provided.
+ */
+function requireConnectable(connectable, context) {
+    if (!connectable) {
+        throw new Error(`${context} requires an IConnectable to be provided. ` +
+            "Ensure the compute resource (ECS, EC2, Lambda with VPC) implements IConnectable.");
+    }
+}
+/**
+ * Process connections from compute resources to data resources.
+ *
+ * Handles the unified connector interface, dispatching to:
+ * - Security group rules for IConnectable and ISecurityGroupConnector resources
+ * - IAM grants for IStorageConnector, IDynamoDBConnector, and IQueueConnector resources
+ *
+ * @param connections - Array of connection specifications
+ * @param grantee - The IAM grantee (task role, execution role, etc.)
+ * @param connectable - Optional IConnectable for security group rules
+ * @returns Array of connection results
+ *
+ * @example
+ * processConnections(
+ *   [database, { resource: bucket, access: "read" }, queue],
+ *   taskRole,
+ *   service
+ * );
+ */
+function processConnections(connections, grantee, connectable) {
+    return connections.map((spec) => {
+        const { resource, access } = (0, connector_js_1.isConnectionConfig)(spec)
+            ? { resource: spec.resource, access: spec.access }
+            : { resource: spec, access: undefined };
+        // Handle unified connector interface (isConnector now returns AnyConnector)
+        if ((0, connector_js_1.isConnector)(resource)) {
+            switch (resource.connectorType) {
+                case "storage": {
+                    const validAccess = validateConnectionAccess(access, "storage", DEFAULT_ACCESS.storage);
+                    return buildIamResult(resource, processStorageConnection(resource, grantee, validAccess));
+                }
+                case "dynamodb": {
+                    const validAccess = validateConnectionAccess(access, "dynamodb", DEFAULT_ACCESS.dynamodb);
+                    return buildIamResult(resource, processDynamoDBConnection(resource, grantee, validAccess));
+                }
+                case "queue": {
+                    const validAccess = validateMessagingAccess(access, DEFAULT_ACCESS.queue);
+                    return buildIamResult(resource, processQueueConnection(resource, grantee, validAccess));
+                }
+                case "securityGroup":
+                case "relational": {
+                    requireConnectable(connectable, `${resource.connectorType} connector`);
+                    connectable.connections.allowToDefaultPort(resource);
+                    return buildSecurityGroupResult(resource);
+                }
+            }
+        }
+        // Legacy IConnectable path
+        if ((0, connector_js_1.isConnectable)(resource)) {
+            requireConnectable(connectable, "IConnectable resource");
+            connectable.connections.allowToDefaultPort(resource);
+            return buildSecurityGroupResult(resource);
+        }
+        throw new Error("Connection resource must be either an IConnector or IConnectable");
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connections.js","sourceRoot":"","sources":["../../../lib/utils/connections.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Shared connection processor for unified connector interface.\n *\n * This module provides the `processConnections` function that handles\n * both security group rules (IConnectable) and IAM grants (IGrantable)\n * in a unified way.\n *\n * @example\n * // In ECS service setup\n * processConnections(\n *   serviceProps.connections,\n *   serviceData.taskRole,  // IGrantable for IAM\n *   service               // IConnectable for security groups\n * );\n *\n * @example\n * // In Lambda setup\n * processConnections(\n *   props.connections,\n *   this.lambdaFunction,  // IGrantable (execution role)\n *   this.lambdaFunction   // IConnectable (security group)\n * );\n */\n\nimport { type IConnectable } from \"aws-cdk-lib/aws-ec2\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\nimport {\n  type ConnectionSpec,\n  type ConnectionResult,\n  type ConnectionAccess,\n  type MessagingAccess,\n  type AnyConnector,\n  type IStorageConnector,\n  type IDynamoDBConnector,\n  type IQueueConnector,\n  CONNECTION_TYPE,\n  isConnectionConfig,\n  isConnector,\n  isConnectable,\n  isConnectionAccess,\n  isMessagingAccess\n} from \"./connector.js\";\n\n/** Default access levels for each connector type. */\nconst DEFAULT_ACCESS = {\n  storage: \"readWrite\",\n  dynamodb: \"readWrite\",\n  queue: \"full\"\n} as const;\n\n/** Grant storage access based on access level. */\nfunction processStorageConnection(\n  connector: IStorageConnector,\n  grantee: IGrantable,\n  access: ConnectionAccess\n): Grant {\n  switch (access) {\n    case \"read\":\n      return connector.grantRead(grantee);\n    case \"write\":\n      return connector.grantWrite(grantee);\n    case \"readWrite\":\n      return connector.grantReadWrite(grantee);\n  }\n}\n\n/** Grant DynamoDB access based on access level. */\nfunction processDynamoDBConnection(\n  connector: IDynamoDBConnector,\n  grantee: IGrantable,\n  access: ConnectionAccess\n): Grant {\n  switch (access) {\n    case \"read\":\n      return connector.grantReadData(grantee);\n    case \"write\":\n      return connector.grantWriteData(grantee);\n    case \"readWrite\":\n      return connector.grantReadWriteData(grantee);\n  }\n}\n\n/** Grant queue access based on access level. */\nfunction processQueueConnection(\n  connector: IQueueConnector,\n  grantee: IGrantable,\n  access: MessagingAccess\n): Grant {\n  switch (access) {\n    case \"send\":\n      return connector.grantSendMessages(grantee);\n    case \"consume\":\n      return connector.grantConsumeMessages(grantee);\n    case \"full\":\n      return connector.grantFull(grantee);\n  }\n}\n\n/** Build an IAM connection result. */\nfunction buildIamResult(\n  connector: AnyConnector,\n  grant: Grant\n): ConnectionResult {\n  return { resource: connector, grant, connectionType: CONNECTION_TYPE.IAM };\n}\n\n/** Build a security group connection result. */\nfunction buildSecurityGroupResult(\n  resource: AnyConnector | IConnectable\n): ConnectionResult {\n  return { resource, connectionType: CONNECTION_TYPE.SECURITY_GROUP };\n}\n\n/** Validate and narrow access type for storage/dynamodb connectors. */\nfunction validateConnectionAccess(\n  access: ConnectionAccess | MessagingAccess | undefined,\n  connectorType: string,\n  defaultAccess: ConnectionAccess\n): ConnectionAccess {\n  if (access === undefined) return defaultAccess;\n  if (isConnectionAccess(access)) return access;\n  throw new Error(\n    `Invalid access \"${access}\" for ${connectorType} connector. ` +\n      `Valid values: read, write, readWrite`\n  );\n}\n\n/** Validate and narrow access type for queue connectors. */\nfunction validateMessagingAccess(\n  access: ConnectionAccess | MessagingAccess | undefined,\n  defaultAccess: MessagingAccess\n): MessagingAccess {\n  if (access === undefined) return defaultAccess;\n  if (isMessagingAccess(access)) return access;\n  throw new Error(\n    `Invalid access \"${access}\" for queue connector. ` +\n      `Valid values: send, consume, full`\n  );\n}\n\n/**\n * Require IConnectable for security group operations.\n * Throws a descriptive error if not provided.\n */\nfunction requireConnectable(\n  connectable: IConnectable | undefined,\n  context: string\n): asserts connectable is IConnectable {\n  if (!connectable) {\n    throw new Error(\n      `${context} requires an IConnectable to be provided. ` +\n        \"Ensure the compute resource (ECS, EC2, Lambda with VPC) implements IConnectable.\"\n    );\n  }\n}\n\n/**\n * Process connections from compute resources to data resources.\n *\n * Handles the unified connector interface, dispatching to:\n * - Security group rules for IConnectable and ISecurityGroupConnector resources\n * - IAM grants for IStorageConnector, IDynamoDBConnector, and IQueueConnector resources\n *\n * @param connections - Array of connection specifications\n * @param grantee - The IAM grantee (task role, execution role, etc.)\n * @param connectable - Optional IConnectable for security group rules\n * @returns Array of connection results\n *\n * @example\n * processConnections(\n *   [database, { resource: bucket, access: \"read\" }, queue],\n *   taskRole,\n *   service\n * );\n */\nexport function processConnections(\n  connections: ConnectionSpec[],\n  grantee: IGrantable,\n  connectable?: IConnectable\n): ConnectionResult[] {\n  return connections.map((spec) => {\n    const { resource, access } = isConnectionConfig(spec)\n      ? { resource: spec.resource, access: spec.access }\n      : { resource: spec, access: undefined };\n\n    // Handle unified connector interface (isConnector now returns AnyConnector)\n    if (isConnector(resource)) {\n      switch (resource.connectorType) {\n        case \"storage\": {\n          const validAccess = validateConnectionAccess(\n            access,\n            \"storage\",\n            DEFAULT_ACCESS.storage\n          );\n          return buildIamResult(\n            resource,\n            processStorageConnection(resource, grantee, validAccess)\n          );\n        }\n\n        case \"dynamodb\": {\n          const validAccess = validateConnectionAccess(\n            access,\n            \"dynamodb\",\n            DEFAULT_ACCESS.dynamodb\n          );\n          return buildIamResult(\n            resource,\n            processDynamoDBConnection(resource, grantee, validAccess)\n          );\n        }\n\n        case \"queue\": {\n          const validAccess = validateMessagingAccess(\n            access,\n            DEFAULT_ACCESS.queue\n          );\n          return buildIamResult(\n            resource,\n            processQueueConnection(resource, grantee, validAccess)\n          );\n        }\n\n        case \"securityGroup\":\n        case \"relational\": {\n          requireConnectable(\n            connectable,\n            `${resource.connectorType} connector`\n          );\n          connectable.connections.allowToDefaultPort(resource);\n          return buildSecurityGroupResult(resource);\n        }\n      }\n    }\n\n    // Legacy IConnectable path\n    if (isConnectable(resource)) {\n      requireConnectable(connectable, \"IConnectable resource\");\n      connectable.connections.allowToDefaultPort(resource);\n      return buildSecurityGroupResult(resource);\n    }\n\n    throw new Error(\n      \"Connection resource must be either an IConnector or IConnectable\"\n    );\n  });\n}\n"]}

package/dist/lib/utils/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/utils/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/utils/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"]}

package/dist/lib/utils/databaseTypes.d.ts

@@ -0,0 +1,85 @@
+import { type Duration } from "aws-cdk-lib";
+import { type IKey } from "aws-cdk-lib/aws-kms";
+import { type SubnetSelection } from "aws-cdk-lib/aws-ec2";
+export type DatabaseEngine = "postgresql" | "mysql";
+export interface EngineConfig {
+    defaultUsername: string;
+    sslParameters: Record<string, string>;
+    rotationAppName: string;
+}
+export interface ProxyConfig {
+    maxConnections?: number;
+    maxIdleConnections?: number;
+    connectionBorrowTimeout?: number;
+    requireTLS?: boolean;
+    vpcSubnets?: SubnetSelection;
+}
+export interface ReadReplicaConfig {
+    instanceType?: string;
+    availabilityZone?: string;
+}
+export interface CredentialsConfig {
+    username?: string;
+    secretRotation?: SecretRotationConfig | false;
+}
+export interface SecretRotationConfig {
+    automaticallyAfter?: Duration;
+}
+export interface EncryptionConfig {
+    storageKey?: EncryptionKeySpec;
+}
+/** Configuration for Database Insights (formerly Performance Insights). */
+export interface DatabaseInsightsConfig {
+    encryptionKey?: EncryptionKeySpec;
+    /** Database Insights mode. Default: "standard". */
+    mode?: "standard" | "advanced";
+}
+export interface AwsManagedKey {
+    readonly awsManaged: true;
+}
+export interface CustomerManagedKeyMarker {
+    readonly useCMK: true;
+}
+export type EncryptionKeySpec = IKey | AwsManagedKey | CustomerManagedKeyMarker;
+export declare function isAwsManagedKey(spec: EncryptionKeySpec | undefined): spec is AwsManagedKey;
+/**
+ * Type guard to check if CMK is explicitly requested.
+ */
+export declare function isCMKRequested(spec: EncryptionKeySpec | undefined): spec is CustomerManagedKeyMarker;
+/**
+ * Convenience constant for specifying AWS managed encryption (the default).
+ * @example
+ * encryption: { storageKey: AWS_MANAGED }
+ */
+export declare const AWS_MANAGED: AwsManagedKey;
+/**
+ * Convenience constant for explicitly requesting CMK.
+ * @example
+ * encryption: { storageKey: USE_CMK }
+ */
+export declare const USE_CMK: CustomerManagedKeyMarker;
+/**
+ * **DESTRUCTIVE**: Changing `storageKey` after cluster creation causes cluster REPLACEMENT.
+ */
+export interface AuroraEncryptionConfig {
+    /** DESTRUCTIVE: Changing after creation causes cluster replacement */
+    storageKey?: EncryptionKeySpec;
+}
+export interface AuroraReaderConfig {
+    scaleWithWriter?: boolean;
+    enableDatabaseInsights?: boolean;
+    identifierSuffix?: string;
+    availabilityZone?: string;
+}
+export interface AuroraWriterConfig {
+    enableDatabaseInsights?: boolean;
+    identifierSuffix?: string;
+    availabilityZone?: string;
+}
+export interface AuroraReadersConfig {
+    /** Mutually exclusive with instances */
+    count?: number;
+    /** Mutually exclusive with count */
+    instances?: AuroraReaderConfig[];
+    defaultEnableDatabaseInsights?: boolean;
+}

package/dist/lib/utils/databaseTypes.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USE_CMK = exports.AWS_MANAGED = void 0;
+exports.isAwsManagedKey = isAwsManagedKey;
+exports.isCMKRequested = isCMKRequested;
+// Type guard to check if the encryption key spec is AWS managed.
+function isAwsManagedKey(spec) {
+    return (spec !== undefined &&
+        typeof spec === "object" &&
+        "awsManaged" in spec &&
+        spec.awsManaged === true);
+}
+/**
+ * Type guard to check if CMK is explicitly requested.
+ */
+function isCMKRequested(spec) {
+    return (spec !== undefined &&
+        typeof spec === "object" &&
+        "useCMK" in spec &&
+        spec.useCMK === true);
+}
+/**
+ * Convenience constant for specifying AWS managed encryption (the default).
+ * @example
+ * encryption: { storageKey: AWS_MANAGED }
+ */
+exports.AWS_MANAGED = { awsManaged: true };
+/**
+ * Convenience constant for explicitly requesting CMK.
+ * @example
+ * encryption: { storageKey: USE_CMK }
+ */
+exports.USE_CMK = { useCMK: true };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/utils/dnsRecords.d.ts

@@ -0,0 +1,4 @@
+import { type Construct } from "constructs";
+import { type IHostedZone } from "aws-cdk-lib/aws-route53";
+import type { DnsRecordInput } from "./domainTypes";
+export declare function addDnsRecords(scope: Construct, zone: IHostedZone, zoneName: string, records: DnsRecordInput[]): void;