@fjall/components-infrastructure 0.88.1 → 0.88.4

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/env.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Declarative environment configuration utility.
+ *
+ * Resolves environment-specific values at CDK synth time without requiring
+ * an App instance. This allows `env()` to be used in `App.getApp()` arguments.
+ *
+ * @example
+ * ```ts
+ * import { App, env } from "@fjall/components-infrastructure";
+ *
+ * const app = App.getApp("myapp", {
+ *   network: { maxAzs: env({ default: 2, production: 3 }) }
+ * });
+ * ```
+ */
+type EnvConfig<T> = {
+    default: T;
+} & Partial<Record<string, T>>;
+/**
+ * Resolve the current deployment environment without App dependency.
+ *
+ * Resolution order:
+ * 1. Module cache (cached after first call)
+ * 2. `process.env.ENVIRONMENT`
+ * 3. `-c environment=<value>` from process.argv
+ * 4. `CDK_DEFAULT_ACCOUNT` → providerAccounts lookup
+ * 5. `-c accountName=<value>` → providerAccounts lookup
+ * 6. `"unknown"` (with warning)
+ */
+export declare function getEnvironment(): string;
+/**
+ * Resolve an environment-specific value at CDK synth time.
+ *
+ * @param config - Object with `default` key and optional environment overrides
+ * @returns The value for the current environment, or the default
+ */
+export declare function env<T>(config: EnvConfig<T>): T;
+/**
+ * Reset the environment cache. For testing only.
+ */
+export declare function _resetEnvironmentCache(): void;
+export {};

package/dist/lib/utils/env.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironment = getEnvironment;
+exports.env = env;
+exports._resetEnvironmentCache = _resetEnvironmentCache;
+const util_1 = require("@fjall/util");
+let cachedEnvironment;
+/**
+ * Resolve the current deployment environment without App dependency.
+ *
+ * Resolution order:
+ * 1. Module cache (cached after first call)
+ * 2. `process.env.ENVIRONMENT`
+ * 3. `-c environment=<value>` from process.argv
+ * 4. `CDK_DEFAULT_ACCOUNT` → providerAccounts lookup
+ * 5. `-c accountName=<value>` → providerAccounts lookup
+ * 6. `"unknown"` (with warning)
+ */
+function getEnvironment() {
+    if (cachedEnvironment !== undefined) {
+        return cachedEnvironment;
+    }
+    // 1. process.env.ENVIRONMENT
+    if (process.env.ENVIRONMENT) {
+        cachedEnvironment = process.env.ENVIRONMENT;
+        return cachedEnvironment;
+    }
+    // 2. -c environment=<value> from process.argv
+    const envFromArgv = parseContextArg("environment");
+    if (envFromArgv) {
+        cachedEnvironment = envFromArgv;
+        return cachedEnvironment;
+    }
+    // 3. CDK_DEFAULT_ACCOUNT → providerAccounts lookup
+    const accountId = process.env.CDK_DEFAULT_ACCOUNT;
+    if (accountId) {
+        const env = resolveEnvironmentFromAccountId(accountId);
+        if (env) {
+            cachedEnvironment = env;
+            return cachedEnvironment;
+        }
+    }
+    // 4. -c accountName=<value> → providerAccounts lookup
+    const accountName = parseContextArg("accountName");
+    if (accountName) {
+        const env = resolveEnvironmentFromAccountName(accountName);
+        if (env) {
+            cachedEnvironment = env;
+            return cachedEnvironment;
+        }
+    }
+    // 5. Fallback
+    console.warn("[fjall] Could not determine environment. " +
+        "Set ENVIRONMENT env var or pass -c environment=<value>.");
+    cachedEnvironment = "unknown";
+    return cachedEnvironment;
+}
+/**
+ * Resolve an environment-specific value at CDK synth time.
+ *
+ * @param config - Object with `default` key and optional environment overrides
+ * @returns The value for the current environment, or the default
+ */
+function env(config) {
+    const environment = getEnvironment();
+    if (environment in config) {
+        return config[environment];
+    }
+    return config.default;
+}
+/**
+ * Reset the environment cache. For testing only.
+ */
+function _resetEnvironmentCache() {
+    cachedEnvironment = undefined;
+}
+/**
+ * Parse a `-c key=value` argument from process.argv.
+ */
+function parseContextArg(key) {
+    const args = process.argv;
+    for (let i = 0; i < args.length - 1; i++) {
+        if (args[i] === "-c") {
+            const parts = args[i + 1].split("=");
+            if (parts[0] === key && parts.length >= 2) {
+                return parts.slice(1).join("=");
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Look up environment from account ID via fjall config providerAccounts.
+ */
+function resolveEnvironmentFromAccountId(accountId) {
+    try {
+        const config = util_1.Config.loadConfig();
+        const account = config.getProviderAccountById(accountId);
+        return account?.environment;
+    }
+    catch (err) {
+        // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.
+        if (process.env.FJALL_DEBUG) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[fjall] Config lookup by accountId failed: ${msg}\n`);
+        }
+        return undefined;
+    }
+}
+/**
+ * Look up environment from account name via fjall config providerAccounts.
+ */
+function resolveEnvironmentFromAccountName(accountName) {
+    try {
+        const config = util_1.Config.loadConfig();
+        const account = config.getProviderAccount(accountName);
+        return account?.environment;
+    }
+    catch (err) {
+        // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.
+        if (process.env.FJALL_DEBUG) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[fjall] Config lookup by accountName failed: ${msg}\n`);
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sourceRoot":"","sources":["../../../lib/utils/env.ts"],"names":[],"mappings":"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","sourcesContent":["import { Config as FjallConfig } from \"@fjall/util\";\n\n/**\n * Declarative environment configuration utility.\n *\n * Resolves environment-specific values at CDK synth time without requiring\n * an App instance. This allows `env()` to be used in `App.getApp()` arguments.\n *\n * @example\n * ```ts\n * import { App, env } from \"@fjall/components-infrastructure\";\n *\n * const app = App.getApp(\"myapp\", {\n *   network: { maxAzs: env({ default: 2, production: 3 }) }\n * });\n * ```\n */\n\ntype EnvConfig<T> = { default: T } & Partial<Record<string, T>>;\n\nlet cachedEnvironment: string | undefined;\n\n/**\n * Resolve the current deployment environment without App dependency.\n *\n * Resolution order:\n * 1. Module cache (cached after first call)\n * 2. `process.env.ENVIRONMENT`\n * 3. `-c environment=<value>` from process.argv\n * 4. `CDK_DEFAULT_ACCOUNT` → providerAccounts lookup\n * 5. `-c accountName=<value>` → providerAccounts lookup\n * 6. `\"unknown\"` (with warning)\n */\nexport function getEnvironment(): string {\n  if (cachedEnvironment !== undefined) {\n    return cachedEnvironment;\n  }\n\n  // 1. process.env.ENVIRONMENT\n  if (process.env.ENVIRONMENT) {\n    cachedEnvironment = process.env.ENVIRONMENT;\n    return cachedEnvironment;\n  }\n\n  // 2. -c environment=<value> from process.argv\n  const envFromArgv = parseContextArg(\"environment\");\n  if (envFromArgv) {\n    cachedEnvironment = envFromArgv;\n    return cachedEnvironment;\n  }\n\n  // 3. CDK_DEFAULT_ACCOUNT → providerAccounts lookup\n  const accountId = process.env.CDK_DEFAULT_ACCOUNT;\n  if (accountId) {\n    const env = resolveEnvironmentFromAccountId(accountId);\n    if (env) {\n      cachedEnvironment = env;\n      return cachedEnvironment;\n    }\n  }\n\n  // 4. -c accountName=<value> → providerAccounts lookup\n  const accountName = parseContextArg(\"accountName\");\n  if (accountName) {\n    const env = resolveEnvironmentFromAccountName(accountName);\n    if (env) {\n      cachedEnvironment = env;\n      return cachedEnvironment;\n    }\n  }\n\n  // 5. Fallback\n  console.warn(\n    \"[fjall] Could not determine environment. \" +\n      \"Set ENVIRONMENT env var or pass -c environment=<value>.\"\n  );\n  cachedEnvironment = \"unknown\";\n  return cachedEnvironment;\n}\n\n/**\n * Resolve an environment-specific value at CDK synth time.\n *\n * @param config - Object with `default` key and optional environment overrides\n * @returns The value for the current environment, or the default\n */\nexport function env<T>(config: EnvConfig<T>): T {\n  const environment = getEnvironment();\n\n  if (environment in config) {\n    return config[environment] as T;\n  }\n\n  return config.default;\n}\n\n/**\n * Reset the environment cache. For testing only.\n */\nexport function _resetEnvironmentCache(): void {\n  cachedEnvironment = undefined;\n}\n\n/**\n * Parse a `-c key=value` argument from process.argv.\n */\nfunction parseContextArg(key: string): string | undefined {\n  const args = process.argv;\n  for (let i = 0; i < args.length - 1; i++) {\n    if (args[i] === \"-c\") {\n      const parts = args[i + 1].split(\"=\");\n      if (parts[0] === key && parts.length >= 2) {\n        return parts.slice(1).join(\"=\");\n      }\n    }\n  }\n  return undefined;\n}\n\n/**\n * Look up environment from account ID via fjall config providerAccounts.\n */\nfunction resolveEnvironmentFromAccountId(\n  accountId: string\n): string | undefined {\n  try {\n    const config = FjallConfig.loadConfig();\n    const account = config.getProviderAccountById(accountId);\n    return account?.environment;\n  } catch (err) {\n    // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.\n    if (process.env.FJALL_DEBUG) {\n      const msg = err instanceof Error ? err.message : String(err);\n      process.stderr.write(\n        `[fjall] Config lookup by accountId failed: ${msg}\\n`\n      );\n    }\n    return undefined;\n  }\n}\n\n/**\n * Look up environment from account name via fjall config providerAccounts.\n */\nfunction resolveEnvironmentFromAccountName(\n  accountName: string\n): string | undefined {\n  try {\n    const config = FjallConfig.loadConfig();\n    const account = config.getProviderAccount(accountName);\n    return account?.environment;\n  } catch (err) {\n    // Config may not exist yet (first deploy, CI). Caller falls back to next strategy.\n    if (process.env.FJALL_DEBUG) {\n      const msg = err instanceof Error ? err.message : String(err);\n      process.stderr.write(\n        `[fjall] Config lookup by accountName failed: ${msg}\\n`\n      );\n    }\n    return undefined;\n  }\n}\n"]}

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

@@ -1,10 +1,8 @@
 import { type Account } from "@aws-sdk/client-organizations";
-import { type ICostAllocationTags } from "../config/aws";
 export interface Config {
     region: string;
     environment: string;
     existingAccounts: Account[];
-    costAllocationTags: ICostAllocationTags[];
     accountId?: string;
     accountName?: string;
     accountIds?: Record<string, string>;