konokenj.cdk-api-mcp-server 0.49.0__py3-none-any.whl → 0.50.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.managedinstances-no-default-capacity-provider.ts

@@ -0,0 +1,107 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as cdk from 'aws-cdk-lib';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm': true,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+  },
+});
+const stack = new cdk.Stack(app, 'integ-managedinstances-no-default-capacity-provider');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+const cluster = new ecs.Cluster(stack, 'ManagedInstancesCluster', {
+  vpc,
+});
+
+// Create IAM roles required for FMI following Omakase specifications
+const infrastructureRole = new iam.Role(stack, 'InfrastructureRole', {
+  roleName: 'InfrastructureRole',
+  assumedBy: new iam.ServicePrincipal('ecs.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonECSInfrastructureRolePolicyForManagedInstances'),
+  ],
+});
+
+const instanceRole = new iam.Role(stack, 'InstanceRole', {
+  roleName: 'InstanceRole',
+  assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonECSInstanceRolePolicyForManagedInstances'),
+  ],
+});
+
+infrastructureRole.grantPassRole(instanceRole);
+
+const instanceProfile = new iam.InstanceProfile(stack, 'InstanceProfile', {
+  instanceProfileName: 'InstanceProfile',
+  role: instanceRole,
+});
+
+// Create a security group for FMI instances
+const fmiSecurityGroup = new ec2.SecurityGroup(stack, 'ManagedInstancesSecurityGroup', {
+  vpc,
+  description: 'Security group for ManagedInstances capacity provider instances',
+  allowAllOutbound: true,
+});
+
+// Create MI Capacity Provider
+const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(stack, 'ManagedInstancesCapacityProvider', {
+  infrastructureRole: infrastructureRole,
+  ec2InstanceProfile: instanceProfile,
+  subnets: vpc.privateSubnets,
+  securityGroups: [fmiSecurityGroup],
+  propagateTags: ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER,
+  instanceRequirements: {
+    vCpuCountMin: 1,
+    memoryMin: cdk.Size.gibibytes(2),
+    cpuManufacturers: [ec2.CpuManufacturer.INTEL],
+    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
+  },
+});
+
+// Add FMI capacity provider to cluster
+cluster.addManagedInstancesCapacityProvider(miCapacityProvider);
+
+// Create a task definition compatible with Managed Instances and Fargate
+const taskDefinition = new ecs.TaskDefinition(stack, 'TaskDef', {
+  compatibility: ecs.Compatibility.FARGATE_AND_MANAGED_INSTANCES,
+  cpu: '256',
+  memoryMiB: '512',
+  networkMode: ecs.NetworkMode.AWS_VPC,
+});
+
+taskDefinition.addContainer('web', {
+  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/docker/library/httpd:2.4'),
+  memoryLimitMiB: 512,
+  portMappings: [
+    {
+      containerPort: 80,
+      protocol: ecs.Protocol.TCP,
+    },
+  ],
+});
+
+// Create a service using the MI capacity provider
+new ecs.FargateService(stack, 'ManagedInstancesService', {
+  cluster,
+  taskDefinition,
+  capacityProviderStrategies: [
+    {
+      capacityProvider: miCapacityProvider.capacityProviderName,
+      weight: 1,
+    },
+  ],
+  desiredCount: 1,
+});
+
+new integ.IntegTest(app, 'ManagedInstancesCapacityProviders', {
+  testCases: [stack],
+  regions: ['us-west-2'],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs-patterns/integ.alb-fargate-service-public-private-switch.ts

@@ -0,0 +1,45 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as ecsPatterns from 'aws-cdk-lib/aws-ecs-patterns';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-ecs-integ-alb-fargate-public-private-switch');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+const cluster = new ecs.Cluster(stack, 'FargateCluster', { vpc });
+
+// Test private load balancer (the problematic case from the issue)
+new ecsPatterns.ApplicationLoadBalancedFargateService(stack, 'PrivateALBFargateService', {
+  cluster,
+  memoryLimitMiB: 1024,
+  cpu: 512,
+  publicLoadBalancer: false, // This should create ECSPrivate target group
+  taskImageOptions: {
+    image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  },
+});
+
+// Test public load balancer for comparison
+new ecsPatterns.ApplicationLoadBalancedFargateService(stack, 'PublicALBFargateService', {
+  cluster,
+  memoryLimitMiB: 1024,
+  cpu: 512,
+  publicLoadBalancer: true, // This should create ECS target group
+  taskImageOptions: {
+    image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  },
+});
+
+new integ.IntegTest(app, 'ALBFargatePublicPrivateSwitchTest', {
+  testCases: [stack],
+  allowDestroy: [
+    'PrivateALBFargateServiceLB3F43693F',
+    'PrivateALBFargateServiceLBPublicListenerECSPrivateGroup81AA5B8B',
+    'PublicALBFargateServiceLBBDD839E7',
+    'PublicALBFargateServiceLBPublicListenerECSGroupD991EA00',
+  ],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2/integ.alb-lambda-multi-value-headers.ts

@@ -19,7 +19,7 @@ const vpc = new ec2.Vpc(stack, 'VPC', {
 });
 
 const fn = new lambda.Function(stack, 'Function', {
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: lambda.Code.fromInline(`
     exports.handler = async (event) => {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2/integ.alb.oidc.ts

@@ -186,7 +186,7 @@ const signinFunction = new lambda.Function(testCase, 'Signin', {
   functionName: 'cdk-integ-alb-oidc-signin-handler',
   code: lambda.Code.fromAsset('alb-oidc-signin-handler', { exclude: ['*.ts'] }),
   handler: 'index.handler',
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   environment: {
     TEST_USERNAME: testUser.username,
     TEST_PASSWORD: testUser.password,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2-actions/integ.cognito.ts

@@ -206,7 +206,7 @@ const signinFunction = new lambda.Function(testCase, 'Signin', {
   functionName: 'cdk-integ-alb-cognito-signin-handler',
   code: lambda.Code.fromAsset('alb-cognito-signin-handler', { exclude: ['*.ts'] }),
   handler: 'index.handler',
-  runtime: lambda.Runtime.NODEJS_18_X,
+  runtime: lambda.Runtime.NODEJS_20_X,
   environment: {
     TEST_USERNAME: testUser.username,
     TEST_PASSWORD: testUser.password,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/README.md

@@ -125,6 +125,102 @@ const s3Destination = new firehose.S3Bucket(bucket, {
 });
 ```
 
+## Data Format Conversion
+
+Data format conversion allows automatic conversion of inputs from JSON to either Parquet or ORC.
+Converting JSON records to columnar formats like Parquet or ORC can help speed up analytical querying while also increasing compression efficiency.
+When data format conversion is specified, it automatically enables Snappy compression on the output.
+
+Only S3 Destinations support data format conversion.
+
+An example of defining an S3 destination configured with data format conversion:
+
+```ts
+declare const bucket: s3.Bucket;
+declare const schemaGlueTable: glue.CfnTable;
+const s3Destination = new firehose.S3Bucket(bucket, {
+  dataFormatConversion: {
+    schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaGlueTable),
+    inputFormat: firehose.InputFormat.OPENX_JSON,
+    outputFormat: firehose.OutputFormat.PARQUET,
+  }
+});
+```
+
+When data format conversion is enabled, the Delivery Stream's buffering size must be at least 64 MiB. 
+Additionally, the default buffering size is changed from 5 MiB to 128 MiB. This mirrors the Cloudformation behavior.
+
+You can only parse JSON and transform it into either Parquet or ORC:
+- to read JSON using OpenX parser, choose `InputFormat.OPENX_JSON`.
+- to read JSON using Hive parser, choose `InputFormat.HIVE_JSON`.
+- to transform into Parquet, choose `OutputFormat.PARQUET`.
+- to transform into ORC, choose `OutputFormat.ORC`.
+
+The following subsections explain how to specify advanced configuration options for each input and output format if the defaults are not desirable
+
+### Input Format: OpenX JSON
+
+Example creation of custom OpenX JSON InputFormat:
+
+```ts
+const inputFormat = new firehose.OpenXJsonInputFormat({
+  lowercaseColumnNames: false,
+  columnToJsonKeyMappings: {"ts": "timestamp"},
+  convertDotsInJsonKeysToUnderscores: true,
+})
+```
+
+### Input Format: Hive JSON
+
+Example creation of custom Hive JSON InputFormat:
+
+```ts
+const inputFormat = new firehose.HiveJsonInputFormat({
+  timestampParsers: [
+    firehose.TimestampParser.fromFormatString('yyyy-MM-dd'),
+    firehose.TimestampParser.EPOCH_MILLIS,
+  ]
+})
+```
+
+Hive JSON allows you to specify custom timestamp formats to parse. The syntax of the format string is Joda Time.
+
+To parse timestamps formatted as milliseconds since epoch, use the convenience constant `TimestampParser.EPOCH_MILLIS`.
+
+### Output Format: Parquet
+
+Example of a custom Parquet OutputFormat, with all values changed from the defaults.
+
+```ts
+const outputFormat = new firehose.ParquetOutputFormat({
+  blockSize: Size.mebibytes(512),
+  compression: firehose.ParquetCompression.UNCOMPRESSED,
+  enableDictionaryCompression: true,
+  maxPadding: Size.bytes(10),
+  pageSize: Size.mebibytes(2),
+  writerVersion: firehose.ParquetWriterVersion.V2,
+})
+```
+
+### Output Format: ORC
+
+Example creation of custom ORC OutputFormat, with all values changed from the defaults.
+
+```ts
+const outputFormat = new firehose.OrcOutputFormat({
+  formatVersion: firehose.OrcFormatVersion.V0_11,
+  blockSize: Size.mebibytes(256),
+  compression: firehose.OrcCompression.NONE,
+  bloomFilterColumns: ['columnA'],
+  bloomFilterFalsePositiveProbability: 0.1,
+  dictionaryKeyThreshold: 0.7,
+  enablePadding: true,
+  paddingTolerance: 0.2,
+  rowIndexStride: 9000,
+  stripeSize: Size.mebibytes(32),
+})
+```
+
 ## Server-side Encryption
 
 Enabling server-side encryption (SSE) requires Amazon Data Firehose to encrypt all data

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.record-format-conversion-schema.ts

@@ -0,0 +1,154 @@
+import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as glue from 'aws-cdk-lib/aws-glue';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+
+const app = new cdk.App();
+
+const SCHEMA_COLUMNS = [
+  {
+    name: 'column_a',
+    type: 'string',
+  },
+  {
+    name: 'column_b',
+    type: 'string',
+  },
+];
+
+class TestStack extends cdk.Stack {
+  public readonly deliveryStreamsToTest: firehose.IDeliveryStream[];
+  public readonly bucket: s3.Bucket;
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    const database = new glue.CfnDatabase(this, 'Database', {
+      databaseInput: {
+        description: 'My database',
+      },
+      catalogId: this.account,
+    });
+
+    const registry = new glue.CfnRegistry(this, 'SchemaRegistry', {
+      name: 'my_schema_registry',
+    });
+
+    const inlineSchemaTable = this.createTableWithInlineSchema(database);
+    const inlineSchemaDeliveryStream = this.createDeliveryStreamWithDataFormatConversion('InlineSchema', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(inlineSchemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    const registrySchemaTable = this.createTableWithRegistrySchema(database, registry);
+    const registrySchemaDeliveryStream = this.createDeliveryStreamWithDataFormatConversion('RegistrySchema', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(registrySchemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    this.deliveryStreamsToTest = [
+      inlineSchemaDeliveryStream,
+      registrySchemaDeliveryStream,
+    ];
+  }
+
+  private createTableWithInlineSchema(database: glue.CfnDatabase): glue.CfnTable {
+    return new glue.CfnTable(this, 'InlineSchemaTable', {
+      catalogId: database.catalogId,
+      databaseName: database.ref,
+      tableInput: {
+        storageDescriptor: {
+          columns: SCHEMA_COLUMNS,
+        },
+      },
+    });
+  }
+
+  private createTableWithRegistrySchema(database: glue.CfnDatabase, registry: glue.CfnRegistry): glue.CfnTable {
+    const schemaDefinition = JSON.stringify({
+      type: 'record',
+      name: 'MyRecord',
+      fields: SCHEMA_COLUMNS,
+    });
+
+    const schema = new glue.CfnSchema(this, 'Schema', {
+      registry: {
+        arn: registry.attrArn,
+      },
+      compatibility: 'NONE',
+      dataFormat: 'AVRO',
+      name: 'my_schema',
+      schemaDefinition: schemaDefinition,
+    });
+
+    return new glue.CfnTable(this, 'RegistrySchemaTable', {
+      catalogId: database.catalogId,
+      databaseName: database.ref,
+      tableInput: {
+        storageDescriptor: {
+          schemaReference: {
+            schemaVersionId: schema.attrInitialSchemaVersionId,
+          },
+        },
+      },
+    });
+  }
+
+  private createDeliveryStreamWithDataFormatConversion(
+    id: string,
+    dataFormatConversion: firehose.DataFormatConversionProps,
+  ): firehose.DeliveryStream {
+    return new firehose.DeliveryStream(this, id, {
+      destination: new firehose.S3Bucket(this.bucket, {
+        dataOutputPrefix: `success/${id}/`,
+        errorOutputPrefix: `error/${id}/`,
+        bufferingInterval: cdk.Duration.seconds(0),
+        dataFormatConversion: dataFormatConversion,
+      }),
+    });
+  }
+}
+
+const stack = new TestStack(app, 'RecordFormatConversionSchema');
+const testCase = new integ.IntegTest(app, 'RecordFormatConversionSchemaTest', {
+  testCases: [stack],
+});
+
+const assertions = testCase.assertions;
+
+// Test each delivery stream with the same input, and verify that each writes the output to the success prefix
+// Relies on waiting timeout to tell if record format conversion failed.
+stack.deliveryStreamsToTest.forEach(deliveryStream => {
+  const putDataCall = assertions.awsApiCall('Firehose', 'putRecord', {
+    DeliveryStreamName: deliveryStream.deliveryStreamName,
+    Record: {
+      Data: JSON.stringify({
+        Column_A: 'foo',
+        Column_B: 'bar',
+      }),
+    },
+  });
+
+  const waitForResultCall = assertions.awsApiCall('S3', 'listObjectsV2', {
+    Bucket: stack.bucket.bucketName,
+    Prefix: `success/${deliveryStream.node.id}/`,
+  }).expect(integ.ExpectedResult.objectLike({
+    KeyCount: 1,
+  })).waitForAssertions({
+    interval: cdk.Duration.seconds(5),
+    totalTimeout: cdk.Duration.minutes(2),
+  });
+
+  const api = waitForResultCall as integ.AwsApiCall;
+  api.waiterProvider?.addPolicyStatementFromSdkCall('s3', 'ListBucket', [stack.bucket.bucketArn]);
+  api.waiterProvider?.addPolicyStatementFromSdkCall('s3', 'GetObject', [stack.bucket.arnForObjects('*')]);
+  putDataCall.next(waitForResultCall);
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-kinesisfirehose/integ.record-format-conversion.ts

@@ -0,0 +1,178 @@
+import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as glue from 'aws-cdk-lib/aws-glue';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+
+const app = new cdk.App();
+
+const SCHEMA_COLUMNS = [
+  {
+    name: 'column_a',
+    type: 'string',
+  },
+  {
+    name: 'column_b',
+    type: 'string',
+  },
+];
+
+class TestStack extends cdk.Stack {
+  public readonly bucket: s3.Bucket;
+  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    this.bucket = new s3.Bucket(this, 'Bucket', {
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+
+    const database = new glue.CfnDatabase(this, 'Database', {
+      databaseInput: {
+        description: 'My database',
+      },
+      catalogId: this.account,
+    });
+
+    const schemaTable = this.createTableWithInlineSchema(database);
+
+    // default hive json input with default orc output
+    this.createDeliveryStreamWithDataFormatConversion('DefaultHiveJsonOrc', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.HIVE_JSON,
+      outputFormat: firehose.OutputFormat.ORC,
+    });
+
+    // default openx json input with default parquet output
+    this.createDeliveryStreamWithDataFormatConversion('DefaultOpenXJsonParquet', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    // custom hive json input
+    this.createDeliveryStreamWithDataFormatConversion('CustomHiveJson', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: new firehose.HiveJsonInputFormat({
+        timestampParsers: [
+          firehose.TimestampParser.EPOCH_MILLIS,
+          firehose.TimestampParser.fromFormatString('yyyy-MM-dd'),
+        ],
+      }),
+      outputFormat: firehose.OutputFormat.ORC,
+    });
+
+    // custom openx json input
+    this.createDeliveryStreamWithDataFormatConversion('CustomOpenXJson', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: new firehose.OpenXJsonInputFormat({
+        lowercaseColumnNames: false,
+        columnToJsonKeyMappings: { column_yay: 'Column_A' },
+        convertDotsInJsonKeysToUnderscores: true,
+      }),
+      outputFormat: firehose.OutputFormat.PARQUET,
+    });
+
+    // custom orc output
+    this.createDeliveryStreamWithDataFormatConversion('CustomOrc', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.OrcOutputFormat({
+        blockSize: cdk.Size.mebibytes(256),
+        bloomFilterColumns: ['column_a'],
+        bloomFilterFalsePositiveProbability: 0.5,
+        compression: firehose.OrcCompression.NONE,
+        dictionaryKeyThreshold: 0.3,
+        formatVersion: firehose.OrcFormatVersion.V0_11,
+        enablePadding: true,
+        paddingTolerance: 0.4,
+        rowIndexStride: 5000,
+        stripeSize: cdk.Size.mebibytes(32),
+      }),
+    });
+
+    // ORC ZLIB compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomOrcZlib', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.OrcOutputFormat({
+        compression: firehose.OrcCompression.ZLIB,
+        formatVersion: firehose.OrcFormatVersion.V0_12,
+      }),
+    });
+
+    // ORC SNAPPY compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomOrcSnappy', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.OrcOutputFormat({
+        compression: firehose.OrcCompression.SNAPPY,
+      }),
+    });
+
+    // custom parquet output format
+    this.createDeliveryStreamWithDataFormatConversion('CustomParquet', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.ParquetOutputFormat({
+        blockSize: cdk.Size.mebibytes(128),
+        pageSize: cdk.Size.mebibytes(2),
+        compression: firehose.ParquetCompression.UNCOMPRESSED,
+        writerVersion: firehose.ParquetWriterVersion.V2,
+        enableDictionaryCompression: true,
+        maxPadding: cdk.Size.bytes(100),
+      }),
+    });
+
+    // Parquet GZIP compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomParquetGzip', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.ParquetOutputFormat({
+        compression: firehose.ParquetCompression.GZIP,
+        writerVersion: firehose.ParquetWriterVersion.V1,
+      }),
+    });
+
+    // Parquet SNAPPY compression
+    this.createDeliveryStreamWithDataFormatConversion('CustomParquetSnappy', {
+      schemaConfiguration: firehose.SchemaConfiguration.fromCfnTable(schemaTable),
+      inputFormat: firehose.InputFormat.OPENX_JSON,
+      outputFormat: new firehose.ParquetOutputFormat({
+        compression: firehose.ParquetCompression.SNAPPY,
+      }),
+    });
+  }
+
+  private createTableWithInlineSchema(database: glue.CfnDatabase): glue.CfnTable {
+    return new glue.CfnTable(this, 'InlineSchemaTable', {
+      catalogId: database.catalogId,
+      databaseName: database.ref,
+      tableInput: {
+        storageDescriptor: {
+          columns: SCHEMA_COLUMNS,
+        },
+      },
+    });
+  }
+
+  private createDeliveryStreamWithDataFormatConversion(
+    id: string,
+    dataFormatConversion: firehose.DataFormatConversionProps,
+  ): firehose.DeliveryStream {
+    return new firehose.DeliveryStream(this, id, {
+      destination: new firehose.S3Bucket(this.bucket, {
+        dataOutputPrefix: `success/${id}/`,
+        errorOutputPrefix: `error/${id}/`,
+        bufferingInterval: cdk.Duration.seconds(0),
+        dataFormatConversion: dataFormatConversion,
+      }),
+    });
+  }
+}
+
+const stack = new TestStack(app, 'RecordFormatConversion');
+new integ.IntegTest(app, 'RecordFormatConversionTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.binary-payload.ts

@@ -10,7 +10,7 @@ const app = new App({
 const stack = new Stack(app, 'IntegBinaryPayload');
 
 const fn = new Function(stack, 'fn', {
-  runtime: Runtime.NODEJS_18_X,
+  runtime: Runtime.NODEJS_20_X,
   handler: 'index.handler',
   code: Code.fromInline(`
     exports.handler = async (event) => {