eoapi-cdk 8.1.1 → 8.2.0

package/lib/stactools-item-generator/index.js

@@ -0,0 +1,204 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StactoolsItemGenerator = 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 aws_ecr_assets_1 = require("aws-cdk-lib/aws-ecr-assets");
+const path = require("path");
+/**
+ * AWS CDK Construct for STAC Item Generation Infrastructure
+ *
+ * The StactoolsItemGenerator creates a serverless, event-driven system for generating
+ * STAC (SpatioTemporal Asset Catalog) items from source data. This construct
+ * implements the first phase of a two-stage ingestion pipeline that transforms
+ * raw geospatial data into standardized STAC metadata.
+ *
+ * ## Architecture Overview
+ *
+ * This construct creates the following AWS resources:
+ * - **SNS Topic**: Entry point for triggering item generation workflows
+ * - **SQS Queue**: Buffers generation requests (120-second visibility timeout)
+ * - **Dead Letter Queue**: Captures failed messages after 5 processing attempts
+ * - **Lambda Function**: Containerized function that generates STAC items using stactools
+ *
+ * ## Data Flow
+ *
+ * 1. External systems publish ItemRequest messages to the SNS topic with metadata about assets
+ * 2. The SQS queue buffers these messages and triggers the Lambda function
+ * 3. The Lambda function:
+ *    - Uses `uvx` to install the required stactools package
+ *    - Executes the `create-item` CLI command with provided arguments
+ *    - Publishes generated STAC items to the ItemLoad topic
+ * 4. Failed processing attempts are sent to the dead letter queue
+ *
+ * ## Operational Characteristics
+ *
+ * - **Scalability**: Lambda scales automatically based on queue depth (up to maxConcurrency)
+ * - **Flexibility**: Supports any stactools package through dynamic installation
+ * - **Reliability**: Dead letter queue captures failed generation attempts
+ * - **Isolation**: Each generation task runs in a fresh container environment
+ * - **Observability**: CloudWatch logs retained for one week
+ *
+ * ## Message Schema
+ *
+ * The function expects messages matching the ItemRequest model:
+ *
+ * ```json
+ * {
+ *   "package_name": "stactools-glad-global-forest-change",
+ *   "group_name": "gladglobalforestchange",
+ *   "create_item_args": [
+ *     "https://example.com/data.tif"
+ *   ],
+ *   "collection_id": "glad-global-forest-change-1.11"
+ * }
+ * ```
+ *
+ * ## Usage Example
+ *
+ * ```typescript
+ * // Create item loader first (or get existing topic ARN)
+ * const loader = new StacItemLoader(this, 'ItemLoader', {
+ *   pgstacDb: database
+ * });
+ *
+ * // Create item generator that feeds the loader
+ * const generator = new StactoolsItemGenerator(this, 'ItemGenerator', {
+ *   itemLoadTopicArn: loader.topic.topicArn,
+ *   lambdaTimeoutSeconds: 120,    // Allow time for package installation
+ *   maxConcurrency: 100,          // Control parallel processing
+ *   batchSize: 10                 // Process 10 requests per invocation
+ * });
+ *
+ * // Grant permission to publish to the loader topic
+ * loader.topic.grantPublish(generator.lambdaFunction);
+ * ```
+ *
+ * ## Publishing Generation Requests
+ *
+ * Send messages to the generator topic to trigger item creation:
+ *
+ * ```bash
+ * aws sns publish --topic-arn $ITEM_GEN_TOPIC --message '{
+ *   "package_name": "stactools-glad-global-forest-change",
+ *   "group_name": "gladglobalforestchange",
+ *   "create_item_args": [
+ *     "https://storage.googleapis.com/earthenginepartners-hansen/GFC-2023-v1.11/Hansen_GFC-2023-v1.11_gain_40N_080W.tif"
+ *   ],
+ *   "collection_id": "glad-global-forest-change-1.11"
+ * }'
+ * ```
+ *
+ * ## Batch Processing Example
+ *
+ * For processing many assets, you can loop through URLs:
+ *
+ * ```bash
+ * while IFS= read -r url; do
+ *   aws sns publish --topic-arn "$ITEM_GEN_TOPIC" --message "{
+ *     \"package_name\": \"stactools-glad-glclu2020\",
+ *     \"group_name\": \"gladglclu2020\",
+ *     \"create_item_args\": [\"$url\"]
+ *   }"
+ * done < urls.txt
+ * ```
+ *
+ * ## Monitoring and Troubleshooting
+ *
+ * - Monitor Lambda logs: `/aws/lambda/{FunctionName}`
+ * - Check dead letter queue for failed generation attempts
+ * - Use CloudWatch metrics to track processing rates and errors
+ * - Failed items can be replayed from the dead letter queue
+ *
+ * ## Supported Stactools Packages
+ *
+ * Any package available on PyPI that follows the stactools plugin pattern
+ * can be used. Examples include:
+ * - `stactools-glad-global-forest-change`
+ * - `stactools-glad-glclu2020`
+ * - `stactools-landsat`
+ * - `stactools-sentinel2`
+ *
+ * @see {@link https://github.com/stactools-packages} for available stactools packages
+ * @see {@link https://stactools.readthedocs.io/} for stactools documentation
+ */
+class StactoolsItemGenerator extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const timeoutSeconds = props.lambdaTimeoutSeconds ?? 120;
+        const lambdaRuntime = props.lambdaRuntime ?? aws_cdk_lib_1.aws_lambda.Runtime.PYTHON_3_11;
+        // 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}-ItemGenTopic`,
+        });
+        // 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.DockerImageFunction(this, "Function", {
+            code: aws_cdk_lib_1.aws_lambda.DockerImageCode.fromImageAsset(path.join(__dirname, ".."), {
+                file: "stactools-item-generator/runtime/Dockerfile",
+                platform: aws_ecr_assets_1.Platform.LINUX_AMD64,
+                buildArgs: {
+                    PYTHON_VERSION: lambdaRuntime.toString().replace("python", ""),
+                },
+            }),
+            memorySize: props.memorySize ?? 1024,
+            timeout: aws_cdk_lib_1.Duration.seconds(timeoutSeconds),
+            logRetention: aws_cdk_lib_1.aws_logs.RetentionDays.ONE_WEEK,
+            environment: {
+                ITEM_LOAD_TOPIC_ARN: props.itemLoadTopicArn,
+                LOG_LEVEL: "INFO",
+                ...props.environment,
+            },
+        });
+        // 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 ?? 10,
+            reportBatchItemFailures: true,
+            maxConcurrency: props.maxConcurrency ?? 100,
+        }));
+        // Grant permissions to publish to the item load topic
+        // Note: This will be granted externally since we only have the ARN
+        // The consuming construct should handle this permission
+        // Create outputs
+        new aws_cdk_lib_1.CfnOutput(this, "TopicArn", {
+            value: this.topic.topicArn,
+            description: "ARN of the StactoolsItemGenerator SNS Topic",
+            exportName: "stactools-item-generator-topic-arn",
+        });
+        new aws_cdk_lib_1.CfnOutput(this, "QueueUrl", {
+            value: this.queue.queueUrl,
+            description: "URL of the StactoolsItemGenerator SQS Queue",
+            exportName: "stactools-item-generator-queue-url",
+        });
+        new aws_cdk_lib_1.CfnOutput(this, "DeadLetterQueueUrl", {
+            value: this.deadLetterQueue.queueUrl,
+            description: "URL of the StactoolsItemGenerator Dead Letter Queue",
+            exportName: "stactools-item-generator-deadletter-queue-url",
+        });
+        new aws_cdk_lib_1.CfnOutput(this, "FunctionName", {
+            value: this.lambdaFunction.functionName,
+            description: "Name of the StactoolsItemGenerator Lambda Function",
+            exportName: "stactools-item-generator-function-name",
+        });
+    }
+}
+exports.StactoolsItemGenerator = StactoolsItemGenerator;
+_a = JSII_RTTI_SYMBOL_1;
+StactoolsItemGenerator[_a] = { fqn: "eoapi-cdk.StactoolsItemGenerator", version: "8.2.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\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 { Platform } from \"aws-cdk-lib/aws-ecr-assets\";\nimport * as path from \"path\";\n\n/**\n * Configuration properties for the StactoolsItemGenerator construct.\n *\n * The StactoolsItemGenerator is part of a two-phase serverless STAC ingestion pipeline\n * that generates STAC items from source data. This construct creates the\n * infrastructure for the first phase of the pipeline - processing metadata\n * about assets and transforming them into standardized STAC items.\n *\n * @example\n * const generator = new StactoolsItemGenerator(this, 'ItemGenerator', {\n *   itemLoadTopicArn: loader.topic.topicArn,\n *   lambdaTimeoutSeconds: 120,\n *   maxConcurrency: 100,\n *   batchSize: 10\n * });\n */\nexport interface StactoolsItemGeneratorProps {\n  /**\n   * The lambda runtime to use for the item generation function.\n   *\n   * The function is containerized using Docker and can accommodate various\n   * stactools packages. The runtime version should be compatible with the\n   * packages you plan to use for STAC item generation.\n   *\n   * @default lambda.Runtime.PYTHON_3_11\n   */\n  readonly lambdaRuntime?: lambda.Runtime;\n\n  /**\n   * The timeout for the item generation lambda in seconds.\n   *\n   * This should accommodate the time needed to:\n   * - Install stactools packages using uvx\n   * - Download and process source data\n   * - Generate STAC metadata\n   * - Publish results to SNS\n   *\n   * The SQS visibility timeout will be set to this value plus 10 seconds.\n   *\n   * @default 120\n   */\n  readonly lambdaTimeoutSeconds?: number;\n\n  /**\n   * Memory size for the lambda function in MB.\n   *\n   * Higher memory allocation may be needed for processing large geospatial\n   * datasets or when stactools packages have high memory requirements.\n   * More memory also provides proportionally more CPU power.\n   *\n   * @default 1024\n   */\n  readonly memorySize?: number;\n\n  /**\n   * Maximum number of concurrent executions.\n   *\n   * This controls how many item generation tasks can run simultaneously.\n   * Higher concurrency enables faster processing of large batches but\n   * may strain downstream systems or external data sources.\n   *\n   * @default 100\n   */\n  readonly maxConcurrency?: number;\n\n  /**\n   * SQS batch size for lambda event source.\n   *\n   * This determines how many generation requests are processed together\n   * in a single lambda invocation. Unlike the loader, generation typically\n   * processes items individually, so smaller batch sizes are common.\n   *\n   * @default 10\n   */\n  readonly batchSize?: number;\n\n  /**\n   * Additional environment variables for the lambda function.\n   *\n   * These will be merged with default environment variables including\n   * ITEM_LOAD_TOPIC_ARN and LOG_LEVEL. Use this for custom configuration\n   * or to pass credentials for external data sources.\n   */\n  readonly environment?: { [key: string]: string };\n\n  /**\n   * ARN of the SNS topic to publish generated items to.\n   *\n   * This is typically the topic from a StacItemLoader construct.\n   * Generated STAC items will be published here for downstream\n   * processing and database insertion.\n   */\n  readonly itemLoadTopicArn: string;\n}\n\n/**\n * AWS CDK Construct for STAC Item Generation Infrastructure\n *\n * The StactoolsItemGenerator creates a serverless, event-driven system for generating\n * STAC (SpatioTemporal Asset Catalog) items from source data. This construct\n * implements the first phase of a two-stage ingestion pipeline that transforms\n * raw geospatial data into standardized STAC metadata.\n *\n * ## Architecture Overview\n *\n * This construct creates the following AWS resources:\n * - **SNS Topic**: Entry point for triggering item generation workflows\n * - **SQS Queue**: Buffers generation requests (120-second visibility timeout)\n * - **Dead Letter Queue**: Captures failed messages after 5 processing attempts\n * - **Lambda Function**: Containerized function that generates STAC items using stactools\n *\n * ## Data Flow\n *\n * 1. External systems publish ItemRequest messages to the SNS topic with metadata about assets\n * 2. The SQS queue buffers these messages and triggers the Lambda function\n * 3. The Lambda function:\n *    - Uses `uvx` to install the required stactools package\n *    - Executes the `create-item` CLI command with provided arguments\n *    - Publishes generated STAC items to the ItemLoad topic\n * 4. Failed processing attempts are sent to the dead letter queue\n *\n * ## Operational Characteristics\n *\n * - **Scalability**: Lambda scales automatically based on queue depth (up to maxConcurrency)\n * - **Flexibility**: Supports any stactools package through dynamic installation\n * - **Reliability**: Dead letter queue captures failed generation attempts\n * - **Isolation**: Each generation task runs in a fresh container environment\n * - **Observability**: CloudWatch logs retained for one week\n *\n * ## Message Schema\n *\n * The function expects messages matching the ItemRequest model:\n *\n * ```json\n * {\n *   \"package_name\": \"stactools-glad-global-forest-change\",\n *   \"group_name\": \"gladglobalforestchange\",\n *   \"create_item_args\": [\n *     \"https://example.com/data.tif\"\n *   ],\n *   \"collection_id\": \"glad-global-forest-change-1.11\"\n * }\n * ```\n *\n * ## Usage Example\n *\n * ```typescript\n * // Create item loader first (or get existing topic ARN)\n * const loader = new StacItemLoader(this, 'ItemLoader', {\n *   pgstacDb: database\n * });\n *\n * // Create item generator that feeds the loader\n * const generator = new StactoolsItemGenerator(this, 'ItemGenerator', {\n *   itemLoadTopicArn: loader.topic.topicArn,\n *   lambdaTimeoutSeconds: 120,    // Allow time for package installation\n *   maxConcurrency: 100,          // Control parallel processing\n *   batchSize: 10                 // Process 10 requests per invocation\n * });\n *\n * // Grant permission to publish to the loader topic\n * loader.topic.grantPublish(generator.lambdaFunction);\n * ```\n *\n * ## Publishing Generation Requests\n *\n * Send messages to the generator topic to trigger item creation:\n *\n * ```bash\n * aws sns publish --topic-arn $ITEM_GEN_TOPIC --message '{\n *   \"package_name\": \"stactools-glad-global-forest-change\",\n *   \"group_name\": \"gladglobalforestchange\",\n *   \"create_item_args\": [\n *     \"https://storage.googleapis.com/earthenginepartners-hansen/GFC-2023-v1.11/Hansen_GFC-2023-v1.11_gain_40N_080W.tif\"\n *   ],\n *   \"collection_id\": \"glad-global-forest-change-1.11\"\n * }'\n * ```\n *\n * ## Batch Processing Example\n *\n * For processing many assets, you can loop through URLs:\n *\n * ```bash\n * while IFS= read -r url; do\n *   aws sns publish --topic-arn \"$ITEM_GEN_TOPIC\" --message \"{\n *     \\\"package_name\\\": \\\"stactools-glad-glclu2020\\\",\n *     \\\"group_name\\\": \\\"gladglclu2020\\\",\n *     \\\"create_item_args\\\": [\\\"$url\\\"]\n *   }\"\n * done < urls.txt\n * ```\n *\n * ## Monitoring and Troubleshooting\n *\n * - Monitor Lambda logs: `/aws/lambda/{FunctionName}`\n * - Check dead letter queue for failed generation attempts\n * - Use CloudWatch metrics to track processing rates and errors\n * - Failed items can be replayed from the dead letter queue\n *\n * ## Supported Stactools Packages\n *\n * Any package available on PyPI that follows the stactools plugin pattern\n * can be used. Examples include:\n * - `stactools-glad-global-forest-change`\n * - `stactools-glad-glclu2020`\n * - `stactools-landsat`\n * - `stactools-sentinel2`\n *\n * @see {@link https://github.com/stactools-packages} for available stactools packages\n * @see {@link https://stactools.readthedocs.io/} for stactools documentation\n */\nexport class StactoolsItemGenerator extends Construct {\n  /**\n   * The SQS queue that buffers item generation requests.\n   *\n   * This queue receives messages from the SNS topic containing ItemRequest\n   * payloads. It's configured with a visibility timeout that matches the\n   * Lambda timeout plus buffer time to prevent duplicate processing.\n   */\n  public readonly queue: sqs.Queue;\n\n  /**\n   * Dead letter queue for failed item generation attempts.\n   *\n   * Messages that fail processing after 5 attempts are sent here for\n   * inspection and potential replay. This helps with debugging stactools\n   * package issues, network failures, or malformed requests.\n   */\n  public readonly deadLetterQueue: sqs.Queue;\n\n  /**\n   * The SNS topic that receives item generation requests.\n   *\n   * External systems publish ItemRequest messages to this topic to trigger\n   * STAC item generation. The topic fans out to the SQS queue for processing.\n   */\n  public readonly topic: sns.Topic;\n\n  /**\n   * The containerized Lambda function that generates STAC items.\n   *\n   * This Docker-based function dynamically installs stactools packages\n   * using uvx, processes source data, and publishes generated STAC items\n   * to the configured ItemLoad SNS topic.\n   */\n  public readonly lambdaFunction: lambda.DockerImageFunction;\n\n  constructor(scope: Construct, id: string, props: StactoolsItemGeneratorProps) {\n    super(scope, id);\n\n    const timeoutSeconds = props.lambdaTimeoutSeconds ?? 120;\n    const lambdaRuntime = props.lambdaRuntime ?? lambda.Runtime.PYTHON_3_11;\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}-ItemGenTopic`,\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.DockerImageFunction(this, \"Function\", {\n      code: lambda.DockerImageCode.fromImageAsset(path.join(__dirname, \"..\"), {\n        file: \"stactools-item-generator/runtime/Dockerfile\",\n        platform: Platform.LINUX_AMD64,\n        buildArgs: {\n          PYTHON_VERSION: lambdaRuntime.toString().replace(\"python\", \"\"),\n        },\n      }),\n      memorySize: props.memorySize ?? 1024,\n      timeout: Duration.seconds(timeoutSeconds),\n      logRetention: logs.RetentionDays.ONE_WEEK,\n      environment: {\n        ITEM_LOAD_TOPIC_ARN: props.itemLoadTopicArn,\n        LOG_LEVEL: \"INFO\",\n        ...props.environment,\n      },\n    });\n\n    // Add SQS event source to the lambda\n    this.lambdaFunction.addEventSource(\n      new lambdaEventSources.SqsEventSource(this.queue, {\n        batchSize: props.batchSize ?? 10,\n        reportBatchItemFailures: true,\n        maxConcurrency: props.maxConcurrency ?? 100,\n      })\n    );\n\n    // Grant permissions to publish to the item load topic\n    // Note: This will be granted externally since we only have the ARN\n    // The consuming construct should handle this permission\n\n    // Create outputs\n    new CfnOutput(this, \"TopicArn\", {\n      value: this.topic.topicArn,\n      description: \"ARN of the StactoolsItemGenerator SNS Topic\",\n      exportName: \"stactools-item-generator-topic-arn\",\n    });\n\n    new CfnOutput(this, \"QueueUrl\", {\n      value: this.queue.queueUrl,\n      description: \"URL of the StactoolsItemGenerator SQS Queue\",\n      exportName: \"stactools-item-generator-queue-url\",\n    });\n\n    new CfnOutput(this, \"DeadLetterQueueUrl\", {\n      value: this.deadLetterQueue.queueUrl,\n      description: \"URL of the StactoolsItemGenerator Dead Letter Queue\",\n      exportName: \"stactools-item-generator-deadletter-queue-url\",\n    });\n\n    new CfnOutput(this, \"FunctionName\", {\n      value: this.lambdaFunction.functionName,\n      description: \"Name of the StactoolsItemGenerator Lambda Function\",\n      exportName: \"stactools-item-generator-function-name\",\n    });\n  }\n}\n"]}

package/lib/stactools-item-generator/runtime/Dockerfile

@@ -0,0 +1,20 @@
+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_CACHE_DIR=/tmp/uv-cache/
+ENV UV_COMPILE_BYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV HOME=/tmp
+ENV PATH=/tmp/.local/bin:$PATH
+
+WORKDIR ${LAMBDA_TASK_ROOT}
+
+COPY stactools-item-generator/runtime/pyproject.toml pyproject.toml
+COPY stactools-item-generator/runtime/src/stactools_item_generator/ ${LAMBDA_TASK_ROOT}/stactools_item_generator/
+
+RUN uv export --no-dev --no-editable -o requirements.txt && \
+  uv pip install --target ${LAMBDA_TASK_ROOT} -r requirements.txt && \
+  uv tool install --with requests stactools;
+
+CMD ["stactools_item_generator.handler.handler"]

package/lib/stactools-item-generator/runtime/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "stactools-item-generator"
+version = "0.1.0"
+description = "An application for generating STAC metadata with any stactools package"
+authors = [
+    { name = "hrodmn", email = "henry@developmentseed.org" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "pydantic>=2.11.0",
+    "stac-pydantic>=3.2.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

package/lib/stactools-item-generator/runtime/src/stactools_item_generator/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from stactools-uvx!")

package/lib/stactools-item-generator/runtime/src/stactools_item_generator/handler.py

@@ -0,0 +1,176 @@
+"""AWS Lambda handler for STAC Item Generation."""
+
+import json
+import logging
+import os
+import subprocess
+import traceback
+from typing import TYPE_CHECKING, Annotated, Any, Dict, List, Optional, TypedDict
+
+import boto3
+from pydantic import ValidationError
+
+if TYPE_CHECKING:
+    from aws_lambda_typing.context import Context
+else:
+    Context = Annotated[object, "Context object"]
+
+from stactools_item_generator.item import ItemRequest, create_stac_item
+
+logger = logging.getLogger()
+if logger.hasHandlers():
+    logger.handlers.clear()
+
+log_handler = logging.StreamHandler()  # <--- Renamed handler variable
+
+log_level_name = os.environ.get("LOG_LEVEL", "INFO").upper()
+log_level = logging._nameToLevel.get(log_level_name, logging.INFO)
+logger.setLevel(log_level)
+
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+log_handler.setFormatter(formatter)
+logger.addHandler(log_handler)
+
+
+def get_topic_arn() -> str:
+    item_load_topic_arn = os.environ.get("ITEM_LOAD_TOPIC_ARN")
+    if not item_load_topic_arn:
+        logger.error("Environment variable ITEM_LOAD_TOPIC_ARN is not set.")
+        raise EnvironmentError("ITEM_LOAD_TOPIC_ARN must be set")
+
+    return item_load_topic_arn
+
+
+def process_record(record: Dict[str, Any], sns_client) -> None:
+    """
+    Processes a single SQS record (within a batch).
+    Extracts the request, calls create_stac_item, and publishes the result.
+    Raises exceptions on failure.
+    """
+    message_id = record.get("messageId", "UNKNOWN_ID")
+    logger.info(f"Processing record: {message_id}")
+    message_str = None
+    try:
+        sqs_body_str = record["body"]
+        logger.debug(f"[{message_id}] SQS message body: {sqs_body_str}")
+        sns_notification = json.loads(sqs_body_str)
+
+        message_str = sns_notification["Message"]
+        logger.debug(f"[{message_id}] SNS Message content: {message_str}")
+
+        message_data = json.loads(message_str)
+        item_request = ItemRequest(**message_data)
+        logger.info(
+            f"[{message_id}] Parsed ItemRequest for package: {item_request.package_name}"
+        )
+        logger.debug(f"[{message_id}] Full ItemRequest: {item_request.model_dump_json()}")
+
+        stac_item = create_stac_item(item_request)
+        logger.info(f"[{message_id}] Successfully created STAC item: {stac_item.id}")
+        logger.debug(
+            f"[{message_id}] Generated STAC Item JSON (sample): "
+            f"{ {k: v for k, v in stac_item.model_dump().items() if k in ['id', 'collection', 'properties']} }"
+        )
+
+        stac_item_json = stac_item.model_dump_json()
+
+        item_load_topic_arn = get_topic_arn()
+        logger.info(
+            f"[{message_id}] Publishing STAC item {stac_item.id} to {item_load_topic_arn}"
+        )
+        response = sns_client.publish(
+            TopicArn=item_load_topic_arn,
+            Message=stac_item_json,
+        )
+        logger.info(
+            f"[{message_id}] SNS publish response MessageId: {response.get('MessageId')}"
+        )
+
+    except json.JSONDecodeError as e:
+        logger.error(f"[{message_id}] Failed to decode JSON: {e}")
+        logger.error(f"[{message_id}] Problematic data (SQS Body): {record.get('body')}")
+        raise
+    except ValidationError as e:
+        logger.error(f"[{message_id}] Failed to validate ItemRequest: {e}")
+        logger.error(f"[{message_id}] Validation errors:\n{e.errors()}")
+        problem_data = message_str if message_str is not None else record.get("body")
+        logger.error(
+            f"[{message_id}] Problematic data (SNS Message or SQS Body): {problem_data}"
+        )
+        raise
+    except (
+        subprocess.CalledProcessError
+    ) as e:  # <--- Catching the imported exception type
+        logger.error(f"[{message_id}] Subprocess command failed:")
+        logger.error(f"[{message_id}] Command: {' '.join(e.cmd)}")
+        logger.error(f"[{message_id}] Return code: {e.returncode}")
+        logger.error(f"[{message_id}] Stdout: {e.stdout}")
+        logger.error(f"[{message_id}] Stderr: {e.stderr}")
+        raise
+    except Exception as e:
+        logger.error(
+            f"[{message_id}] An unexpected error occurred processing record: {e}"
+        )
+        logger.error(traceback.format_exc())
+        raise
+
+
+class BatchItemFailure(TypedDict):
+    itemIdentifier: str
+
+
+class PartialBatchFailureResponse(TypedDict):
+    batchItemFailures: List[BatchItemFailure]
+
+
+def handler(
+    event: Dict[str, Any], context: Context
+) -> Optional[PartialBatchFailureResponse]:
+    """
+    AWS Lambda handler function triggered by SQS with batching enabled.
+
+    Processes messages in batches, attempts to generate STAC items, publishes
+    successful results to SNS, and reports partial batch failures to SQS.
+    """
+    try:
+        sns_client = boto3.client("sns", region_name=os.getenv("AWS_DEFAULT_REGION"))
+    except Exception as e:
+        logging.error(f"Error: {str(e)}")
+        raise EnvironmentError("AWS_DEFAULT_REGION must be set") from e
+
+    records = event.get("Records", [])
+    aws_request_id = getattr(context, "aws_request_id", "N/A")
+    remaining_time = getattr(context, "get_remaining_time_in_millis", lambda: "N/A")()
+
+    logger.info(f"Received batch with {len(records)} records.")
+    logger.debug(
+        f"Lambda Context: RequestId={aws_request_id}, RemainingTime={remaining_time}ms"
+    )
+
+    batch_item_failures: List[BatchItemFailure] = []
+
+    for record in records:
+        message_id = record.get("messageId")
+        if not message_id:
+            logger.warning("Record missing messageId, cannot report failure for it.")
+            continue
+
+        try:
+            process_record(record, sns_client)
+            logger.info(f"[{message_id}] Successfully processed.")
+
+        except Exception:
+            logger.error(f"[{message_id}] Marked as failed.")
+            batch_item_failures.append({"itemIdentifier": message_id})
+
+    if batch_item_failures:
+        logger.warning(
+            f"Finished processing batch. {len(batch_item_failures)} failure(s) reported."
+        )
+        logger.info(
+            f"Returning failed item identifiers: {[f['itemIdentifier'] for f in batch_item_failures]}"
+        )
+        return {"batchItemFailures": batch_item_failures}
+    else:
+        logger.info("Finished processing batch. All records successful.")
+        return None

package/lib/stactools-item-generator/runtime/src/stactools_item_generator/item.py

@@ -0,0 +1,77 @@
+import json
+import logging
+import subprocess
+from tempfile import NamedTemporaryFile
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+from stac_pydantic.item import Item
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+
+class ItemRequest(BaseModel):
+    package_name: str = Field(..., description="Name of the stactools package")
+    group_name: str = Field(..., description="Group name for the STAC item")
+    create_item_args: List[str] = Field(
+        ..., description="Arguments for create-item command"
+    )
+    create_item_options: Dict[str, str] = Field(
+        default_factory=dict, description="Options for create-item command"
+    )
+    collection_id: Optional[str] = Field(
+        None, description="value for the collection field of the item json"
+    )
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "package_name": "stactools-glad-glclu2020",
+                "group_name": "gladglclu2020",
+                "create_item_args": [
+                    "https://storage.googleapis.com/earthenginepartners-hansen/GLCLU2000-2020/v2/2000/50N_090W.tif"
+                ],
+            }
+        }
+    )
+
+
+def create_stac_item(request: ItemRequest) -> Item:
+    """
+    Create a STAC item using a stactools package
+    """
+    logger.info(f"Received request: {json.dumps(request.model_dump())}")
+
+    if not request.package_name:
+        raise ValueError("Missing required parameter: package_name")
+
+    command = [
+        "uvx",
+        "--with",
+        f"requests,{request.package_name}",
+        "--from",
+        "stactools",
+        "stac",
+        request.group_name,
+        "create-item",
+        *request.create_item_args,
+    ]
+
+    for option, value in request.create_item_options.items():
+        command.extend([f"--{option}", value])
+
+    logger.info(f"Executing command: {' '.join(command)}")
+
+    with NamedTemporaryFile(suffix=".json") as output:
+        command.append(output.name)
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+
+        logger.info(f"Command output: {result.stdout}")
+        with open(output.name) as f:
+            item_dict = json.load(f)
+
+    if request.collection_id:
+        item_dict["collection"] = request.collection_id
+
+    return Item(**item_dict)

package/lib/tipg-api/index.js

@@ -57,5 +57,5 @@ class TiPgApiLambda extends constructs_1.Construct {
 }
 exports.TiPgApiLambda = TiPgApiLambda;
 _a = JSII_RTTI_SYMBOL_1;
-TiPgApiLambda[_a] = { fqn: "eoapi-cdk.TiPgApiLambda", version: "8.1.1" };
+TiPgApiLambda[_a] = { fqn: "eoapi-cdk.TiPgApiLambda", version: "8.2.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;;AAAA,6CAWqB;AACrB,2CAAuC;AAEvC,6BAA6B;AAE3B,MAAa,aAAc,SAAQ,sBAAS;IAI1C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAyB;QACjE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,kBAAkB,GAAG,IAAI,wBAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE;YAC5D,WAAW;YACX,OAAO,EAAE,wBAAM,CAAC,OAAO,CAAC,WAAW;YACnC,OAAO,EAAE,iBAAiB;YAC1B,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,sBAAI,CAAC,aAAa,CAAC,QAAQ;YACzC,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7B,IAAI,EAAE,wBAAM,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE;gBAC5D,IAAI,EAAE,6BAA6B;gBACnC,SAAS,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE;aACtC,CAAC;YACF,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,UAAU,EAAE,KAAK,CAAC,eAAe;YACjC,iBAAiB,EAAE,IAAI;YACvB,WAAW,EAAE;gBACX,iBAAiB,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS;gBAC3C,gBAAgB,EAAE,GAAG;gBACrB,gBAAgB,EAAE,GAAG;gBACrB,GAAG,KAAK,CAAC,MAAM;aAChB;YACD,iEAAiE;YACjE,GAAG,KAAK,CAAC,qBAAqB;SAC/B,CAAC,CAAC;QAEH,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAElD,IAAI,KAAK,CAAC,GAAG,EAAC,CAAC;YACb,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,qBAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,6BAA6B,CAAC,CAAC;QAC3G,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,8BAAY,CAAC,OAAO,CACtC,IAAI,EACJ,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,WAAW,EACtC;YACE,oBAAoB,EAAE,KAAK,CAAC,iBAAiB;gBAC3C,CAAC,CAAC;oBACE,UAAU,EAAE,KAAK,CAAC,iBAAiB;iBACpC;gBACH,CAAC,CAAC,SAAS;YACb,kBAAkB,EAChB,IAAI,2CAAyB,CAAC,qBAAqB,CACjD,aAAa,EACb,IAAI,CAAC,kBAAkB,EACvB,KAAK,CAAC,iBAAiB;gBACrB,CAAC,CAAC;oBACE,gBAAgB,EACd,IAAI,8BAAY,CAAC,gBAAgB,EAAE,CAAC,eAAe,CACjD,MAAM,EACN,8BAAY,CAAC,YAAY,CAAC,MAAM,CAC9B,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAC7B,CACF;iBACJ;gBACH,CAAC,CAAC,SAAS,CACd;SACJ,CACF,CAAC;QAEF,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAI,CAAC;QAExB,IAAI,uBAAS,CAAC,IAAI,EAAE,iBAAiB,EAAE;YACrC,UAAU,EAAE,GAAG,mBAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS,UAAU;YACjD,KAAK,EAAE,IAAI,CAAC,GAAG;SAChB,CAAC,CAAC;IACL,CAAC;;AAvEH,sCAwEC","sourcesContent":["import {\n  Stack,\n  aws_apigatewayv2 as apigatewayv2,\n  aws_apigatewayv2_integrations as apigatewayv2_integrations,\n  aws_ec2 as ec2,\n  aws_lambda as lambda,\n  aws_logs as logs,\n  aws_rds as rds,\n  aws_secretsmanager as secretsmanager,\n  CfnOutput,\n  Duration,\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport { CustomLambdaFunctionProps } from \"../utils\";\nimport * as path from 'path';\n\n  export class TiPgApiLambda extends Construct {\n    readonly url: string;\n    public tiPgLambdaFunction: lambda.Function;\n\n    constructor(scope: Construct, id: string, props: TiPgApiLambdaProps) {\n      super(scope, id);\n\n      this.tiPgLambdaFunction = new lambda.Function(this, \"lambda\", {\n        // defaults\n        runtime: lambda.Runtime.PYTHON_3_11,\n        handler: \"handler.handler\",\n        memorySize: 1024,\n        logRetention: logs.RetentionDays.ONE_WEEK,\n        timeout: Duration.seconds(30),\n        code: lambda.Code.fromDockerBuild(path.join(__dirname, '..'), {\n          file: \"tipg-api/runtime/Dockerfile\",\n          buildArgs: { PYTHON_VERSION: '3.11' },\n        }),\n        vpc: props.vpc,\n        vpcSubnets: props.subnetSelection,\n        allowPublicSubnet: true,\n        environment: {\n          PGSTAC_SECRET_ARN: props.dbSecret.secretArn,\n          DB_MIN_CONN_SIZE: \"1\",\n          DB_MAX_CONN_SIZE: \"1\",\n          ...props.apiEnv,\n        },\n        // overwrites defaults with user-provided configurable properties\n        ...props.lambdaFunctionOptions\n      });\n\n      props.dbSecret.grantRead(this.tiPgLambdaFunction);\n\n      if (props.vpc){\n        this.tiPgLambdaFunction.connections.allowTo(props.db, ec2.Port.tcp(5432), \"allow connections from tipg\");\n      }\n\n      const tipgApi = new apigatewayv2.HttpApi(\n        this,\n        `${Stack.of(this).stackName}-tipg-api`,\n        {\n          defaultDomainMapping: props.tipgApiDomainName\n            ? {\n                domainName: props.tipgApiDomainName,\n              }\n            : undefined,\n          defaultIntegration:\n            new apigatewayv2_integrations.HttpLambdaIntegration(\n              \"integration\",\n              this.tiPgLambdaFunction,\n              props.tipgApiDomainName\n                ? {\n                    parameterMapping:\n                      new apigatewayv2.ParameterMapping().overwriteHeader(\n                        \"host\",\n                        apigatewayv2.MappingValue.custom(\n                          props.tipgApiDomainName.name\n                        )\n                      ),\n                  }\n                : undefined\n            ),\n        }\n      );\n\n      this.url = tipgApi.url!;\n\n      new CfnOutput(this, \"tipg-api-output\", {\n        exportName: `${Stack.of(this).stackName}-tip-url`,\n        value: this.url,\n      });\n    }\n  }\n\n  export interface TiPgApiLambdaProps {\n    /**\n     * VPC into which the lambda should be deployed.\n     */\n    readonly vpc?: ec2.IVpc;\n\n    /**\n     * RDS Instance with installed pgSTAC or pgbouncer server.\n     */\n    readonly db: rds.IDatabaseInstance | ec2.IInstance;\n\n    /**\n     * Subnet into which the lambda should be deployed.\n     */\n    readonly subnetSelection?: ec2.SubnetSelection;\n\n    /**\n     * Secret containing connection information for pgSTAC database.\n     */\n    readonly dbSecret: secretsmanager.ISecret;\n\n    /**\n     * Customized environment variables to send to titiler-pgstac runtime.\n     */\n    readonly apiEnv?: Record<string, string>;\n\n    /**\n     * Custom Domain Name for tipg API. If defined, will create the\n     * domain name and integrate it with the tipg API.\n     *\n     * @default - undefined\n     */\n    readonly tipgApiDomainName?: apigatewayv2.IDomainName;\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"]}

package/lib/titiler-pgstac-api/index.js

@@ -77,5 +77,5 @@ class TitilerPgstacApiLambda extends constructs_1.Construct {
 }
 exports.TitilerPgstacApiLambda = TitilerPgstacApiLambda;
 _a = JSII_RTTI_SYMBOL_1;
-TitilerPgstacApiLambda[_a] = { fqn: "eoapi-cdk.TitilerPgstacApiLambda", version: "8.1.1" };
+TitilerPgstacApiLambda[_a] = { fqn: "eoapi-cdk.TitilerPgstacApiLambda", version: "8.2.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Stack,\n  aws_apigatewayv2 as apigatewayv2,\n  aws_apigatewayv2_integrations as apigatewayv2_integrations,\n  aws_iam as iam,\n  aws_ec2 as ec2,\n  aws_rds as rds,\n  aws_lambda as lambda,\n  aws_secretsmanager as secretsmanager,\n  CfnOutput,\n  Duration,\n  aws_logs,\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport { CustomLambdaFunctionProps } from \"../utils\";\nimport * as path from 'path';\n\n  // default settings that can be overridden by the user-provided environment.\n  let defaultTitilerPgstacEnv :{ [key: string]: any } = {\n    \"CPL_VSIL_CURL_ALLOWED_EXTENSIONS\": \".tif,.TIF,.tiff\",\n    \"GDAL_CACHEMAX\": \"200\",\n    \"GDAL_DISABLE_READDIR_ON_OPEN\": \"EMPTY_DIR\",\n    \"GDAL_INGESTED_BYTES_AT_OPEN\": \"32768\",\n    \"GDAL_HTTP_MERGE_CONSECUTIVE_RANGES\": \"YES\",\n    \"GDAL_HTTP_MULTIPLEX\": \"YES\",\n    \"GDAL_HTTP_VERSION\": \"2\",\n    \"PYTHONWARNINGS\": \"ignore\",\n    \"VSI_CACHE\": \"TRUE\",\n    \"VSI_CACHE_SIZE\": \"5000000\",\n    \"DB_MIN_CONN_SIZE\": \"1\",\n    \"DB_MAX_CONN_SIZE\": \"1\"\n  }\n\n  export class TitilerPgstacApiLambda extends Construct {\n    readonly url: string;\n    public titilerPgstacLambdaFunction: lambda.Function;\n\n    constructor(scope: Construct, id: string, props: TitilerPgStacApiLambdaProps) {\n      super(scope, id);\n\n      this.titilerPgstacLambdaFunction = new lambda.Function(this, \"lambda\", {\n        // defaults\n        runtime: lambda.Runtime.PYTHON_3_11,\n        handler: \"handler.handler\",\n        memorySize: 3008,\n        logRetention: aws_logs.RetentionDays.ONE_WEEK,\n        timeout: Duration.seconds(30),\n        code: lambda.Code.fromDockerBuild(path.join(__dirname, '..'), {\n          file: \"titiler-pgstac-api/runtime/Dockerfile\",\n          buildArgs: { PYTHON_VERSION: '3.11' }\n        }),\n        vpc: props.vpc,\n        vpcSubnets: props.subnetSelection,\n        allowPublicSubnet: true,\n        // if user provided environment variables, merge them with the defaults.\n        environment: props.apiEnv ? { ...defaultTitilerPgstacEnv, ...props.apiEnv, \"PGSTAC_SECRET_ARN\": props.dbSecret.secretArn } : defaultTitilerPgstacEnv,\n        // overwrites defaults with user-provided configurable properties\n        ...props.lambdaFunctionOptions,\n      });\n\n      // grant access to buckets using addToRolePolicy\n      if (props.buckets) {\n        props.buckets.forEach(bucket => {\n          this.titilerPgstacLambdaFunction.addToRolePolicy(new iam.PolicyStatement({\n            actions: [\"s3:GetObject\"],\n            resources: [`arn:aws:s3:::${bucket}/*`],\n          }));\n        });\n      }\n\n      props.dbSecret.grantRead(this.titilerPgstacLambdaFunction);\n\n      if (props.vpc) {\n        this.titilerPgstacLambdaFunction.connections.allowTo(props.db, ec2.Port.tcp(5432), \"allow connections from titiler\");\n      }\n\n      const stacApi = new apigatewayv2.HttpApi(\n        this,\n        `${Stack.of(this).stackName}-titiler-pgstac-api`,\n        {\n          defaultDomainMapping: props.titilerPgstacApiDomainName\n            ? {\n                domainName: props.titilerPgstacApiDomainName,\n              }\n            : undefined,\n          defaultIntegration:\n            new apigatewayv2_integrations.HttpLambdaIntegration(\n              \"integration\",\n              this.titilerPgstacLambdaFunction,\n              props.titilerPgstacApiDomainName\n                ? {\n                    parameterMapping:\n                      new apigatewayv2.ParameterMapping().overwriteHeader(\n                        \"host\",\n                        apigatewayv2.MappingValue.custom(\n                          props.titilerPgstacApiDomainName.name\n                        )\n                      ),\n                  }\n                : undefined\n            ),\n        }\n      );\n\n      this.url = stacApi.url!;\n\n      new CfnOutput(this, \"titiler-pgstac-api-output\", {\n        exportName: `${Stack.of(this).stackName}-titiler-pgstac-url`,\n        value: this.url,\n      });\n    }\n  }\n\n  export interface TitilerPgStacApiLambdaProps {\n    /**\n     * VPC into which the lambda should be deployed.\n     */\n    readonly vpc?: ec2.IVpc;\n\n    /**\n     * RDS Instance with installed pgSTAC or pgbouncer server.\n     */\n    readonly db: rds.IDatabaseInstance | ec2.IInstance;\n\n    /**\n     * Subnet into which the lambda should be deployed.\n     */\n    readonly subnetSelection?: ec2.SubnetSelection;\n\n    /**\n     * Secret containing connection information for pgSTAC database.\n     */\n    readonly dbSecret: secretsmanager.ISecret;\n\n    /**\n     * Customized environment variables to send to titiler-pgstac runtime. These will be merged with `defaultTitilerPgstacEnv`.\n     * The database secret arn is automatically added to the environment variables at deployment.\n    /*/\n    readonly apiEnv?: Record<string, string>;\n\n    /**\n     * list of buckets the lambda will be granted access to.\n     */\n    readonly buckets?: string[];\n\n    /**\n     * Custom Domain Name Options for Titiler Pgstac API,\n     *\n     * @default - undefined.\n     */\n    readonly titilerPgstacApiDomainName?: apigatewayv2.IDomainName;\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"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eoapi-cdk",
-  "version": "8.1.1",
+  "version": "8.2.0",
   "description": "A set of constructs deploying pgSTAC with CDK",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "eoapi-cdk"
+version = "0.0"
+requires-python = ">=3.11"
+dependencies = [
+  "stactools-item-generator",
+  "stac-item-loader",
+]
+
+[tool.uv.sources]
+stactools-item-generator = { workspace = true }
+stac-item-loader = { workspace = true }
+
+[tool.uv.workspace]
+members = ["lib/stac-item-loader/runtime", "lib/stactools-item-generator/runtime"]
+
+[dependency-groups]
+deploy = [
+    "aws-cdk-lib==2.190.0",
+    "constructs==10.3.0",
+    "pydantic>=2.11.5",
+    "pydantic-settings[yaml]>=2.8.1",
+    "python-dotenv>=1.1.0",
+    "pyyaml>=6.0.2",
+    "types-pyyaml>=6.0.12.20250516",
+]
+dev = [
+    "aws-lambda-typing>=2.20.0",
+    "httpx>=0.28.1",
+    "pytest>=8.3.5",
+    "pytest-mock>=3.14.0",
+    "pytest-postgresql>=7.0.1",
+]
+
+[tool.pytest.ini_options]
+addopts = "-vv --ignore=cdk.out --no-header --tb=native"
+pythonpath = "."
+testpaths = [
+    "lib/stactools-item-generator/runtime/tests",
+    "lib/stac-item-loader/runtime/tests",
+]
+
+[tool.ruff]
+
+[tool.ruff.lint]