@fjall/components-infrastructure 0.75.3 → 0.77.1

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

@@ -49,7 +49,7 @@ class ComputeFactory {
         return (app, scope) => {
             const computeProps = {
                 ...{
-                    vpc: app.getDefaultVpc(),
+                    vpc: app.getVpc(),
                     ecrRepository: app.getDefaultContainerRegistry()
                 },
                 ...props
@@ -92,8 +92,8 @@ class Compute extends constructs_1.Construct {
         this.compute = new ec2_1.Ec2Instance(this.scope, `${this.id}Ec2`, ec2Props);
         this.connections = this.compute.connections;
         if (props.connections) {
-            for (var conn of props.connections) {
-                this.compute.connections.allowTo(conn, aws_ec2_1.Port.allTcp());
+            for (const conn of props.connections) {
+                this.compute.connections.allowToDefaultPort(conn);
             }
         }
     }
@@ -129,8 +129,8 @@ class Compute extends constructs_1.Construct {
             this.compute = new ecs_1.default(this.scope, `${this.id}Fargate`, fargateProps);
         }
         if (props.connections) {
-            for (var conn of props.connections) {
-                this.compute.connections.allowTo(conn, aws_ec2_1.Port.allTcp());
+            for (const conn of props.connections) {
+                this.compute.connections.allowToDefaultPort(conn);
             }
         }
         this.connections = this.compute.connections;
@@ -158,7 +158,7 @@ class Compute extends constructs_1.Construct {
             memorySize: props.memorySize,
             lambdaDescription: props.lambdaDescription,
             roleDescription: props.roleDescription,
-            inlinePolicy: props.inlinePolicy || {},
+            inlinePolicy: props.inlinePolicy || [],
             enableFunctionUrl: props.enableFunctionUrl,
             functionUrlAuthType: props.functionUrlAuthType,
             functionUrlCors: convertCorsOptions(props.functionUrlCors),
@@ -171,4 +171,4 @@ class Compute extends constructs_1.Construct {
     }
 }
 exports.Compute = Compute;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compute.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/compute.ts"],"names":[],"mappings":"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","sourcesContent":["import { RepositoryImage } from \"aws-cdk-lib/aws-ecs\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\nimport {\n  Connections,\n  IConnectable,\n  IVpc,\n  Port,\n  SubnetType,\n  UserData,\n  IMachineImage\n} from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Code,\n  Runtime,\n  FunctionUrlAuthType,\n  HttpMethod,\n  FunctionUrlCorsOptions\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Duration } from \"aws-cdk-lib\";\nimport { PolicyDocument } from \"aws-cdk-lib/aws-iam\";\n\nimport { Construct } from \"constructs\";\n\nimport App from \"../../app\";\n\nimport FargateCluster, {\n  ContainerSecret,\n  FargateClusterProps,\n  Protocol,\n  ScalingType,\n  DomainConfig\n} from \"../../resources/aws/compute/ecs\";\nimport EcsFreeTier from \"../../resources/aws/compute/ecsFreeTier\";\nimport EcsSpot from \"../../resources/aws/compute/ecsSpot\";\nimport { Ec2Instance } from \"../../resources/aws/compute/ec2\";\nimport { LambdaFunction } from \"../../resources/aws/compute/lambda\";\nimport { KeyValue } from \"../../types\";\nimport { SecretImport } from \"../../resources/aws/secrets\";\n\n// User-friendly HTTP method type\nexport type HttpMethodString =\n  | \"GET\"\n  | \"POST\"\n  | \"PUT\"\n  | \"DELETE\"\n  | \"HEAD\"\n  | \"OPTIONS\"\n  | \"PATCH\";\n\n// User-friendly CORS options that accept string methods\nexport interface SimplifiedCorsOptions {\n  allowedOrigins?: string[];\n  allowedMethods?: HttpMethodString[];\n  allowedHeaders?: string[];\n  maxAge?: Duration;\n  allowCredentials?: boolean;\n  exposeHeaders?: string[];\n}\n\ninterface IComputeProps {\n  vpc?: IVpc;\n  ecrRepository?: Repository | RepositoryImage;\n\n  // Compute type selection\n  type?: \"ecs\" | \"ec2\" | \"lambda\";\n\n  // ECS subtype selection (only applicable when type is \"ecs\")\n  ecsType?: \"fargate\" | \"freetier\" | \"spot\";\n\n  // ECS-specific properties\n  parentDomain?: string;\n  domainConfig?: DomainConfig;\n\n  /**\n   * Path to Dockerfile for building custom image.\n   * Note: This is metadata for the CLI build process,\n   * not used during CDK synthesis\n   */\n  dockerfilePath?: string;\n\n  /**\n   * Port the container listens on (default: 80)\n   */\n  containerPort?: number;\n\n  /**\n   * Environmnet variables to pass to the container\n   */\n  containerEnvironment?: {\n    [key: string]: string;\n  };\n\n  /**\n   * Safely import secrets from another resource,\n   *  object key is used as name when passing to container\n   */\n  containerSecretsImport?: {\n    [key: string]: SecretImport;\n  };\n\n  // EC2-specific properties\n  instanceType?: string;\n  enableSSH?: boolean;\n  userData?: UserData;\n  machineImage?: IMachineImage;\n  minCapacity?: number;\n  maxCapacity?: number;\n\n  // Lambda-specific properties\n  runtime?: Runtime;\n  handler?: string;\n  code?: Code;\n  timeout?: number;\n  memorySize?: number;\n  lambdaDescription?: string;\n  roleDescription?: string;\n  inlinePolicy?: {\n    [name: string]: PolicyDocument;\n  };\n\n  // Lambda URL properties\n  enableFunctionUrl?: boolean;\n  functionUrlAuthType?: FunctionUrlAuthType;\n  functionUrlCors?: SimplifiedCorsOptions;\n\n  connections?: IConnectable[];\n}\n\n// Helper function to convert string HTTP methods to HttpMethod enum\nfunction convertHttpMethods(methods: HttpMethodString[]): HttpMethod[] {\n  const methodMap: Record<HttpMethodString, HttpMethod> = {\n    GET: HttpMethod.GET,\n    POST: HttpMethod.POST,\n    PUT: HttpMethod.PUT,\n    DELETE: HttpMethod.DELETE,\n    HEAD: HttpMethod.HEAD,\n    OPTIONS: HttpMethod.OPTIONS,\n    PATCH: HttpMethod.PATCH\n  };\n\n  return methods.map((method) => {\n    const httpMethod = methodMap[method];\n    if (!httpMethod) {\n      throw new Error(\n        `Invalid HTTP method: ${method}. Valid methods are: ${Object.keys(methodMap).join(\", \")}`\n      );\n    }\n    return httpMethod;\n  });\n}\n\n// Convert simplified CORS options to CDK CORS options\nfunction convertCorsOptions(\n  simplifiedCors?: SimplifiedCorsOptions\n): FunctionUrlCorsOptions | undefined {\n  if (!simplifiedCors) return undefined;\n\n  return {\n    allowedOrigins: simplifiedCors.allowedOrigins,\n    allowedMethods: simplifiedCors.allowedMethods\n      ? convertHttpMethods(simplifiedCors.allowedMethods)\n      : undefined,\n    allowedHeaders: simplifiedCors.allowedHeaders,\n    maxAge: simplifiedCors.maxAge,\n    allowCredentials: simplifiedCors.allowCredentials,\n    exposedHeaders: simplifiedCors.exposeHeaders\n  };\n}\n\nexport class ComputeFactory {\n  static build(id: string, props: IComputeProps) {\n    return (app: App, scope: Construct) => {\n      const computeProps = {\n        ...{\n          vpc: app.getDefaultVpc(),\n          ecrRepository: app.getDefaultContainerRegistry()\n        },\n        ...props\n      };\n\n      return new Compute(scope, id, computeProps);\n    };\n  }\n}\n\nexport class Compute extends Construct implements IConnectable {\n  public id: string;\n  public scope: Construct;\n  public vpc: IVpc;\n\n  public connections: Connections;\n\n  private compute:\n    | FargateCluster\n    | EcsFreeTier\n    | EcsSpot\n    | Ec2Instance\n    | LambdaFunction;\n\n  constructor(scope: Construct, id: string, props: IComputeProps) {\n    super(scope, id);\n    this.id = id;\n    this.scope = scope;\n\n    this.addCompute(props);\n  }\n\n  addCompute(props: IComputeProps) {\n    const computeType = props.type || \"ecs\";\n\n    if (computeType === \"ec2\") {\n      this.addEc2Compute(props);\n    } else if (computeType === \"lambda\") {\n      this.addLambdaCompute(props);\n    } else {\n      this.addEcsCompute(props);\n    }\n  }\n\n  private addEc2Compute(props: IComputeProps) {\n    const ec2Props = {\n      serviceName: `${this.id}Service`,\n      instanceType: props.instanceType || \"t3.micro\",\n      enableSSH: props.enableSSH || false,\n      userData: props.userData,\n      machineImage: props.machineImage,\n      minCapacity: props.minCapacity || 1,\n      maxCapacity: props.maxCapacity || 1,\n      vpc: props.vpc\n    };\n\n    this.compute = new Ec2Instance(this.scope, `${this.id}Ec2`, ec2Props);\n    this.connections = this.compute.connections;\n\n    if (props.connections) {\n      for (var conn of props.connections) {\n        this.compute.connections.allowTo(conn, Port.allTcp());\n      }\n    }\n  }\n\n  private addEcsCompute(props: IComputeProps) {\n    const ecsType = props.ecsType || \"fargate\";\n\n    // Common ECS props\n    const baseEcsProps = {\n      ...props,\n      containerPort: props.containerPort || 80,\n      serviceName: `${this.id}Service`,\n      clusterName: `${this.id}Cluster`,\n      ecrRepository: props.ecrRepository || \"amazon/amazon-ecs-sample\",\n      containerEnvironment: props.containerEnvironment || {},\n      containerSecretsImport: props.containerSecretsImport || {},\n      vpc: props.vpc\n    };\n\n    if (ecsType === \"freetier\") {\n      // Use EC2-based ECS for free tier\n      this.compute = new EcsFreeTier(\n        this.scope,\n        `${this.id}EcsFreeTier`,\n        baseEcsProps\n      );\n    } else if (ecsType === \"spot\") {\n      // Use EC2 Spot instances for cost optimization\n      this.compute = new EcsSpot(this.scope, `${this.id}EcsSpot`, baseEcsProps);\n    } else {\n      // Default to Fargate\n      const fargateProps = {\n        ...baseEcsProps,\n        scalingType: ScalingType.CPU,\n        protocol: props.domainConfig ? Protocol.HTTPS : Protocol.HTTP,\n        domainConfig: props.domainConfig\n      } as FargateClusterProps;\n\n      this.compute = new FargateCluster(\n        this.scope,\n        `${this.id}Fargate`,\n        fargateProps\n      );\n    }\n\n    if (props.connections) {\n      for (var conn of props.connections) {\n        this.compute.connections.allowTo(conn, Port.allTcp());\n      }\n    }\n\n    this.connections = this.compute.connections;\n  }\n\n  private addLambdaCompute(props: IComputeProps) {\n    let code = props.code;\n\n    if (!code) {\n      if (!props.ecrRepository) {\n        throw new Error(\n          \"Either code or ecrRepository must be provided for Lambda compute type\"\n        );\n      }\n\n      if (props.ecrRepository instanceof Repository) {\n        code = Code.fromEcrImage(props.ecrRepository, {\n          tagOrDigest: \"latest\"\n        });\n      } else {\n        throw new Error(\n          \"ecrRepository must be a Repository instance for Lambda compute type\"\n        );\n      }\n    }\n\n    const lambdaProps = {\n      code: code,\n      handler: props.handler || \"index.handler\",\n      runtime: props.runtime || Runtime.NODEJS_18_X,\n      timeout: props.timeout,\n      memorySize: props.memorySize,\n      lambdaDescription: props.lambdaDescription,\n      roleDescription: props.roleDescription,\n      inlinePolicy: props.inlinePolicy || {},\n      enableFunctionUrl: props.enableFunctionUrl,\n      functionUrlAuthType: props.functionUrlAuthType,\n      functionUrlCors: convertCorsOptions(props.functionUrlCors),\n      environment: props.containerEnvironment\n    };\n\n    this.compute = new LambdaFunction(\n      this.scope,\n      `${this.id}Lambda`,\n      lambdaProps\n    );\n\n    // Lambda functions don't use security groups unless VPC-enabled\n    // Create empty connections object for interface compatibility\n    this.connections = new Connections();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compute.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/compute.ts"],"names":[],"mappings":"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","sourcesContent":["import { type RepositoryImage } from \"aws-cdk-lib/aws-ecs\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\nimport {\n  Connections,\n  type IConnectable,\n  type IVpc,\n  type UserData,\n  type IMachineImage\n} from \"aws-cdk-lib/aws-ec2\";\nimport {\n  Code,\n  Runtime,\n  type FunctionUrlAuthType,\n  HttpMethod,\n  type FunctionUrlCorsOptions\n} from \"aws-cdk-lib/aws-lambda\";\nimport { type Duration } from \"aws-cdk-lib\";\nimport { type PolicyStatement } from \"aws-cdk-lib/aws-iam\";\n\nimport { Construct } from \"constructs\";\n\nimport type App from \"../../app\";\n\nimport FargateCluster, {\n  type FargateClusterProps,\n  Protocol,\n  ScalingType,\n  type DomainConfig\n} from \"../../resources/aws/compute/ecs\";\nimport EcsFreeTier from \"../../resources/aws/compute/ecsFreeTier\";\nimport EcsSpot from \"../../resources/aws/compute/ecsSpot\";\nimport { Ec2Instance } from \"../../resources/aws/compute/ec2\";\nimport { LambdaFunction } from \"../../resources/aws/compute/lambda\";\nimport { type SecretImport } from \"../../resources/aws/secrets\";\n\n// User-friendly HTTP method type\nexport type HttpMethodString =\n  | \"GET\"\n  | \"POST\"\n  | \"PUT\"\n  | \"DELETE\"\n  | \"HEAD\"\n  | \"OPTIONS\"\n  | \"PATCH\";\n\n// User-friendly CORS options that accept string methods\nexport interface SimplifiedCorsOptions {\n  allowedOrigins?: string[];\n  allowedMethods?: HttpMethodString[];\n  allowedHeaders?: string[];\n  maxAge?: Duration;\n  allowCredentials?: boolean;\n  exposeHeaders?: string[];\n}\n\ninterface IComputeProps {\n  vpc?: IVpc;\n  ecrRepository?: Repository | RepositoryImage;\n\n  // Compute type selection\n  type?: \"ecs\" | \"ec2\" | \"lambda\";\n\n  // ECS subtype selection (only applicable when type is \"ecs\")\n  ecsType?: \"fargate\" | \"freetier\" | \"spot\";\n\n  // ECS-specific properties\n  parentDomain?: string;\n  domainConfig?: DomainConfig;\n\n  /**\n   * Path to Dockerfile for building custom image.\n   * Note: This is metadata for the CLI build process,\n   * not used during CDK synthesis\n   */\n  dockerfilePath?: string;\n\n  /**\n   * Port the container listens on (default: 80)\n   */\n  containerPort?: number;\n\n  /**\n   * CPU units for Fargate tasks (256, 512, 1024, 2048, 4096)\n   */\n  cpu?: number;\n\n  /**\n   * Memory in MiB for Fargate tasks (512-30720)\n   */\n  memoryLimitMiB?: number;\n\n  /**\n   * Environmnet variables to pass to the container\n   */\n  containerEnvironment?: {\n    [key: string]: string;\n  };\n\n  /**\n   * Safely import secrets from another resource,\n   *  object key is used as name when passing to container\n   */\n  containerSecretsImport?: {\n    [key: string]: SecretImport;\n  };\n\n  // EC2-specific properties\n  instanceType?: string;\n  enableSSH?: boolean;\n  userData?: UserData;\n  machineImage?: IMachineImage;\n  minCapacity?: number;\n  maxCapacity?: number;\n\n  // Lambda-specific properties\n  runtime?: Runtime;\n  handler?: string;\n  code?: Code;\n  timeout?: number;\n  memorySize?: number;\n  lambdaDescription?: string;\n  roleDescription?: string;\n  inlinePolicy?: PolicyStatement[];\n\n  // Lambda URL properties\n  enableFunctionUrl?: boolean;\n  functionUrlAuthType?: FunctionUrlAuthType;\n  functionUrlCors?: SimplifiedCorsOptions;\n\n  connections?: IConnectable[];\n}\n\n// Helper function to convert string HTTP methods to HttpMethod enum\nfunction convertHttpMethods(methods: HttpMethodString[]): HttpMethod[] {\n  const methodMap: Record<HttpMethodString, HttpMethod> = {\n    GET: HttpMethod.GET,\n    POST: HttpMethod.POST,\n    PUT: HttpMethod.PUT,\n    DELETE: HttpMethod.DELETE,\n    HEAD: HttpMethod.HEAD,\n    OPTIONS: HttpMethod.OPTIONS,\n    PATCH: HttpMethod.PATCH\n  };\n\n  return methods.map((method) => {\n    const httpMethod = methodMap[method];\n    if (!httpMethod) {\n      throw new Error(\n        `Invalid HTTP method: ${method}. Valid methods are: ${Object.keys(methodMap).join(\", \")}`\n      );\n    }\n    return httpMethod;\n  });\n}\n\n// Convert simplified CORS options to CDK CORS options\nfunction convertCorsOptions(\n  simplifiedCors?: SimplifiedCorsOptions\n): FunctionUrlCorsOptions | undefined {\n  if (!simplifiedCors) return undefined;\n\n  return {\n    allowedOrigins: simplifiedCors.allowedOrigins,\n    allowedMethods: simplifiedCors.allowedMethods\n      ? convertHttpMethods(simplifiedCors.allowedMethods)\n      : undefined,\n    allowedHeaders: simplifiedCors.allowedHeaders,\n    maxAge: simplifiedCors.maxAge,\n    allowCredentials: simplifiedCors.allowCredentials,\n    exposedHeaders: simplifiedCors.exposeHeaders\n  };\n}\n\nexport class ComputeFactory {\n  static build(id: string, props: IComputeProps) {\n    return (app: App, scope: Construct) => {\n      const computeProps = {\n        ...{\n          vpc: app.getVpc(),\n          ecrRepository: app.getDefaultContainerRegistry()\n        },\n        ...props\n      };\n\n      return new Compute(scope, id, computeProps);\n    };\n  }\n}\n\nexport class Compute extends Construct implements IConnectable {\n  public id: string;\n  public scope: Construct;\n  public vpc: IVpc;\n\n  public connections: Connections;\n\n  private compute:\n    | FargateCluster\n    | EcsFreeTier\n    | EcsSpot\n    | Ec2Instance\n    | LambdaFunction;\n\n  constructor(scope: Construct, id: string, props: IComputeProps) {\n    super(scope, id);\n    this.id = id;\n    this.scope = scope;\n\n    this.addCompute(props);\n  }\n\n  addCompute(props: IComputeProps) {\n    const computeType = props.type || \"ecs\";\n\n    if (computeType === \"ec2\") {\n      this.addEc2Compute(props);\n    } else if (computeType === \"lambda\") {\n      this.addLambdaCompute(props);\n    } else {\n      this.addEcsCompute(props);\n    }\n  }\n\n  private addEc2Compute(props: IComputeProps) {\n    const ec2Props = {\n      serviceName: `${this.id}Service`,\n      instanceType: props.instanceType || \"t3.micro\",\n      enableSSH: props.enableSSH || false,\n      userData: props.userData,\n      machineImage: props.machineImage,\n      minCapacity: props.minCapacity || 1,\n      maxCapacity: props.maxCapacity || 1,\n      vpc: props.vpc\n    };\n\n    this.compute = new Ec2Instance(this.scope, `${this.id}Ec2`, ec2Props);\n    this.connections = this.compute.connections;\n\n    if (props.connections) {\n      for (const conn of props.connections) {\n        this.compute.connections.allowToDefaultPort(conn);\n      }\n    }\n  }\n\n  private addEcsCompute(props: IComputeProps) {\n    const ecsType = props.ecsType || \"fargate\";\n\n    // Common ECS props\n    const baseEcsProps = {\n      ...props,\n      containerPort: props.containerPort || 80,\n      serviceName: `${this.id}Service`,\n      clusterName: `${this.id}Cluster`,\n      ecrRepository: props.ecrRepository || \"amazon/amazon-ecs-sample\",\n      containerEnvironment: props.containerEnvironment || {},\n      containerSecretsImport: props.containerSecretsImport || {},\n      vpc: props.vpc\n    };\n\n    if (ecsType === \"freetier\") {\n      // Use EC2-based ECS for free tier\n      this.compute = new EcsFreeTier(\n        this.scope,\n        `${this.id}EcsFreeTier`,\n        baseEcsProps\n      );\n    } else if (ecsType === \"spot\") {\n      // Use EC2 Spot instances for cost optimization\n      this.compute = new EcsSpot(this.scope, `${this.id}EcsSpot`, baseEcsProps);\n    } else {\n      // Default to Fargate\n      const fargateProps = {\n        ...baseEcsProps,\n        scalingType: ScalingType.CPU,\n        protocol: props.domainConfig ? Protocol.HTTPS : Protocol.HTTP,\n        domainConfig: props.domainConfig\n      } as FargateClusterProps;\n\n      this.compute = new FargateCluster(\n        this.scope,\n        `${this.id}Fargate`,\n        fargateProps\n      );\n    }\n\n    if (props.connections) {\n      for (const conn of props.connections) {\n        this.compute.connections.allowToDefaultPort(conn);\n      }\n    }\n\n    this.connections = this.compute.connections;\n  }\n\n  private addLambdaCompute(props: IComputeProps) {\n    let code = props.code;\n\n    if (!code) {\n      if (!props.ecrRepository) {\n        throw new Error(\n          \"Either code or ecrRepository must be provided for Lambda compute type\"\n        );\n      }\n\n      if (props.ecrRepository instanceof Repository) {\n        code = Code.fromEcrImage(props.ecrRepository, {\n          tagOrDigest: \"latest\"\n        });\n      } else {\n        throw new Error(\n          \"ecrRepository must be a Repository instance for Lambda compute type\"\n        );\n      }\n    }\n\n    const lambdaProps = {\n      code: code,\n      handler: props.handler || \"index.handler\",\n      runtime: props.runtime || Runtime.NODEJS_18_X,\n      timeout: props.timeout,\n      memorySize: props.memorySize,\n      lambdaDescription: props.lambdaDescription,\n      roleDescription: props.roleDescription,\n      inlinePolicy: props.inlinePolicy || [],\n      enableFunctionUrl: props.enableFunctionUrl,\n      functionUrlAuthType: props.functionUrlAuthType,\n      functionUrlCors: convertCorsOptions(props.functionUrlCors),\n      environment: props.containerEnvironment\n    };\n\n    this.compute = new LambdaFunction(\n      this.scope,\n      `${this.id}Lambda`,\n      lambdaProps\n    );\n\n    // Lambda functions don't use security groups unless VPC-enabled\n    // Create empty connections object for interface compatibility\n    this.connections = new Connections();\n  }\n}\n"]}

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

@@ -1,33 +1,194 @@
-import { Stack } from "aws-cdk-lib";
 import { Construct } from "constructs";
-import { Connections, IConnectable, IVpc, SubnetType } from "aws-cdk-lib/aws-ec2";
-interface ExistingVpcConfig {
-    vpcId?: string;
-    subnetType?: SubnetType;
-}
-interface NewVpcConfig {
-    subnetType?: SubnetType;
-    accountId: string;
-}
-type VpcProps = ExistingVpcConfig | NewVpcConfig;
-type DatabaseType = "Aurora" | "Instance" | "FreeTier";
-interface DatabaseProps {
-    type: DatabaseType;
-    databaseName: string;
-    vpc: VpcProps;
-    tags: {
-        [key: string]: string;
+import type App from "../../app";
+import { type Secret } from "../../resources/aws/secrets";
+import { type Connections, type IConnectable, type IVpc, type SubnetSelection } from "aws-cdk-lib/aws-ec2";
+import { type IInstanceEngine, type IClusterEngine } from "aws-cdk-lib/aws-rds";
+import { type Duration } from "aws-cdk-lib";
+import { type IKey } from "aws-cdk-lib/aws-kms";
+export type DatabaseEngine = "postgresql" | "mysql";
+export interface EngineConfig {
+    defaultUsername: string;
+    sslParameters: Record<string, string>;
+    rotationAppName: string;
+}
+export declare const DATABASE_ENGINE_CONFIG: Record<DatabaseEngine, {
+    aurora: {
+        version: string;
+        majorVersion: string;
     };
+    instance: {
+        version: string;
+        majorVersion: string;
+    };
+    defaultUsername: string;
+    sslParameters: Record<string, string>;
+    rotationAppName: string;
+}>;
+export declare function getAuroraClusterEngine(engine: DatabaseEngine): IClusterEngine;
+export declare function getInstanceEngine(engine: DatabaseEngine): IInstanceEngine;
+export declare function getEngineConfig(engine: DatabaseEngine): EngineConfig;
+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;
+}
+export type PerformanceInsightsRetentionPeriod = 7 | 31 | 93 | 186 | 372 | 731;
+export interface PerformanceInsightsConfig {
+    encryptionKey?: EncryptionKeySpec;
+    /** Retention period in days. Default: 31 (1 month). */
+    retentionPeriod?: PerformanceInsightsRetentionPeriod;
 }
+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;
 /**
- * @deprecated Use Storage instead
+ * Type guard to check if CMK is explicitly requested.
  */
-export declare class Database extends Stack implements IConnectable {
-    connections: Connections;
+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;
+    enablePerformanceInsights?: boolean;
+    identifierSuffix?: string;
+    availabilityZone?: string;
+}
+export interface AuroraWriterConfig {
+    enablePerformanceInsights?: boolean;
+    identifierSuffix?: string;
+    availabilityZone?: string;
+}
+export interface AuroraReadersConfig {
+    /** Mutually exclusive with instances */
+    count?: number;
+    /** Mutually exclusive with count */
+    instances?: AuroraReaderConfig[];
+    defaultEnablePerformanceInsights?: boolean;
+}
+/**
+ * Base props for database configuration.
+ */
+type BaseDatabaseProps = {
+    vpc?: IVpc;
+    databaseName: string;
+    instanceType?: string;
+};
+export interface AuroraDatabaseProps extends BaseDatabaseProps {
+    type: "Aurora";
+    databaseEngine?: DatabaseEngine;
+    /** Overrides databaseEngine if provided */
+    engine?: IClusterEngine;
+    writer?: AuroraWriterConfig;
+    readers?: AuroraReadersConfig | false;
+    proxy?: ProxyConfig | false;
+    credentials?: CredentialsConfig;
+    /** DESTRUCTIVE: Changing storageKey causes cluster replacement */
+    encryption?: AuroraEncryptionConfig;
+    backupRetention?: number;
+    monitoringInterval?: Duration;
+    preferredMaintenanceWindow?: string;
+    port?: number;
+    performanceInsights?: PerformanceInsightsConfig | false;
+    /** ARN or identifier of DB cluster snapshot to restore from */
+    snapshotIdentifier?: string;
+}
+export interface GlobalAuroraDatabaseProps extends BaseDatabaseProps {
+    type: "GlobalAurora";
+    primaryRegion: string;
+    secondaryRegions?: string[];
+    globalClusterIdentifier?: string;
+    enableGlobalWriteForwarding?: boolean;
+    databaseEngine?: DatabaseEngine;
+    /** Overrides databaseEngine if provided */
+    engine?: IClusterEngine;
+    writer?: AuroraWriterConfig;
+    readers?: AuroraReadersConfig | false;
+    proxy?: ProxyConfig | false;
+    credentials?: CredentialsConfig;
+    /** DESTRUCTIVE: Changing storageKey causes cluster replacement */
+    encryption?: AuroraEncryptionConfig;
+    backupRetention?: number;
+    monitoringInterval?: Duration;
+    preferredMaintenanceWindow?: string;
+    port?: number;
+    performanceInsights?: PerformanceInsightsConfig | false;
+    /** ARN or identifier of DB cluster snapshot to restore from */
+    snapshotIdentifier?: string;
+}
+export interface InstanceDatabaseProps extends BaseDatabaseProps {
+    type: "Instance";
+    databaseEngine?: DatabaseEngine;
+    /** Overrides databaseEngine if provided */
+    engine?: IInstanceEngine;
+    allocatedStorage?: number;
+    port?: number;
+    multiAz?: boolean;
+    performanceInsights?: PerformanceInsightsConfig | false;
+    proxy?: ProxyConfig | false;
+    readReplica?: ReadReplicaConfig | false;
+    credentials?: CredentialsConfig;
+    encryption?: EncryptionConfig;
+    publiclyAccessible?: boolean;
+    /** ARN or identifier of DB instance snapshot to restore from */
+    snapshotIdentifier?: string;
+}
+export type IDatabaseProps = AuroraDatabaseProps | InstanceDatabaseProps | GlobalAuroraDatabaseProps;
+export declare class DatabaseFactory {
+    static build<T extends IDatabaseProps>(id: string, props: T): (app: App, scope: Construct) => Database;
+}
+export declare class Database extends Construct implements IConnectable {
+    id: string;
+    scope: Construct;
     vpc: IVpc;
+    connections: Connections;
+    private databaseName;
     private database;
-    constructor(scope: Construct, id: string, props: DatabaseProps);
-    addVpc(props: DatabaseProps): void;
-    addDatabase(props: DatabaseProps): void;
+    constructor(scope: Construct, id: string, props: IDatabaseProps);
+    addDatabase(props: IDatabaseProps): void;
+    private addAurora;
+    private addAuroraGlobal;
+    private addRdsInstance;
+    getCredentials(): Secret;
+    getHostEndpoint(): string;
+    getHostPort(): string;
+    getDatabaseName(): string;
 }
 export {};