cdk-drizzle-migrate 1.0.1 → 2.0.0

package/API.md

@@ -161,24 +161,12 @@ const drizzleMigrateProps: DrizzleMigrateProps = { ... }
 
 | **Name** | **Type** | **Description** |
 | --- | --- | --- |
-| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.dbSecret">dbSecret</a></code> | <code>aws-cdk-lib.aws_secretsmanager.ISecret</code> | The database secret containing connection details Must contain standard CDK database secret properties: username, password, host, port, engine, etc. |
 | <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.migrationsPath">migrationsPath</a></code> | <code>string</code> | The path to the migrations directory This directory will be bundled with the Lambda function. |
-| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.vpc">vpc</a></code> | <code>aws-cdk-lib.aws_ec2.IVpc</code> | The VPC where the Lambda function will be deployed Required to allow the Lambda function to connect to the database. |
-| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.cluster">cluster</a></code> | <code>aws-cdk-lib.aws_rds.IDatabaseCluster \| aws-cdk-lib.aws_rds.IDatabaseInstance</code> | Optional database cluster or instance If provided and a new security group is created, the security group will be configured to allow access to the database. |
+| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.cluster">cluster</a></code> | <code>aws-cdk-lib.aws_rds.IDatabaseCluster \| aws-cdk-lib.aws_rds.IDatabaseInstance \| aws-cdk-lib.aws_dsql.CfnCluster</code> | Optional database cluster or instance Supports both traditional RDS/Aurora clusters and DSQL clusters - For RDS/Aurora: security groups will be configured to allow access - For DSQL: IAM authentication will be used instead of secrets. |
+| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.dbSecret">dbSecret</a></code> | <code>aws-cdk-lib.aws_secretsmanager.ISecret</code> | The database secret containing connection details Must contain standard CDK database secret properties: username, password, host, port, engine, etc. |
 | <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.handlerProps">handlerProps</a></code> | <code>aws-cdk-lib.aws_lambda_nodejs.NodejsFunctionProps</code> | Optional properties to customize the Lambda function Excludes runtime, entry, and handler which are managed by the construct. |
-| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.vpcSubnets">vpcSubnets</a></code> | <code>aws-cdk-lib.aws_ec2.SubnetSelection</code> | Optional subnet selection to deploy the Lambda function. |
-
----
-
-##### `dbSecret`<sup>Required</sup> <a name="dbSecret" id="cdk-drizzle-migrate.DrizzleMigrateProps.property.dbSecret"></a>
-
-```typescript
-public readonly dbSecret: ISecret;
-```
-
-- *Type:* aws-cdk-lib.aws_secretsmanager.ISecret
-
-The database secret containing connection details Must contain standard CDK database secret properties: username, password, host, port, engine, etc.
+| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.vpc">vpc</a></code> | <code>aws-cdk-lib.aws_ec2.IVpc</code> | The VPC where the Lambda function will be deployed Required when your database is only accessible in a VPC. |
+| <code><a href="#cdk-drizzle-migrate.DrizzleMigrateProps.property.vpcSubnets">vpcSubnets</a></code> | <code>aws-cdk-lib.aws_ec2.SubnetSelection</code> | Optional subnet selection to deploy the Lambda function Only used when vpc is specified. |
 
 ---
 
@@ -194,28 +182,31 @@ The path to the migrations directory This directory will be bundled with the Lam
 
 ---
 
-##### `vpc`<sup>Required</sup> <a name="vpc" id="cdk-drizzle-migrate.DrizzleMigrateProps.property.vpc"></a>
+##### `cluster`<sup>Optional</sup> <a name="cluster" id="cdk-drizzle-migrate.DrizzleMigrateProps.property.cluster"></a>
 
 ```typescript
-public readonly vpc: IVpc;
+public readonly cluster: IDatabaseCluster | IDatabaseInstance | CfnCluster;
 ```
 
-- *Type:* aws-cdk-lib.aws_ec2.IVpc
+- *Type:* aws-cdk-lib.aws_rds.IDatabaseCluster | aws-cdk-lib.aws_rds.IDatabaseInstance | aws-cdk-lib.aws_dsql.CfnCluster
+- *Default:* No database connection is configured
 
-The VPC where the Lambda function will be deployed Required to allow the Lambda function to connect to the database.
+Optional database cluster or instance Supports both traditional RDS/Aurora clusters and DSQL clusters - For RDS/Aurora: security groups will be configured to allow access - For DSQL: IAM authentication will be used instead of secrets.
 
 ---
 
-##### `cluster`<sup>Optional</sup> <a name="cluster" id="cdk-drizzle-migrate.DrizzleMigrateProps.property.cluster"></a>
+##### `dbSecret`<sup>Optional</sup> <a name="dbSecret" id="cdk-drizzle-migrate.DrizzleMigrateProps.property.dbSecret"></a>
 
 ```typescript
-public readonly cluster: IDatabaseCluster | IDatabaseInstance;
+public readonly dbSecret: ISecret;
 ```
 
-- *Type:* aws-cdk-lib.aws_rds.IDatabaseCluster | aws-cdk-lib.aws_rds.IDatabaseInstance
-- *Default:* No database connection is configured
+- *Type:* aws-cdk-lib.aws_secretsmanager.ISecret
+- *Default:* undefined for DSQL clusters using IAM authentication
 
-Optional database cluster or instance If provided and a new security group is created, the security group will be configured to allow access to the database.
+The database secret containing connection details Must contain standard CDK database secret properties: username, password, host, port, engine, etc.
+
+Not required when relying on IAM authentication (such as DSQL).
 
 ---
 
@@ -232,6 +223,21 @@ Optional properties to customize the Lambda function Excludes runtime, entry, an
 
 ---
 
+##### `vpc`<sup>Optional</sup> <a name="vpc" id="cdk-drizzle-migrate.DrizzleMigrateProps.property.vpc"></a>
+
+```typescript
+public readonly vpc: IVpc;
+```
+
+- *Type:* aws-cdk-lib.aws_ec2.IVpc
+- *Default:* use VPC of your RDS/Aurora cluster
+
+The VPC where the Lambda function will be deployed Required when your database is only accessible in a VPC.
+
+Not required for DSQL as it uses public endpoints with IAM authentication
+
+---
+
 ##### `vpcSubnets`<sup>Optional</sup> <a name="vpcSubnets" id="cdk-drizzle-migrate.DrizzleMigrateProps.property.vpcSubnets"></a>
 
 ```typescript
@@ -241,7 +247,7 @@ public readonly vpcSubnets: SubnetSelection;
 - *Type:* aws-cdk-lib.aws_ec2.SubnetSelection
 - *Default:* PRIVATE_WITH_EGRESS subnets
 
-Optional subnet selection to deploy the Lambda function.
+Optional subnet selection to deploy the Lambda function Only used when vpc is specified.
 
 ---
 

package/CLAUDE.md

@@ -0,0 +1,79 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a Projen managed AWS CDK construct library that enables
+running Drizzle ORM migrations against RDS clusters at deploy time. It
+supports PostgreSQL, MariaDB, and MySQL engines and is designed for
+enterprise environments with isolated subnets.
+
+## Development Commands
+
+- **Build**: `npx projen build` - Compiles TypeScript and runs all build steps
+- **Test**: `npx projen test` - Runs Jest tests and synthesizes integration stacks
+- **Lint**: `npx projen eslint` - Runs ESLint on source files
+- **Format**: `npx projen format` - Formats code with Prettier
+
+### Lambda Handler Development
+
+When modifying the Lambda handler code in `lambda/handler.ts`:
+
+1. Transpile to JavaScript: `npx projen build:handler`
+2. This generates `src/handler/handler.js` which is used by the CDK construct
+3. The build automatically runs before compilation via pre-compile hook
+
+### Unit testing
+
+- Run unit tests: `npx jest test/drizzle-migration.test.ts`
+- Run a single test: `npx jest test/drizzle-migrate.test.ts --no-coverage -t "creates resources"`
+
+### Integration Testing
+
+The project has three integration test stacks for different database engines:
+
+- **PostgreSQL**: `npx projen integ:deploy:postgres`, `npx projen integ:destroy:postgres`
+- **MariaDB**: `npx projen integ:deploy:mariadb`, `npx projen  integ:destroy:mariadb`
+- **Aurora Serverless**: `npx projen integ:deploy:serverless`, `npx projen integ:destroy:serverless`
+
+Generate migrations for integration tests:
+- `npx projen  integ:generate-migrations:postgres`
+- `npx projen integ:generate-migrations:mariadb`
+- `npx projen integ:generate-migrations:serverless`
+
+Synthesize all integration stacks: `npx projen integ:synth:all`
+
+## Architecture
+
+### Core Components
+
+- **DrizzleMigrate** (`src/drizzle-migrate-provider.ts`): Main CDK construct that creates a Lambda function to run migrations
+- **Lambda Handler** (`lambda/handler.ts`): Runtime code that connects to RDS and executes Drizzle migrations
+- **Integration Tests** (`integ/`): Three separate CDK apps testing different database engines
+
+### Key Design Patterns
+
+1. **Handler Bundling**: The Lambda handler is transpiled from TypeScript to JavaScript using esbuild and bundled with the construct to avoid Node.js dependency issues
+
+2. **Security Groups**: If a database cluster/instance is passed to the construct, it automatically configures security group rules to allow Lambda access
+
+3. **Multi-Engine Support**: The handler detects database engine from the secret and uses appropriate Drizzle drivers (postgres-js, mysql2)
+
+4. **Migration Path Bundling**: The specified migrations directory is bundled with the Lambda function and read at runtime
+
+### Dependencies
+
+- Uses Projen for project configuration and task management
+- CDK v2
+- Drizzle ORM and drizzle-kit for database operations
+- esbuild for Lambda handler transpilation
+- Jest for testing with integration stack synthesis
+
+## File Structure
+
+- `src/` - CDK construct source code
+- `lambda/` - Lambda handler source (TypeScript)
+- `src/handler/` - Generated JavaScript handler (do not edit directly)
+- `integ/` - Integration test CDK applications
+- `test/` - Unit tests

package/README.md

@@ -1,7 +1,7 @@
 # About
 
 This CDK construct library makes it possible to run the drizzle
-migrate at deploy of your stack time against the RDS cluster of your
+migrate at deploy of your stack time against the RDS or DSQL cluster of your
 choice. The supported engines are PostgreSQL, MariaDB and MySQL.
 
 This construct library is intended to be used in enterprise
@@ -31,6 +31,8 @@ actually want to create migrations.
 
 # Usage
 
+## RDS and Aurora
+
 Have an RDS database and a secret that stores your db
 credentials. Usually this will be the root secret for your RDS
 database:
@@ -64,6 +66,17 @@ Your secret should look like the standard one created by CDK:
 }
 ```
 
+## DSQL
+
+For DSQL there is no secret where credentials are stored. Only IAM
+access is supported.
+
+Drizzle doesn't really support DSQL, so if you create migrations you
+will often need to tweak them manually as so little of postgresql is
+supported.
+
+## Migrations
+
 Specify the path where the migrations are stored, `migrations` in this case.
 
 When this resource is deployed, it will run `drizzle-kit migrate` for
@@ -80,9 +93,9 @@ security group if no security group is present in
 If you do not pass a cluster, make sure to pass in a security group in
 `handlerProps.securityGroups` which can connect to your database.
 
-Also if you do not pass a cluster you, but still create a database,
-you may wish to add a dependency to make sure the database is created,
-before the migration is run:
+Also if you do not pass a cluster, but you still want to create a
+database, you may wish to add a dependency to make sure the database
+is created, before the migration is run:
 
 ```ts
 migrator.resource.node.addDependency(cluster)
@@ -95,14 +108,15 @@ migrator.resource.node.addDependency(cluster)
 
 # Working on this code
 
-1. Install packages: `npm i`
+1. Install packages: `npm ci`
 
 2. Bootstrap CDK if not done: `npx cdk bootstrap
    aws://123456/us-east-1`. Replace 123456 with your AWS account.
 
 ## Handler notes
 
-When making changes to the Lambda handler code in `lambda/index.ts`, you need to transpile it to JavaScript:
+When making changes to the Lambda handler code in `lambda/index.ts`,
+you need to transpile it to JavaScript:
 
 ```bash
 npx projen build:handler

package/lib/drizzle-migrate-provider.d.ts

@@ -1,4 +1,5 @@
 import { CustomResource } from "aws-cdk-lib";
+import * as dsql from "aws-cdk-lib/aws-dsql";
 import * as ec2 from "aws-cdk-lib/aws-ec2";
 import { NodejsFunction, NodejsFunctionProps } from "aws-cdk-lib/aws-lambda-nodejs";
 import * as rds from "aws-cdk-lib/aws-rds";
@@ -10,9 +11,12 @@ import { Construct } from "constructs";
 export interface DrizzleMigrateProps {
     /**
      * The database secret containing connection details
-     * Must contain standard CDK database secret properties: username, password, host, port, engine, etc.
+     * Must contain standard CDK database secret properties: username,
+     * password, host, port, engine, etc.
+     * Not required when relying on IAM authentication (such as DSQL).
+     * @default - undefined for DSQL clusters using IAM authentication
      */
-    readonly dbSecret: secretsmanager.ISecret;
+    readonly dbSecret?: secretsmanager.ISecret;
     /**
      * The path to the migrations directory
      * This directory will be bundled with the Lambda function
@@ -26,21 +30,25 @@ export interface DrizzleMigrateProps {
     readonly handlerProps?: NodejsFunctionProps;
     /**
      * The VPC where the Lambda function will be deployed
-     * Required to allow the Lambda function to connect to the database
+     * Required when your database is only accessible in a VPC.
+     * Not required for DSQL as it uses public endpoints with IAM authentication
+     * @default - use VPC of your RDS/Aurora cluster
      */
-    readonly vpc: ec2.IVpc;
+    readonly vpc?: ec2.IVpc;
     /**
      * Optional subnet selection to deploy the Lambda function
+     * Only used when vpc is specified
      * @default - PRIVATE_WITH_EGRESS subnets
      */
     readonly vpcSubnets?: ec2.SubnetSelection;
     /**
      * Optional database cluster or instance
-     * If provided and a new security group is created, the security group will be
-     * configured to allow access to the database
+     * Supports both traditional RDS/Aurora clusters and DSQL clusters
+     * - For RDS/Aurora: security groups will be configured to allow access
+     * - For DSQL: IAM authentication will be used instead of secrets
      * @default - No database connection is configured
      */
-    readonly cluster?: rds.IDatabaseCluster | rds.IDatabaseInstance;
+    readonly cluster?: rds.IDatabaseCluster | rds.IDatabaseInstance | dsql.CfnCluster;
 }
 /**
  * A custom resource that runs Drizzle migrations

package/lib/drizzle-migrate-provider.js

@@ -7,46 +7,78 @@ const assert_1 = require("assert");
 const fs_1 = require("fs");
 const path = require("path");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
+const dsql = require("aws-cdk-lib/aws-dsql");
+const iam = require("aws-cdk-lib/aws-iam");
 const lambda = require("aws-cdk-lib/aws-lambda");
 const aws_lambda_nodejs_1 = require("aws-cdk-lib/aws-lambda-nodejs");
 const logs = require("aws-cdk-lib/aws-logs");
 const cr = require("aws-cdk-lib/custom-resources");
 const constructs_1 = require("constructs");
+/**
+ * Helper function to determine if a cluster is a DSQL cluster
+ */
+function isDsqlCluster(cluster) {
+    return cluster instanceof dsql.CfnCluster;
+}
 /**
  * A custom resource that runs Drizzle migrations
  */
 class DrizzleMigrate extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
+        // Validate configuration
+        const isDsql = props.cluster && isDsqlCluster(props.cluster);
+        if (!isDsql && !props.dbSecret) {
+            throw new Error("Either dbSecret (for traditional RDS) or cluster with DSQL must be provided");
+        }
+        if (!isDsql && !props.vpc) {
+            throw new Error("VPC is required for traditional RDS databases");
+        }
+        if (isDsql && props.dbSecret) {
+            throw new Error("dbSecret should not be provided when using DSQL cluster (uses IAM authentication)");
+        }
         const migrationsDir = path.join(process.cwd(), props.migrationsPath);
         (0, assert_1.strict)((0, fs_1.existsSync)(migrationsDir), `Migrations directory ${migrationsDir} does not exist`);
         const handlerDir = path.join(__dirname, "handler");
         const ts_filename = path.join(handlerDir, "index.ts");
         const js_filename = path.join(handlerDir, "index.js");
         const entry = (0, fs_1.existsSync)(ts_filename) ? ts_filename : js_filename;
+        const environment = {
+            NO_COLOR: "1",
+            ...(props.handlerProps?.environment || {}),
+        };
+        // Create explicit log group for the Lambda handler
+        const logGroup = new logs.LogGroup(this, "MigrateHandlerLogGroup", {
+            retention: logs.RetentionDays.ONE_WEEK,
+            // Keep log group, it's annoying when it gets deleted for new
+            // deploys, and something has gone wrong. You have no way to
+            // look at the logs in that case.
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.RETAIN,
+        });
         const onEventHandler = new aws_lambda_nodejs_1.NodejsFunction(this, "MigrateHandler", {
             runtime: lambda.Runtime.NODEJS_20_X,
             entry: entry,
-            logRetention: logs.RetentionDays.ONE_WEEK,
+            logGroup: logGroup,
+            loggingFormat: lambda.LoggingFormat.JSON,
+            applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,
             timeout: aws_cdk_lib_1.Duration.minutes(5),
             vpc: props.vpc,
             vpcSubnets: props.vpcSubnets,
             ...props.handlerProps,
-            environment: {
-                NO_COLOR: "1",
-                ...(props.handlerProps?.environment || {}),
-            },
+            environment,
             bundling: {
                 sourceMap: false,
                 // Include the migrations directory in the bundle
                 commandHooks: {
                     beforeBundling(_, outputDir) {
-                        return [
+                        const commands = [
                             `cp ${handlerDir}/handler.js ${outputDir}`,
                             `cp -r ${migrationsDir} ${path.join(outputDir, "migrations")}`,
+                            // Always download RDS certificate for SSL connections (both RDS and DSQL need it)
                             `mkdir -p ${path.join(outputDir, "certs")}`,
                             `curl --silent -fL https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem -o ${path.join(outputDir, "certs", "global-bundle.pem")}`,
                         ];
+                        return commands;
                     },
                     afterBundling() {
                         return [];
@@ -58,30 +90,55 @@ class DrizzleMigrate extends constructs_1.Construct {
                 ...props.handlerProps?.bundling,
             },
         });
-        // If the user gave us a security group, assume it can connect to the database.
-        // If not, make sure the CDK created security group allows access to the DB.
-        if (props.cluster &&
-            (!props.handlerProps ||
-                typeof props.handlerProps.securityGroups === "undefined" ||
-                props.handlerProps.securityGroups.length === 0)) {
-            props.cluster.connections.allowDefaultPortFrom(onEventHandler.connections, "Allow drizzle migrate lambda to connect to db");
+        // Handle database connection setup
+        if (isDsql) {
+            // For DSQL, grant IAM permissions instead of VPC security groups
+            const dsqlCluster = props.cluster;
+            onEventHandler.addToRolePolicy(new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: ["dsql:DbConnectAdmin"],
+                resources: [dsqlCluster.attrResourceArn],
+            }));
+        }
+        else {
+            // Traditional RDS setup with security groups
+            if (props.cluster &&
+                (!props.handlerProps ||
+                    typeof props.handlerProps.securityGroups === "undefined" ||
+                    props.handlerProps.securityGroups.length === 0)) {
+                const rdsCluster = props.cluster;
+                rdsCluster.connections.allowDefaultPortFrom(onEventHandler.connections, "Allow drizzle migrate lambda to connect to db");
+            }
+            // Grant the Lambda function permission to read the secret
+            props.dbSecret.grantRead(onEventHandler);
         }
         this.handler = onEventHandler;
-        // Grant the Lambda function permission to read the secret
-        props.dbSecret.grantRead(onEventHandler);
         const provider = new cr.Provider(this, "Provider", {
             onEventHandler,
-            logRetention: logs.RetentionDays.ONE_WEEK,
+            logGroup,
         });
+        // Build custom resource properties based on database type
+        const customResourceProperties = {
+            // We're now using a fixed path inside the Lambda bundle
+            migrationsPath: "migrations",
+            // Adding a timestamp ensures the resource is updated on each deployment
+            timestamp: Date.now().toString(),
+        };
+        if (isDsql) {
+            // For DSQL, construct the endpoint from cluster ID and region
+            // DSQL endpoint format: ${clusterId}.dsql.${region}.on.aws
+            const dsqlCluster = props.cluster;
+            const clusterId = dsqlCluster.attrIdentifier;
+            const region = aws_cdk_lib_1.Stack.of(this).region;
+            customResourceProperties.endpoint = `${clusterId}.dsql.${region}.on.aws`;
+            customResourceProperties.port = "5432";
+        }
+        else {
+            customResourceProperties.secretArn = props.dbSecret.secretArn;
+        }
         this.resource = new aws_cdk_lib_1.CustomResource(this, "CustomResource", {
             serviceToken: provider.serviceToken,
-            properties: {
-                secretArn: props.dbSecret.secretArn,
-                // We're now using a fixed path inside the Lambda bundle
-                migrationsPath: "migrations",
-                // Adding a timestamp ensures the resource is updated on each deployment
-                timestamp: Date.now().toString(),
-            },
+            properties: customResourceProperties,
         });
         const resourceCfn = this.resource.node.defaultChild;
         resourceCfn.addPropertyOverride("ServiceTimeout", 900);
@@ -93,5 +150,5 @@ class DrizzleMigrate extends constructs_1.Construct {
 }
 exports.DrizzleMigrate = DrizzleMigrate;
 _a = JSII_RTTI_SYMBOL_1;
-DrizzleMigrate[_a] = { fqn: "cdk-drizzle-migrate.DrizzleMigrate", version: "1.0.1" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drizzle-migrate-provider.js","sourceRoot":"","sources":["../src/drizzle-migrate-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { strict as assert } from \"assert\"\nimport { existsSync } from \"fs\"\nimport * as path from \"path\"\nimport { CfnResource, CustomResource, Duration } from \"aws-cdk-lib\"\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport { NodejsFunction, NodejsFunctionProps } from \"aws-cdk-lib/aws-lambda-nodejs\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as rds from \"aws-cdk-lib/aws-rds\"\nimport * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport * as cr from \"aws-cdk-lib/custom-resources\"\nimport { Construct } from \"constructs\"\n\n/**\n * Properties for DrizzleMigrate\n */\nexport interface DrizzleMigrateProps {\n  /**\n   * The database secret containing connection details\n   * Must contain standard CDK database secret properties: username, password, host, port, engine, etc.\n   */\n  readonly dbSecret: secretsmanager.ISecret\n\n  /**\n   * The path to the migrations directory\n   * This directory will be bundled with the Lambda function\n   */\n  readonly migrationsPath: string\n\n  /**\n   * Optional properties to customize the Lambda function\n   * Excludes runtime, entry, and handler which are managed by the construct\n   * @default - Default Lambda configuration is used\n   */\n  readonly handlerProps?: NodejsFunctionProps\n\n  /**\n   * The VPC where the Lambda function will be deployed\n   * Required to allow the Lambda function to connect to the database\n   */\n  readonly vpc: ec2.IVpc\n\n  /**\n   * Optional subnet selection to deploy the Lambda function\n   * @default - PRIVATE_WITH_EGRESS subnets\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection\n\n  /**\n   * Optional database cluster or instance\n   * If provided and a new security group is created, the security group will be\n   * configured to allow access to the database\n   * @default - No database connection is configured\n   */\n  readonly cluster?: rds.IDatabaseCluster | rds.IDatabaseInstance\n}\n\n/**\n * A custom resource that runs Drizzle migrations\n */\nexport class DrizzleMigrate extends Construct {\n  /**\n   * The custom resource that was created\n   */\n  public readonly resource: CustomResource\n\n  /**\n   * The Lambda function that executes the migrations\n   */\n  public readonly handler: NodejsFunction\n\n  constructor(scope: Construct, id: string, props: DrizzleMigrateProps) {\n    super(scope, id)\n\n    const migrationsDir = path.join(process.cwd(), props.migrationsPath)\n    assert(\n      existsSync(migrationsDir),\n      `Migrations directory ${migrationsDir} does not exist`\n    )\n    const handlerDir = path.join(__dirname, \"handler\")\n\n    const ts_filename = path.join(handlerDir, \"index.ts\")\n    const js_filename = path.join(handlerDir, \"index.js\")\n    const entry = existsSync(ts_filename) ? ts_filename : js_filename\n\n    const onEventHandler = new NodejsFunction(this, \"MigrateHandler\", {\n      runtime: lambda.Runtime.NODEJS_20_X,\n      entry: entry,\n      logRetention: logs.RetentionDays.ONE_WEEK,\n      timeout: Duration.minutes(5),\n      vpc: props.vpc,\n      vpcSubnets: props.vpcSubnets,\n      ...props.handlerProps,\n      environment: {\n        NO_COLOR: \"1\",\n        ...(props.handlerProps?.environment || {}),\n      },\n      bundling: {\n        sourceMap: false,\n        // Include the migrations directory in the bundle\n        commandHooks: {\n          beforeBundling(_: string, outputDir: string): string[] {\n            return [\n              `cp ${handlerDir}/handler.js ${outputDir}`,\n              `cp -r ${migrationsDir} ${path.join(outputDir, \"migrations\")}`,\n              `mkdir -p ${path.join(outputDir, \"certs\")}`,\n              `curl --silent -fL https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem -o ${path.join(outputDir, \"certs\", \"global-bundle.pem\")}`,\n            ]\n          },\n          afterBundling(): string[] {\n            return []\n          },\n          beforeInstall(): string[] {\n            return []\n          },\n        },\n        ...props.handlerProps?.bundling,\n      },\n    })\n\n    // If the user gave us a security group, assume it can connect to the database.\n    // If not, make sure the CDK created security group allows access to the DB.\n    if (\n      props.cluster &&\n      (!props.handlerProps ||\n        typeof props.handlerProps.securityGroups === \"undefined\" ||\n        props.handlerProps.securityGroups.length === 0)\n    ) {\n      props.cluster.connections.allowDefaultPortFrom(\n        onEventHandler.connections,\n        \"Allow drizzle migrate lambda to connect to db\"\n      )\n    }\n\n    this.handler = onEventHandler\n\n    // Grant the Lambda function permission to read the secret\n    props.dbSecret.grantRead(onEventHandler)\n\n    const provider = new cr.Provider(this, \"Provider\", {\n      onEventHandler,\n      logRetention: logs.RetentionDays.ONE_WEEK,\n    })\n\n    this.resource = new CustomResource(this, \"CustomResource\", {\n      serviceToken: provider.serviceToken,\n      properties: {\n        secretArn: props.dbSecret.secretArn,\n        // We're now using a fixed path inside the Lambda bundle\n        migrationsPath: \"migrations\",\n        // Adding a timestamp ensures the resource is updated on each deployment\n        timestamp: Date.now().toString(),\n      },\n    })\n\n    const resourceCfn = this.resource.node.defaultChild as CfnResource\n    resourceCfn.addPropertyOverride(\"ServiceTimeout\", 900)\n\n    // Add dependency to ensure database is created before migrations run\n    if (props.cluster) {\n      this.resource.node.addDependency(props.cluster)\n    }\n  }\n}\n"]}
+DrizzleMigrate[_a] = { fqn: "cdk-drizzle-migrate.DrizzleMigrate", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drizzle-migrate-provider.js","sourceRoot":"","sources":["../src/drizzle-migrate-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { strict as assert } from \"assert\"\nimport { existsSync } from \"fs\"\nimport * as path from \"path\"\nimport { CfnResource, CustomResource, Duration, Stack, RemovalPolicy } from \"aws-cdk-lib\"\nimport * as dsql from \"aws-cdk-lib/aws-dsql\"\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport { NodejsFunction, NodejsFunctionProps } from \"aws-cdk-lib/aws-lambda-nodejs\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as rds from \"aws-cdk-lib/aws-rds\"\nimport * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport * as cr from \"aws-cdk-lib/custom-resources\"\nimport { Construct } from \"constructs\"\n\n/**\n * Helper function to determine if a cluster is a DSQL cluster\n */\nfunction isDsqlCluster(\n  cluster: rds.IDatabaseCluster | rds.IDatabaseInstance | dsql.CfnCluster\n): cluster is dsql.CfnCluster {\n  return cluster instanceof dsql.CfnCluster\n}\n\n/**\n * Properties for DrizzleMigrate\n */\nexport interface DrizzleMigrateProps {\n  /**\n   * The database secret containing connection details\n   * Must contain standard CDK database secret properties: username,\n   * password, host, port, engine, etc.\n   * Not required when relying on IAM authentication (such as DSQL).\n   * @default - undefined for DSQL clusters using IAM authentication\n   */\n  readonly dbSecret?: secretsmanager.ISecret\n\n  /**\n   * The path to the migrations directory\n   * This directory will be bundled with the Lambda function\n   */\n  readonly migrationsPath: string\n\n  /**\n   * Optional properties to customize the Lambda function\n   * Excludes runtime, entry, and handler which are managed by the construct\n   * @default - Default Lambda configuration is used\n   */\n  readonly handlerProps?: NodejsFunctionProps\n\n  /**\n   * The VPC where the Lambda function will be deployed\n   * Required when your database is only accessible in a VPC.\n   * Not required for DSQL as it uses public endpoints with IAM authentication\n   * @default - use VPC of your RDS/Aurora cluster\n   */\n  readonly vpc?: ec2.IVpc\n\n  /**\n   * Optional subnet selection to deploy the Lambda function\n   * Only used when vpc is specified\n   * @default - PRIVATE_WITH_EGRESS subnets\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection\n\n  /**\n   * Optional database cluster or instance\n   * Supports both traditional RDS/Aurora clusters and DSQL clusters\n   * - For RDS/Aurora: security groups will be configured to allow access\n   * - For DSQL: IAM authentication will be used instead of secrets\n   * @default - No database connection is configured\n   */\n  readonly cluster?: rds.IDatabaseCluster | rds.IDatabaseInstance | dsql.CfnCluster\n}\n\n/**\n * A custom resource that runs Drizzle migrations\n */\nexport class DrizzleMigrate extends Construct {\n  /**\n   * The custom resource that was created\n   */\n  public readonly resource: CustomResource\n\n  /**\n   * The Lambda function that executes the migrations\n   */\n  public readonly handler: NodejsFunction\n\n  constructor(scope: Construct, id: string, props: DrizzleMigrateProps) {\n    super(scope, id)\n\n    // Validate configuration\n    const isDsql = props.cluster && isDsqlCluster(props.cluster)\n    if (!isDsql && !props.dbSecret) {\n      throw new Error(\n        \"Either dbSecret (for traditional RDS) or cluster with DSQL must be provided\"\n      )\n    }\n    if (!isDsql && !props.vpc) {\n      throw new Error(\"VPC is required for traditional RDS databases\")\n    }\n    if (isDsql && props.dbSecret) {\n      throw new Error(\n        \"dbSecret should not be provided when using DSQL cluster (uses IAM authentication)\"\n      )\n    }\n\n    const migrationsDir = path.join(process.cwd(), props.migrationsPath)\n    assert(\n      existsSync(migrationsDir),\n      `Migrations directory ${migrationsDir} does not exist`\n    )\n    const handlerDir = path.join(__dirname, \"handler\")\n\n    const ts_filename = path.join(handlerDir, \"index.ts\")\n    const js_filename = path.join(handlerDir, \"index.js\")\n    const entry = existsSync(ts_filename) ? ts_filename : js_filename\n\n    const environment: Record<string, string> = {\n      NO_COLOR: \"1\",\n      ...(props.handlerProps?.environment || {}),\n    }\n\n    // Create explicit log group for the Lambda handler\n    const logGroup = new logs.LogGroup(this, \"MigrateHandlerLogGroup\", {\n      retention: logs.RetentionDays.ONE_WEEK,\n      // Keep log group, it's annoying when it gets deleted for new\n      // deploys, and something has gone wrong. You have no way to\n      // look at the logs in that case.\n      removalPolicy: RemovalPolicy.RETAIN,\n    })\n\n    const onEventHandler = new NodejsFunction(this, \"MigrateHandler\", {\n      runtime: lambda.Runtime.NODEJS_20_X,\n      entry: entry,\n      logGroup: logGroup,\n      loggingFormat: lambda.LoggingFormat.JSON,\n      applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,\n      timeout: Duration.minutes(5),\n      vpc: props.vpc,\n      vpcSubnets: props.vpcSubnets,\n      ...props.handlerProps,\n      environment,\n      bundling: {\n        sourceMap: false,\n        // Include the migrations directory in the bundle\n        commandHooks: {\n          beforeBundling(_: string, outputDir: string): string[] {\n            const commands = [\n              `cp ${handlerDir}/handler.js ${outputDir}`,\n              `cp -r ${migrationsDir} ${path.join(outputDir, \"migrations\")}`,\n              // Always download RDS certificate for SSL connections (both RDS and DSQL need it)\n              `mkdir -p ${path.join(outputDir, \"certs\")}`,\n              `curl --silent -fL https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem -o ${path.join(outputDir, \"certs\", \"global-bundle.pem\")}`,\n            ]\n\n            return commands\n          },\n          afterBundling(): string[] {\n            return []\n          },\n          beforeInstall(): string[] {\n            return []\n          },\n        },\n        ...props.handlerProps?.bundling,\n      },\n    })\n\n    // Handle database connection setup\n    if (isDsql) {\n      // For DSQL, grant IAM permissions instead of VPC security groups\n      const dsqlCluster = props.cluster as dsql.CfnCluster\n      onEventHandler.addToRolePolicy(\n        new iam.PolicyStatement({\n          effect: iam.Effect.ALLOW,\n          actions: [\"dsql:DbConnectAdmin\"],\n          resources: [dsqlCluster.attrResourceArn],\n        })\n      )\n    } else {\n      // Traditional RDS setup with security groups\n      if (\n        props.cluster &&\n        (!props.handlerProps ||\n          typeof props.handlerProps.securityGroups === \"undefined\" ||\n          props.handlerProps.securityGroups.length === 0)\n      ) {\n        const rdsCluster = props.cluster as rds.IDatabaseCluster | rds.IDatabaseInstance\n        rdsCluster.connections.allowDefaultPortFrom(\n          onEventHandler.connections,\n          \"Allow drizzle migrate lambda to connect to db\"\n        )\n      }\n\n      // Grant the Lambda function permission to read the secret\n      props.dbSecret!.grantRead(onEventHandler)\n    }\n\n    this.handler = onEventHandler\n\n    const provider = new cr.Provider(this, \"Provider\", {\n      onEventHandler,\n      logGroup,\n    })\n\n    // Build custom resource properties based on database type\n    const customResourceProperties: Record<string, string> = {\n      // We're now using a fixed path inside the Lambda bundle\n      migrationsPath: \"migrations\",\n      // Adding a timestamp ensures the resource is updated on each deployment\n      timestamp: Date.now().toString(),\n    }\n\n    if (isDsql) {\n      // For DSQL, construct the endpoint from cluster ID and region\n      // DSQL endpoint format: ${clusterId}.dsql.${region}.on.aws\n      const dsqlCluster = props.cluster as dsql.CfnCluster\n      const clusterId = dsqlCluster.attrIdentifier\n      const region = Stack.of(this).region\n      customResourceProperties.endpoint = `${clusterId}.dsql.${region}.on.aws`\n      customResourceProperties.port = \"5432\"\n    } else {\n      customResourceProperties.secretArn = props.dbSecret!.secretArn\n    }\n\n    this.resource = new CustomResource(this, \"CustomResource\", {\n      serviceToken: provider.serviceToken,\n      properties: customResourceProperties,\n    })\n\n    const resourceCfn = this.resource.node.defaultChild as CfnResource\n    resourceCfn.addPropertyOverride(\"ServiceTimeout\", 900)\n\n    // Add dependency to ensure database is created before migrations run\n    if (props.cluster) {\n      this.resource.node.addDependency(props.cluster)\n    }\n  }\n}\n"]}