eoapi-cdk 8.1.1 → 8.2.1

package/lib/stac-item-loader/index.d.ts

@@ -0,0 +1,337 @@
+import { aws_ec2 as ec2, aws_lambda as lambda, aws_sqs as sqs, aws_sns as sns } from "aws-cdk-lib";
+import { Construct } from "constructs";
+import { PgStacDatabase } from "../database";
+import { CustomLambdaFunctionProps } from "../utils";
+/**
+ * Configuration properties for the StacItemLoader construct.
+ *
+ * The StacItemLoader is part of a two-phase serverless STAC ingestion pipeline
+ * that loads STAC items into a pgstac database. This construct creates
+ * the infrastructure for receiving STAC items from multiple sources:
+ * 1. SNS messages containing STAC metadata (direct ingestion)
+ * 2. S3 event notifications for STAC items uploaded to S3 buckets
+ *
+ * Items from both sources are batched and inserted into PostgreSQL with the pgstac extension.
+ *
+ * @example
+ * const loader = new StacItemLoader(this, 'ItemLoader', {
+ *   pgstacDb: database,
+ *   batchSize: 1000,
+ *   maxBatchingWindowMinutes: 1,
+ *   lambdaTimeoutSeconds: 300
+ * });
+ */
+export interface StacItemLoaderProps {
+    /**
+     * The PgSTAC database instance to load items into.
+     *
+     * This database must have the pgstac extension installed and be properly
+     * configured with collections before items can be loaded. The loader will
+     * use AWS Secrets Manager to securely access database credentials.
+     */
+    readonly pgstacDb: PgStacDatabase;
+    /**
+     * VPC into which the lambda should be deployed.
+     */
+    readonly vpc?: ec2.IVpc;
+    /**
+     * Subnet into which the lambda should be deployed.
+     */
+    readonly subnetSelection?: ec2.SubnetSelection;
+    /**
+     * The lambda runtime to use for the item loading function.
+     *
+     * The function is implemented in Python and uses pypgstac for database
+     * operations. Ensure the runtime version is compatible with the pgstac
+     * version specified in the database configuration.
+     *
+     * @default lambda.Runtime.PYTHON_3_11
+     */
+    readonly lambdaRuntime?: lambda.Runtime;
+    /**
+     * The timeout for the item load lambda in seconds.
+     *
+     * This should accommodate the time needed to process up to `batchSize`
+     * items and perform database insertions. The SQS visibility timeout
+     * will be set to this value plus 10 seconds.
+     *
+     * @default 300
+     */
+    readonly lambdaTimeoutSeconds?: number;
+    /**
+     * Memory size for the lambda function in MB.
+     *
+     * Higher memory allocation may improve performance when processing
+     * large batches of STAC items, especially for memory-intensive
+     * database operations.
+     *
+     * @default 1024
+     */
+    readonly memorySize?: number;
+    /**
+     * SQS batch size for lambda event source.
+     *
+     * This determines the maximum number of STAC items that will be
+     * processed together in a single lambda invocation. Larger batch
+     * sizes improve database insertion efficiency but require more
+     * memory and longer processing time.
+     *
+     * **Batching Behavior**: SQS will wait to accumulate up to this many
+     * messages before triggering the Lambda, OR until the maxBatchingWindow
+     * timeout is reached, whichever comes first. This creates an efficient
+     * balance between throughput and latency.
+     *
+     * @default 500
+     */
+    readonly batchSize?: number;
+    /**
+     * Maximum batching window in minutes.
+     *
+     * Even if the batch size isn't reached, the lambda will be triggered
+     * after this time period to ensure timely processing of items.
+     * This prevents items from waiting indefinitely in low-volume scenarios.
+     *
+     * **Important**: This timeout works in conjunction with batchSize - SQS
+     * will trigger the Lambda when EITHER the batch size is reached OR this
+     * time window expires, ensuring items are processed in a timely manner
+     * regardless of volume.
+     *
+     * @default 1
+     */
+    readonly maxBatchingWindowMinutes?: number;
+    /**
+     * Maximum concurrent executions for the StacItemLoader Lambda function
+     *
+     * This limit will be applied to the Lambda function and will control how
+     * many concurrent batches will be released from the SQS queue.
+     *
+     * @default 2
+     */
+    readonly maxConcurrency?: number;
+    /**
+     * Additional environment variables for the lambda function.
+     *
+     * These will be merged with the default environment variables including
+     * PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags.
+     */
+    readonly environment?: {
+        [key: string]: string;
+    };
+    /**
+     * Can be used to override the default lambda function properties.
+     *
+     * @default - defined in the construct.
+     */
+    readonly lambdaFunctionOptions?: CustomLambdaFunctionProps;
+}
+/**
+ * AWS CDK Construct for STAC Item Loading Infrastructure
+ *
+ * The StacItemLoader creates a serverless, event-driven system for loading
+ * STAC (SpatioTemporal Asset Catalog) items into a PostgreSQL database with
+ * the pgstac extension. This construct supports multiple ingestion pathways
+ * for flexible STAC item loading.
+ *
+ * ## Architecture Overview
+ *
+ * This construct creates the following AWS resources:
+ * - **SNS Topic**: Entry point for STAC items and S3 event notifications
+ * - **SQS Queue**: Buffers and batches messages before processing (60-second visibility timeout)
+ * - **Dead Letter Queue**: Captures failed loading attempts after 5 retries
+ * - **Lambda Function**: Python function that processes batches and inserts items into pgstac
+ *
+ * ## Data Flow
+ *
+ * The loader supports two primary data ingestion patterns:
+ *
+ * ### Direct STAC Item Publishing
+ * 1. STAC items (JSON) are published directly to the SNS topic in message bodies
+ * 2. The SQS queue collects messages and batches them (up to {batchSize} items or 1 minute window)
+ * 3. The Lambda function receives batches, validates items, and inserts into pgstac
+ *
+ * ### S3 Event-Driven Loading
+ * 1. An S3 bucket is configured to send notifications to the SNS topic when json files are created
+ * 2. STAC items are uploaded to S3 buckets as JSON/GeoJSON files
+ * 3. S3 event notifications are sent to the SNS topic when items are uploaded
+ * 4. The Lambda function receives S3 events in the SQS message batch, fetches items from S3, and loads into pgstac
+ *
+ * ## Batching Behavior
+ *
+ * The SQS-to-Lambda integration uses intelligent batching to optimize performance:
+ *
+ * - **Batch Size**: Lambda waits to receive up to `batchSize` messages (default: 500)
+ * - **Batching Window**: If fewer than `batchSize` messages are available, Lambda
+ *   triggers after `maxBatchingWindow` minutes (default: 1 minute)
+ * - **Trigger Condition**: Lambda executes when EITHER condition is met first
+ * - **Concurrency**: Limited to `maxConcurrency` concurrent executions to prevent database overload
+ * - **Partial Failures**: Uses `reportBatchItemFailures` to retry only failed items
+ *
+ * This approach balances throughput (larger batches = fewer database connections)
+ * with latency (time-based triggers prevent indefinite waiting).
+ *
+ * ## Error Handling and Dead Letter Queue
+ *
+ * Failed messages are sent to the dead letter queue after 5 processing attempts.
+ * **Important**: This construct provides NO automated handling of dead letter queue
+ * messages - monitoring, inspection, and reprocessing of failed items is the
+ * responsibility of the implementing application.
+ *
+ * Consider implementing:
+ * - CloudWatch alarms on dead letter queue depth
+ * - Manual or automated reprocessing workflows
+ * - Logging and alerting for failed items
+ * - Regular cleanup of old dead letter messages (14-day retention)
+ *
+ * ## Operational Characteristics
+ *
+ * - **Scalability**: Lambda scales automatically based on queue depth
+ * - **Reliability**: Dead letter queue captures failures for debugging
+ * - **Efficiency**: Batching optimizes database operations for high throughput
+ * - **Security**: Database credentials accessed via AWS Secrets Manager
+ * - **Observability**: CloudWatch logs retained for one week
+ *
+ * ## Prerequisites
+ *
+ * Before using this construct, ensure:
+ * - The pgstac database has collections loaded (items require existing collection IDs)
+ * - Database credentials are stored in AWS Secrets Manager
+ * - The pgstac extension is properly installed and configured
+ *
+ * ## Usage Example
+ *
+ * ```typescript
+ * // Create database first
+ * const database = new PgStacDatabase(this, 'Database', {
+ *   pgstacVersion: '0.9.5'
+ * });
+ *
+ * // Create item loader
+ * const loader = new StacItemLoader(this, 'ItemLoader', {
+ *   pgstacDb: database,
+ *   batchSize: 1000,          // Process up to 1000 items per batch
+ *   maxBatchingWindowMinutes: 1, // Wait max 1 minute to fill batch
+ *   lambdaTimeoutSeconds: 300     // Allow up to 300 seconds for database operations
+ * });
+ *
+ * // The topic ARN can be used by other services to publish items
+ * new CfnOutput(this, 'LoaderTopicArn', {
+ *   value: loader.topic.topicArn
+ * });
+ * ```
+ *
+ * ## Direct Item Publishing
+ *
+ * External services can publish STAC items directly to the topic:
+ *
+ * ```bash
+ * aws sns publish --topic-arn $ITEM_LOAD_TOPIC --message '{
+ *   "type": "Feature",
+ *   "stac_version": "1.0.0",
+ *   "id": "example-item",
+ *   "properties": {"datetime": "2021-01-01T00:00:00Z"},
+ *   "geometry": {"type": "Polygon", "coordinates": [...]},
+ *   "collection": "example-collection"
+ * }'
+ * ```
+ *
+ * ## S3 Event Configuration
+ *
+ * To enable S3 event-driven loading, configure S3 bucket notifications to send
+ * events to the SNS topic when STAC items (.json or .geojson files) are uploaded:
+ *
+ * ```typescript
+ * // Configure S3 bucket to send notifications to the loader topic
+ * bucket.addEventNotification(
+ *   s3.EventType.OBJECT_CREATED,
+ *   new s3n.SnsDestination(loader.topic),
+ *   { suffix: '.json' }
+ * );
+ *
+ * bucket.addEventNotification(
+ *   s3.EventType.OBJECT_CREATED,
+ *   new s3n.SnsDestination(loader.topic),
+ *   { suffix: '.geojson' }
+ * );
+ * ```
+ *
+ * When STAC items are uploaded to the configured S3 bucket, the loader will:
+ * 1. Receive S3 event notifications via SNS
+ * 2. Fetch the STAC item JSON from S3
+ * 3. Validate and load the item into the pgstac database
+ *
+ * ## Monitoring and Troubleshooting
+ *
+ * - Monitor Lambda logs: `/aws/lambda/{FunctionName}`
+ * - **Dead Letter Queue**: Check for failed items - **no automated handling provided**
+ * - Use batch item failure reporting for partial batch processing
+ * - CloudWatch metrics available for queue depth and Lambda performance
+ *
+ * ### Dead Letter Queue Management
+ *
+ * Applications must implement their own dead letter queue monitoring:
+ *
+ * ```typescript
+ * // Example: CloudWatch alarm for dead letter queue depth
+ * new cloudwatch.Alarm(this, 'DeadLetterAlarm', {
+ *   metric: loader.deadLetterQueue.metricApproximateNumberOfVisibleMessages(),
+ *   threshold: 1,
+ *   evaluationPeriods: 1
+ * });
+ *
+ * // Example: Lambda to reprocess dead letter messages
+ * const reprocessFunction = new lambda.Function(this, 'Reprocess', {
+ *   // Implementation to fetch and republish failed messages
+ * });
+ * ```
+ *
+ */
+export declare class StacItemLoader extends Construct {
+    /**
+     * The SNS topic that receives STAC items and S3 event notifications for loading.
+     *
+     * This topic serves as the entry point for two types of events:
+     * 1. Direct STAC item JSON documents published by external services
+     * 2. S3 event notifications when STAC items are uploaded to configured buckets
+     *
+     * The topic fans out to the SQS queue for batched processing.
+     */
+    readonly topic: sns.Topic;
+    /**
+     * The SQS queue that buffers messages before processing.
+     *
+     * This queue collects both direct STAC items from SNS and S3 event
+     * notifications, batching them for efficient database operations.
+     * Configured with a visibility timeout that accommodates Lambda
+     * processing time plus buffer.
+     */
+    readonly queue: sqs.Queue;
+    /**
+     * Dead letter queue for failed item loading attempts.
+     *
+     * Messages that fail processing after 5 attempts are sent here
+     * for inspection and potential replay. Retains messages for 14 days
+     * to allow for debugging and manual intervention.
+     *
+     * **User Responsibility**: This construct provides NO automated monitoring,
+     * alerting, or reprocessing of dead letter queue messages. Applications
+     * using this construct must implement their own:
+     * - Dead letter queue depth monitoring and alerting
+     * - Failed message inspection and debugging workflows
+     * - Manual or automated reprocessing mechanisms
+     * - Cleanup procedures for old failed messages
+     */
+    readonly deadLetterQueue: sqs.Queue;
+    /**
+     * The Lambda function that loads STAC items into the pgstac database.
+     *
+     * This Python function receives batches of messages from SQS and processes
+     * them based on their type:
+     * - Direct STAC items: Validates and loads directly into pgstac
+     * - S3 events: Fetches STAC items from S3, validates, and loads into pgstac
+     *
+     * The function connects to PostgreSQL using credentials from Secrets Manager
+     * and uses pypgstac for efficient database operations.
+     */
+    readonly lambdaFunction: lambda.Function;
+    constructor(scope: Construct, id: string, props: StacItemLoaderProps);
+}

package/lib/stac-item-loader/index.js

@@ -0,0 +1,255 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StacItemLoader = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const path = require("path");
+/**
+ * AWS CDK Construct for STAC Item Loading Infrastructure
+ *
+ * The StacItemLoader creates a serverless, event-driven system for loading
+ * STAC (SpatioTemporal Asset Catalog) items into a PostgreSQL database with
+ * the pgstac extension. This construct supports multiple ingestion pathways
+ * for flexible STAC item loading.
+ *
+ * ## Architecture Overview
+ *
+ * This construct creates the following AWS resources:
+ * - **SNS Topic**: Entry point for STAC items and S3 event notifications
+ * - **SQS Queue**: Buffers and batches messages before processing (60-second visibility timeout)
+ * - **Dead Letter Queue**: Captures failed loading attempts after 5 retries
+ * - **Lambda Function**: Python function that processes batches and inserts items into pgstac
+ *
+ * ## Data Flow
+ *
+ * The loader supports two primary data ingestion patterns:
+ *
+ * ### Direct STAC Item Publishing
+ * 1. STAC items (JSON) are published directly to the SNS topic in message bodies
+ * 2. The SQS queue collects messages and batches them (up to {batchSize} items or 1 minute window)
+ * 3. The Lambda function receives batches, validates items, and inserts into pgstac
+ *
+ * ### S3 Event-Driven Loading
+ * 1. An S3 bucket is configured to send notifications to the SNS topic when json files are created
+ * 2. STAC items are uploaded to S3 buckets as JSON/GeoJSON files
+ * 3. S3 event notifications are sent to the SNS topic when items are uploaded
+ * 4. The Lambda function receives S3 events in the SQS message batch, fetches items from S3, and loads into pgstac
+ *
+ * ## Batching Behavior
+ *
+ * The SQS-to-Lambda integration uses intelligent batching to optimize performance:
+ *
+ * - **Batch Size**: Lambda waits to receive up to `batchSize` messages (default: 500)
+ * - **Batching Window**: If fewer than `batchSize` messages are available, Lambda
+ *   triggers after `maxBatchingWindow` minutes (default: 1 minute)
+ * - **Trigger Condition**: Lambda executes when EITHER condition is met first
+ * - **Concurrency**: Limited to `maxConcurrency` concurrent executions to prevent database overload
+ * - **Partial Failures**: Uses `reportBatchItemFailures` to retry only failed items
+ *
+ * This approach balances throughput (larger batches = fewer database connections)
+ * with latency (time-based triggers prevent indefinite waiting).
+ *
+ * ## Error Handling and Dead Letter Queue
+ *
+ * Failed messages are sent to the dead letter queue after 5 processing attempts.
+ * **Important**: This construct provides NO automated handling of dead letter queue
+ * messages - monitoring, inspection, and reprocessing of failed items is the
+ * responsibility of the implementing application.
+ *
+ * Consider implementing:
+ * - CloudWatch alarms on dead letter queue depth
+ * - Manual or automated reprocessing workflows
+ * - Logging and alerting for failed items
+ * - Regular cleanup of old dead letter messages (14-day retention)
+ *
+ * ## Operational Characteristics
+ *
+ * - **Scalability**: Lambda scales automatically based on queue depth
+ * - **Reliability**: Dead letter queue captures failures for debugging
+ * - **Efficiency**: Batching optimizes database operations for high throughput
+ * - **Security**: Database credentials accessed via AWS Secrets Manager
+ * - **Observability**: CloudWatch logs retained for one week
+ *
+ * ## Prerequisites
+ *
+ * Before using this construct, ensure:
+ * - The pgstac database has collections loaded (items require existing collection IDs)
+ * - Database credentials are stored in AWS Secrets Manager
+ * - The pgstac extension is properly installed and configured
+ *
+ * ## Usage Example
+ *
+ * ```typescript
+ * // Create database first
+ * const database = new PgStacDatabase(this, 'Database', {
+ *   pgstacVersion: '0.9.5'
+ * });
+ *
+ * // Create item loader
+ * const loader = new StacItemLoader(this, 'ItemLoader', {
+ *   pgstacDb: database,
+ *   batchSize: 1000,          // Process up to 1000 items per batch
+ *   maxBatchingWindowMinutes: 1, // Wait max 1 minute to fill batch
+ *   lambdaTimeoutSeconds: 300     // Allow up to 300 seconds for database operations
+ * });
+ *
+ * // The topic ARN can be used by other services to publish items
+ * new CfnOutput(this, 'LoaderTopicArn', {
+ *   value: loader.topic.topicArn
+ * });
+ * ```
+ *
+ * ## Direct Item Publishing
+ *
+ * External services can publish STAC items directly to the topic:
+ *
+ * ```bash
+ * aws sns publish --topic-arn $ITEM_LOAD_TOPIC --message '{
+ *   "type": "Feature",
+ *   "stac_version": "1.0.0",
+ *   "id": "example-item",
+ *   "properties": {"datetime": "2021-01-01T00:00:00Z"},
+ *   "geometry": {"type": "Polygon", "coordinates": [...]},
+ *   "collection": "example-collection"
+ * }'
+ * ```
+ *
+ * ## S3 Event Configuration
+ *
+ * To enable S3 event-driven loading, configure S3 bucket notifications to send
+ * events to the SNS topic when STAC items (.json or .geojson files) are uploaded:
+ *
+ * ```typescript
+ * // Configure S3 bucket to send notifications to the loader topic
+ * bucket.addEventNotification(
+ *   s3.EventType.OBJECT_CREATED,
+ *   new s3n.SnsDestination(loader.topic),
+ *   { suffix: '.json' }
+ * );
+ *
+ * bucket.addEventNotification(
+ *   s3.EventType.OBJECT_CREATED,
+ *   new s3n.SnsDestination(loader.topic),
+ *   { suffix: '.geojson' }
+ * );
+ * ```
+ *
+ * When STAC items are uploaded to the configured S3 bucket, the loader will:
+ * 1. Receive S3 event notifications via SNS
+ * 2. Fetch the STAC item JSON from S3
+ * 3. Validate and load the item into the pgstac database
+ *
+ * ## Monitoring and Troubleshooting
+ *
+ * - Monitor Lambda logs: `/aws/lambda/{FunctionName}`
+ * - **Dead Letter Queue**: Check for failed items - **no automated handling provided**
+ * - Use batch item failure reporting for partial batch processing
+ * - CloudWatch metrics available for queue depth and Lambda performance
+ *
+ * ### Dead Letter Queue Management
+ *
+ * Applications must implement their own dead letter queue monitoring:
+ *
+ * ```typescript
+ * // Example: CloudWatch alarm for dead letter queue depth
+ * new cloudwatch.Alarm(this, 'DeadLetterAlarm', {
+ *   metric: loader.deadLetterQueue.metricApproximateNumberOfVisibleMessages(),
+ *   threshold: 1,
+ *   evaluationPeriods: 1
+ * });
+ *
+ * // Example: Lambda to reprocess dead letter messages
+ * const reprocessFunction = new lambda.Function(this, 'Reprocess', {
+ *   // Implementation to fetch and republish failed messages
+ * });
+ * ```
+ *
+ */
+class StacItemLoader extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const timeoutSeconds = props.lambdaTimeoutSeconds ?? 300;
+        const lambdaRuntime = props.lambdaRuntime ?? aws_cdk_lib_1.aws_lambda.Runtime.PYTHON_3_11;
+        const maxConcurrency = props.maxConcurrency ?? 2;
+        // Create dead letter queue
+        this.deadLetterQueue = new aws_cdk_lib_1.aws_sqs.Queue(this, "DeadLetterQueue", {
+            retentionPeriod: aws_cdk_lib_1.Duration.days(14),
+        });
+        // Create main queue
+        this.queue = new aws_cdk_lib_1.aws_sqs.Queue(this, "Queue", {
+            visibilityTimeout: aws_cdk_lib_1.Duration.seconds(timeoutSeconds + 10),
+            encryption: aws_cdk_lib_1.aws_sqs.QueueEncryption.SQS_MANAGED,
+            deadLetterQueue: {
+                maxReceiveCount: 5,
+                queue: this.deadLetterQueue,
+            },
+        });
+        // Create SNS topic
+        this.topic = new aws_cdk_lib_1.aws_sns.Topic(this, "Topic", {
+            displayName: `${id}-StacItemLoaderTopic`,
+        });
+        // Subscribe the queue to the topic
+        this.topic.addSubscription(new aws_cdk_lib_1.aws_sns_subscriptions.SqsSubscription(this.queue));
+        // Create the lambda function
+        this.lambdaFunction = new aws_cdk_lib_1.aws_lambda.Function(this, "Function", {
+            runtime: lambdaRuntime,
+            handler: "stac_item_loader.handler.handler",
+            vpc: props.vpc,
+            vpcSubnets: props.subnetSelection,
+            code: aws_cdk_lib_1.aws_lambda.Code.fromDockerBuild(path.join(__dirname, ".."), {
+                file: "stac-item-loader/runtime/Dockerfile",
+                platform: "linux/amd64",
+                buildArgs: {
+                    PYTHON_VERSION: lambdaRuntime.toString().replace("python", ""),
+                    PGSTAC_VERSION: props.pgstacDb.pgstacVersion,
+                },
+            }),
+            memorySize: props.memorySize ?? 1024,
+            timeout: aws_cdk_lib_1.Duration.seconds(timeoutSeconds),
+            reservedConcurrentExecutions: maxConcurrency,
+            logRetention: aws_cdk_lib_1.aws_logs.RetentionDays.ONE_WEEK,
+            environment: {
+                PGSTAC_SECRET_ARN: props.pgstacDb.pgstacSecret.secretArn,
+                ...props.environment,
+            },
+            // overwrites defaults with user-provided configurable properties
+            ...props.lambdaFunctionOptions,
+        });
+        // Grant permissions to read the database secret
+        props.pgstacDb.pgstacSecret.grantRead(this.lambdaFunction);
+        // Add SQS event source to the lambda
+        this.lambdaFunction.addEventSource(new aws_cdk_lib_1.aws_lambda_event_sources.SqsEventSource(this.queue, {
+            batchSize: props.batchSize ?? 500,
+            maxBatchingWindow: aws_cdk_lib_1.Duration.minutes(props.maxBatchingWindowMinutes ?? 1),
+            maxConcurrency: maxConcurrency,
+            reportBatchItemFailures: true,
+        }));
+        // Create outputs
+        new aws_cdk_lib_1.CfnOutput(this, "TopicArn", {
+            value: this.topic.topicArn,
+            description: "ARN of the StacItemLoader SNS Topic",
+            exportName: "stac-item-loader-topic-arn",
+        });
+        new aws_cdk_lib_1.CfnOutput(this, "QueueUrl", {
+            value: this.queue.queueUrl,
+            description: "URL of the StacItemLoader SQS Queue",
+            exportName: "stac-item-loader-queue-url",
+        });
+        new aws_cdk_lib_1.CfnOutput(this, "DeadLetterQueueUrl", {
+            value: this.deadLetterQueue.queueUrl,
+            description: "URL of the StacItemLoader Dead Letter Queue",
+            exportName: "stac-item-loader-deadletter-queue-url",
+        });
+        new aws_cdk_lib_1.CfnOutput(this, "FunctionName", {
+            value: this.lambdaFunction.functionName,
+            description: "Name of the StacItemLoader Lambda Function",
+            exportName: "stac-item-loader-function-name",
+        });
+    }
+}
+exports.StacItemLoader = StacItemLoader;
+_a = JSII_RTTI_SYMBOL_1;
+StacItemLoader[_a] = { fqn: "eoapi-cdk.StacItemLoader", version: "8.2.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  aws_ec2 as ec2,\n  aws_lambda as lambda,\n  aws_sqs as sqs,\n  aws_sns as sns,\n  aws_sns_subscriptions as snsSubscriptions,\n  aws_lambda_event_sources as lambdaEventSources,\n  aws_logs as logs,\n  Duration,\n  CfnOutput,\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport { PgStacDatabase } from \"../database\";\nimport * as path from \"path\";\nimport { CustomLambdaFunctionProps } from \"../utils\";\n\n/**\n * Configuration properties for the StacItemLoader construct.\n *\n * The StacItemLoader is part of a two-phase serverless STAC ingestion pipeline\n * that loads STAC items into a pgstac database. This construct creates\n * the infrastructure for receiving STAC items from multiple sources:\n * 1. SNS messages containing STAC metadata (direct ingestion)\n * 2. S3 event notifications for STAC items uploaded to S3 buckets\n *\n * Items from both sources are batched and inserted into PostgreSQL with the pgstac extension.\n *\n * @example\n * const loader = new StacItemLoader(this, 'ItemLoader', {\n *   pgstacDb: database,\n *   batchSize: 1000,\n *   maxBatchingWindowMinutes: 1,\n *   lambdaTimeoutSeconds: 300\n * });\n */\nexport interface StacItemLoaderProps {\n  /**\n   * The PgSTAC database instance to load items into.\n   *\n   * This database must have the pgstac extension installed and be properly\n   * configured with collections before items can be loaded. The loader will\n   * use AWS Secrets Manager to securely access database credentials.\n   */\n  readonly pgstacDb: PgStacDatabase;\n\n  /**\n   * VPC into which the lambda should be deployed.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Subnet into which the lambda should be deployed.\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * The lambda runtime to use for the item loading function.\n   *\n   * The function is implemented in Python and uses pypgstac for database\n   * operations. Ensure the runtime version is compatible with the pgstac\n   * version specified in the database configuration.\n   *\n   * @default lambda.Runtime.PYTHON_3_11\n   */\n  readonly lambdaRuntime?: lambda.Runtime;\n\n  /**\n   * The timeout for the item load lambda in seconds.\n   *\n   * This should accommodate the time needed to process up to `batchSize`\n   * items and perform database insertions. The SQS visibility timeout\n   * will be set to this value plus 10 seconds.\n   *\n   * @default 300\n   */\n  readonly lambdaTimeoutSeconds?: number;\n\n  /**\n   * Memory size for the lambda function in MB.\n   *\n   * Higher memory allocation may improve performance when processing\n   * large batches of STAC items, especially for memory-intensive\n   * database operations.\n   *\n   * @default 1024\n   */\n  readonly memorySize?: number;\n\n  /**\n   * SQS batch size for lambda event source.\n   *\n   * This determines the maximum number of STAC items that will be\n   * processed together in a single lambda invocation. Larger batch\n   * sizes improve database insertion efficiency but require more\n   * memory and longer processing time.\n   *\n   * **Batching Behavior**: SQS will wait to accumulate up to this many\n   * messages before triggering the Lambda, OR until the maxBatchingWindow\n   * timeout is reached, whichever comes first. This creates an efficient\n   * balance between throughput and latency.\n   *\n   * @default 500\n   */\n  readonly batchSize?: number;\n\n  /**\n   * Maximum batching window in minutes.\n   *\n   * Even if the batch size isn't reached, the lambda will be triggered\n   * after this time period to ensure timely processing of items.\n   * This prevents items from waiting indefinitely in low-volume scenarios.\n   *\n   * **Important**: This timeout works in conjunction with batchSize - SQS\n   * will trigger the Lambda when EITHER the batch size is reached OR this\n   * time window expires, ensuring items are processed in a timely manner\n   * regardless of volume.\n   *\n   * @default 1\n   */\n  readonly maxBatchingWindowMinutes?: number;\n\n  /**\n   * Maximum concurrent executions for the StacItemLoader Lambda function\n   *\n   * This limit will be applied to the Lambda function and will control how\n   * many concurrent batches will be released from the SQS queue.\n   *\n   * @default 2\n   */\n  readonly maxConcurrency?: number;\n\n  /**\n   * Additional environment variables for the lambda function.\n   *\n   * These will be merged with the default environment variables including\n   * PGSTAC_SECRET_ARN. Use this for custom configuration or debugging flags.\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * Can be used to override the default lambda function properties.\n   *\n   * @default - defined in the construct.\n   */\n  readonly lambdaFunctionOptions?: CustomLambdaFunctionProps;\n}\n\n/**\n * AWS CDK Construct for STAC Item Loading Infrastructure\n *\n * The StacItemLoader creates a serverless, event-driven system for loading\n * STAC (SpatioTemporal Asset Catalog) items into a PostgreSQL database with\n * the pgstac extension. This construct supports multiple ingestion pathways\n * for flexible STAC item loading.\n *\n * ## Architecture Overview\n *\n * This construct creates the following AWS resources:\n * - **SNS Topic**: Entry point for STAC items and S3 event notifications\n * - **SQS Queue**: Buffers and batches messages before processing (60-second visibility timeout)\n * - **Dead Letter Queue**: Captures failed loading attempts after 5 retries\n * - **Lambda Function**: Python function that processes batches and inserts items into pgstac\n *\n * ## Data Flow\n *\n * The loader supports two primary data ingestion patterns:\n *\n * ### Direct STAC Item Publishing\n * 1. STAC items (JSON) are published directly to the SNS topic in message bodies\n * 2. The SQS queue collects messages and batches them (up to {batchSize} items or 1 minute window)\n * 3. The Lambda function receives batches, validates items, and inserts into pgstac\n *\n * ### S3 Event-Driven Loading\n * 1. An S3 bucket is configured to send notifications to the SNS topic when json files are created\n * 2. STAC items are uploaded to S3 buckets as JSON/GeoJSON files\n * 3. S3 event notifications are sent to the SNS topic when items are uploaded\n * 4. The Lambda function receives S3 events in the SQS message batch, fetches items from S3, and loads into pgstac\n *\n * ## Batching Behavior\n *\n * The SQS-to-Lambda integration uses intelligent batching to optimize performance:\n *\n * - **Batch Size**: Lambda waits to receive up to `batchSize` messages (default: 500)\n * - **Batching Window**: If fewer than `batchSize` messages are available, Lambda\n *   triggers after `maxBatchingWindow` minutes (default: 1 minute)\n * - **Trigger Condition**: Lambda executes when EITHER condition is met first\n * - **Concurrency**: Limited to `maxConcurrency` concurrent executions to prevent database overload\n * - **Partial Failures**: Uses `reportBatchItemFailures` to retry only failed items\n *\n * This approach balances throughput (larger batches = fewer database connections)\n * with latency (time-based triggers prevent indefinite waiting).\n *\n * ## Error Handling and Dead Letter Queue\n *\n * Failed messages are sent to the dead letter queue after 5 processing attempts.\n * **Important**: This construct provides NO automated handling of dead letter queue\n * messages - monitoring, inspection, and reprocessing of failed items is the\n * responsibility of the implementing application.\n *\n * Consider implementing:\n * - CloudWatch alarms on dead letter queue depth\n * - Manual or automated reprocessing workflows\n * - Logging and alerting for failed items\n * - Regular cleanup of old dead letter messages (14-day retention)\n *\n * ## Operational Characteristics\n *\n * - **Scalability**: Lambda scales automatically based on queue depth\n * - **Reliability**: Dead letter queue captures failures for debugging\n * - **Efficiency**: Batching optimizes database operations for high throughput\n * - **Security**: Database credentials accessed via AWS Secrets Manager\n * - **Observability**: CloudWatch logs retained for one week\n *\n * ## Prerequisites\n *\n * Before using this construct, ensure:\n * - The pgstac database has collections loaded (items require existing collection IDs)\n * - Database credentials are stored in AWS Secrets Manager\n * - The pgstac extension is properly installed and configured\n *\n * ## Usage Example\n *\n * ```typescript\n * // Create database first\n * const database = new PgStacDatabase(this, 'Database', {\n *   pgstacVersion: '0.9.5'\n * });\n *\n * // Create item loader\n * const loader = new StacItemLoader(this, 'ItemLoader', {\n *   pgstacDb: database,\n *   batchSize: 1000,          // Process up to 1000 items per batch\n *   maxBatchingWindowMinutes: 1, // Wait max 1 minute to fill batch\n *   lambdaTimeoutSeconds: 300     // Allow up to 300 seconds for database operations\n * });\n *\n * // The topic ARN can be used by other services to publish items\n * new CfnOutput(this, 'LoaderTopicArn', {\n *   value: loader.topic.topicArn\n * });\n * ```\n *\n * ## Direct Item Publishing\n *\n * External services can publish STAC items directly to the topic:\n *\n * ```bash\n * aws sns publish --topic-arn $ITEM_LOAD_TOPIC --message '{\n *   \"type\": \"Feature\",\n *   \"stac_version\": \"1.0.0\",\n *   \"id\": \"example-item\",\n *   \"properties\": {\"datetime\": \"2021-01-01T00:00:00Z\"},\n *   \"geometry\": {\"type\": \"Polygon\", \"coordinates\": [...]},\n *   \"collection\": \"example-collection\"\n * }'\n * ```\n *\n * ## S3 Event Configuration\n *\n * To enable S3 event-driven loading, configure S3 bucket notifications to send\n * events to the SNS topic when STAC items (.json or .geojson files) are uploaded:\n *\n * ```typescript\n * // Configure S3 bucket to send notifications to the loader topic\n * bucket.addEventNotification(\n *   s3.EventType.OBJECT_CREATED,\n *   new s3n.SnsDestination(loader.topic),\n *   { suffix: '.json' }\n * );\n *\n * bucket.addEventNotification(\n *   s3.EventType.OBJECT_CREATED,\n *   new s3n.SnsDestination(loader.topic),\n *   { suffix: '.geojson' }\n * );\n * ```\n *\n * When STAC items are uploaded to the configured S3 bucket, the loader will:\n * 1. Receive S3 event notifications via SNS\n * 2. Fetch the STAC item JSON from S3\n * 3. Validate and load the item into the pgstac database\n *\n * ## Monitoring and Troubleshooting\n *\n * - Monitor Lambda logs: `/aws/lambda/{FunctionName}`\n * - **Dead Letter Queue**: Check for failed items - **no automated handling provided**\n * - Use batch item failure reporting for partial batch processing\n * - CloudWatch metrics available for queue depth and Lambda performance\n *\n * ### Dead Letter Queue Management\n *\n * Applications must implement their own dead letter queue monitoring:\n *\n * ```typescript\n * // Example: CloudWatch alarm for dead letter queue depth\n * new cloudwatch.Alarm(this, 'DeadLetterAlarm', {\n *   metric: loader.deadLetterQueue.metricApproximateNumberOfVisibleMessages(),\n *   threshold: 1,\n *   evaluationPeriods: 1\n * });\n *\n * // Example: Lambda to reprocess dead letter messages\n * const reprocessFunction = new lambda.Function(this, 'Reprocess', {\n *   // Implementation to fetch and republish failed messages\n * });\n * ```\n *\n */\nexport class StacItemLoader extends Construct {\n  /**\n   * The SNS topic that receives STAC items and S3 event notifications for loading.\n   *\n   * This topic serves as the entry point for two types of events:\n   * 1. Direct STAC item JSON documents published by external services\n   * 2. S3 event notifications when STAC items are uploaded to configured buckets\n   *\n   * The topic fans out to the SQS queue for batched processing.\n   */\n  public readonly topic: sns.Topic;\n\n  /**\n   * The SQS queue that buffers messages before processing.\n   *\n   * This queue collects both direct STAC items from SNS and S3 event\n   * notifications, batching them for efficient database operations.\n   * Configured with a visibility timeout that accommodates Lambda\n   * processing time plus buffer.\n   */\n  public readonly queue: sqs.Queue;\n\n  /**\n   * Dead letter queue for failed item loading attempts.\n   *\n   * Messages that fail processing after 5 attempts are sent here\n   * for inspection and potential replay. Retains messages for 14 days\n   * to allow for debugging and manual intervention.\n   *\n   * **User Responsibility**: This construct provides NO automated monitoring,\n   * alerting, or reprocessing of dead letter queue messages. Applications\n   * using this construct must implement their own:\n   * - Dead letter queue depth monitoring and alerting\n   * - Failed message inspection and debugging workflows\n   * - Manual or automated reprocessing mechanisms\n   * - Cleanup procedures for old failed messages\n   */\n  public readonly deadLetterQueue: sqs.Queue;\n\n  /**\n   * The Lambda function that loads STAC items into the pgstac database.\n   *\n   * This Python function receives batches of messages from SQS and processes\n   * them based on their type:\n   * - Direct STAC items: Validates and loads directly into pgstac\n   * - S3 events: Fetches STAC items from S3, validates, and loads into pgstac\n   *\n   * The function connects to PostgreSQL using credentials from Secrets Manager\n   * and uses pypgstac for efficient database operations.\n   */\n  public readonly lambdaFunction: lambda.Function;\n\n  constructor(scope: Construct, id: string, props: StacItemLoaderProps) {\n    super(scope, id);\n\n    const timeoutSeconds = props.lambdaTimeoutSeconds ?? 300;\n    const lambdaRuntime = props.lambdaRuntime ?? lambda.Runtime.PYTHON_3_11;\n    const maxConcurrency = props.maxConcurrency ?? 2;\n\n    // Create dead letter queue\n    this.deadLetterQueue = new sqs.Queue(this, \"DeadLetterQueue\", {\n      retentionPeriod: Duration.days(14),\n    });\n\n    // Create main queue\n    this.queue = new sqs.Queue(this, \"Queue\", {\n      visibilityTimeout: Duration.seconds(timeoutSeconds + 10),\n      encryption: sqs.QueueEncryption.SQS_MANAGED,\n      deadLetterQueue: {\n        maxReceiveCount: 5,\n        queue: this.deadLetterQueue,\n      },\n    });\n\n    // Create SNS topic\n    this.topic = new sns.Topic(this, \"Topic\", {\n      displayName: `${id}-StacItemLoaderTopic`,\n    });\n\n    // Subscribe the queue to the topic\n    this.topic.addSubscription(\n      new snsSubscriptions.SqsSubscription(this.queue)\n    );\n\n    // Create the lambda function\n    this.lambdaFunction = new lambda.Function(this, \"Function\", {\n      runtime: lambdaRuntime,\n      handler: \"stac_item_loader.handler.handler\",\n      vpc: props.vpc,\n      vpcSubnets: props.subnetSelection,\n      code: lambda.Code.fromDockerBuild(path.join(__dirname, \"..\"), {\n        file: \"stac-item-loader/runtime/Dockerfile\",\n        platform: \"linux/amd64\",\n        buildArgs: {\n          PYTHON_VERSION: lambdaRuntime.toString().replace(\"python\", \"\"),\n          PGSTAC_VERSION: props.pgstacDb.pgstacVersion,\n        },\n      }),\n      memorySize: props.memorySize ?? 1024,\n      timeout: Duration.seconds(timeoutSeconds),\n      reservedConcurrentExecutions: maxConcurrency,\n      logRetention: logs.RetentionDays.ONE_WEEK,\n      environment: {\n        PGSTAC_SECRET_ARN: props.pgstacDb.pgstacSecret.secretArn,\n        ...props.environment,\n      },\n      // overwrites defaults with user-provided configurable properties\n      ...props.lambdaFunctionOptions,\n    });\n\n    // Grant permissions to read the database secret\n    props.pgstacDb.pgstacSecret.grantRead(this.lambdaFunction);\n\n    // Add SQS event source to the lambda\n    this.lambdaFunction.addEventSource(\n      new lambdaEventSources.SqsEventSource(this.queue, {\n        batchSize: props.batchSize ?? 500,\n        maxBatchingWindow: Duration.minutes(\n          props.maxBatchingWindowMinutes ?? 1\n        ),\n        maxConcurrency: maxConcurrency,\n        reportBatchItemFailures: true,\n      })\n    );\n\n    // Create outputs\n    new CfnOutput(this, \"TopicArn\", {\n      value: this.topic.topicArn,\n      description: \"ARN of the StacItemLoader SNS Topic\",\n      exportName: \"stac-item-loader-topic-arn\",\n    });\n\n    new CfnOutput(this, \"QueueUrl\", {\n      value: this.queue.queueUrl,\n      description: \"URL of the StacItemLoader SQS Queue\",\n      exportName: \"stac-item-loader-queue-url\",\n    });\n\n    new CfnOutput(this, \"DeadLetterQueueUrl\", {\n      value: this.deadLetterQueue.queueUrl,\n      description: \"URL of the StacItemLoader Dead Letter Queue\",\n      exportName: \"stac-item-loader-deadletter-queue-url\",\n    });\n\n    new CfnOutput(this, \"FunctionName\", {\n      value: this.lambdaFunction.functionName,\n      description: \"Name of the StacItemLoader Lambda Function\",\n      exportName: \"stac-item-loader-function-name\",\n    });\n  }\n}\n"]}

package/lib/stac-item-loader/runtime/Dockerfile

@@ -0,0 +1,18 @@
+ARG PYTHON_VERSION=3.11
+FROM public.ecr.aws/lambda/python:${PYTHON_VERSION}
+COPY --from=ghcr.io/astral-sh/uv:0.7.8 /uv /uvx /bin/
+
+ENV UV_COMPILE_BYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /asset
+
+COPY stac-item-loader/runtime/pyproject.toml pyproject.toml
+COPY stac-item-loader/runtime/src/stac_item_loader/ stac_item_loader/
+
+ARG PGSTAC_VERSION=0.9.6
+RUN uv add --no-sync pypgstac==${PGSTAC_VERSION} && \
+  uv export --no-dev --no-editable -o requirements.txt && \
+  uv pip install --target /asset -r requirements.txt
+
+CMD ["stac_item_loader.handler.handler"]