MinimalLambda.Envelopes.KinesisFirehose 2.6.0

MinimalLambda.Envelopes.KinesisFirehose

Strongly-typed Kinesis Firehose event handling for the MinimalLambda framework.

Overview

This package provides strongly-typed envelopes for handling Kinesis Firehose transformation events in Lambda functions. It contains classes that can be used as input and output types for Lambda functions that transform data records for Kinesis Data Firehose.

The envelopes extend the base KinesisFirehoseEvent and KinesisFirehoseResponse with strongly-typed DataContent properties for easier data transformation. Instead of manually decoding base64 data from record.Data and parsing JSON, you access deserialized payloads directly via record.DataContent:

Quick Start

Define your data types, then create a transformation handler:

using System;
using MinimalLambda.Builder;
using MinimalLambda.Envelopes.KinesisFirehose;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

var builder = LambdaApplication.CreateBuilder();
var lambda = builder.Build();

// KinesisFirehoseEventEnvelope<InputData> provides the Firehose event with deserialized records
// KinesisFirehoseResponseEnvelope<OutputData> wraps the response and serializes the transformed data
lambda.MapHandler(
 ([FromEvent] KinesisFirehoseEventEnvelope<InputData> request, ILogger<Program> logger) =>
 {
 var response = new KinesisFirehoseResponseEnvelope<OutputData>
 {
 Records = new List<KinesisFirehoseResponseEnvelope<OutputData>.FirehoseRecordEnvelope>()
 };

 foreach (var record in request.Records)
 {
 logger.LogInformation("Processing record: {Name}", record.DataContent?.Name);

 // Transform the data
 var transformedData = new OutputData(
 $"{record.DataContent?.Name?.ToUpper()}",
 record.DataContent?.Value * 2 ?? 0
 );

 // Add to response
 response.Records.Add(new KinesisFirehoseResponseEnvelope<OutputData>.FirehoseRecordEnvelope
 {
 RecordId = record.RecordId,
 Result = "Ok",
 DataContent = transformedData
 });
 }

 return response;
 }
);

await lambda.RunAsync();

// Your input and output data types
internal record InputData(string Name, int Value);

internal record OutputData(string TransformedName, int TransformedValue);

Custom Envelopes

To implement custom deserialization or serialization logic, extend the appropriate base class and override the payload handling method:

// Example: Custom XML deserialization for Firehose events
public sealed class XmlKinesisFirehoseEventEnvelope<T> : KinesisFirehoseEventEnvelopeBase<T>
{
 public override void ExtractPayload(EnvelopeOptions options)
 {
 foreach (var record in Records)
 {
 var decodedData = record.DecodeData();
 using var stringReader = new StringReader(decodedData);
 using var xmlReader = XmlReader.Create(stringReader, options.XmlReaderSettings);
 var serializer = new XmlSerializer(typeof(T));
 record.DataContent = (T)serializer.Deserialize(xmlReader)!;
 }
 }
}

// Example: Custom XML serialization for Firehose responses
public sealed class XmlKinesisFirehoseResponseEnvelope<T> : KinesisFirehoseResponseEnvelopeBase<T>
{
 public override void PackPayload(EnvelopeOptions options)
 {
 foreach (var record in Records)
 {
 using var stringWriter = new StringWriter();
 using var xmlWriter = XmlWriter.Create(stringWriter, options.XmlWriterSettings);
 var serializer = new XmlSerializer(typeof(T));
 serializer.Serialize(xmlWriter, record.DataContent);
 record.EncodeData(stringWriter.ToString());
 }
 }
}

This pattern allows you to support multiple serialization formats while maintaining the same envelope interface.

AOT Support

When using .NET Native AOT, register all envelope and payload types in your JsonSerializerContext:

[JsonSerializable(typeof(KinesisFirehoseEventEnvelope<InputData>))]
[JsonSerializable(typeof(KinesisFirehoseResponseEnvelope<OutputData>))]
[JsonSerializable(typeof(InputData))]
[JsonSerializable(typeof(OutputData))]
internal partial class SerializerContext : JsonSerializerContext;

Register the serializer and configure envelope options to use the context:

builder.Services.AddLambdaSerializerWithContext<SerializerContext>();

builder.Services.ConfigureEnvelopeOptions(options =>
{
 options.JsonOptions.TypeInfoResolver = SerializerContext.Default;
});

Other Packages

Additional packages in the minimal-lambda framework for abstractions, observability, and event source handling.

License

This project is licensed under the MIT License. See for details.