@fjall/components-infrastructure 0.86.1 → 0.87.3

package/dist/lib/resources/aws/database/dynamodb.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBTable = void 0;
+const constructs_1 = require("constructs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
+function toAttributeType(type) {
+    switch (type) {
+        case "S":
+            return aws_dynamodb_1.AttributeType.STRING;
+        case "N":
+            return aws_dynamodb_1.AttributeType.NUMBER;
+        case "B":
+            return aws_dynamodb_1.AttributeType.BINARY;
+    }
+}
+function toBillingMode(mode) {
+    switch (mode) {
+        case "PROVISIONED":
+            return aws_dynamodb_1.BillingMode.PROVISIONED;
+        case "PAY_PER_REQUEST":
+        default:
+            return aws_dynamodb_1.BillingMode.PAY_PER_REQUEST;
+    }
+}
+function toStreamViewType(stream) {
+    switch (stream) {
+        case "NEW_IMAGE":
+            return aws_dynamodb_1.StreamViewType.NEW_IMAGE;
+        case "OLD_IMAGE":
+            return aws_dynamodb_1.StreamViewType.OLD_IMAGE;
+        case "NEW_AND_OLD_IMAGES":
+            return aws_dynamodb_1.StreamViewType.NEW_AND_OLD_IMAGES;
+        case "KEYS_ONLY":
+            return aws_dynamodb_1.StreamViewType.KEYS_ONLY;
+        default:
+            return undefined;
+    }
+}
+function toRemovalPolicy(policy) {
+    switch (policy) {
+        case "RETAIN":
+            return aws_cdk_lib_1.RemovalPolicy.RETAIN;
+        case "SNAPSHOT":
+            return aws_cdk_lib_1.RemovalPolicy.SNAPSHOT;
+        case "DESTROY":
+        default:
+            return aws_cdk_lib_1.RemovalPolicy.DESTROY;
+    }
+}
+function toProjectionType(type) {
+    switch (type) {
+        case "ALL":
+            return aws_dynamodb_1.ProjectionType.ALL;
+        case "KEYS_ONLY":
+            return aws_dynamodb_1.ProjectionType.KEYS_ONLY;
+        case "INCLUDE":
+            return aws_dynamodb_1.ProjectionType.INCLUDE;
+        default:
+            return undefined;
+    }
+}
+class DynamoDBTable extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.id = id;
+        this.table = new aws_dynamodb_1.Table(this, `${id}Table`, {
+            tableName: props.tableName,
+            partitionKey: {
+                name: props.partitionKey.name,
+                type: toAttributeType(props.partitionKey.type)
+            },
+            sortKey: props.sortKey
+                ? {
+                    name: props.sortKey.name,
+                    type: toAttributeType(props.sortKey.type)
+                }
+                : undefined,
+            billingMode: toBillingMode(props.billingMode),
+            readCapacity: props.billingMode === "PROVISIONED" ? props.readCapacity : undefined,
+            writeCapacity: props.billingMode === "PROVISIONED" ? props.writeCapacity : undefined,
+            stream: toStreamViewType(props.stream),
+            pointInTimeRecovery: props.pointInTimeRecovery ?? true,
+            removalPolicy: toRemovalPolicy(props.removalPolicy),
+            timeToLiveAttribute: props.timeToLiveAttribute
+        });
+        if (props.globalSecondaryIndexes) {
+            for (const gsi of props.globalSecondaryIndexes) {
+                const gsiProps = {
+                    indexName: gsi.indexName,
+                    partitionKey: {
+                        name: gsi.partitionKey.name,
+                        type: toAttributeType(gsi.partitionKey.type)
+                    },
+                    sortKey: gsi.sortKey
+                        ? {
+                            name: gsi.sortKey.name,
+                            type: toAttributeType(gsi.sortKey.type)
+                        }
+                        : undefined,
+                    projectionType: toProjectionType(gsi.projectionType),
+                    nonKeyAttributes: gsi.nonKeyAttributes
+                };
+                this.table.addGlobalSecondaryIndex(gsiProps);
+            }
+        }
+        new aws_cdk_lib_1.CfnOutput(this, `${id}TableName`, {
+            key: `${id}TableName`,
+            value: this.table.tableName,
+            description: `DynamoDB table name for ${id}`
+        });
+        new aws_cdk_lib_1.CfnOutput(this, `${id}TableArn`, {
+            key: `${id}TableArn`,
+            value: this.table.tableArn,
+            description: `DynamoDB table ARN for ${id}`
+        });
+        if (props.stream) {
+            new aws_cdk_lib_1.CfnOutput(this, `${id}TableStreamArn`, {
+                key: `${id}TableStreamArn`,
+                value: this.table.tableStreamArn || "",
+                description: `DynamoDB table stream ARN for ${id}`
+            });
+        }
+    }
+    /**
+     * Get the DynamoDB table name.
+     */
+    getTableName() {
+        return this.table.tableName;
+    }
+    /**
+     * Get the DynamoDB table ARN.
+     */
+    getTableArn() {
+        return this.table.tableArn;
+    }
+    /**
+     * Get the DynamoDB table stream ARN (if streaming is enabled).
+     */
+    getTableStreamArn() {
+        return this.table.tableStreamArn;
+    }
+    /**
+     * Get the underlying CDK Table construct.
+     */
+    getTable() {
+        return this.table;
+    }
+    /**
+     * Grant read permissions to the grantee.
+     */
+    grantRead(grantee) {
+        return this.table.grantReadData(grantee);
+    }
+    /**
+     * Grant write permissions to the grantee.
+     */
+    grantWrite(grantee) {
+        return this.table.grantWriteData(grantee);
+    }
+    /**
+     * Grant read and write permissions to the grantee.
+     */
+    grantReadWrite(grantee) {
+        return this.table.grantReadWriteData(grantee);
+    }
+    /**
+     * Grant full access (read, write, delete) to the grantee.
+     */
+    grantFullAccess(grantee) {
+        return this.table.grantFullAccess(grantee);
+    }
+    /**
+     * Grant stream read permissions to the grantee.
+     */
+    grantStreamRead(grantee) {
+        return this.table.grantStreamRead(grantee);
+    }
+}
+exports.DynamoDBTable = DynamoDBTable;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamodb.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/database/dynamodb.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { CfnOutput, RemovalPolicy } from \"aws-cdk-lib\";\nimport {\n  Table,\n  AttributeType,\n  BillingMode,\n  StreamViewType,\n  ProjectionType,\n  type GlobalSecondaryIndexProps,\n  type ITable\n} from \"aws-cdk-lib/aws-dynamodb\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\n\nexport type DynamoDBAttributeType = \"S\" | \"N\" | \"B\";\n\nexport interface DynamoDBKeySchema {\n  name: string;\n  type: DynamoDBAttributeType;\n}\n\nexport interface DynamoDBGlobalSecondaryIndex {\n  indexName: string;\n  partitionKey: DynamoDBKeySchema;\n  sortKey?: DynamoDBKeySchema;\n  projectionType?: \"ALL\" | \"KEYS_ONLY\" | \"INCLUDE\";\n  nonKeyAttributes?: string[];\n}\n\nexport interface DynamoDBTableProps {\n  tableName?: string;\n  partitionKey: DynamoDBKeySchema;\n  sortKey?: DynamoDBKeySchema;\n  billingMode?: \"PAY_PER_REQUEST\" | \"PROVISIONED\";\n  readCapacity?: number;\n  writeCapacity?: number;\n  globalSecondaryIndexes?: DynamoDBGlobalSecondaryIndex[];\n  timeToLiveAttribute?: string;\n  stream?: \"NEW_IMAGE\" | \"OLD_IMAGE\" | \"NEW_AND_OLD_IMAGES\" | \"KEYS_ONLY\";\n  pointInTimeRecovery?: boolean;\n  encryption?: \"AWS_OWNED\" | \"AWS_MANAGED\" | \"CUSTOMER_MANAGED\";\n  removalPolicy?: \"DESTROY\" | \"RETAIN\" | \"SNAPSHOT\";\n}\n\nfunction toAttributeType(type: DynamoDBAttributeType): AttributeType {\n  switch (type) {\n    case \"S\":\n      return AttributeType.STRING;\n    case \"N\":\n      return AttributeType.NUMBER;\n    case \"B\":\n      return AttributeType.BINARY;\n  }\n}\n\nfunction toBillingMode(mode?: \"PAY_PER_REQUEST\" | \"PROVISIONED\"): BillingMode {\n  switch (mode) {\n    case \"PROVISIONED\":\n      return BillingMode.PROVISIONED;\n    case \"PAY_PER_REQUEST\":\n    default:\n      return BillingMode.PAY_PER_REQUEST;\n  }\n}\n\nfunction toStreamViewType(\n  stream?: \"NEW_IMAGE\" | \"OLD_IMAGE\" | \"NEW_AND_OLD_IMAGES\" | \"KEYS_ONLY\"\n): StreamViewType | undefined {\n  switch (stream) {\n    case \"NEW_IMAGE\":\n      return StreamViewType.NEW_IMAGE;\n    case \"OLD_IMAGE\":\n      return StreamViewType.OLD_IMAGE;\n    case \"NEW_AND_OLD_IMAGES\":\n      return StreamViewType.NEW_AND_OLD_IMAGES;\n    case \"KEYS_ONLY\":\n      return StreamViewType.KEYS_ONLY;\n    default:\n      return undefined;\n  }\n}\n\nfunction toRemovalPolicy(\n  policy?: \"DESTROY\" | \"RETAIN\" | \"SNAPSHOT\"\n): RemovalPolicy {\n  switch (policy) {\n    case \"RETAIN\":\n      return RemovalPolicy.RETAIN;\n    case \"SNAPSHOT\":\n      return RemovalPolicy.SNAPSHOT;\n    case \"DESTROY\":\n    default:\n      return RemovalPolicy.DESTROY;\n  }\n}\n\nfunction toProjectionType(\n  type?: \"ALL\" | \"KEYS_ONLY\" | \"INCLUDE\"\n): ProjectionType | undefined {\n  switch (type) {\n    case \"ALL\":\n      return ProjectionType.ALL;\n    case \"KEYS_ONLY\":\n      return ProjectionType.KEYS_ONLY;\n    case \"INCLUDE\":\n      return ProjectionType.INCLUDE;\n    default:\n      return undefined;\n  }\n}\n\nexport class DynamoDBTable extends Construct {\n  public readonly id: string;\n  private table: Table;\n\n  constructor(scope: Construct, id: string, props: DynamoDBTableProps) {\n    super(scope, id);\n    this.id = id;\n\n    this.table = new Table(this, `${id}Table`, {\n      tableName: props.tableName,\n      partitionKey: {\n        name: props.partitionKey.name,\n        type: toAttributeType(props.partitionKey.type)\n      },\n      sortKey: props.sortKey\n        ? {\n            name: props.sortKey.name,\n            type: toAttributeType(props.sortKey.type)\n          }\n        : undefined,\n      billingMode: toBillingMode(props.billingMode),\n      readCapacity:\n        props.billingMode === \"PROVISIONED\" ? props.readCapacity : undefined,\n      writeCapacity:\n        props.billingMode === \"PROVISIONED\" ? props.writeCapacity : undefined,\n      stream: toStreamViewType(props.stream),\n      pointInTimeRecovery: props.pointInTimeRecovery ?? true,\n      removalPolicy: toRemovalPolicy(props.removalPolicy),\n      timeToLiveAttribute: props.timeToLiveAttribute\n    });\n\n    if (props.globalSecondaryIndexes) {\n      for (const gsi of props.globalSecondaryIndexes) {\n        const gsiProps: GlobalSecondaryIndexProps = {\n          indexName: gsi.indexName,\n          partitionKey: {\n            name: gsi.partitionKey.name,\n            type: toAttributeType(gsi.partitionKey.type)\n          },\n          sortKey: gsi.sortKey\n            ? {\n                name: gsi.sortKey.name,\n                type: toAttributeType(gsi.sortKey.type)\n              }\n            : undefined,\n          projectionType: toProjectionType(gsi.projectionType),\n          nonKeyAttributes: gsi.nonKeyAttributes\n        };\n        this.table.addGlobalSecondaryIndex(gsiProps);\n      }\n    }\n\n    new CfnOutput(this, `${id}TableName`, {\n      key: `${id}TableName`,\n      value: this.table.tableName,\n      description: `DynamoDB table name for ${id}`\n    });\n\n    new CfnOutput(this, `${id}TableArn`, {\n      key: `${id}TableArn`,\n      value: this.table.tableArn,\n      description: `DynamoDB table ARN for ${id}`\n    });\n\n    if (props.stream) {\n      new CfnOutput(this, `${id}TableStreamArn`, {\n        key: `${id}TableStreamArn`,\n        value: this.table.tableStreamArn || \"\",\n        description: `DynamoDB table stream ARN for ${id}`\n      });\n    }\n  }\n\n  /**\n   * Get the DynamoDB table name.\n   */\n  public getTableName(): string {\n    return this.table.tableName;\n  }\n\n  /**\n   * Get the DynamoDB table ARN.\n   */\n  public getTableArn(): string {\n    return this.table.tableArn;\n  }\n\n  /**\n   * Get the DynamoDB table stream ARN (if streaming is enabled).\n   */\n  public getTableStreamArn(): string | undefined {\n    return this.table.tableStreamArn;\n  }\n\n  /**\n   * Get the underlying CDK Table construct.\n   */\n  public getTable(): ITable {\n    return this.table;\n  }\n\n  /**\n   * Grant read permissions to the grantee.\n   */\n  public grantRead(grantee: IGrantable): Grant {\n    return this.table.grantReadData(grantee);\n  }\n\n  /**\n   * Grant write permissions to the grantee.\n   */\n  public grantWrite(grantee: IGrantable): Grant {\n    return this.table.grantWriteData(grantee);\n  }\n\n  /**\n   * Grant read and write permissions to the grantee.\n   */\n  public grantReadWrite(grantee: IGrantable): Grant {\n    return this.table.grantReadWriteData(grantee);\n  }\n\n  /**\n   * Grant full access (read, write, delete) to the grantee.\n   */\n  public grantFullAccess(grantee: IGrantable): Grant {\n    return this.table.grantFullAccess(grantee);\n  }\n\n  /**\n   * Grant stream read permissions to the grantee.\n   */\n  public grantStreamRead(grantee: IGrantable): Grant {\n    return this.table.grantStreamRead(grantee);\n  }\n}\n"]}

package/dist/lib/resources/aws/database/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./database";
 export * from "./rdsAurora";
 export * from "./rdsInstance";
+export * from "./dynamodb";

package/dist/lib/resources/aws/database/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./database"), exports);
 __exportStar(require("./rdsAurora"), exports);
 __exportStar(require("./rdsInstance"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvcmVzb3VyY2VzL2F3cy9kYXRhYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNkNBQTJCO0FBQzNCLDhDQUE0QjtBQUM1QixnREFBOEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9kYXRhYmFzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmRzQXVyb3JhXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZHNJbnN0YW5jZVwiO1xuIl19
+__exportStar(require("./dynamodb"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvcmVzb3VyY2VzL2F3cy9kYXRhYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNkNBQTJCO0FBQzNCLDhDQUE0QjtBQUM1QixnREFBOEI7QUFDOUIsNkNBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZGF0YWJhc2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Jkc0F1cm9yYVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmRzSW5zdGFuY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2R5bmFtb2RiXCI7XG4iXX0=

package/dist/lib/resources/aws/database/migrationLambda.d.ts

@@ -0,0 +1,80 @@
+import { Construct } from "constructs";
+import { Function } from "aws-cdk-lib/aws-lambda";
+import { type IVpc, type IConnectable } from "aws-cdk-lib/aws-ec2";
+/**
+ * Props for creating a Migration Lambda
+ */
+export interface MigrationLambdaProps {
+    /**
+     * VPC where the Lambda will be deployed.
+     * Must be the same VPC as the database.
+     */
+    vpc: IVpc;
+    /**
+     * Database construct to connect to.
+     * Used for security group configuration.
+     */
+    database: IConnectable;
+    /**
+     * Database credentials secret ARN.
+     * Lambda will fetch credentials from this secret.
+     */
+    secretArn: string;
+    /**
+     * Database endpoint hostname.
+     */
+    databaseEndpoint: string;
+    /**
+     * Database port.
+     */
+    databasePort: string;
+    /**
+     * Database name.
+     */
+    databaseName: string;
+    /**
+     * Database engine type.
+     * Currently only PostgreSQL is supported.
+     */
+    databaseEngine: "postgresql";
+    /**
+     * Optional timeout in seconds.
+     * Default: 300 (5 minutes)
+     */
+    timeout?: number;
+    /**
+     * Optional memory size in MB.
+     * Default: 256
+     */
+    memorySize?: number;
+}
+/**
+ * Migration Lambda construct for executing database migrations inside a VPC.
+ *
+ * This Lambda can be invoked by the Fjall CLI to run migrations against databases
+ * that are not accessible from the deployment machine (e.g., private VPC databases).
+ *
+ * The Lambda:
+ * 1. Fetches database credentials from Secrets Manager
+ * 2. Connects to the database using the bundled pg driver
+ * 3. Executes provided SQL statements
+ *
+ * @example
+ * ```typescript
+ * const migrationLambda = new MigrationLambda(this, "Migration", {
+ *   vpc: network.getVpc(),
+ *   database: databaseConstruct,
+ *   secretArn: credentials.secret.secretArn,
+ *   databaseEndpoint: cluster.clusterEndpoint.hostname,
+ *   databasePort: "5432",
+ *   databaseName: "payload",
+ *   databaseEngine: "postgresql"
+ * });
+ * ```
+ */
+export declare class MigrationLambda extends Construct {
+    readonly function: Function;
+    readonly functionArn: string;
+    readonly functionName: string;
+    constructor(scope: Construct, id: string, props: MigrationLambdaProps);
+}

package/dist/lib/resources/aws/database/migrationLambda.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationLambda = void 0;
+const constructs_1 = require("constructs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const path = require("path");
+/**
+ * Migration Lambda construct for executing database migrations inside a VPC.
+ *
+ * This Lambda can be invoked by the Fjall CLI to run migrations against databases
+ * that are not accessible from the deployment machine (e.g., private VPC databases).
+ *
+ * The Lambda:
+ * 1. Fetches database credentials from Secrets Manager
+ * 2. Connects to the database using the bundled pg driver
+ * 3. Executes provided SQL statements
+ *
+ * @example
+ * ```typescript
+ * const migrationLambda = new MigrationLambda(this, "Migration", {
+ *   vpc: network.getVpc(),
+ *   database: databaseConstruct,
+ *   secretArn: credentials.secret.secretArn,
+ *   databaseEndpoint: cluster.clusterEndpoint.hostname,
+ *   databasePort: "5432",
+ *   databaseName: "payload",
+ *   databaseEngine: "postgresql"
+ * });
+ * ```
+ */
+class MigrationLambda extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const stackName = aws_cdk_lib_1.Stack.of(this).stackName;
+        // Create security group for the Lambda
+        const securityGroup = new aws_ec2_1.SecurityGroup(this, `${id}SecurityGroup`, {
+            vpc: props.vpc,
+            description: `Security group for ${id} migration Lambda`,
+            allowAllOutbound: true
+        });
+        // Allow Lambda to connect to the database
+        props.database.connections.allowFrom(securityGroup, aws_ec2_1.Port.tcp(parseInt(props.databasePort, 10)), `Allow ${id} migration Lambda to connect to database`);
+        // Create execution role with necessary permissions
+        const executionRole = new aws_iam_1.Role(this, `${id}ExecutionRole`, {
+            assumedBy: new aws_iam_1.ServicePrincipal("lambda.amazonaws.com"),
+            description: `Execution role for ${id} migration Lambda`,
+            managedPolicies: [
+                aws_iam_1.ManagedPolicy.fromManagedPolicyArn(scope, `${id}VpcExecutionPolicy`, "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole")
+            ]
+        });
+        // Add Secrets Manager permissions
+        executionRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: ["secretsmanager:GetSecretValue"],
+            resources: [props.secretArn]
+        }));
+        // Create log group with retention
+        const logGroup = new aws_logs_1.LogGroup(this, `${id}LogGroup`, {
+            logGroupName: `/aws/lambda/${stackName}-${id}`,
+            retention: aws_logs_1.RetentionDays.ONE_WEEK
+        });
+        // Path to the Lambda handler code
+        // This directory contains index.mjs and package.json with pg dependency
+        const handlerPath = path.join(__dirname, "migration-lambda-handler");
+        // Create the Lambda function with bundled dependencies
+        // The handler directory must have node_modules installed during CDK synth
+        // or use CDK's bundling feature
+        this.function = new aws_lambda_1.Function(this, `${id}Function`, {
+            functionName: `${stackName}-${id}`,
+            runtime: aws_lambda_1.Runtime.NODEJS_20_X,
+            handler: "index.handler",
+            code: aws_lambda_1.Code.fromAsset(handlerPath, {
+                bundling: {
+                    image: aws_lambda_1.Runtime.NODEJS_20_X.bundlingImage,
+                    command: [
+                        "bash",
+                        "-c",
+                        ["npm install --omit=dev", "cp -r . /asset-output/"].join(" && ")
+                    ]
+                }
+            }),
+            vpc: props.vpc,
+            vpcSubnets: { subnetType: aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS },
+            securityGroups: [securityGroup],
+            role: executionRole,
+            timeout: aws_cdk_lib_1.Duration.seconds(props.timeout ?? 300),
+            memorySize: props.memorySize ?? 256,
+            environment: {
+                SECRET_ARN: props.secretArn,
+                DATABASE_ENDPOINT: props.databaseEndpoint,
+                DATABASE_PORT: props.databasePort,
+                DATABASE_NAME: props.databaseName,
+                DATABASE_ENGINE: props.databaseEngine
+            },
+            logGroup
+        });
+        this.functionArn = this.function.functionArn;
+        this.functionName = this.function.functionName;
+        // Export function ARN for CLI use
+        new aws_cdk_lib_1.CfnOutput(this, `${id}FunctionArn`, {
+            key: `${stackName}${id}FunctionArn`,
+            exportName: `${stackName}${id}FunctionArn`,
+            value: this.functionArn,
+            description: `ARN of the ${id} migration Lambda function`
+        });
+        new aws_cdk_lib_1.CfnOutput(this, `${id}FunctionName`, {
+            key: `${stackName}${id}FunctionName`,
+            exportName: `${stackName}${id}FunctionName`,
+            value: this.functionName,
+            description: `Name of the ${id} migration Lambda function`
+        });
+    }
+}
+exports.MigrationLambda = MigrationLambda;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrationLambda.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/database/migrationLambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { Duration, CfnOutput, Stack } from \"aws-cdk-lib\";\nimport { Code, Runtime, Function } from \"aws-cdk-lib/aws-lambda\";\nimport {\n  PolicyStatement,\n  Effect,\n  Role,\n  ServicePrincipal,\n  ManagedPolicy\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  type IVpc,\n  SubnetType,\n  SecurityGroup,\n  Port,\n  type IConnectable\n} from \"aws-cdk-lib/aws-ec2\";\nimport { LogGroup, RetentionDays } from \"aws-cdk-lib/aws-logs\";\nimport * as path from \"path\";\n\n/**\n * Props for creating a Migration Lambda\n */\nexport interface MigrationLambdaProps {\n  /**\n   * VPC where the Lambda will be deployed.\n   * Must be the same VPC as the database.\n   */\n  vpc: IVpc;\n\n  /**\n   * Database construct to connect to.\n   * Used for security group configuration.\n   */\n  database: IConnectable;\n\n  /**\n   * Database credentials secret ARN.\n   * Lambda will fetch credentials from this secret.\n   */\n  secretArn: string;\n\n  /**\n   * Database endpoint hostname.\n   */\n  databaseEndpoint: string;\n\n  /**\n   * Database port.\n   */\n  databasePort: string;\n\n  /**\n   * Database name.\n   */\n  databaseName: string;\n\n  /**\n   * Database engine type.\n   * Currently only PostgreSQL is supported.\n   */\n  databaseEngine: \"postgresql\";\n\n  /**\n   * Optional timeout in seconds.\n   * Default: 300 (5 minutes)\n   */\n  timeout?: number;\n\n  /**\n   * Optional memory size in MB.\n   * Default: 256\n   */\n  memorySize?: number;\n}\n\n/**\n * Migration Lambda construct for executing database migrations inside a VPC.\n *\n * This Lambda can be invoked by the Fjall CLI to run migrations against databases\n * that are not accessible from the deployment machine (e.g., private VPC databases).\n *\n * The Lambda:\n * 1. Fetches database credentials from Secrets Manager\n * 2. Connects to the database using the bundled pg driver\n * 3. Executes provided SQL statements\n *\n * @example\n * ```typescript\n * const migrationLambda = new MigrationLambda(this, \"Migration\", {\n *   vpc: network.getVpc(),\n *   database: databaseConstruct,\n *   secretArn: credentials.secret.secretArn,\n *   databaseEndpoint: cluster.clusterEndpoint.hostname,\n *   databasePort: \"5432\",\n *   databaseName: \"payload\",\n *   databaseEngine: \"postgresql\"\n * });\n * ```\n */\nexport class MigrationLambda extends Construct {\n  public readonly function: Function;\n  public readonly functionArn: string;\n  public readonly functionName: string;\n\n  constructor(scope: Construct, id: string, props: MigrationLambdaProps) {\n    super(scope, id);\n\n    const stackName = Stack.of(this).stackName;\n\n    // Create security group for the Lambda\n    const securityGroup = new SecurityGroup(this, `${id}SecurityGroup`, {\n      vpc: props.vpc,\n      description: `Security group for ${id} migration Lambda`,\n      allowAllOutbound: true\n    });\n\n    // Allow Lambda to connect to the database\n    props.database.connections.allowFrom(\n      securityGroup,\n      Port.tcp(parseInt(props.databasePort, 10)),\n      `Allow ${id} migration Lambda to connect to database`\n    );\n\n    // Create execution role with necessary permissions\n    const executionRole = new Role(this, `${id}ExecutionRole`, {\n      assumedBy: new ServicePrincipal(\"lambda.amazonaws.com\"),\n      description: `Execution role for ${id} migration Lambda`,\n      managedPolicies: [\n        ManagedPolicy.fromManagedPolicyArn(\n          scope,\n          `${id}VpcExecutionPolicy`,\n          \"arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole\"\n        )\n      ]\n    });\n\n    // Add Secrets Manager permissions\n    executionRole.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\"secretsmanager:GetSecretValue\"],\n        resources: [props.secretArn]\n      })\n    );\n\n    // Create log group with retention\n    const logGroup = new LogGroup(this, `${id}LogGroup`, {\n      logGroupName: `/aws/lambda/${stackName}-${id}`,\n      retention: RetentionDays.ONE_WEEK\n    });\n\n    // Path to the Lambda handler code\n    // This directory contains index.mjs and package.json with pg dependency\n    const handlerPath = path.join(__dirname, \"migration-lambda-handler\");\n\n    // Create the Lambda function with bundled dependencies\n    // The handler directory must have node_modules installed during CDK synth\n    // or use CDK's bundling feature\n    this.function = new Function(this, `${id}Function`, {\n      functionName: `${stackName}-${id}`,\n      runtime: Runtime.NODEJS_20_X,\n      handler: \"index.handler\",\n      code: Code.fromAsset(handlerPath, {\n        bundling: {\n          image: Runtime.NODEJS_20_X.bundlingImage,\n          command: [\n            \"bash\",\n            \"-c\",\n            [\"npm install --omit=dev\", \"cp -r . /asset-output/\"].join(\" && \")\n          ]\n        }\n      }),\n      vpc: props.vpc,\n      vpcSubnets: { subnetType: SubnetType.PRIVATE_WITH_EGRESS },\n      securityGroups: [securityGroup],\n      role: executionRole,\n      timeout: Duration.seconds(props.timeout ?? 300),\n      memorySize: props.memorySize ?? 256,\n      environment: {\n        SECRET_ARN: props.secretArn,\n        DATABASE_ENDPOINT: props.databaseEndpoint,\n        DATABASE_PORT: props.databasePort,\n        DATABASE_NAME: props.databaseName,\n        DATABASE_ENGINE: props.databaseEngine\n      },\n      logGroup\n    });\n\n    this.functionArn = this.function.functionArn;\n    this.functionName = this.function.functionName;\n\n    // Export function ARN for CLI use\n    new CfnOutput(this, `${id}FunctionArn`, {\n      key: `${stackName}${id}FunctionArn`,\n      exportName: `${stackName}${id}FunctionArn`,\n      value: this.functionArn,\n      description: `ARN of the ${id} migration Lambda function`\n    });\n\n    new CfnOutput(this, `${id}FunctionName`, {\n      key: `${stackName}${id}FunctionName`,\n      exportName: `${stackName}${id}FunctionName`,\n      value: this.functionName,\n      description: `Name of the ${id} migration Lambda function`\n    });\n  }\n}\n"]}

package/dist/lib/resources/aws/database/rdsAurora.d.ts

@@ -28,6 +28,21 @@ interface RdsProps {
     snapshotIdentifier?: string;
     /** Username from the snapshot (required when restoring from snapshot to reset password) */
     snapshotUsername?: string;
+    /** Allow access from VPC CIDR (avoids cross-stack cyclic dependencies with Lambda) */
+    allowVpcAccess?: boolean;
+    /**
+     * Make database publicly accessible from the internet.
+     * WARNING: This is a security risk and should only be used for development
+     * or when building Payload apps locally that need database access.
+     * When enabled, the database is placed in public subnets.
+     */
+    publiclyAccessible?: boolean;
+    /**
+     * IP address to allow access from when publiclyAccessible is true.
+     * If not specified, access is restricted to VPC only even when public.
+     * Format: CIDR notation (e.g., "203.0.113.0/32" for single IP)
+     */
+    allowedIpCidr?: string;
 }
 export declare class RdsAurora extends Construct implements IConnectable {
     connections: Connections;